HttpClientSession.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "HttpClient.h"
 
namespace SC
{
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionCookie
{
    enum Flag : uint8_t
    {
        Secure       = 1 << 0,
        HttpOnly     = 1 << 1,
        DomainCookie = 1 << 2,
    };
 
    StringSpan name;
    StringSpan value;
    StringSpan domain;
    StringSpan path;
    uint8_t    flags = 0;
 
    [[nodiscard]] bool isInUse() const { return not name.isEmpty(); }
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionAuthCacheEntry
{
    StringSpan origin;              
    StringSpan authorizationHeader; 
 
    [[nodiscard]] bool isInUse() const { return not origin.isEmpty(); }
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionAuthChallenge
{
    enum Target : uint8_t
    {
        Origin,
        Proxy,
    };
 
    enum Scheme : uint8_t
    {
        Unsupported,
        Basic,
    };
 
    Target     target = Origin;
    Scheme     scheme = Unsupported;
    StringSpan realm;
 
    [[nodiscard]] const char*        getTargetName() const { return getTargetName(target); }
    [[nodiscard]] const char*        getSchemeName() const { return getSchemeName(scheme); }
    [[nodiscard]] static const char* getTargetName(Target target);
    [[nodiscard]] static const char* getSchemeName(Scheme scheme);
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionMemory
{
    Span<HttpClientHeader>                requestHeaders; 
    Span<HttpClientSessionCookie>         cookies;        
    Span<HttpClientSessionAuthCacheEntry> authEntries;    
    Span<char>                            headerScratch;  
    Span<char>                            stateScratch;   
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionRetryPolicy
{
    uint8_t maxAttempts = 1;
 
    bool retryTransportErrors             = true;
    bool retryHttpStatusCodes             = true;
    bool retryNonIdempotentReplayableBody = false;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSessionRetryState
{
    HttpClientRequest::Method    method = HttpClientRequest::HttpGET;
    HttpClientSessionRetryPolicy policy;
    uint8_t                      attemptsStarted       = 0;
    bool                         requestBodyReplayable = true;
 
    [[nodiscard]] bool    isStarted() const { return attemptsStarted > 0; }
    [[nodiscard]] bool    hasAttemptsRemaining() const { return attemptsStarted < policy.maxAttempts; }
    [[nodiscard]] uint8_t getRemainingAttempts() const
    {
        return attemptsStarted < policy.maxAttempts ? static_cast<uint8_t>(policy.maxAttempts - attemptsStarted) : 0;
    }
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientSession
{
    [[nodiscard]] Result init(const HttpClientSessionMemory& memory);
    void                 clear();
    void                 clearCookies();
    void                 clearAuthorizations();
 
    [[nodiscard]] Result addAuthorization(StringSpan origin, StringSpan authorizationHeader);
    [[nodiscard]] bool   findAuthorization(StringSpan origin, StringSpan& authorizationHeader) const;
    [[nodiscard]] bool   hasAuthorization(StringSpan origin) const;
    [[nodiscard]] bool   findCookie(StringSpan name, StringSpan domain, StringSpan path,
                                    HttpClientSessionCookie& cookie) const;
    [[nodiscard]] bool   hasCookie(StringSpan name, StringSpan domain, StringSpan path) const;
    [[nodiscard]] Result prepareRequest(const HttpClientRequest& source, HttpClientRequest& prepared);
    [[nodiscard]] Result captureResponse(const HttpClientRequest& request, const HttpClientResponse& response);
 
    [[nodiscard]] static Result makeBasicAuthorization(StringSpan username, StringSpan password, Span<char> destination,
                                                       StringSpan& authorizationHeader);
    [[nodiscard]] static bool   findBasicAuthChallenge(const HttpClientResponse&              response,
                                                       HttpClientSessionAuthChallenge::Target target,
                                                       HttpClientSessionAuthChallenge&        challenge);
    [[nodiscard]] static Result makeBasicAuthorizationForChallenge(const HttpClientResponse&              response,
                                                                   HttpClientSessionAuthChallenge::Target target,
                                                                   StringSpan username, StringSpan password,
                                                                   Span<char>  destination,
                                                                   StringSpan& authorizationHeader);
 
    [[nodiscard]] Result beginRetry(HttpClientSessionRetryState& state, const HttpClientRequest& request,
                                    HttpClientSessionRetryPolicy policy) const;
    [[nodiscard]] bool   shouldRetry(HttpClientSessionRetryState& state, Result transportResult,
                                     const HttpClientResponse* response) const;
 
    [[nodiscard]] static bool isIdempotentMethod(HttpClientRequest::Method method);
    [[nodiscard]] static bool isRetryableStatusCode(int statusCode);
 
    [[nodiscard]] bool   isInitialized() const { return initialized; }
    [[nodiscard]] size_t getNumCookies() const;
    [[nodiscard]] size_t getNumAuthorizations() const;
 
  private:
    [[nodiscard]] Result copyStateString(StringSpan source, StringSpan& destination);
    [[nodiscard]] Result appendPreparedHeader(StringSpan name, StringSpan value, size_t& numHeaders);
    [[nodiscard]] Result appendScratch(StringSpan text, bool addSeparator);
    [[nodiscard]] Result appendMatchingCookies(StringSpan url, size_t& numHeaders);
    [[nodiscard]] Result captureSetCookie(StringSpan requestUrl, StringSpan setCookie);
 
    HttpClientSessionMemory sessionMemory;
    size_t                  stateScratchUsed  = 0;
    size_t                  headerScratchUsed = 0;
    bool                    initialized       = false;
};
 
} // namespace SC