CurlHttp.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/SpscQueue.h"
#include "HAL/LowLevelMemTracker.h"
#include "HAL/ThreadSafeBool.h"
#include "HAL/ThreadSafeCounter.h"
#include "GenericPlatform/HttpRequestCommon.h"
#include "GenericPlatform/HttpResponseCommon.h"
 
class FCurlHttpResponse;
 
#if WITH_CURL
#if PLATFORM_MICROSOFT
#include "Microsoft/AllowMicrosoftPlatformTypes.h"
#endif
 
#ifdef PLATFORM_CURL_INCLUDE
    #include PLATFORM_CURL_INCLUDE
#else
    #include "curl/curl.h"
#endif
 
#if PLATFORM_MICROSOFT
#include "Microsoft/HideMicrosoftPlatformTypes.h"
#endif
 
#if !defined(CURL_ENABLE_DEBUG_CALLBACK)
    #define CURL_ENABLE_DEBUG_CALLBACK 0
#endif
 
#if !defined(CURL_ENABLE_NO_TIMEOUTS_OPTION)
    #define CURL_ENABLE_NO_TIMEOUTS_OPTION 0
#endif
 
namespace
{
    void* CurlMalloc(size_t Size)
    {
        LLM_SCOPE_BYNAME(TEXT("Networking/Curl"));
        return FMemory::Malloc(Size);
    }
 
    void CurlFree(void* Ptr)
    {
        LLM_SCOPE_BYNAME(TEXT("Networking/Curl"));
        FMemory::Free(Ptr);
    }
 
    void* CurlRealloc(void* Ptr, size_t Size)
    {
        void* Return = NULL;
 
        if (Size)
        {
            LLM_SCOPE_BYNAME(TEXT("Networking/Curl"));
            Return = FMemory::Realloc(Ptr, Size);
        }
 
        return Return;
    }
 
    char * CurlStrdup(const char * ZeroTerminatedString)
    {
        char * Copy = NULL;
        check(ZeroTerminatedString);
        if (ZeroTerminatedString)
        {
            LLM_SCOPE_BYNAME(TEXT("Networking/Curl"));
 
            SIZE_T StrLen = FCStringAnsi::Strlen(ZeroTerminatedString);
            Copy = reinterpret_cast<char*>(FMemory::Malloc(StrLen + 1));
            if (Copy)
            {
                FCStringAnsi::Strncpy(Copy, ZeroTerminatedString, StrLen + 1);
                check(FCStringAnsi::Strcmp(Copy, ZeroTerminatedString) == 0);
            }
        }
        return Copy;
    }
 
    void* CurlCalloc(size_t NumElems, size_t ElemSize)
    {
        void* Return = NULL;
        const size_t Size = NumElems * ElemSize;
        if (Size)
        {
            LLM_SCOPE_BYNAME(TEXT("Networking/Curl"));
 
            Return = FMemory::Malloc(Size);
 
            if (Return)
            {
                FMemory::Memzero(Return, Size);
            }
        }
 
        return Return;
    }
}
 
class FCurlHttpRequest : public FHttpRequestCommon
{
public:
 
    // implementation friends
    friend class FCurlHttpResponse;
 
    //~ Begin IHttpBase Interface
    virtual FString GetHeader(const FString& HeaderName) const override;
    virtual TArray<FString> GetAllHeaders() const override;
    virtual FString GetContentType() const override;
    virtual uint64 GetContentLength() const override;
    virtual const TArray<uint8>& GetContent() const override;
    //~ End IHttpBase Interface
 
    //~ Begin IHttpRequest Interface
    virtual FString GetVerb() const override;
    virtual void SetVerb(const FString& InVerb) override;
    virtual void SetOption(const FName Option, const FString& OptionValue) override;
    virtual void SetContent(const TArray<uint8>& ContentPayload) override;
    virtual void SetContent(TArray<uint8>&& ContentPayload) override;
    virtual void SetContentAsString(const FString& ContentString) override;
    virtual bool SetContentAsStreamedFile(const FString& Filename) override;
    virtual bool SetContentFromStream(TSharedRef<FArchive, ESPMode::ThreadSafe> Stream) override;
    virtual void SetHeader(const FString& HeaderName, const FString& HeaderValue) override;
    virtual void AppendToHeader(const FString& HeaderName, const FString& AdditionalHeaderValue) override;
    virtual bool ProcessRequest() override;
    virtual void Tick(float DeltaSeconds) override;
    //~ End IHttpRequest Interface
 
    //~ Begin IHttpRequestThreaded Interface
    virtual bool StartThreadedRequest() override;
    virtual void FinishRequest() override;
    virtual bool IsThreadedRequestComplete() override;
    virtual void TickThreadedRequest(float DeltaSeconds) override;
    //~ End IHttpRequestThreaded Interface
 
    bool SetupRequestHttpThread();
 
    void  CleanupRequestHttpThread();
 
    inline CURL * GetEasyHandle() const
    {
        return EasyHandle;
    }
 
    void MarkAsCompleted(CURLcode InCurlCompletionResult);
    
    void SetAddToCurlMultiResult(CURLMcode Result)
    {
        CurlAddToMultiResult = Result;
    }
 
    FCurlHttpRequest();
 
    virtual ~FCurlHttpRequest();
 
protected:
    virtual bool SetupRequest() override;
 
private:
 
    static size_t StaticUploadCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes, void* UserData);
 
    size_t UploadCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes);
 
    static int StaticSeekCallback(void* UserData, curl_off_t Offset, int Origin);
 
    int SeekCallback(curl_off_t Offset, int Origin);
 
    static size_t StaticReceiveResponseHeaderCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes, void* UserData);
 
    size_t ReceiveResponseHeaderCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes);
 
    static size_t StaticReceiveResponseBodyCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes, void* UserData);
 
    size_t ReceiveResponseBodyCallback(void* Ptr, size_t SizeInBlocks, size_t BlockSizeInBytes);
 
    static size_t StaticDebugCallback(CURL * Handle, curl_infotype DebugInfoType, char * DebugInfo, size_t DebugInfoSize, void* UserData);
 
    size_t DebugCallback(CURL * Handle, curl_infotype DebugInfoType, char * DebugInfo, size_t DebugInfoSize);
 
    virtual void AbortRequest() override;
 
    void CheckProgressDelegate();
 
    void BroadcastNewlyReceivedHeaders();
 
    static FString CombineHeaderKeyValue(const FString& HeaderKey, const FString& HeaderValue);
 
    virtual void CleanupRequest() override;
 
    void OnAnyActivityOccur(FStringView Reason);
 
    virtual void ClearInCaseOfRetry() override;
 
    virtual FHttpResponsePtr CreateResponse() override;
    virtual void MockResponseData() override;
 
    void SetupOptionUnixSocketPath();
    void SetupOptionHttpVersion();
 
private:
 
    CURL *          EasyHandle; 
    curl_slist *    HeaderList;
    FString         Verb;
    std::atomic<bool> bCurlRequestCompleted;
    bool            bRedirected;
    CURLMcode       CurlAddToMultiResult;
    CURLcode        CurlCompletionResult;
    bool bIsRequestPayloadSeekable = false;
    TMap<FString, FString> Headers;
    bool bAnyHttpActivity;
    TSpscQueue<TPair<FString, FString>> NewlyReceivedHeaders;
    std::atomic<int64> BytesSent;
    std::atomic<int64> TotalBytesSent;
    std::atomic<int64> TotalBytesRead;
    uint64 LastReportedBytesRead;
    uint64 LastReportedBytesSent;
    static const constexpr int32 NumberOfInfoMessagesToCache = 50;
    int32 LeastRecentlyCachedInfoMessageIndex;
    FCriticalSection InfoMessageCacheCriticalSection;
    TArray<FString, TFixedAllocator<NumberOfInfoMessagesToCache>> InfoMessageCache;
};
 
class FCurlHttpResponse : public FHttpResponseCommon
{
public:
    // implementation friends
    friend class FCurlHttpRequest;
 
    //~ Begin IHttpBase Interface
    virtual TArray<FString> GetAllHeaders() const override; 
    virtual FString GetContentType() const override;
    virtual uint64 GetContentLength() const override;
    //~ End IHttpBase Interface
 
    FCurlHttpResponse(const FCurlHttpRequest& InRequest);
 
private:
    uint64 ContentLength;
    int32 volatile bSucceeded;
};
 
#endif //WITH_CURL