ssgx_http_t_structs.h

Go to the documentation of this file.

#ifndef SAFEHERON_SGX_TRUSTED_HTTP_STRUCT_H
#define SAFEHERON_SGX_TRUSTED_HTTP_STRUCT_H
#include <any>
#include <map>
#include <string>
#include <unordered_map>
namespace ssgx {
namespace http_t {
// Enum for HTTP Status Codes, used to represent various response states
enum class HttpStatusCode {
    // Informational responses
    Continue100 = 100,          
    SwitchingProtocol101 = 101, 
    Processing102 = 102,        
    EarlyHints103 = 103,        
 
    // Successful responses
    OK200 = 200,                          
    Created201 = 201,                     
    Accepted202 = 202,                    
    NonAuthoritativeInformation203 = 203, 
    NoContent204 = 204,                   
    ResetContent205 = 205,                
    PartialContent206 = 206,              
    MultiStatus207 = 207,                 
    AlreadyReported208 = 208,             
    IMUsed226 = 226,                      
 
    // Redirection responses
    MultipleChoices300 = 300,   
    MovedPermanently301 = 301,  
    Found302 = 302,             
    SeeOther303 = 303,          
    NotModified304 = 304,       
    UseProxy305 = 305,          
    Unused306 = 306,            
    TemporaryRedirect307 = 307, 
    PermanentRedirect308 = 308, 
 
    // Client error responses
    BadRequest400 = 400,                  
    Unauthorized401 = 401,                
    PaymentRequired402 = 402,             
    Forbidden403 = 403,                   
    NotFound404 = 404,                    
    MethodNotAllowed405 = 405,            
    NotAcceptable406 = 406,               
    ProxyAuthenticationRequired407 = 407, 
    RequestTimeout408 = 408,              
    Conflict409 = 409,                    
    Gone410 = 410,                        
    LengthRequired411 = 411,              
    PreconditionFailed412 = 412,          
    PayloadTooLarge413 = 413,             
    UriTooLong414 = 414,                  
    UnsupportedMediaType415 = 415,        
    RangeNotSatisfiable416 = 416,         
    ExpectationFailed417 = 417,           
    ImATeapot418 = 418,                   
    MisdirectedRequest421 = 421,          
    UnprocessableContent422 = 422,        
    Locked423 = 423,                      
    FailedDependency424 = 424,            
    TooEarly425 = 425,                    
    UpgradeRequired426 = 426,             
    PreconditionRequired428 = 428,        
    TooManyRequests429 = 429,             
    RequestHeaderFieldsTooLarge431 = 431, 
    UnavailableForLegalReasons451 = 451,  
 
    // Server error responses
    InternalServerError500 = 500,           
    NotImplemented501 = 501,                
    BadGateway502 = 502,                    
    ServiceUnavailable503 = 503,            
    GatewayTimeout504 = 504,                
    HttpVersionNotSupported505 = 505,       
    VariantAlsoNegotiates506 = 506,         
    InsufficientStorage507 = 507,           
    LoopDetected508 = 508,                  
    NotExtended510 = 510,                   
    NetworkAuthenticationRequired511 = 511, 
};
 
struct ci {
    bool operator()(const std::string& s1, const std::string& s2) const {
        return std::lexicographical_compare(
            s1.begin(), s1.end(), s2.begin(), s2.end(),
            [](unsigned char c1, unsigned char c2) { return ::tolower(c1) < ::tolower(c2); });
    }
};
 
using TypeHeaders = std::map<std::string, std::string, ci>;
using TypeParams = std::map<std::string, std::string>;
 
class Request {
  public:
    void SetMethod(const char* buf, size_t buf_len);
 
    void SetMethod(const std::string& method);
 
    std::string Method() const;
 
    void SetPath(const char* buf, size_t buf_len);
 
    void SetPath(const std::string& path);
 
    std::string Path() const;
 
    void SetHeaders(const TypeHeaders& headers);
 
    const TypeHeaders& Headers() const;
 
    void SetHeader(const std::string& key, const std::string& val);
 
    void SetHeader(const std::string& key, int64_t val);
 
    bool HasHeader(const std::string& key) const;
 
    std::string GetHeaderValue(const std::string& key, const char* def = "") const;
 
    uint64_t GetHeaderValueUint64(const std::string& key, uint64_t def = 0) const;
 
    void SetParams(const TypeParams& params);
 
    const TypeParams& Params() const;
 
    void SetParam(const std::string& key, const std::string& val);
 
    void SetParam(const std::string& key, int64_t val);
 
    bool HasParam(const std::string& key) const;
 
    std::string GetParamValue(const std::string& key, const char* def = "") const;
 
    void SetBody(const char* buf, size_t buf_len);
 
    void SetBody(const std::string& body);
 
    const std::string& Body() const;
 
    bool FromJsonStr(const std::string& json_str);
 
    bool FromJsonStr(const char* json_str);
 
    bool ToJsonStr(std::string& json_str) const;
 
    template <typename T>
    void SetAttribute(const std::string& key, T&& value) {
        data_[key] = std::forward<T>(value);
    }
 
    template <typename T>
    T& GetAttribute(const std::string& key) {
        return GetInternal<T>(key);
    }
 
    template <typename T>
    [[maybe_unused]] [[nodiscard]] bool HasAttribute(const std::string& key) const {
        auto it = data_.find(key);
        return (it != data_.end() && it->second.type() == typeid(T));
    }
 
  private:
    std::string method_;
    std::string path_; //"/api/v1/xxx"
    TypeParams params_;
    TypeHeaders headers_;
    std::string body_;
    std::unordered_map<std::string, std::any> data_;
 
    // 内部通用的 `Get` 逻辑，避免代码重复
    template <typename T>
    T& GetInternal(const std::string& key) {
        auto it = data_.find(key);
        if (it == data_.end()) {
            throw std::runtime_error("Key '" + key + "' not found in Attribute");
        }
        return std::any_cast<T&>(it->second);
    }
};
 
class Response {
  public:
    void SetStatusCode(HttpStatusCode status);
 
    HttpStatusCode StatusCode() const;
 
    void SetHeaders(const TypeHeaders& headers);
 
    const TypeHeaders& Headers() const;
 
    void SetHeader(const std::string& key, const std::string& val);
 
    void SetHeader(const std::string& key, int64_t val);
 
    bool HasHeader(const std::string& key) const;
 
    std::string GetHeaderValue(const std::string& key, const char* def = "") const;
 
    uint64_t GetHeaderValueUint64(const std::string& key, uint64_t def = 0) const;
 
    void SetBody(const char* buf, size_t buf_len);
 
    void SetBody(const std::string& body);
 
    const std::string& Body() const;
 
    bool FromJsonStrWithoutBody(const std::string& json_str);
 
    bool ToJsonStrWithoutBody(std::string& json_str) const;
 
    void SetResp(const char* s, size_t n, const std::string& content_type, HttpStatusCode status);
 
    void SetResp(const std::string& s, const std::string& content_type, HttpStatusCode status);
 
    void SetRespRedirect(const std::string& url, HttpStatusCode status_code = HttpStatusCode::Found302);
 
    void SetResp404NotFound();
 
    void SetResp500InternalServerError();
 
    void SetResp403Forbidden();
 
    void SetResp204NoContent();
 
  private:
    HttpStatusCode status_code_ = HttpStatusCode::InternalServerError500;
    TypeHeaders headers_;
    std::string body_;
};
 
} // namespace http_t
} // namespace ssgx
 
#endif // SAFEHERON_SGX_TRUSTED_HTTP_STRUCT_H