ssgx_http_t_client.h

Go to the documentation of this file.

#ifndef SAFEHERON_SGX_TRUSTED_HTTP_CLIENT_H
#define SAFEHERON_SGX_TRUSTED_HTTP_CLIENT_H
 
#include <map>
#include <string>
 
#include "ssgx_http_t_structs.h"
 
namespace ssgx {
namespace http_t {
 
/* Time out for connection, in seconds */
constexpr int SSGX_HTTP_CLIENT_TIMEOUT = 5;
 
enum class ErrorCode {
    Success = 0,            
    InvalidParam = 1,       
    InvalidCall = 2,        
    InvalidUrl = 3,         
    SetSeedFailed = 4,      
    ServerCAError = 5,      
    SSLConfigFailed = 6,    
    SSLSetupFailed = 7,     
    SSLHostWrong = 8,       
    SSLHandShakeFailed = 9, 
    VerifyCertFailed = 10,  
    ConnectFailed = 11,     
    WriteFailed = 12,       
    ReadFailed = 13,        
    MallocFailed = 14,      
    Unknown = 9999, 
};
 
class Error {
  public:
    Error() = default;
    Error(const Error& other) = default;
    Error(ErrorCode error_code, std::string error_msg, std::string internal_err)
        : error_code_(error_code), error_msg_(std::move(error_msg)), internal_err_(std::move(internal_err)) {
    }
 
    [[nodiscard]] ErrorCode code() const {
        return error_code_;
    }
    [[nodiscard]] const std::string& message() const {
        return error_msg_;
    }
    [[nodiscard]] const std::string& internal_error() const {
        return internal_err_;
    }
 
  private:
    ErrorCode error_code_ = ErrorCode::Unknown;
    std::string error_msg_;
    std::string internal_err_;
};
 
class Result {
  public:
    Result() = default;
    Result(std::unique_ptr<Response>&& res, const Error& err) : res_(std::move(res)), err_(err) {
    }
    // Response
    explicit operator bool() const {
        return res_ != nullptr;
    }
    bool operator==(std::nullptr_t) const {
        return res_ == nullptr;
    }
    bool operator!=(std::nullptr_t) const {
        return res_ != nullptr;
    }
    [[nodiscard]] const Response& value() const {
        return *res_;
    }
    Response& value() {
        return *res_;
    }
    const Response& operator*() const {
        return *res_;
    }
    Response& operator*() {
        return *res_;
    }
    const Response* operator->() const {
        return res_.get();
    }
    Response* operator->() {
        return res_.get();
    }
 
    // Error
    [[nodiscard]] Error error() const {
        return err_;
    }
 
  private:
    std::unique_ptr<Response> res_;
    Error err_ = Error(ErrorCode::Unknown, "Invalid", "Unknown");
};
 
class Client {
  public:
    explicit Client(const std::string& host);
 
    explicit Client(const std::string& host, int port);
 
    explicit Client(const std::string& host, int port, const std::string& server_ca);
 
    virtual ~Client() = default;
 
    Result Get(const std::string& path, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Get(const std::string& path, const TypeHeaders & headers, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Get(const std::string& path, const TypeParams& params, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Get(const std::string& path, const TypeHeaders& headers, const TypeParams& params,
               int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, const TypeHeaders& headers, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, const char* body, size_t content_length, const std::string& content_type,
                int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, const TypeHeaders& headers, const char* body, size_t content_length,
                const std::string& content_type, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, const std::string& body, const std::string& content_type,
                int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
    Result Post(const std::string& path, const TypeHeaders& headers, const std::string& body,
                const std::string& content_type, int time_out_sec = SSGX_HTTP_CLIENT_TIMEOUT);
 
  private:
    [[nodiscard]] Result SendRequest(const std::string& method, const std::string& path, const TypeHeaders& headers,
                                     const TypeParams& params, const std::string& body, const std::string& content_type,
                                     int time_out_sec) const;
 
    int port_ = -1;         
    std::string host_;      
    std::string server_ca_; 
};
 
} // namespace http_t
} // namespace ssgx
 
#endif // SAFEHERON_SGX_TRUSTED_HTTP_CLIENT_H