// SPDX-License-Identifier: MIT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <dlfcn.h>

#include "wrappedlibs.h"

#include "wrapper32.h"
#include "bridge.h"
#include "librarian.h"
#include "librarian/library_private.h"
#include "x64emu.h"
#include "debug.h"
#include "box32context.h"
#include "emu/x64emu_private.h"
#include "callback.h"
#include "elfloader.h"

static const char* curlName = "libcurl.so.4";
#define ALTNAME "libcurl.so"

#define ALTNAME2 "libcurl-gnutls.so.4"
#define LIBNAME curl

#include "generated/wrappedcurltypes32.h"

#include "wrappercallback32.h"

#define LONG          0
#define OBJECTPOINT   10000
#define STRINGPOINT   10000
#define FUNCTIONPOINT 20000
#define OFF_T         30000
#define BLOB          40000
#define CINIT(name,type,number) CURLOPT_ ## name = type + number
#define CURLOPT(na,t,nu) na = t + nu

typedef enum {
  CINIT(WRITEDATA, OBJECTPOINT, 1),
  CINIT(URL, STRINGPOINT, 2),
  CINIT(PORT, LONG, 3),
  CINIT(PROXY, STRINGPOINT, 4),
  CINIT(USERPWD, STRINGPOINT, 5),
  CINIT(PROXYUSERPWD, STRINGPOINT, 6),
  CINIT(RANGE, STRINGPOINT, 7),
  CINIT(READDATA, OBJECTPOINT, 9),
  CINIT(ERRORBUFFER, OBJECTPOINT, 10),
  CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
  CINIT(READFUNCTION, FUNCTIONPOINT, 12),
  CINIT(TIMEOUT, LONG, 13),
  CINIT(INFILESIZE, LONG, 14),
  CINIT(POSTFIELDS, OBJECTPOINT, 15),
  CINIT(REFERER, STRINGPOINT, 16),
  CINIT(FTPPORT, STRINGPOINT, 17),
  CINIT(USERAGENT, STRINGPOINT, 18),
  CINIT(LOW_SPEED_LIMIT, LONG, 19),
  CINIT(LOW_SPEED_TIME, LONG, 20),
  CINIT(RESUME_FROM, LONG, 21),
  CINIT(COOKIE, STRINGPOINT, 22),
  CINIT(HTTPHEADER, OBJECTPOINT, 23),
  CINIT(HTTPPOST, OBJECTPOINT, 24),
  CINIT(SSLCERT, STRINGPOINT, 25),
  CINIT(KEYPASSWD, STRINGPOINT, 26),
  CINIT(CRLF, LONG, 27),
  CINIT(QUOTE, OBJECTPOINT, 28),
  CINIT(HEADERDATA, OBJECTPOINT, 29),
  CINIT(COOKIEFILE, STRINGPOINT, 31),
  CINIT(SSLVERSION, LONG, 32),
  CINIT(TIMECONDITION, LONG, 33),
  CINIT(TIMEVALUE, LONG, 34),
  CINIT(CUSTOMREQUEST, STRINGPOINT, 36),
  CINIT(STDERR, OBJECTPOINT, 37),
  CINIT(POSTQUOTE, OBJECTPOINT, 39),
  CINIT(OBSOLETE40, OBJECTPOINT, 40),
  CINIT(VERBOSE, LONG, 41),
  CINIT(HEADER, LONG, 42),
  CINIT(NOPROGRESS, LONG, 43),
  CINIT(NOBODY, LONG, 44),
  CINIT(FAILONERROR, LONG, 45),
  CINIT(UPLOAD, LONG, 46),
  CINIT(POST, LONG, 47),
  CINIT(DIRLISTONLY, LONG, 48),
  CINIT(APPEND, LONG, 50),
  CINIT(NETRC, LONG, 51),
  CINIT(FOLLOWLOCATION, LONG, 52),
  CINIT(TRANSFERTEXT, LONG, 53),
  CINIT(PUT, LONG, 54),
  CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
  CINIT(PROGRESSDATA, OBJECTPOINT, 57),
#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA
  CINIT(AUTOREFERER, LONG, 58),
  CINIT(PROXYPORT, LONG, 59),
  CINIT(POSTFIELDSIZE, LONG, 60),
  CINIT(HTTPPROXYTUNNEL, LONG, 61),
  CINIT(INTERFACE, STRINGPOINT, 62),
  CINIT(KRBLEVEL, STRINGPOINT, 63),
  CINIT(SSL_VERIFYPEER, LONG, 64),
  CINIT(CAINFO, STRINGPOINT, 65),
  CINIT(MAXREDIRS, LONG, 68),
  CINIT(FILETIME, LONG, 69),
  CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
  CINIT(MAXCONNECTS, LONG, 71),
  CINIT(OBSOLETE72, LONG, 72),
  CINIT(FRESH_CONNECT, LONG, 74),
  CINIT(FORBID_REUSE, LONG, 75),
  CINIT(RANDOM_FILE, STRINGPOINT, 76),
  CINIT(EGDSOCKET, STRINGPOINT, 77),
  CINIT(CONNECTTIMEOUT, LONG, 78),
  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
  CINIT(HTTPGET, LONG, 80),
  CINIT(SSL_VERIFYHOST, LONG, 81),
  CINIT(COOKIEJAR, STRINGPOINT, 82),
  CINIT(SSL_CIPHER_LIST, STRINGPOINT, 83),
  CINIT(HTTP_VERSION, LONG, 84),
  CINIT(FTP_USE_EPSV, LONG, 85),
  CINIT(SSLCERTTYPE, STRINGPOINT, 86),
  CINIT(SSLKEY, STRINGPOINT, 87),
  CINIT(SSLKEYTYPE, STRINGPOINT, 88),
  CINIT(SSLENGINE, STRINGPOINT, 89),
  CINIT(SSLENGINE_DEFAULT, LONG, 90),
  CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91),
  CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
  CINIT(PREQUOTE, OBJECTPOINT, 93),
  CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
  CINIT(DEBUGDATA, OBJECTPOINT, 95),
  CINIT(COOKIESESSION, LONG, 96),
  CINIT(CAPATH, STRINGPOINT, 97),
  CINIT(BUFFERSIZE, LONG, 98),
  CINIT(NOSIGNAL, LONG, 99),
  CINIT(SHARE, OBJECTPOINT, 100),
  CINIT(PROXYTYPE, LONG, 101),
  CINIT(ACCEPT_ENCODING, STRINGPOINT, 102),
  CINIT(PRIVATE, OBJECTPOINT, 103),
  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
  CINIT(UNRESTRICTED_AUTH, LONG, 105),
  CINIT(FTP_USE_EPRT, LONG, 106),
  CINIT(HTTPAUTH, LONG, 107),
  CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
  CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
  CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
  CINIT(PROXYAUTH, LONG, 111),
  CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
  CINIT(IPRESOLVE, LONG, 113),
  CINIT(MAXFILESIZE, LONG, 114),
  CINIT(INFILESIZE_LARGE, OFF_T, 115),
  CINIT(RESUME_FROM_LARGE, OFF_T, 116),
  CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
  CINIT(NETRC_FILE, STRINGPOINT, 118),
  CINIT(USE_SSL, LONG, 119),
  CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
  CINIT(TCP_NODELAY, LONG, 121),
  CINIT(FTPSSLAUTH, LONG, 129),
  CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
  CINIT(IOCTLDATA, OBJECTPOINT, 131),
  CINIT(FTP_ACCOUNT, STRINGPOINT, 134),
  CINIT(COOKIELIST, STRINGPOINT, 135),
  CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
  CINIT(FTP_SKIP_PASV_IP, LONG, 137),
  CINIT(FTP_FILEMETHOD, LONG, 138),
  CINIT(LOCALPORT, LONG, 139),
  CINIT(LOCALPORTRANGE, LONG, 140),
  CINIT(CONNECT_ONLY, LONG, 141),
  CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
  CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
  CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
  CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
  CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
  CINIT(FTP_ALTERNATIVE_TO_USER, STRINGPOINT, 147),
  CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
  CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
  CINIT(SSL_SESSIONID_CACHE, LONG, 150),
  CINIT(SSH_AUTH_TYPES, LONG, 151),
  CINIT(SSH_PUBLIC_KEYFILE, STRINGPOINT, 152),
  CINIT(SSH_PRIVATE_KEYFILE, STRINGPOINT, 153),
  CINIT(FTP_SSL_CCC, LONG, 154),
  CINIT(TIMEOUT_MS, LONG, 155),
  CINIT(CONNECTTIMEOUT_MS, LONG, 156),
  CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
  CINIT(HTTP_CONTENT_DECODING, LONG, 158),
  CINIT(NEW_FILE_PERMS, LONG, 159),
  CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
  CINIT(POSTREDIR, LONG, 161),
  CINIT(SSH_HOST_PUBLIC_KEY_MD5, STRINGPOINT, 162),
  CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
  CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
  CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
  CINIT(PROXY_TRANSFER_MODE, LONG, 166),
  CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
  CINIT(SEEKDATA, OBJECTPOINT, 168),
  CINIT(CRLFILE, STRINGPOINT, 169),
  CINIT(ISSUERCERT, STRINGPOINT, 170),
  CINIT(ADDRESS_SCOPE, LONG, 171),
  CINIT(CERTINFO, LONG, 172),
  CINIT(USERNAME, STRINGPOINT, 173),
  CINIT(PASSWORD, STRINGPOINT, 174),
  CINIT(PROXYUSERNAME, STRINGPOINT, 175),
  CINIT(PROXYPASSWORD, STRINGPOINT, 176),
  CINIT(NOPROXY, STRINGPOINT, 177),
  CINIT(TFTP_BLKSIZE, LONG, 178),
  CINIT(SOCKS5_GSSAPI_SERVICE, STRINGPOINT, 179),
  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
  CINIT(PROTOCOLS, LONG, 181),
  CINIT(REDIR_PROTOCOLS, LONG, 182),
  CINIT(SSH_KNOWNHOSTS, STRINGPOINT, 183),
  CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
  CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
  CINIT(MAIL_FROM, STRINGPOINT, 186),
  CINIT(MAIL_RCPT, OBJECTPOINT, 187),
  CINIT(FTP_USE_PRET, LONG, 188),
  CINIT(RTSP_REQUEST, LONG, 189),
  CINIT(RTSP_SESSION_ID, STRINGPOINT, 190),
  CINIT(RTSP_STREAM_URI, STRINGPOINT, 191),
  CINIT(RTSP_TRANSPORT, STRINGPOINT, 192),
  CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
  CINIT(RTSP_SERVER_CSEQ, LONG, 194),
  CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
  CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
  CINIT(WILDCARDMATCH, LONG, 197),
  CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),
  CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),
  CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),
  CINIT(CHUNK_DATA, OBJECTPOINT, 201),
  CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
  CINIT(RESOLVE, OBJECTPOINT, 203),
  CINIT(TLSAUTH_USERNAME, STRINGPOINT, 204),
  CINIT(TLSAUTH_PASSWORD, STRINGPOINT, 205),
  CINIT(TLSAUTH_TYPE, STRINGPOINT, 206),
  CINIT(TRANSFER_ENCODING, LONG, 207),
  CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),
  CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),
  CINIT(GSSAPI_DELEGATION, LONG, 210),
  CINIT(DNS_SERVERS, STRINGPOINT, 211),
  CINIT(ACCEPTTIMEOUT_MS, LONG, 212),
  CINIT(TCP_KEEPALIVE, LONG, 213),
  CINIT(TCP_KEEPIDLE, LONG, 214),
  CINIT(TCP_KEEPINTVL, LONG, 215),
  CINIT(SSL_OPTIONS, LONG, 216),
  CINIT(MAIL_AUTH, STRINGPOINT, 217),
  CINIT(SASL_IR, LONG, 218),
  CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219),
  CINIT(XOAUTH2_BEARER, STRINGPOINT, 220),
  CINIT(DNS_INTERFACE, STRINGPOINT, 221),
  CINIT(DNS_LOCAL_IP4, STRINGPOINT, 222),
  CINIT(DNS_LOCAL_IP6, STRINGPOINT, 223),
  CINIT(LOGIN_OPTIONS, STRINGPOINT, 224),
  CINIT(SSL_ENABLE_NPN, LONG, 225),
  CINIT(SSL_ENABLE_ALPN, LONG, 226),
  CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227),
  CINIT(PROXYHEADER, OBJECTPOINT, 228),
  CINIT(HEADEROPT, LONG, 229),
  CINIT(PINNEDPUBLICKEY, STRINGPOINT, 230),
  CINIT(UNIX_SOCKET_PATH, STRINGPOINT, 231),
  CINIT(SSL_VERIFYSTATUS, LONG, 232),
  CINIT(SSL_FALSESTART, LONG, 233),
  CINIT(PATH_AS_IS, LONG, 234),
  CINIT(PROXY_SERVICE_NAME, STRINGPOINT, 235),
  CINIT(SERVICE_NAME, STRINGPOINT, 236),
  CINIT(PIPEWAIT, LONG, 237),
  CINIT(DEFAULT_PROTOCOL, STRINGPOINT, 238),
  CINIT(STREAM_WEIGHT, LONG, 239),
  CINIT(STREAM_DEPENDS, OBJECTPOINT, 240),
  CINIT(STREAM_DEPENDS_E, OBJECTPOINT, 241),
  CINIT(TFTP_NO_OPTIONS, LONG, 242),
  CINIT(CONNECT_TO, OBJECTPOINT, 243),
  CINIT(TCP_FASTOPEN, LONG, 244),
  CINIT(KEEP_SENDING_ON_ERROR, LONG, 245),
  CINIT(PROXY_CAINFO, STRINGPOINT, 246),
  CINIT(PROXY_CAPATH, STRINGPOINT, 247),
  CINIT(PROXY_SSL_VERIFYPEER, LONG, 248),
  CINIT(PROXY_SSL_VERIFYHOST, LONG, 249),
  CINIT(PROXY_SSLVERSION, LONG, 250),
  CINIT(PROXY_TLSAUTH_USERNAME, STRINGPOINT, 251),
  CINIT(PROXY_TLSAUTH_PASSWORD, STRINGPOINT, 252),
  CINIT(PROXY_TLSAUTH_TYPE, STRINGPOINT, 253),
  CINIT(PROXY_SSLCERT, STRINGPOINT, 254),
  CINIT(PROXY_SSLCERTTYPE, STRINGPOINT, 255),
  CINIT(PROXY_SSLKEY, STRINGPOINT, 256),
  CINIT(PROXY_SSLKEYTYPE, STRINGPOINT, 257),
  CINIT(PROXY_KEYPASSWD, STRINGPOINT, 258),
  CINIT(PROXY_SSL_CIPHER_LIST, STRINGPOINT, 259),
  CINIT(PROXY_CRLFILE, STRINGPOINT, 260),
  CINIT(PROXY_SSL_OPTIONS, LONG, 261),
  CINIT(PRE_PROXY, STRINGPOINT, 262),
  CINIT(PROXY_PINNEDPUBLICKEY, STRINGPOINT, 263),
  CINIT(ABSTRACT_UNIX_SOCKET, STRINGPOINT, 264),
  CINIT(SUPPRESS_CONNECT_HEADERS, LONG, 265),
  CINIT(REQUEST_TARGET, STRINGPOINT, 266),
  CINIT(SOCKS5_AUTH, LONG, 267),
  CINIT(SSH_COMPRESSION, LONG, 268),
  CINIT(MIMEPOST, OBJECTPOINT, 269),
  CINIT(TIMEVALUE_LARGE, OFF_T, 270),
  CINIT(HAPPY_EYEBALLS_TIMEOUT_MS, LONG, 271),
  CINIT(RESOLVER_START_FUNCTION, FUNCTIONPOINT, 272),
  CINIT(RESOLVER_START_DATA, OBJECTPOINT, 273),
  CINIT(HAPROXYPROTOCOL, LONG, 274),
  CINIT(DNS_SHUFFLE_ADDRESSES, LONG, 275),
  CINIT(TLS13_CIPHERS, STRINGPOINT, 276),
  CINIT(PROXY_TLS13_CIPHERS, STRINGPOINT, 277),
  CINIT(DISALLOW_USERNAME_IN_URL, LONG, 278),
  CINIT(DOH_URL, STRINGPOINT, 279),
  CINIT(UPLOAD_BUFFERSIZE, LONG, 280),
  CINIT(UPKEEP_INTERVAL_MS, LONG, 281),
  CINIT(CURLU, OBJECTPOINT, 282),
  CINIT(TRAILERFUNCTION, FUNCTIONPOINT, 283),
  CINIT(TRAILERDATA, OBJECTPOINT, 284),
  CINIT(HTTP09_ALLOWED, LONG, 285),
  CINIT(ALTSVC_CTRL, LONG, 286),
  CINIT(ALTSVC, STRINGPOINT, 287),
  CINIT(MAXAGE_CONN, LONG, 288),
  CINIT(SASL_AUTHZID, STRINGPOINT, 289),
  CINIT(MAIL_RCPT_ALLOWFAILS, LONG, 290),
  CINIT(SSLCERT_BLOB, BLOB, 291),
  CINIT(SSLKEY_BLOB, BLOB, 292),
  CINIT(PROXY_SSLCERT_BLOB, BLOB, 293),
  CINIT(PROXY_SSLKEY_BLOB, BLOB, 294),
  CINIT(ISSUERCERT_BLOB, BLOB, 295),
  CINIT(PROXY_ISSUERCERT, STRINGPOINT, 296),
  CINIT(PROXY_ISSUERCERT_BLOB, BLOB, 297),
  CINIT(SSL_EC_CURVES, STRINGPOINT, 298),
  CINIT(HSTS_CTRL, LONG, 299),
  CINIT(HSTS, STRINGPOINT, 300),
  CINIT(HSTSREADFUNCTION, FUNCTIONPOINT, 301),
  CINIT(HSTSREADDATA, OBJECTPOINT, 302),
  CINIT(HSTSWRITEFUNCTION, FUNCTIONPOINT, 303),
  CINIT(HSTSWRITEDATA, OBJECTPOINT, 304),
  CINIT(AWS_SIGV4, STRINGPOINT, 305),
  CINIT(DOH_SSL_VERIFYPEER, LONG, 306),
  CINIT(DOH_SSL_VERIFYHOST, LONG, 307),
  CINIT(DOH_SSL_VERIFYSTATUS, LONG, 308),
  CINIT(CAINFO_BLOB, BLOB, 309),
  CINIT(PROXY_CAINFO_BLOB, BLOB, 310),
  CINIT(SSH_HOST_PUBLIC_KEY_SHA256, STRINGPOINT, 311),
  CINIT(PREREQFUNCTION, FUNCTIONPOINT, 312),
  CINIT(PREREQDATA, OBJECTPOINT, 313),
  CINIT(MAXLIFETIME_CONN, LONG, 314),
  CINIT(MIME_OPTIONS, LONG, 315),
  CINIT(SSH_HOSTKEYFUNCTION, FUNCTIONPOINT, 316),
  CINIT(SSH_HOSTKEYDATA, OBJECTPOINT, 317),
  CINIT(PROTOCOLS_STR, STRINGPOINT, 318),
  CINIT(REDIR_PROTOCOLS_STR, STRINGPOINT, 319),
  CINIT(WS_OPTIONS, LONG, 320),
  CINIT(CA_CACHE_TIMEOUT, LONG, 321),
  CINIT(QUICK_EXIT, LONG, 322),
  CINIT(HAPROXY_CLIENT_IP, STRINGPOINT, 323),
  CINIT(SERVER_RESPONSE_TIMEOUT_MS, LONG, 324),
  CURLOPT_LASTENTRY /* the last unused */
} CURLoption;

typedef enum {
  CURLOPT(CURLMOPT_SOCKETFUNCTION, FUNCTIONPOINT, 1),
  CURLOPT(CURLMOPT_SOCKETDATA, OBJECTPOINT, 2),
  CURLOPT(CURLMOPT_PIPELINING, LONG, 3),
  CURLOPT(CURLMOPT_TIMERFUNCTION, FUNCTIONPOINT, 4),
  CURLOPT(CURLMOPT_TIMERDATA, OBJECTPOINT, 5),
  CURLOPT(CURLMOPT_MAXCONNECTS, LONG, 6),
  CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, LONG, 7),
  CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, LONG, 8),
  CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9),
  CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10),
  CURLOPT(CURLMOPT_PIPELINING_SITE_BL, OBJECTPOINT, 11),
  CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, OBJECTPOINT, 12),
  CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, LONG, 13),
  CURLOPT(CURLMOPT_PUSHFUNCTION, FUNCTIONPOINT, 14),
  CURLOPT(CURLMOPT_PUSHDATA, OBJECTPOINT, 15),
  CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, LONG, 16),
  CURLMOPT_LASTENTRY /* the last unused */
} CURLMoption;

typedef enum {
  CURLSHOPT_NONE,
  CURLSHOPT_SHARE,
  CURLSHOPT_UNSHARE,
  CURLSHOPT_LOCKFUNC,
  CURLSHOPT_UNLOCKFUNC,
  CURLSHOPT_USERDATA,
  CURLSHOPT_LAST  /* never use */
} CURLSHoption;


#undef LONG
#undef OBJECTPOINT
#undef STRINGPOINT
#undef FUNCTIONPOINT
#undef OFF_T
#undef CURLOPT
#undef CINIT

#define SUPER() \
    GO(0)   \
    GO(1)   \
    GO(2)   \
    GO(3)

// write
#define GO(A)   \
static uintptr_t my_write_fct_##A = 0;   \
static size_t my_write_##A(char* ptr, size_t size, size_t nmemb, void* userdata)     \
{                                       \
    return (size_t)RunFunctionFmt(my_write_fct_##A, "pLLp", ptr, size, nmemb, userdata);\
}
SUPER()
#undef GO
static void* find_write_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_write_fct_##A == (uintptr_t)fct) return my_write_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_write_fct_##A == 0) {my_write_fct_##A = (uintptr_t)fct; return my_write_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl write callback\n");
    return NULL;
}

// read
#define GO(A)   \
static uintptr_t my_read_fct_##A = 0;   \
static size_t my_read_##A(char* buffer, size_t size, size_t nitems, void* userdata)     \
{                                       \
    return (size_t)RunFunctionFmt(my_read_fct_##A, "pLLp", buffer, size, nitems, userdata);\
}
SUPER()
#undef GO
static void* find_read_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_read_fct_##A == (uintptr_t)fct) return my_read_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_read_fct_##A == 0) {my_read_fct_##A = (uintptr_t)fct; return my_read_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl read callback\n");
    return NULL;
}

// ioctl
#define GO(A)   \
static uintptr_t my_ioctl_fct_##A = 0;   \
static size_t my_ioctl_##A(void* handle, int32_t fnc, void* userdata)     \
{                                       \
    return (size_t)RunFunctionFmt(my_ioctl_fct_##A, "pip", handle, fnc, userdata);\
}
SUPER()
#undef GO
static void* find_ioctl_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_ioctl_fct_##A == (uintptr_t)fct) return my_ioctl_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_ioctl_fct_##A == 0) {my_ioctl_fct_##A = (uintptr_t)fct; return my_ioctl_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl ioctl callback\n");
    return NULL;
}

// seek
#define GO(A)   \
static uintptr_t my_seek_fct_##A = 0;   \
static int32_t my_seek_##A(void* userdata, int64_t off, int32_t origin)     \
{                                       \
    return (int32_t)RunFunctionFmt(my_seek_fct_##A, "pIi", userdata, off, origin);\
}
SUPER()
#undef GO
static void* find_seek_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_seek_fct_##A == (uintptr_t)fct) return my_seek_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_seek_fct_##A == 0) {my_seek_fct_##A = (uintptr_t)fct; return my_seek_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl seek callback\n");
    return NULL;
}

// header
#define GO(A)   \
static uintptr_t my_header_fct_##A = 0;   \
static size_t my_header_##A(char* buffer, size_t size, size_t nitems, void* userdata)     \
{                                       \
    return (size_t)RunFunctionFmt(my_header_fct_##A, "pLLp", buffer, size, nitems, userdata);\
}
SUPER()
#undef GO
static void* find_header_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_header_fct_##A == (uintptr_t)fct) return my_header_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_header_fct_##A == 0) {my_header_fct_##A = (uintptr_t)fct; return my_header_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl header callback\n");
    return NULL;
}

// progress
#define GO(A)   \
static uintptr_t my_progress_fct_##A = 0;   \
static int my_progress_##A(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)     \
{                                       \
    return (int)RunFunctionFmt(my_progress_fct_##A, "pdddd", clientp, dltotal, dlnow, ultotal, ulnow);\
}
SUPER()
#undef GO
static void* find_progress_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_progress_fct_##A == (uintptr_t)fct) return my_progress_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_progress_fct_##A == 0) {my_progress_fct_##A = (uintptr_t)fct; return my_progress_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl progress callback\n");
    return NULL;
}

// progress_int
#define GO(A)   \
static uintptr_t my_progress_int_fct_##A = 0;   \
static int my_progress_int_##A(void *clientp, uint64_t dltotal, uint64_t dlnow, uint64_t ultotal, uint64_t ulnow)     \
{                                       \
    return (int)RunFunctionFmt(my_progress_int_fct_##A, "pUUUU", clientp, dltotal, dlnow, ultotal, ulnow);\
}
SUPER()
#undef GO
static void* find_progress_int_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_progress_int_fct_##A == (uintptr_t)fct) return my_progress_int_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_progress_int_fct_##A == 0) {my_progress_int_fct_##A = (uintptr_t)fct; return my_progress_int_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl progress_int callback\n");
    return NULL;
}

// socket
#define GO(A)   \
static uintptr_t my_socket_fct_##A = 0;                                         \
static int my_socket_##A(void *a, int b, int c, void* d, void* e)               \
{                                                                               \
    return (int)RunFunctionFmt(my_socket_fct_##A, "piipp", a, b, c, d, e);   \
}
SUPER()
#undef GO
static void* find_socket_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_socket_fct_##A == (uintptr_t)fct) return my_socket_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_socket_fct_##A == 0) {my_socket_fct_##A = (uintptr_t)fct; return my_socket_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl socket callback\n");
    return NULL;
}

// timer
#define GO(A)   \
static uintptr_t my_timer_fct_##A = 0;                                  \
static int my_timer_##A(void *a, long b, void* c)                       \
{                                                                       \
    return (int)RunFunctionFmt(my_timer_fct_##A, "plp", a, b, c);  \
}
SUPER()
#undef GO
static void* find_timer_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_timer_fct_##A == (uintptr_t)fct) return my_timer_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_timer_fct_##A == 0) {my_timer_fct_##A = (uintptr_t)fct; return my_timer_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl timer callback\n");
    return NULL;
}

// push
#define GO(A)   \
static uintptr_t my_push_fct_##A = 0;                                       \
static int my_push_##A(void *a, void* b, size_t c, void* d, void* e)        \
{                                                                           \
    return (int)RunFunctionFmt(my_push_fct_##A, "ppLpp", a, b, c, d, e); \
}
SUPER()
#undef GO
static void* find_push_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_push_fct_##A == (uintptr_t)fct) return my_push_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_push_fct_##A == 0) {my_push_fct_##A = (uintptr_t)fct; return my_push_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl push callback\n");
    return NULL;
}

// debug
#define GO(A)   \
static uintptr_t my_debug_fct_##A = 0;                                          \
static int my_debug_##A(void *a, int b, void* c, size_t d, void* e)             \
{                                                                               \
    return (int)RunFunctionFmt(my_debug_fct_##A, "pipLp", a, b, c, d, e);    \
}
SUPER()
#undef GO
static void* find_debug_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_debug_fct_##A == (uintptr_t)fct) return my_debug_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_debug_fct_##A == 0) {my_debug_fct_##A = (uintptr_t)fct; return my_debug_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl debug callback\n");
    return NULL;
}

// lockcb
#define GO(A)   \
static uintptr_t my_lockcb_fct_##A = 0;                     \
static void my_lockcb_##A(void *a, int b, int c, void* d)   \
{                                                           \
    RunFunctionFmt(my_lockcb_fct_##A, "piip", a, b, c, d);  \
}
SUPER()
#undef GO
static void* find_lockcb_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_lockcb_fct_##A == (uintptr_t)fct) return my_lockcb_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_lockcb_fct_##A == 0) {my_lockcb_fct_##A = (uintptr_t)fct; return my_lockcb_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl lockcb callback\n");
    return NULL;
}

// unlockcb
#define GO(A)   \
static uintptr_t my_unlockcb_fct_##A = 0;                   \
static void my_unlockcb_##A(void *a, int b, void* c)        \
{                                                           \
    RunFunctionFmt(my_unlockcb_fct_##A, "pip", a, b, c);    \
}
SUPER()
#undef GO
static void* find_unlockcb_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_unlockcb_fct_##A == (uintptr_t)fct) return my_unlockcb_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_unlockcb_fct_##A == 0) {my_unlockcb_fct_##A = (uintptr_t)fct; return my_unlockcb_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl unlockcb callback\n");
    return NULL;
}

// ssl_ctx_callback
#define GO(A)   \
static uintptr_t my_ssl_ctx_callback_fct_##A = 0;                               \
static int my_ssl_ctx_callback_##A(void *a, void* b, void* c)                   \
{                                                                               \
    return (int)RunFunctionFmt(my_ssl_ctx_callback_fct_##A, "ppp", a, b, c);    \
}
SUPER()
#undef GO
static void* find_ssl_ctx_callback_Fct(void* fct)
{
    if(!fct) return NULL;
    if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
    #define GO(A) if(my_ssl_ctx_callback_fct_##A == (uintptr_t)fct) return my_ssl_ctx_callback_##A;
    SUPER()
    #undef GO
    #define GO(A) if(my_ssl_ctx_callback_fct_##A == 0) {my_ssl_ctx_callback_fct_##A = (uintptr_t)fct; return my_ssl_ctx_callback_##A; }
    SUPER()
    #undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl ssl_ctx_callback callback\n");
    return NULL;
}

// malloc_callback
#define GO(A)                                                             \
    static uintptr_t my_malloc_callback_fct_##A = 0;                      \
    static void* my_malloc_callback_##A(size_t a)                         \
    {                                                                     \
        return (void*)RunFunctionFmt(my_malloc_callback_fct_##A, "L", a); \
    }
SUPER()
#undef GO
static void* find_malloc_callback_Fct(void* fct)
{
    if (!fct) return NULL;
    if (GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct);
#define GO(A) \
    if (my_malloc_callback_fct_##A == (uintptr_t)fct) return my_malloc_callback_##A;
    SUPER()
#undef GO
#define GO(A)                                        \
    if (my_malloc_callback_fct_##A == 0) {           \
        my_malloc_callback_fct_##A = (uintptr_t)fct; \
        return my_malloc_callback_##A;               \
    }
    SUPER()
#undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl malloc_callback callback\n");
    return NULL;
}

// free_callback
#define GO(A)                                             \
    static uintptr_t my_free_callback_fct_##A = 0;        \
    static void my_free_callback_##A(void* a)             \
    {                                                     \
        RunFunctionFmt(my_free_callback_fct_##A, "p", a); \
    }
SUPER()
#undef GO
static void* find_free_callback_Fct(void* fct)
{
    if (!fct) return NULL;
    if (GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct);
#define GO(A) \
    if (my_free_callback_fct_##A == (uintptr_t)fct) return my_free_callback_##A;
    SUPER()
#undef GO
#define GO(A)                                      \
    if (my_free_callback_fct_##A == 0) {           \
        my_free_callback_fct_##A = (uintptr_t)fct; \
        return my_free_callback_##A;               \
    }
    SUPER()
#undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl free_callback callback\n");
    return NULL;
}

// realloc_callback
#define GO(A)                                                                  \
    static uintptr_t my_realloc_callback_fct_##A = 0;                          \
    static void* my_realloc_callback_##A(void* a, size_t b)                    \
    {                                                                          \
        return (void*)RunFunctionFmt(my_realloc_callback_fct_##A, "pL", a, b); \
    }
SUPER()
#undef GO
static void* find_realloc_callback_Fct(void* fct)
{
    if (!fct) return NULL;
    if (GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct);
#define GO(A) \
    if (my_realloc_callback_fct_##A == (uintptr_t)fct) return my_realloc_callback_##A;
    SUPER()
#undef GO
#define GO(A)                                         \
    if (my_realloc_callback_fct_##A == 0) {           \
        my_realloc_callback_fct_##A = (uintptr_t)fct; \
        return my_realloc_callback_##A;               \
    }
    SUPER()
#undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl realloc_callback callback\n");
    return NULL;
}

// strdup_callback
#define GO(A)                                                             \
    static uintptr_t my_strdup_callback_fct_##A = 0;                      \
    static void* my_strdup_callback_##A(void* a)                          \
    {                                                                     \
        return (void*)RunFunctionFmt(my_strdup_callback_fct_##A, "p", a); \
    }
SUPER()
#undef GO
static void* find_strdup_callback_Fct(void* fct)
{
    if (!fct) return NULL;
    if (GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct);
#define GO(A) \
    if (my_strdup_callback_fct_##A == (uintptr_t)fct) return my_strdup_callback_##A;
    SUPER()
#undef GO
#define GO(A)                                        \
    if (my_strdup_callback_fct_##A == 0) {           \
        my_strdup_callback_fct_##A = (uintptr_t)fct; \
        return my_strdup_callback_##A;               \
    }
    SUPER()
#undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl strdup_callback callback\n");
    return NULL;
}


// calloc_callback
#define GO(A)                                                                 \
    static uintptr_t my_calloc_callback_fct_##A = 0;                          \
    static void* my_calloc_callback_##A(size_t a, size_t b)                   \
    {                                                                         \
        return (void*)RunFunctionFmt(my_calloc_callback_fct_##A, "LL", a, b); \
    }
SUPER()
#undef GO
static void* find_calloc_callback_Fct(void* fct)
{
    if (!fct) return NULL;
    if (GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct);
#define GO(A) \
    if (my_calloc_callback_fct_##A == (uintptr_t)fct) return my_calloc_callback_##A;
    SUPER()
#undef GO
#define GO(A)                                        \
    if (my_calloc_callback_fct_##A == 0) {           \
        my_calloc_callback_fct_##A = (uintptr_t)fct; \
        return my_calloc_callback_##A;               \
    }
    SUPER()
#undef GO
    printf_log(LOG_NONE, "Warning, no more slot for curl calloc_callback callback\n");
    return NULL;
}
#undef SUPER

EXPORT uint32_t my32_curl_easy_setopt(x64emu_t* emu, void* handle, uint32_t option, void* param)
{
    (void)emu;

    switch(option) {
        case CURLOPT_WRITEFUNCTION:
            return my->curl_easy_setopt(handle, option, find_write_Fct(param));
        case CURLOPT_READFUNCTION:
            return my->curl_easy_setopt(handle, option, find_read_Fct(param));
        case CURLOPT_IOCTLFUNCTION:
            return my->curl_easy_setopt(handle, option, find_ioctl_Fct(param));
        case CURLOPT_SEEKFUNCTION:
            return my->curl_easy_setopt(handle, option, find_seek_Fct(param));
        case CURLOPT_HEADERFUNCTION:
            return my->curl_easy_setopt(handle, option, find_header_Fct(param));
        case CURLOPT_PROGRESSFUNCTION:
            return my->curl_easy_setopt(handle, option, find_progress_Fct(param));
        case CURLOPT_XFERINFOFUNCTION:
            return my->curl_easy_setopt(handle, option, find_progress_int_Fct(param));
        case CURLOPT_DEBUGFUNCTION:
            return my->curl_easy_setopt(handle, option, find_debug_Fct(param));
        case CURLOPT_SSL_CTX_FUNCTION:
            return my->curl_easy_setopt(handle, option, find_ssl_ctx_callback_Fct(param));
        case CURLOPT_SSL_CTX_DATA:
            return my->curl_easy_setopt(handle, option, param);
        case CURLOPT_SOCKOPTFUNCTION:
        case CURLOPT_OPENSOCKETFUNCTION:
        case CURLOPT_CLOSESOCKETFUNCTION:
        case CURLOPT_CONV_TO_NETWORK_FUNCTION:
        case CURLOPT_CONV_FROM_NETWORK_FUNCTION:
        case CURLOPT_CONV_FROM_UTF8_FUNCTION:
        case CURLOPT_INTERLEAVEFUNCTION:
        case CURLOPT_CHUNK_BGN_FUNCTION:
        case CURLOPT_CHUNK_END_FUNCTION:
        case CURLOPT_FNMATCH_FUNCTION:
        case CURLOPT_RESOLVER_START_FUNCTION:
        case CURLOPT_TRAILERFUNCTION:
        case CURLOPT_HSTSREADFUNCTION:
        case CURLOPT_HSTSWRITEFUNCTION:
        case CURLOPT_PREREQFUNCTION:
        case CURLOPT_SSH_HOSTKEYFUNCTION:
            printf_log(LOG_NONE, "Error: unimplemented option %u in curl_easy_setopt\n", option);
            return 48; //unknown option...
        default:
            return my->curl_easy_setopt(handle, option, param);
    }
}

EXPORT uint32_t my32_curl_multi_setopt(x64emu_t* emu, void* handle, uint32_t option, void* param)
{
    (void)emu;

    switch(option) {
        case CURLMOPT_SOCKETFUNCTION:
            return my->curl_multi_setopt(handle, option, find_socket_Fct(param));
        case CURLMOPT_TIMERFUNCTION:
            return my->curl_multi_setopt(handle, option, find_timer_Fct(param));
        case CURLMOPT_PUSHFUNCTION:
            return my->curl_multi_setopt(handle, option, find_push_Fct(param));
        default:
            return my->curl_multi_setopt(handle, option, param);
    }
}

EXPORT uint32_t my32_curl_share_setopt(x64emu_t* emu, void* handle, CURLSHoption option, void* param)
{
    switch(option) {
        case CURLSHOPT_LOCKFUNC:
            return my->curl_share_setopt(handle, option, find_lockcb_Fct(param));
        case CURLSHOPT_UNLOCKFUNC:
            return my->curl_share_setopt(handle, option, find_unlockcb_Fct(param));
        default:
            return my->curl_share_setopt(handle, option, param);
    }
}

EXPORT int my32_curl_global_init_mem(x64emu_t* emu, long flags, void* m, void* f, void* r, void* s, void* c)
{
    return my->curl_global_init_mem(flags,
        find_malloc_callback_Fct(m),
        find_free_callback_Fct(f),
        find_realloc_callback_Fct(r),
        find_strdup_callback_Fct(s),
        find_calloc_callback_Fct(c));
}

#include "wrappedlib_init32.h"
