ssgx_http_u.h

Go to the documentation of this file.

#ifndef SSGX_HTTP_U_CALLBACK_MANAGER_H
#define SSGX_HTTP_U_CALLBACK_MANAGER_H
 
#include <cstddef>
#include <mutex>
#include <sgx_error.h>
#include <sgx_urts.h>
#include <unordered_map>
 
namespace ssgx {
 
namespace http_u {
 
using HttpOnMessageCallback = sgx_status_t (*)(sgx_enclave_id_t eid, int* retval, const char* server_id,
                                               const char* req_method, const char* req_path,
                                               const char* req_params_json, const char* req_headers_json,
                                               const uint8_t* req_body, size_t req_body_size,
                                               char** resp_status_headers_json, uint8_t** resp_body,
                                               size_t* resp_body_size);
 
using RegisterEidCallback = sgx_status_t (*)(sgx_enclave_id_t eid, sgx_enclave_id_t enclave_eid);
 
 
class HttpCallbackManager {
  public:
    static HttpCallbackManager& GetInstance() {
        static HttpCallbackManager instance;
        return instance;
    }
    bool RegisterCallbacks(sgx_enclave_id_t eid, RegisterEidCallback register_cb, HttpOnMessageCallback http_cb) {
        std::lock_guard<std::mutex> lock(mutex_);
        http_callback_map_[eid] = http_cb;
        sgx_status_t status = register_cb(eid, eid);
        return status == SGX_SUCCESS;
    }
 
    bool HasHttpCallback(sgx_enclave_id_t eid) const {
        std::lock_guard<std::mutex> lock(mutex_);
        return http_callback_map_.count(eid) > 0;
    }
 
    HttpOnMessageCallback GetHttpCallback(sgx_enclave_id_t eid) const {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = http_callback_map_.find(eid);
        if (it != http_callback_map_.end()) {
            return it->second;
        }
        return nullptr;
    }
 
  public:
    HttpCallbackManager(const HttpCallbackManager&) = delete;
    HttpCallbackManager& operator=(const HttpCallbackManager&) = delete;
 
    HttpCallbackManager(HttpCallbackManager&&) = delete;
    HttpCallbackManager& operator=(HttpCallbackManager&&) = delete;
 
  private:
    HttpCallbackManager() = default;
    ~HttpCallbackManager() = default;
 
    mutable std::mutex mutex_;
    std::unordered_map<sgx_enclave_id_t, HttpOnMessageCallback> http_callback_map_;
};
 
} // namespace http_u
} // namespace ssgx
 
#endif // SSGX_HTTP_U_CALLBACK_MANAGER_H