ACurl.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <cstddef>
#include <optional>
#include <queue>
#include <AUI/ACurl.h>
 
#include "AUI/IO/AEOFException.h"
#include "AUI/IO/IInputStream.h"
#include "AUI/Traits/values.h"
#include "AFormMultipart.h"
#include <AUI/IO/APipe.h>
#include <AUI/Common/AByteBufferView.h>
#include <AUI/Common/AByteBuffer.h>
#include <AUI/Common/ASignal.h>
#include <AUI/Reflect/AEnumerate.h>
#include <AUI/Thread/AFuture.h>
 
class AString;
class ACurlMulti;

class API_AUI_CURL ACurl: public AObject {
friend class ACurlMulti;
public:
   enum class Http {
       VERSION_NONE, /* setting this means we don't care, and that we'd
                        like the library to choose the best possible
                        for us! */
       VERSION_1_0,  /* please use HTTP 1.0 in the request */
       VERSION_1_1,  /* please use HTTP 1.1 in the request */
       VERSION_2_0,  /* please use HTTP 2 in the request */
       VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */
       VERSION_2_PRIOR_KNOWLEDGE,  /* please use HTTP 2 without HTTP/1.1
                                      Upgrade */
       VERSION_3 = 30, /* Makes use of explicit HTTP/3 without fallback.
                          Use CURLOPT_ALTSVC to enable HTTP/3 upgrade */
       VERSION_LAST /* *ILLEGAL* http version */
   };
 
   enum class ResponseCode {
       HTTP_100_CONTINUE                        = 100,
       HTTP_101_SWITCHING_PROTOCOL              = 101,
       HTTP_102_PROCESSING                      = 102,
       HTTP_103_EARLY_HINTS                     = 103,
       HTTP_200_OK                              = 200,
       HTTP_201_CREATED                         = 201,
       HTTP_202_ACCEPTED                        = 202,
       HTTP_203_NON_AUTHORITATIVE_INFORMATION   = 203,
       HTTP_204_NO_CONTENT                      = 204,
       HTTP_205_RESET_CONTENT                   = 205,
       HTTP_206_PARTIAL_CONTENT                 = 206,
       HTTP_300_MULTIPLE_CHOICE                 = 300,
       HTTP_301_MOVED_PERMANENTLY               = 301,
       HTTP_302_FOUND                           = 302,
       HTTP_303_SEE_OTHER                       = 303,
       HTTP_304_NOT_MODIFIED                    = 304,
       HTTP_305_USE_PROXY                       = 305,
       HTTP_306_SWITCH_PROXY                    = 306,
       HTTP_307_TEMPORARY_REDIRECT              = 307,
       HTTP_308_PERMANENT_REDIRECT              = 308,
       HTTP_400_BAD_REQUEST                     = 400,
       HTTP_401_UNAUTHORIZED                    = 401,
       HTTP_402_PAYMENT_REQUIRED                = 402,
       HTTP_403_FORBIDDEN                       = 403,
       HTTP_404_NOT_FOUND                       = 404,
       HTTP_405_METHOD_NOT_ALLOWED              = 405,
       HTTP_406_NOT_ACCEPTABLE                  = 406,
       HTTP_407_PROXY_AUTHENTICATION_REQUIRED   = 407,
       HTTP_408_REQUEST_TIMEOUT                 = 408,
       HTTP_409_CONFLICT                        = 409,
       HTTP_410_GONE                            = 410,
       HTTP_411_LENGTH_REQUIRED                 = 411,
       HTTP_412_PRECONDITION_FAILED             = 412,
       HTTP_413_REQUEST_ENTITY_TOO_LARGE        = 413,
       HTTP_414_REQUEST_URI_TOO_LONG            = 414,
       HTTP_415_UNSUPPORTED_MEDIA_TYPE          = 415,
       HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
       HTTP_417_EXPECTATION_FAILED              = 417,
       HTTP_500_INTERNAL_SERVER_ERROR           = 500,
       HTTP_501_NOT_IMPLEMENTED                 = 501,
       HTTP_502_BAD_GATEWAY                     = 502,
       HTTP_503_SERVICE_UNAVAILABLE             = 503,
       HTTP_504_GATEWAY_TIMEOUT                 = 504,
       HTTP_505_HTTP_VERSION_NOT_SUPPORTED      = 505,
 
       /* don't forget to update AUI_ENUM_VALUES at the bottom */
   };
 
   enum class Method {
       HTTP_GET,
       HTTP_POST,
       HTTP_PUT,
       HTTP_DELETE,
   };

   struct Response {
       ResponseCode code;
       AString contentType;
       AByteBuffer body;
   };
 
 
   struct API_AUI_CURL ErrorDescription {
       int curlStatus;
       AString description;
 
       void throwException() const;
   };

   using WriteCallback = std::function<size_t(AByteBufferView data)>;

   using WriteCallbackV2 = std::function<size_t(ACurl& curl, AByteBufferView data)>;

   using ReadCallback = std::function<std::size_t(char* dst, size_t maxLen)>;
   using HeaderCallback = std::function<void(AByteBufferView)>;
   using ErrorCallback = std::function<void(const ErrorDescription& description)>;
 
 
   class Exception: public AIOException {
   public:
       using AIOException::AIOException;
       Exception(const ErrorDescription& errorDescription): AIOException(errorDescription.description),
                                                            mCurlStatus(errorDescription.curlStatus) {
 
       }
 
       [[nodiscard]]
       int curlStatus() const noexcept {
           return mCurlStatus;
       }
 
   private:
       int mCurlStatus;
   };
 
   class API_AUI_CURL Builder {
   friend class ACurl;
   private:
       void* mCURL;
       WriteCallbackV2 mWriteCallback;
       ReadCallback mReadCallback;
       ErrorCallback mErrorCallback;
       HeaderCallback mHeaderCallback;
       bool mThrowExceptionOnError = false;
       AVector<AString> mHeaders;
       AString mUrl, mParams;
       Method mMethod = Method::HTTP_GET;
       std::function<void(ACurl&)> mOnSuccess;
 
   public:
       explicit Builder(AString url);
       Builder(const Builder&) = delete;
       ~Builder();

       Builder& withWriteCallback(WriteCallback callback) {
           return withWriteCallback([callback = std::move(callback)](ACurl&, AByteBufferView buffer) {
               return callback(buffer);
           });
       }

       Builder& withWriteCallback(WriteCallbackV2 callback) {
           AUI_ASSERTX(mWriteCallback == nullptr, "write callback already set");
           mWriteCallback = std::move(callback);
           return *this;
       }

        Builder& withMultipart(const AFormMultipart& multipart) {
           withInputStream(multipart.makeInputStream());
           mHeaders.push_back("Content-Type: multipart/form-data; boundary={}"_format(multipart.boundary()));
           return *this;
        }

       Builder& withBody(ReadCallback callback) {
           AUI_ASSERTX(mReadCallback == nullptr, "write callback already set");
           mReadCallback = std::move(callback);
           return *this;
       }

       Builder& withInputStream(_<IInputStream> inputStream) {
           withBody([inputStream = std::move(inputStream)](char* dst, std::size_t length) {
               auto v = inputStream->read(dst, length);
               if (v == 0) {
                   throw AEOFException();
               }
               return v;
           });
           return *this;
       }

       Builder& withTimeout(std::chrono::seconds timeout);

       Builder& withBody(std::string contents) {
           AUI_ASSERTX(mReadCallback == nullptr, "write callback already set");
 
           struct Body {
               explicit Body(std::string b) : contents(std::move(b)), i(contents.begin()) {}
 
               std::string contents;
               std::string::iterator i;
           };
           auto b = _new<Body>(std::move(contents));
 
           mReadCallback = [body = std::move(b)](char* dst, std::size_t length) mutable {
               if (body->i == body->contents.end()) {
                   throw AEOFException();
               }
               std::size_t remaining = std::distance(body->i, body->contents.end());
               length = glm::min(length, remaining);
               std::memcpy(dst, &*body->i, length);
               body->i += length;
               return length;
           };
 
           return *this;
       }

       Builder& withHeaderCallback(HeaderCallback headerCallback) {
           mHeaderCallback = std::move(headerCallback);
           return *this;
       }

       Builder& withErrorCallback(ErrorCallback callback) {
           AUI_ASSERTX(mErrorCallback == nullptr, "error callback already set");
           mErrorCallback = std::move(callback);
           return *this;
       }
 
       Builder& withDestinationBuffer(aui::constraint::avoid_copy<AByteBuffer> dst) {
           return withWriteCallback([dst](AByteBufferView b) {
               (*dst) << b;
               return b.size();
           });
       }
 
       Builder& withOutputStream(_<IOutputStream> dst) {
           return withWriteCallback([dst = std::move(dst)](AByteBufferView b) {
               (*dst) << b;
               return b.size();
           });
       }
 
       Builder& throwExceptionOnError(bool throwExceptionOnError) noexcept {
           mThrowExceptionOnError = throwExceptionOnError;
           return *this;
       }

       Builder& withRanges(size_t begin, size_t end);

       Builder& withRanges(size_t begin) {
           return withRanges(begin, 0);
       }

       Builder& withLowSpeedLimit(size_t speed);

       Builder& withLowSpeedTime(std::chrono::seconds duration);
 
 
       Builder& withHttpVersion(Http version);
       Builder& withUpload(bool upload);
       Builder& withCustomRequest(const AString& v);
       Builder& withOnSuccess(std::function<void(ACurl&)> onSuccess) {
           mOnSuccess = std::move(onSuccess);
           return *this;
       }
 
       template<aui::invocable OnSuccess>
       Builder& withOnSuccess(OnSuccess&& onSuccess) {
           mOnSuccess = [onSuccess = std::forward<OnSuccess>(onSuccess)](ACurl&) {
               onSuccess();
           };
           return *this;
       }

       Builder& withMethod(Method method) noexcept {
           mMethod = method;
           return *this;
       };
 

       Builder& withParams(const AVector<std::pair<AString /* key */, AString /* value */>>& params);

       Builder& withParams(AString params) noexcept {
           mParams = std::move(params);
           return *this;
       };
 
       Builder& withHeaders(AVector<AString> headers) {
           mHeaders = std::move(headers);
           return *this;
       }

       _unique<IInputStream> toInputStream();

       Response runBlocking();

        AFuture<Response> runAsync();

        AFuture<Response> runAsync(ACurlMulti& curlMulti);
   };
 
   explicit ACurl(Builder& builder):
       ACurl(std::move(builder))
   {
 
   }
   explicit ACurl(Builder&& builder) noexcept {
       operator=(std::move(builder));
   }
   ACurl(ACurl&& o) noexcept {
       operator=(std::move(o));
   }
 
   virtual ~ACurl();
 
   ACurl& operator=(Builder&& o) noexcept;
   ACurl& operator=(ACurl&& o) noexcept;
 
   int64_t getContentLength() const;
   int64_t getNumberOfBytesDownloaded() const;
   AString getContentType() const;
 
   void run();

   virtual void close();
 
   [[nodiscard]]
   void* handle() const noexcept {
       return mCURL;
   }
 
   [[nodiscard]]
   ResponseCode getResponseCode() const;
 
   [[nodiscard]]
   AString getErrorString() const noexcept {
       return AString::fromLatin1(mErrorBuffer);
   }
 
private:
   void* mCURL;
   struct curl_slist* mCurlHeaders = nullptr;
   char mErrorBuffer[256];
   bool mCloseRequested = false;
   bool mThrowExceptionOnError = false;
   std::string mPostFieldsStorage;
 
   static size_t writeCallback(char* ptr, size_t size, size_t nmemb, void* userdata) noexcept;
   static size_t readCallback(char* ptr, size_t size, size_t nmemb, void* userdata) noexcept;
   static size_t headerCallback(char *buffer, size_t size, size_t nitems, void *userdata) noexcept;
 
   WriteCallbackV2 mWriteCallback;
   ReadCallback mReadCallback;
   HeaderCallback mHeaderCallback;
 
   void reportSuccess() {
       emit success;
   }
 
   void reportFail(const ErrorDescription& errorDescription) {
       emit fail(errorDescription);
   }
 
   void reportFail(int statusCode) {
       reportFail(ErrorDescription{statusCode, AString::fromLatin1(mErrorBuffer)});
   }
 
   template<typename Ret>
   Ret getInfo(int curlInfo) const;
 
 
signals:

   emits<ErrorDescription> fail;

   emits<> success;
 
 
   emits<> closeRequested;
};
 
 
AUI_ENUM_VALUES(ACurl::ResponseCode,
               ACurl::ResponseCode::HTTP_100_CONTINUE,
               ACurl::ResponseCode::HTTP_101_SWITCHING_PROTOCOL,
               ACurl::ResponseCode::HTTP_102_PROCESSING,
               ACurl::ResponseCode::HTTP_103_EARLY_HINTS,
               ACurl::ResponseCode::HTTP_200_OK,
               ACurl::ResponseCode::HTTP_201_CREATED,
               ACurl::ResponseCode::HTTP_202_ACCEPTED,
               ACurl::ResponseCode::HTTP_203_NON_AUTHORITATIVE_INFORMATION,
               ACurl::ResponseCode::HTTP_204_NO_CONTENT,
               ACurl::ResponseCode::HTTP_205_RESET_CONTENT,
               ACurl::ResponseCode::HTTP_206_PARTIAL_CONTENT,
               ACurl::ResponseCode::HTTP_300_MULTIPLE_CHOICE,
               ACurl::ResponseCode::HTTP_301_MOVED_PERMANENTLY,
               ACurl::ResponseCode::HTTP_302_FOUND,
               ACurl::ResponseCode::HTTP_303_SEE_OTHER,
               ACurl::ResponseCode::HTTP_304_NOT_MODIFIED,
               ACurl::ResponseCode::HTTP_305_USE_PROXY,
               ACurl::ResponseCode::HTTP_306_SWITCH_PROXY,
               ACurl::ResponseCode::HTTP_307_TEMPORARY_REDIRECT,
               ACurl::ResponseCode::HTTP_308_PERMANENT_REDIRECT,
               ACurl::ResponseCode::HTTP_400_BAD_REQUEST,
               ACurl::ResponseCode::HTTP_401_UNAUTHORIZED,
               ACurl::ResponseCode::HTTP_402_PAYMENT_REQUIRED,
               ACurl::ResponseCode::HTTP_403_FORBIDDEN,
               ACurl::ResponseCode::HTTP_404_NOT_FOUND,
               ACurl::ResponseCode::HTTP_405_METHOD_NOT_ALLOWED,
               ACurl::ResponseCode::HTTP_406_NOT_ACCEPTABLE,
               ACurl::ResponseCode::HTTP_407_PROXY_AUTHENTICATION_REQUIRED,
               ACurl::ResponseCode::HTTP_408_REQUEST_TIMEOUT,
               ACurl::ResponseCode::HTTP_409_CONFLICT,
               ACurl::ResponseCode::HTTP_410_GONE,
               ACurl::ResponseCode::HTTP_411_LENGTH_REQUIRED,
               ACurl::ResponseCode::HTTP_412_PRECONDITION_FAILED,
               ACurl::ResponseCode::HTTP_413_REQUEST_ENTITY_TOO_LARGE,
               ACurl::ResponseCode::HTTP_414_REQUEST_URI_TOO_LONG,
               ACurl::ResponseCode::HTTP_415_UNSUPPORTED_MEDIA_TYPE,
               ACurl::ResponseCode::HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
               ACurl::ResponseCode::HTTP_417_EXPECTATION_FAILED,
               ACurl::ResponseCode::HTTP_500_INTERNAL_SERVER_ERROR,
               ACurl::ResponseCode::HTTP_501_NOT_IMPLEMENTED,
               ACurl::ResponseCode::HTTP_502_BAD_GATEWAY,
               ACurl::ResponseCode::HTTP_503_SERVICE_UNAVAILABLE,
               ACurl::ResponseCode::HTTP_504_GATEWAY_TIMEOUT,
               ACurl::ResponseCode::HTTP_505_HTTP_VERSION_NOT_SUPPORTED)

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.