From efa06dc0cac58e398feea975403f5149c4f6a792 Mon Sep 17 00:00:00 2001 From: luoliangyi <87842688@qq.com> Date: Wed, 11 May 2022 19:06:03 +0800 Subject: [PATCH] =?UTF-8?q?=E7=BC=96=E8=AF=91=EF=BD=8D=EF=BD=89=EF=BD=90?= =?UTF-8?q?=EF=BD=93=EF=BC=96=EF=BC=94=E7=89=88=E6=9C=AC=E7=9A=84=EF=BD=8C?= =?UTF-8?q?=EF=BD=89=EF=BD=82=EF=BD=83=EF=BD=95=EF=BD=92=EF=BD=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../libcurl/uos/mips64/include/curl/curl.h | 3090 +++++++++++++++++ .../libcurl/uos/mips64/include/curl/curlver.h | 77 + .../libcurl/uos/mips64/include/curl/easy.h | 123 + .../libcurl/uos/mips64/include/curl/mprintf.h | 50 + .../libcurl/uos/mips64/include/curl/multi.h | 457 +++ .../libcurl/uos/mips64/include/curl/options.h | 68 + .../uos/mips64/include/curl/stdcheaders.h | 33 + .../libcurl/uos/mips64/include/curl/system.h | 488 +++ .../uos/mips64/include/curl/typecheck-gcc.h | 707 ++++ .../libcurl/uos/mips64/include/curl/urlapi.h | 145 + third_party/libcurl/uos/mips64/lib/libcurl.a | Bin 0 -> 1264654 bytes third_party/libcurl/uos/mips64/lib/libcurl.la | 41 + .../uos/mips64/lib/pkgconfig/libcurl.pc | 39 + 13 files changed, 5318 insertions(+) create mode 100644 third_party/libcurl/uos/mips64/include/curl/curl.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/curlver.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/easy.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/mprintf.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/multi.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/options.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/stdcheaders.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/system.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/typecheck-gcc.h create mode 100644 third_party/libcurl/uos/mips64/include/curl/urlapi.h create mode 100644 third_party/libcurl/uos/mips64/lib/libcurl.a create mode 100755 third_party/libcurl/uos/mips64/lib/libcurl.la create mode 100644 third_party/libcurl/uos/mips64/lib/pkgconfig/libcurl.pc diff --git a/third_party/libcurl/uos/mips64/include/curl/curl.h b/third_party/libcurl/uos/mips64/include/curl/curl.h new file mode 100644 index 00000000..2e260d51 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/curl.h @@ -0,0 +1,3090 @@ +#ifndef CURLINC_CURL_H +#define CURLINC_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * https://curl.se/libcurl/ + */ + +#ifdef CURL_NO_OLDIES +#define CURL_STRICTER +#endif + +#include "curlver.h" /* libcurl version defines */ +#include "system.h" /* determine things run-time */ + +/* + * Define CURL_WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && \ + !defined(__SYMBIAN32__) +#define CURL_WIN32 +#endif + +#include +#include + +#if (defined(__FreeBSD__) && (__FreeBSD__ >= 2)) || defined(__MidnightBSD__) +/* Needed for __FreeBSD_version or __MidnightBSD_version symbol definition */ +#include +#endif + +/* The include stuff here below is mainly for time_t! */ +#include +#include + +#if defined(CURL_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || \ + defined(__LWIP_OPT_H__) || defined(LWIP_HDR_OPT_H)) +/* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ +#include +#include +#endif +#endif + +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish + libc5-based Linux systems. Only include it on systems that are known to + require it! */ +#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ + defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \ + defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ + defined(__CYGWIN__) || defined(AMIGA) || defined(__NuttX__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) || \ + (defined(__MidnightBSD_version) && (__MidnightBSD_version < 100000)) +#include +#endif + +#if !defined(CURL_WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(CURL_WIN32) +#include +#endif + +/* Compatibility for non-Clang compilers */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_easy CURL; +typedef struct Curl_share CURLSH; +#else +typedef void CURL; +typedef void CURLSH; +#endif + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(CURL_WIN32) || defined(__SYMBIAN32__) || \ + (__has_declspec_attribute(dllexport) && \ + __has_declspec_attribute(dllimport)) +# if defined(BUILDING_LIBCURL) +# define CURL_EXTERN __declspec(dllexport) +# else +# define CURL_EXTERN __declspec(dllimport) +# endif +#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) +# define CURL_EXTERN CURL_EXTERN_SYMBOL +#else +# define CURL_EXTERN +#endif + +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(CURL_WIN32) && !defined(__LWIP_OPT_H__) && !defined(LWIP_HDR_OPT_H) +typedef SOCKET curl_socket_t; +#define CURL_SOCKET_BAD INVALID_SOCKET +#else +typedef int curl_socket_t; +#define CURL_SOCKET_BAD -1 +#endif +#define curl_socket_typedef +#endif /* curl_socket_typedef */ + +/* enum for the different supported SSL backends */ +typedef enum { + CURLSSLBACKEND_NONE = 0, + CURLSSLBACKEND_OPENSSL = 1, + CURLSSLBACKEND_GNUTLS = 2, + CURLSSLBACKEND_NSS = 3, + CURLSSLBACKEND_OBSOLETE4 = 4, /* Was QSOSSL. */ + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_WOLFSSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_SECURETRANSPORT = 9, + CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */ + CURLSSLBACKEND_MBEDTLS = 11, + CURLSSLBACKEND_MESALINK = 12, + CURLSSLBACKEND_BEARSSL = 13, + CURLSSLBACKEND_RUSTLS = 14 +} curl_sslbackend; + +/* aliases for library clones and renames */ +#define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL +#define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL + +/* deprecated names: */ +#define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL +#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT + +struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ + long contentslength; /* length of contents field, see also + CURL_HTTPPOST_LARGE */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ + struct curl_slist *contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ + +/* specified content is a file name */ +#define CURL_HTTPPOST_FILENAME (1<<0) +/* specified content is a file name */ +#define CURL_HTTPPOST_READFILE (1<<1) +/* name is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRNAME (1<<2) +/* contents is only stored pointer do not free in formfree */ +#define CURL_HTTPPOST_PTRCONTENTS (1<<3) +/* upload file from buffer */ +#define CURL_HTTPPOST_BUFFER (1<<4) +/* upload file from pointer contents */ +#define CURL_HTTPPOST_PTRBUFFER (1<<5) +/* upload file contents by using the regular read callback to get the data and + pass the given pointer as custom pointer */ +#define CURL_HTTPPOST_CALLBACK (1<<6) +/* use size in 'contentlen', added in 7.46.0 */ +#define CURL_HTTPPOST_LARGE (1<<7) + + char *showfilename; /* The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ + void *userp; /* custom pointer used for + HTTPPOST_CALLBACK posts */ + curl_off_t contentlen; /* alternative length of contents + field. Used if CURL_HTTPPOST_LARGE is + set. Added in 7.46.0 */ +}; + + +/* This is a return code for the progress callback that, when returned, will + signal libcurl to continue executing the default progress function */ +#define CURL_PROGRESSFUNC_CONTINUE 0x10000001 + +/* This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now + considered deprecated but was the only choice up until 7.31.0 */ +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + +/* This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced + in 7.32.0, avoids the use of floating point numbers and provides more + detailed information. */ +typedef int (*curl_xferinfo_callback)(void *clientp, + curl_off_t dltotal, + curl_off_t dlnow, + curl_off_t ultotal, + curl_off_t ulnow); + +#ifndef CURL_MAX_READ_SIZE + /* The maximum receive buffer size configurable via CURLOPT_BUFFERSIZE. */ +#define CURL_MAX_READ_SIZE 524288 +#endif + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very bad buffer size for uploads on + Windows, while 16K for some odd reason performed a lot better. + We do the ifndef check to allow this value to easier be changed at build + time for those who feel adventurous. The practical minimum is about + 400 bytes since libcurl uses a buffer of this size as a scratch area + (unrelated to network send operations). */ +#define CURL_MAX_WRITE_SIZE 16384 +#endif + +#ifndef CURL_MAX_HTTP_HEADER +/* The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ +#define CURL_MAX_HTTP_HEADER (100*1024) +#endif + +/* This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ +#define CURL_WRITEFUNC_PAUSE 0x10000001 + +typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + +/* This callback will be called when a new resolver request is made */ +typedef int (*curl_resolver_start_callback)(void *resolver_state, + void *reserved, void *userdata); + +/* enumeration of file types */ +typedef enum { + CURLFILETYPE_FILE = 0, + CURLFILETYPE_DIRECTORY, + CURLFILETYPE_SYMLINK, + CURLFILETYPE_DEVICE_BLOCK, + CURLFILETYPE_DEVICE_CHAR, + CURLFILETYPE_NAMEDPIPE, + CURLFILETYPE_SOCKET, + CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ + + CURLFILETYPE_UNKNOWN /* should never occur */ +} curlfiletype; + +#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) +#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) +#define CURLFINFOFLAG_KNOWN_TIME (1<<2) +#define CURLFINFOFLAG_KNOWN_PERM (1<<3) +#define CURLFINFOFLAG_KNOWN_UID (1<<4) +#define CURLFINFOFLAG_KNOWN_GID (1<<5) +#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) +#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) + +/* Information about a single file, used when doing FTP wildcard matching */ +struct curl_fileinfo { + char *filename; + curlfiletype filetype; + time_t time; /* always zero! */ + unsigned int perm; + int uid; + int gid; + curl_off_t size; + long int hardlinks; + + struct { + /* If some of these fields is not NULL, it is a pointer to b_data. */ + char *time; + char *perm; + char *user; + char *group; + char *target; /* pointer to the target filename of a symlink */ + } strings; + + unsigned int flags; + + /* used internally */ + char *b_data; + size_t b_size; + size_t b_used; +}; + +/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ +#define CURL_CHUNK_BGN_FUNC_OK 0 +#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ +#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ + +/* if splitting of data transfer is enabled, this callback is called before + download of an individual chunk started. Note that parameter "remains" works + only for FTP wildcard downloading (for now), otherwise is not used */ +typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, + void *ptr, + int remains); + +/* return codes for CURLOPT_CHUNK_END_FUNCTION */ +#define CURL_CHUNK_END_FUNC_OK 0 +#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ + +/* If splitting of data transfer is enabled this callback is called after + download of an individual chunk finished. + Note! After this callback was set then it have to be called FOR ALL chunks. + Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. + This is the reason why we don't need "transfer_info" parameter in this + callback and we are not interested in "remains" parameter too. */ +typedef long (*curl_chunk_end_callback)(void *ptr); + +/* return codes for FNMATCHFUNCTION */ +#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ +#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */ +#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ + +/* callback type for wildcard downloading pattern matching. If the + string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ +typedef int (*curl_fnmatch_callback)(void *ptr, + const char *pattern, + const char *string); + +/* These are the return codes for the seek callbacks */ +#define CURL_SEEKFUNC_OK 0 +#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ +#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so + libcurl might try other means instead */ +typedef int (*curl_seek_callback)(void *instream, + curl_off_t offset, + int origin); /* 'whence' */ + +/* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ +#define CURL_READFUNC_ABORT 0x10000000 +/* This is a return code for the read callback that, when returned, will + signal libcurl to pause sending data on the current transfer. */ +#define CURL_READFUNC_PAUSE 0x10000001 + +/* Return code for when the trailing headers' callback has terminated + without any errors*/ +#define CURL_TRAILERFUNC_OK 0 +/* Return code for when was an error in the trailing header's list and we + want to abort the request */ +#define CURL_TRAILERFUNC_ABORT 1 + +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +typedef int (*curl_trailer_callback)(struct curl_slist **list, + void *userdata); + +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ + CURLSOCKTYPE_LAST /* never use */ +} curlsocktype; + +/* The return code from the sockopt_callback can signal information back + to libcurl: */ +#define CURL_SOCKOPT_OK 0 +#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return + CURLE_ABORTED_BY_CALLBACK */ +#define CURL_SOCKOPT_ALREADY_CONNECTED 2 + +typedef int (*curl_sockopt_callback)(void *clientp, + curl_socket_t curlfd, + curlsocktype purpose); + +struct curl_sockaddr { + int family; + int socktype; + int protocol; + unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it + turned really ugly and painful on the systems that + lack this type */ + struct sockaddr addr; +}; + +typedef curl_socket_t +(*curl_opensocket_callback)(void *clientp, + curlsocktype purpose, + struct curl_sockaddr *address); + +typedef int +(*curl_closesocket_callback)(void *clientp, curl_socket_t item); + +typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ +} curlioerr; + +typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ +} curliocmd; + +typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + +#ifndef CURL_DID_MEMORY_FUNC_TYPEDEFS +/* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ +typedef void *(*curl_malloc_callback)(size_t size); +typedef void (*curl_free_callback)(void *ptr); +typedef void *(*curl_realloc_callback)(void *ptr, size_t size); +typedef char *(*curl_strdup_callback)(const char *str); +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + +#define CURL_DID_MEMORY_FUNC_TYPEDEFS +#endif + +/* the kind of data that is passed to information_callback*/ +typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ + CURLINFO_SSL_DATA_OUT, /* 6 */ + CURLINFO_END +} curl_infotype; + +typedef int (*curl_debug_callback) + (CURL *handle, /* the handle/transfer this concerns */ + curl_infotype type, /* what kind of data */ + char *data, /* points to the data */ + size_t size, /* size of the data pointed to */ + void *userptr); /* whatever the user please */ + +/* This is the CURLOPT_PREREQFUNCTION callback prototype. */ +typedef int (*curl_prereq_callback)(void *clientp, + char *conn_primary_ip, + char *conn_local_ip, + int conn_primary_port, + int conn_local_port); + +/* Return code for when the pre-request callback has terminated without + any errors */ +#define CURL_PREREQFUNC_OK 0 +/* Return code for when the pre-request callback wants to abort the + request */ +#define CURL_PREREQFUNC_ABORT 1 + +/* All possible error codes from all sorts of curl functions. Future versions + may return other values, stay prepared. + + Always add new return codes last. Never *EVER* remove any. The return + codes must remain the same! + */ + +typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ + CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for + 7.17.0, reused in April 2011 for 7.21.5] */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ + CURLE_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ + CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for + 7.15.4, reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server + [was obsoleted in August 2007 for 7.17.0, + reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_HTTP2, /* 16 - A problem in the http2 framing layer. + [was obsoleted in August 2007 for 7.17.0, + reused in July 2014 for 7.38.0] */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_OBSOLETE24, /* 24 - NOT USED */ + CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ + CURLE_READ_ERROR, /* 26 - couldn't open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ + CURLE_OBSOLETE29, /* 29 - NOT USED */ + CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ + CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ + CURLE_OBSOLETE32, /* 32 - NOT USED */ + CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_FUNCTION_NOT_FOUND, /* 41 - NOT USED starting with 7.53.0 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ + CURLE_TOO_MANY_REDIRECTS, /* 47 - catch endless re-direct loops */ + CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ + CURLE_SETOPT_OPTION_SYNTAX, /* 49 - Malformed setopt option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_OBSOLETE51, /* 51 - NOT USED */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_OBSOLETE57, /* 57 - NOT IN USE */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ + CURLE_PEER_FAILED_VERIFICATION, /* 60 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_OBSOLETE62, /* 62 - NOT IN USE since 7.82.0 */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ + CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ + CURLE_TFTP_PERM, /* 69 - permission problem on server */ + CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ + CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ + CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ + CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ + CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ + CURLE_CONV_FAILED, /* 75 - conversion failed */ + CURLE_OBSOLETE76, /* 76 - NOT IN USE since 7.82.0 */ + CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing + or wrong format */ + CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ + CURLE_SSH, /* 79 - error from the SSH layer, somewhat + generic so the error message will be of + interest when this has happened */ + + CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL + connection */ + CURLE_AGAIN, /* 81 - socket is not ready for send/recv, + wait till it's ready and try again (Added + in 7.18.2) */ + CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or + wrong format (Added in 7.19.0) */ + CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in + 7.19.0) */ + CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ + CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ + CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ + CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ + CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ + CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the + session will be queued */ + CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not + match */ + CURLE_SSL_INVALIDCERTSTATUS, /* 91 - invalid certificate status */ + CURLE_HTTP2_STREAM, /* 92 - stream error in HTTP/2 framing layer + */ + CURLE_RECURSIVE_API_CALL, /* 93 - an api function was called from + inside a callback */ + CURLE_AUTH_ERROR, /* 94 - an authentication function returned an + error */ + CURLE_HTTP3, /* 95 - An HTTP/3 layer problem */ + CURLE_QUIC_CONNECT_ERROR, /* 96 - QUIC connection error */ + CURLE_PROXY, /* 97 - proxy handshake error */ + CURLE_SSL_CLIENTCERT, /* 98 - client-side certificate required */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsolete error code re-used in 7.38.0 */ +#define CURLE_OBSOLETE16 CURLE_HTTP2 + +/* Previously obsolete error codes re-used in 7.24.0 */ +#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED +#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT + +/* compatibility with older names */ +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING +#define CURLE_FTP_WEIRD_SERVER_REPLY CURLE_WEIRD_SERVER_REPLY + +/* The following were added in 7.62.0 */ +#define CURLE_SSL_CACERT CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.21.5, April 2011 */ +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + +/* Added for 7.78.0 */ +#define CURLE_TELNET_OPTION_SYNTAX CURLE_SETOPT_OPTION_SYNTAX + +/* The following were added in 7.17.1 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.17.0 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ +#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 +#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 +#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 +#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 +#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 +#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 +#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 +#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 +#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 +#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 +#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 +#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN + +#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED +#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE +#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR +#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL +#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS +#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR +#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED + +/* The following were added earlier */ + +#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED +#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME +#define CURLE_LDAP_INVALID_URL CURLE_OBSOLETE62 +#define CURLE_CONV_REQD CURLE_OBSOLETE76 + +/* This was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ +#define CURLE_ALREADY_COMPLETE 99999 + +/* Provide defines for really old option names */ +#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */ +#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */ +#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA + +/* Since long deprecated options with no code in the lib that does anything + with them. */ +#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40 +#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72 + +#endif /*!CURL_NO_OLDIES*/ + +/* + * Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was + * return for the transfers. + */ +typedef enum { + CURLPX_OK, + CURLPX_BAD_ADDRESS_TYPE, + CURLPX_BAD_VERSION, + CURLPX_CLOSED, + CURLPX_GSSAPI, + CURLPX_GSSAPI_PERMSG, + CURLPX_GSSAPI_PROTECTION, + CURLPX_IDENTD, + CURLPX_IDENTD_DIFFER, + CURLPX_LONG_HOSTNAME, + CURLPX_LONG_PASSWD, + CURLPX_LONG_USER, + CURLPX_NO_AUTH, + CURLPX_RECV_ADDRESS, + CURLPX_RECV_AUTH, + CURLPX_RECV_CONNECT, + CURLPX_RECV_REQACK, + CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED, + CURLPX_REPLY_COMMAND_NOT_SUPPORTED, + CURLPX_REPLY_CONNECTION_REFUSED, + CURLPX_REPLY_GENERAL_SERVER_FAILURE, + CURLPX_REPLY_HOST_UNREACHABLE, + CURLPX_REPLY_NETWORK_UNREACHABLE, + CURLPX_REPLY_NOT_ALLOWED, + CURLPX_REPLY_TTL_EXPIRED, + CURLPX_REPLY_UNASSIGNED, + CURLPX_REQUEST_FAILED, + CURLPX_RESOLVE_HOST, + CURLPX_SEND_AUTH, + CURLPX_SEND_CONNECT, + CURLPX_SEND_REQUEST, + CURLPX_UNKNOWN_FAIL, + CURLPX_UNKNOWN_MODE, + CURLPX_USER_REJECTED, + CURLPX_LAST /* never use */ +} CURLproxycode; + +/* This prototype applies to all conversion callbacks */ +typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); + +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an OpenSSL + or WolfSSL SSL_CTX, + or an mbedTLS + mbedtls_ssl_config */ + void *userptr); + +typedef enum { + CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use + CONNECT HTTP/1.1 */ + CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT + HTTP/1.0 */ + CURLPROXY_HTTPS = 2, /* added in 7.52.0 */ + CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already + in 7.10 */ + CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ + CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ + CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the + host name rather than the IP address. added + in 7.18.0 */ +} curl_proxytype; /* this enum was added in 7.10 */ + +/* + * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: + * + * CURLAUTH_NONE - No HTTP authentication + * CURLAUTH_BASIC - HTTP Basic authentication (default) + * CURLAUTH_DIGEST - HTTP Digest authentication + * CURLAUTH_NEGOTIATE - HTTP Negotiate (SPNEGO) authentication + * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated) + * CURLAUTH_NTLM - HTTP NTLM authentication + * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour + * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper + * CURLAUTH_BEARER - HTTP Bearer token authentication + * CURLAUTH_ONLY - Use together with a single other type to force no + * authentication or just that single type + * CURLAUTH_ANY - All fine types set + * CURLAUTH_ANYSAFE - All fine types except Basic + */ + +#define CURLAUTH_NONE ((unsigned long)0) +#define CURLAUTH_BASIC (((unsigned long)1)<<0) +#define CURLAUTH_DIGEST (((unsigned long)1)<<1) +#define CURLAUTH_NEGOTIATE (((unsigned long)1)<<2) +/* Deprecated since the advent of CURLAUTH_NEGOTIATE */ +#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE +/* Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct */ +#define CURLAUTH_GSSAPI CURLAUTH_NEGOTIATE +#define CURLAUTH_NTLM (((unsigned long)1)<<3) +#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#define CURLAUTH_BEARER (((unsigned long)1)<<6) +#define CURLAUTH_AWS_SIGV4 (((unsigned long)1)<<7) +#define CURLAUTH_ONLY (((unsigned long)1)<<31) +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) +#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) + +#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ +#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ +#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ +#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ +#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ +#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ +#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ +#define CURLSSH_AUTH_GSSAPI (1<<5) /* gssapi (kerberos, ...) */ +#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY + +#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ +#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ +#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ + +#define CURL_ERROR_SIZE 256 + +enum curl_khtype { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS, + CURLKHTYPE_ECDSA, + CURLKHTYPE_ED25519 +}; + +struct curl_khkey { + const char *key; /* points to a null-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; + enum curl_khtype keytype; +}; + +/* this is the set of return values expected from the curl_sshkeycallback + callback */ +enum curl_khstat { + CURLKHSTAT_FINE_ADD_TO_FILE, + CURLKHSTAT_FINE, + CURLKHSTAT_REJECT, /* reject the connection, return an error */ + CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + CURLKHSTAT_FINE_REPLACE, /* accept and replace the wrong key*/ + CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */ +}; + +/* this is the set of status codes pass in to the callback */ +enum curl_khmatch { + CURLKHMATCH_OK, /* match */ + CURLKHMATCH_MISMATCH, /* host found, key mismatch! */ + CURLKHMATCH_MISSING, /* no matching host/key found */ + CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */ +}; + +typedef int + (*curl_sshkeycallback) (CURL *easy, /* easy handle */ + const struct curl_khkey *knownkey, /* known */ + const struct curl_khkey *foundkey, /* found */ + enum curl_khmatch, /* libcurl's view on the keys */ + void *clientp); /* custom pointer passed from app */ + +/* parameter for the CURLOPT_USE_SSL option */ +typedef enum { + CURLUSESSL_NONE, /* do not attempt to use SSL */ + CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ + CURLUSESSL_ALL, /* SSL for all communication or fail */ + CURLUSESSL_LAST /* not an option, never use */ +} curl_usessl; + +/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ + +/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the + name of improving interoperability with older servers. Some SSL libraries + have introduced work-arounds for this flaw but those work-arounds sometimes + make the SSL communication fail. To regain functionality with those broken + servers, a user can this way allow the vulnerability back. */ +#define CURLSSLOPT_ALLOW_BEAST (1<<0) + +/* - NO_REVOKE tells libcurl to disable certificate revocation checks for those + SSL backends where such behavior is present. */ +#define CURLSSLOPT_NO_REVOKE (1<<1) + +/* - NO_PARTIALCHAIN tells libcurl to *NOT* accept a partial certificate chain + if possible. The OpenSSL backend has this ability. */ +#define CURLSSLOPT_NO_PARTIALCHAIN (1<<2) + +/* - REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline + checks and ignore missing revocation list for those SSL backends where such + behavior is present. */ +#define CURLSSLOPT_REVOKE_BEST_EFFORT (1<<3) + +/* - CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of + operating system. Currently implemented under MS-Windows. */ +#define CURLSSLOPT_NATIVE_CA (1<<4) + +/* - CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use + a client certificate for authentication. (Schannel) */ +#define CURLSSLOPT_AUTO_CLIENT_CERT (1<<5) + +/* The default connection attempt delay in milliseconds for happy eyeballs. + CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document + this value, keep them in sync. */ +#define CURL_HET_DEFAULT 200L + +/* The default connection upkeep interval in milliseconds. */ +#define CURL_UPKEEP_INTERVAL_DEFAULT 60000L + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2009 */ + +#define CURLFTPSSL_NONE CURLUSESSL_NONE +#define CURLFTPSSL_TRY CURLUSESSL_TRY +#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL +#define CURLFTPSSL_ALL CURLUSESSL_ALL +#define CURLFTPSSL_LAST CURLUSESSL_LAST +#define curl_ftpssl curl_usessl +#endif /*!CURL_NO_OLDIES*/ + +/* parameter for the CURLOPT_FTP_SSL_CCC option */ +typedef enum { + CURLFTPSSL_CCC_NONE, /* do not send CCC */ + CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ + CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ + CURLFTPSSL_CCC_LAST /* not an option, never use */ +} curl_ftpccc; + +/* parameter for the CURLOPT_FTPSSLAUTH option */ +typedef enum { + CURLFTPAUTH_DEFAULT, /* let libcurl decide */ + CURLFTPAUTH_SSL, /* use "AUTH SSL" */ + CURLFTPAUTH_TLS, /* use "AUTH TLS" */ + CURLFTPAUTH_LAST /* not an option, never use */ +} curl_ftpauth; + +/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ +typedef enum { + CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */ + CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD + again if MKD succeeded, for SFTP this does + similar magic */ + CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD + again even if MKD failed! */ + CURLFTP_CREATE_DIR_LAST /* not an option, never use */ +} curl_ftpcreatedir; + +/* parameter for the CURLOPT_FTP_FILEMETHOD option */ +typedef enum { + CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ + CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ + CURLFTPMETHOD_NOCWD, /* no CWD at all */ + CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ + CURLFTPMETHOD_LAST /* not an option, never use */ +} curl_ftpmethod; + +/* bitmask defines for CURLOPT_HEADEROPT */ +#define CURLHEADER_UNIFIED 0 +#define CURLHEADER_SEPARATE (1<<0) + +/* CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option */ +#define CURLALTSVC_READONLYFILE (1<<2) +#define CURLALTSVC_H1 (1<<3) +#define CURLALTSVC_H2 (1<<4) +#define CURLALTSVC_H3 (1<<5) + + +struct curl_hstsentry { + char *name; + size_t namelen; + unsigned int includeSubDomains:1; + char expire[18]; /* YYYYMMDD HH:MM:SS [null-terminated] */ +}; + +struct curl_index { + size_t index; /* the provided entry's "index" or count */ + size_t total; /* total number of entries to save */ +}; + +typedef enum { + CURLSTS_OK, + CURLSTS_DONE, + CURLSTS_FAIL +} CURLSTScode; + +typedef CURLSTScode (*curl_hstsread_callback)(CURL *easy, + struct curl_hstsentry *e, + void *userp); +typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy, + struct curl_hstsentry *e, + struct curl_index *i, + void *userp); + +/* CURLHSTS_* are bits for the CURLOPT_HSTS option */ +#define CURLHSTS_ENABLE (long)(1<<0) +#define CURLHSTS_READONLYFILE (long)(1<<1) + +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +#define CURLPROTO_HTTP (1<<0) +#define CURLPROTO_HTTPS (1<<1) +#define CURLPROTO_FTP (1<<2) +#define CURLPROTO_FTPS (1<<3) +#define CURLPROTO_SCP (1<<4) +#define CURLPROTO_SFTP (1<<5) +#define CURLPROTO_TELNET (1<<6) +#define CURLPROTO_LDAP (1<<7) +#define CURLPROTO_LDAPS (1<<8) +#define CURLPROTO_DICT (1<<9) +#define CURLPROTO_FILE (1<<10) +#define CURLPROTO_TFTP (1<<11) +#define CURLPROTO_IMAP (1<<12) +#define CURLPROTO_IMAPS (1<<13) +#define CURLPROTO_POP3 (1<<14) +#define CURLPROTO_POP3S (1<<15) +#define CURLPROTO_SMTP (1<<16) +#define CURLPROTO_SMTPS (1<<17) +#define CURLPROTO_RTSP (1<<18) +#define CURLPROTO_RTMP (1<<19) +#define CURLPROTO_RTMPT (1<<20) +#define CURLPROTO_RTMPE (1<<21) +#define CURLPROTO_RTMPTE (1<<22) +#define CURLPROTO_RTMPS (1<<23) +#define CURLPROTO_RTMPTS (1<<24) +#define CURLPROTO_GOPHER (1<<25) +#define CURLPROTO_SMB (1<<26) +#define CURLPROTO_SMBS (1<<27) +#define CURLPROTO_MQTT (1<<28) +#define CURLPROTO_GOPHERS (1<<29) +#define CURLPROTO_ALL (~0) /* enable everything */ + +/* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +#define CURLOPTTYPE_LONG 0 +#define CURLOPTTYPE_OBJECTPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 +#define CURLOPTTYPE_BLOB 40000 + +/* *STRINGPOINT is an alias for OBJECTPOINT to allow tools to extract the + string options from the header file */ + + +#define CURLOPT(na,t,nu) na = t + nu + +/* CURLOPT aliases that make no run-time difference */ + +/* 'char *' argument to a string with a trailing zero */ +#define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'struct curl_slist *' argument */ +#define CURLOPTTYPE_SLISTPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'void *' argument passed untouched to callback */ +#define CURLOPTTYPE_CBPOINT CURLOPTTYPE_OBJECTPOINT + +/* 'long' argument with a set of values/bitmask */ +#define CURLOPTTYPE_VALUES CURLOPTTYPE_LONG + +/* + * All CURLOPT_* values. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CURLOPT(CURLOPT_WRITEDATA, CURLOPTTYPE_CBPOINT, 1), + + /* The full URL to get/put */ + CURLOPT(CURLOPT_URL, CURLOPTTYPE_STRINGPOINT, 2), + + /* Port number to connect to, if other than default. */ + CURLOPT(CURLOPT_PORT, CURLOPTTYPE_LONG, 3), + + /* Name of proxy to use. */ + CURLOPT(CURLOPT_PROXY, CURLOPTTYPE_STRINGPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CURLOPT(CURLOPT_USERPWD, CURLOPTTYPE_STRINGPOINT, 5), + + /* "user:password" to use with proxy. */ + CURLOPT(CURLOPT_PROXYUSERPWD, CURLOPTTYPE_STRINGPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CURLOPT(CURLOPT_RANGE, CURLOPTTYPE_STRINGPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CURLOPT(CURLOPT_READDATA, CURLOPTTYPE_CBPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. */ + CURLOPT(CURLOPT_ERRORBUFFER, CURLOPTTYPE_OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_WRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_READFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CURLOPT(CURLOPT_TIMEOUT, CURLOPTTYPE_LONG, 13), + + /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was successful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CURLOPT(CURLOPT_INFILESIZE, CURLOPTTYPE_LONG, 14), + + /* POST static input fields. */ + CURLOPT(CURLOPT_POSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CURLOPT(CURLOPT_REFERER, CURLOPTTYPE_STRINGPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CURLOPT(CURLOPT_FTPPORT, CURLOPTTYPE_STRINGPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CURLOPT(CURLOPT_USERAGENT, CURLOPTTYPE_STRINGPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ + CURLOPT(CURLOPT_LOW_SPEED_LIMIT, CURLOPTTYPE_LONG, 19), + + /* Set the "low speed time" */ + CURLOPT(CURLOPT_LOW_SPEED_TIME, CURLOPTTYPE_LONG, 20), + + /* Set the continuation offset. + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CURLOPT(CURLOPT_RESUME_FROM, CURLOPTTYPE_LONG, 21), + + /* Set cookie in request: */ + CURLOPT(CURLOPT_COOKIE, CURLOPTTYPE_STRINGPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind. This + list is also used for RTSP (in spite of its name) */ + CURLOPT(CURLOPT_HTTPHEADER, CURLOPTTYPE_SLISTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CURLOPT(CURLOPT_HTTPPOST, CURLOPTTYPE_OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CURLOPT(CURLOPT_SSLCERT, CURLOPTTYPE_STRINGPOINT, 25), + + /* password for the SSL or SSH private key */ + CURLOPT(CURLOPT_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 26), + + /* send TYPE parameter? */ + CURLOPT(CURLOPT_CRLF, CURLOPTTYPE_LONG, 27), + + /* send linked-list of QUOTE commands */ + CURLOPT(CURLOPT_QUOTE, CURLOPTTYPE_SLISTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CURLOPT(CURLOPT_HEADERDATA, CURLOPTTYPE_CBPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CURLOPT(CURLOPT_COOKIEFILE, CURLOPTTYPE_STRINGPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_SSLVERSION, CURLOPTTYPE_VALUES, 32), + + /* What kind of HTTP time condition to use, see defines */ + CURLOPT(CURLOPT_TIMECONDITION, CURLOPTTYPE_VALUES, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CURLOPT(CURLOPT_TIMEVALUE, CURLOPTTYPE_LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CURLOPT(CURLOPT_CUSTOMREQUEST, CURLOPTTYPE_STRINGPOINT, 36), + + /* FILE handle to use instead of stderr */ + CURLOPT(CURLOPT_STDERR, CURLOPTTYPE_OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CURLOPT(CURLOPT_POSTQUOTE, CURLOPTTYPE_SLISTPOINT, 39), + + /* OBSOLETE, do not use! */ + CURLOPT(CURLOPT_OBSOLETE40, CURLOPTTYPE_OBJECTPOINT, 40), + + /* talk a lot */ + CURLOPT(CURLOPT_VERBOSE, CURLOPTTYPE_LONG, 41), + + /* throw the header out too */ + CURLOPT(CURLOPT_HEADER, CURLOPTTYPE_LONG, 42), + + /* shut off the progress meter */ + CURLOPT(CURLOPT_NOPROGRESS, CURLOPTTYPE_LONG, 43), + + /* use HEAD to get http document */ + CURLOPT(CURLOPT_NOBODY, CURLOPTTYPE_LONG, 44), + + /* no output on http error codes >= 400 */ + CURLOPT(CURLOPT_FAILONERROR, CURLOPTTYPE_LONG, 45), + + /* this is an upload */ + CURLOPT(CURLOPT_UPLOAD, CURLOPTTYPE_LONG, 46), + + /* HTTP POST method */ + CURLOPT(CURLOPT_POST, CURLOPTTYPE_LONG, 47), + + /* bare names when listing directories */ + CURLOPT(CURLOPT_DIRLISTONLY, CURLOPTTYPE_LONG, 48), + + /* Append instead of overwrite on upload! */ + CURLOPT(CURLOPT_APPEND, CURLOPTTYPE_LONG, 50), + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CURLOPT(CURLOPT_NETRC, CURLOPTTYPE_VALUES, 51), + + /* use Location: Luke! */ + CURLOPT(CURLOPT_FOLLOWLOCATION, CURLOPTTYPE_LONG, 52), + + /* transfer data in text/ASCII format */ + CURLOPT(CURLOPT_TRANSFERTEXT, CURLOPTTYPE_LONG, 53), + + /* HTTP PUT */ + CURLOPT(CURLOPT_PUT, CURLOPTTYPE_LONG, 54), + + /* 55 = OBSOLETE */ + + /* DEPRECATED + * Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CURLOPT(CURLOPT_PROGRESSFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 56), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CURLOPT(CURLOPT_XFERINFODATA, CURLOPTTYPE_CBPOINT, 57), +#define CURLOPT_PROGRESSDATA CURLOPT_XFERINFODATA + + /* We want the referrer field set automatically when following locations */ + CURLOPT(CURLOPT_AUTOREFERER, CURLOPTTYPE_LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CURLOPT(CURLOPT_PROXYPORT, CURLOPTTYPE_LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CURLOPT(CURLOPT_POSTFIELDSIZE, CURLOPTTYPE_LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CURLOPT(CURLOPT_HTTPPROXYTUNNEL, CURLOPTTYPE_LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CURLOPT(CURLOPT_INTERFACE, CURLOPTTYPE_STRINGPOINT, 62), + + /* Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but doesn't match one of these, 'private' will be used. */ + CURLOPT(CURLOPT_KRBLEVEL, CURLOPTTYPE_STRINGPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CURLOPT(CURLOPT_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO, CURLOPTTYPE_STRINGPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CURLOPT(CURLOPT_MAXREDIRS, CURLOPTTYPE_LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + CURLOPT(CURLOPT_FILETIME, CURLOPTTYPE_LONG, 69), + + /* This points to a linked list of telnet options */ + CURLOPT(CURLOPT_TELNETOPTIONS, CURLOPTTYPE_SLISTPOINT, 70), + + /* Max amount of cached alive connections */ + CURLOPT(CURLOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 71), + + /* OBSOLETE, do not use! */ + CURLOPT(CURLOPT_OBSOLETE72, CURLOPTTYPE_LONG, 72), + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CURLOPT(CURLOPT_FRESH_CONNECT, CURLOPTTYPE_LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CURLOPT(CURLOPT_FORBID_REUSE, CURLOPTTYPE_LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CURLOPT(CURLOPT_RANDOM_FILE, CURLOPTTYPE_STRINGPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CURLOPT(CURLOPT_EGDSOCKET, CURLOPTTYPE_STRINGPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects are + OK within this time, then fine... This only aborts the connect phase. */ + CURLOPT(CURLOPT_CONNECTTIMEOUT, CURLOPTTYPE_LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CURLOPT(CURLOPT_HEADERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. + */ + CURLOPT(CURLOPT_HTTPGET, CURLOPTTYPE_LONG, 80), + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CURLOPT(CURLOPT_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CURLOPT(CURLOPT_COOKIEJAR, CURLOPTTYPE_STRINGPOINT, 82), + + /* Specify which SSL ciphers to use */ + CURLOPT(CURLOPT_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CURLOPT(CURLOPT_HTTP_VERSION, CURLOPTTYPE_VALUES, 84), + + /* Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CURLOPT(CURLOPT_FTP_USE_EPSV, CURLOPTTYPE_LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CURLOPT(CURLOPT_SSLKEY, CURLOPTTYPE_STRINGPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CURLOPT(CURLOPT_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CURLOPT(CURLOPT_SSLENGINE, CURLOPTTYPE_STRINGPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CURLOPT(CURLOPT_SSLENGINE_DEFAULT, CURLOPTTYPE_LONG, 90), + + /* Non-zero value means to use the global dns cache */ + /* DEPRECATED, do not use! */ + CURLOPT(CURLOPT_DNS_USE_GLOBAL_CACHE, CURLOPTTYPE_LONG, 91), + + /* DNS cache timeout */ + CURLOPT(CURLOPT_DNS_CACHE_TIMEOUT, CURLOPTTYPE_LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CURLOPT(CURLOPT_PREQUOTE, CURLOPTTYPE_SLISTPOINT, 93), + + /* set the debug function */ + CURLOPT(CURLOPT_DEBUGFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CURLOPT(CURLOPT_DEBUGDATA, CURLOPTTYPE_CBPOINT, 95), + + /* mark this as start of a cookie session */ + CURLOPT(CURLOPT_COOKIESESSION, CURLOPTTYPE_LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAPATH, CURLOPTTYPE_STRINGPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CURLOPT(CURLOPT_BUFFERSIZE, CURLOPTTYPE_LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CURLOPT(CURLOPT_NOSIGNAL, CURLOPTTYPE_LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CURLOPT(CURLOPT_SHARE, CURLOPTTYPE_OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and + CURLPROXY_SOCKS5. */ + CURLOPT(CURLOPT_PROXYTYPE, CURLOPTTYPE_VALUES, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. Before 7.21.6, this was known as + CURLOPT_ENCODING */ + CURLOPT(CURLOPT_ACCEPT_ENCODING, CURLOPTTYPE_STRINGPOINT, 102), + + /* Set pointer to private data */ + CURLOPT(CURLOPT_PRIVATE, CURLOPTTYPE_OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CURLOPT(CURLOPT_HTTP200ALIASES, CURLOPTTYPE_SLISTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + CURLOPT(CURLOPT_UNRESTRICTED_AUTH, CURLOPTTYPE_LONG, 105), + + /* Specifically switch on or off the FTP engine's use of the EPRT command ( + it also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CURLOPT(CURLOPT_FTP_USE_EPRT, CURLOPTTYPE_LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CURLOPT(CURLOPT_HTTPAUTH, CURLOPTTYPE_VALUES, 107), + + /* Set the ssl context callback function, currently only for OpenSSL or + WolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument. + The function must match the curl_ssl_ctx_callback prototype. */ + CURLOPT(CURLOPT_SSL_CTX_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CURLOPT(CURLOPT_SSL_CTX_DATA, CURLOPTTYPE_CBPOINT, 109), + + /* FTP Option that causes missing dirs to be created on the remote server. + In 7.19.4 we introduced the convenience enums for this option using the + CURLFTP_CREATE_DIR prefix. + */ + CURLOPT(CURLOPT_FTP_CREATE_MISSING_DIRS, CURLOPTTYPE_LONG, 110), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CURLOPT(CURLOPT_PROXYAUTH, CURLOPTTYPE_VALUES, 111), + + /* FTP option that changes the timeout, in seconds, associated with + getting a response. This is different from transfer timeout time and + essentially places a demand on the FTP server to acknowledge commands + in a timely manner. */ + CURLOPT(CURLOPT_FTP_RESPONSE_TIMEOUT, CURLOPTTYPE_LONG, 112), +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to use those IP versions only. This only has effect on + systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CURLOPT(CURLOPT_IPRESOLVE, CURLOPTTYPE_VALUES, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. + + Note there is also _LARGE version which adds large file support for + platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ + CURLOPT(CURLOPT_MAXFILESIZE, CURLOPTTYPE_LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CURLOPT(CURLOPT_INFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 115), + + /* Sets the continuation offset. There is also a CURLOPTTYPE_LONG version + * of this; look above for RESUME_FROM. + */ + CURLOPT(CURLOPT_RESUME_FROM_LARGE, CURLOPTTYPE_OFF_T, 116), + + /* Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CURLOPT(CURLOPT_MAXFILESIZE_LARGE, CURLOPTTYPE_OFF_T, 117), + + /* Set this option to the file name of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ + CURLOPT(CURLOPT_NETRC_FILE, CURLOPTTYPE_STRINGPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + CURLUSESSL_TRY - try using SSL, proceed anyway otherwise + CURLUSESSL_CONTROL - SSL for the control connection or fail + CURLUSESSL_ALL - SSL for all communication or fail + */ + CURLOPT(CURLOPT_USE_SSL, CURLOPTTYPE_VALUES, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CURLOPT(CURLOPT_POSTFIELDSIZE_LARGE, CURLOPTTYPE_OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CURLOPT(CURLOPT_TCP_NODELAY, CURLOPTTYPE_LONG, 121), + + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 123 OBSOLETE. Gone in 7.16.0 */ + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 127 OBSOLETE. Gone in 7.16.0 */ + /* 128 OBSOLETE. Gone in 7.16.0 */ + + /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + CURLOPT(CURLOPT_FTPSSLAUTH, CURLOPTTYPE_VALUES, 129), + + CURLOPT(CURLOPT_IOCTLFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 130), + CURLOPT(CURLOPT_IOCTLDATA, CURLOPTTYPE_CBPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* null-terminated string for pass on to the FTP server when asked for + "account" info */ + CURLOPT(CURLOPT_FTP_ACCOUNT, CURLOPTTYPE_STRINGPOINT, 134), + + /* feed cookie into cookie engine */ + CURLOPT(CURLOPT_COOKIELIST, CURLOPTTYPE_STRINGPOINT, 135), + + /* ignore Content-Length */ + CURLOPT(CURLOPT_IGNORE_CONTENT_LENGTH, CURLOPTTYPE_LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ + CURLOPT(CURLOPT_FTP_SKIP_PASV_IP, CURLOPTTYPE_LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CURLOPT(CURLOPT_FTP_FILEMETHOD, CURLOPTTYPE_VALUES, 138), + + /* Local port number to bind the socket to */ + CURLOPT(CURLOPT_LOCALPORT, CURLOPTTYPE_LONG, 139), + + /* Number of ports to try, including the first one set with LOCALPORT. + Thus, setting it to 1 will make no additional attempts but the first. + */ + CURLOPT(CURLOPT_LOCALPORTRANGE, CURLOPTTYPE_LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CURLOPT(CURLOPT_CONNECT_ONLY, CURLOPTTYPE_LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPT(CURLOPT_CONV_FROM_NETWORK_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CURLOPT(CURLOPT_CONV_TO_NETWORK_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 143), + + /* Function that will be called to convert from UTF8 + (instead of using the iconv calls in libcurl) + Note that this is used only for SSL certificate processing */ + CURLOPT(CURLOPT_CONV_FROM_UTF8_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CURLOPT(CURLOPT_MAX_SEND_SPEED_LARGE, CURLOPTTYPE_OFF_T, 145), + CURLOPT(CURLOPT_MAX_RECV_SPEED_LARGE, CURLOPTTYPE_OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CURLOPT(CURLOPT_FTP_ALTERNATIVE_TO_USER, CURLOPTTYPE_STRINGPOINT, 147), + + /* callback function for setting socket options */ + CURLOPT(CURLOPT_SOCKOPTFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 148), + CURLOPT(CURLOPT_SOCKOPTDATA, CURLOPTTYPE_CBPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CURLOPT(CURLOPT_SSL_SESSIONID_CACHE, CURLOPTTYPE_LONG, 150), + + /* allowed SSH authentication methods */ + CURLOPT(CURLOPT_SSH_AUTH_TYPES, CURLOPTTYPE_VALUES, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CURLOPT(CURLOPT_SSH_PUBLIC_KEYFILE, CURLOPTTYPE_STRINGPOINT, 152), + CURLOPT(CURLOPT_SSH_PRIVATE_KEYFILE, CURLOPTTYPE_STRINGPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CURLOPT(CURLOPT_FTP_SSL_CCC, CURLOPTTYPE_LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CURLOPT(CURLOPT_TIMEOUT_MS, CURLOPTTYPE_LONG, 155), + CURLOPT(CURLOPT_CONNECTTIMEOUT_MS, CURLOPTTYPE_LONG, 156), + + /* set to zero to disable the libcurl's decoding and thus pass the raw body + data to the application even when it is encoded/compressed */ + CURLOPT(CURLOPT_HTTP_TRANSFER_DECODING, CURLOPTTYPE_LONG, 157), + CURLOPT(CURLOPT_HTTP_CONTENT_DECODING, CURLOPTTYPE_LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CURLOPT(CURLOPT_NEW_FILE_PERMS, CURLOPTTYPE_LONG, 159), + CURLOPT(CURLOPT_NEW_DIRECTORY_PERMS, CURLOPTTYPE_LONG, 160), + + /* Set the behavior of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CURLOPT(CURLOPT_POSTREDIR, CURLOPTTYPE_VALUES, 161), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, CURLOPTTYPE_STRINGPOINT, 162), + + /* Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + CURLOPT(CURLOPT_OPENSOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 163), + CURLOPT(CURLOPT_OPENSOCKETDATA, CURLOPTTYPE_CBPOINT, 164), + + /* POST volatile input fields. */ + CURLOPT(CURLOPT_COPYPOSTFIELDS, CURLOPTTYPE_OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CURLOPT(CURLOPT_PROXY_TRANSFER_MODE, CURLOPTTYPE_LONG, 166), + + /* Callback function for seeking in the input stream */ + CURLOPT(CURLOPT_SEEKFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 167), + CURLOPT(CURLOPT_SEEKDATA, CURLOPTTYPE_CBPOINT, 168), + + /* CRL file */ + CURLOPT(CURLOPT_CRLFILE, CURLOPTTYPE_STRINGPOINT, 169), + + /* Issuer certificate */ + CURLOPT(CURLOPT_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 170), + + /* (IPv6) Address scope */ + CURLOPT(CURLOPT_ADDRESS_SCOPE, CURLOPTTYPE_LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CURLOPT(CURLOPT_CERTINFO, CURLOPTTYPE_LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CURLOPT(CURLOPT_USERNAME, CURLOPTTYPE_STRINGPOINT, 173), + CURLOPT(CURLOPT_PASSWORD, CURLOPTTYPE_STRINGPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CURLOPT(CURLOPT_PROXYUSERNAME, CURLOPTTYPE_STRINGPOINT, 175), + CURLOPT(CURLOPT_PROXYPASSWORD, CURLOPTTYPE_STRINGPOINT, 176), + + /* Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ + CURLOPT(CURLOPT_NOPROXY, CURLOPTTYPE_STRINGPOINT, 177), + + /* block size for TFTP transfers */ + CURLOPT(CURLOPT_TFTP_BLKSIZE, CURLOPTTYPE_LONG, 178), + + /* Socks Service */ + /* DEPRECATED, do not use! */ + CURLOPT(CURLOPT_SOCKS5_GSSAPI_SERVICE, CURLOPTTYPE_STRINGPOINT, 179), + + /* Socks Service */ + CURLOPT(CURLOPT_SOCKS5_GSSAPI_NEC, CURLOPTTYPE_LONG, 180), + + /* set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ + CURLOPT(CURLOPT_PROTOCOLS, CURLOPTTYPE_LONG, 181), + + /* set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. */ + CURLOPT(CURLOPT_REDIR_PROTOCOLS, CURLOPTTYPE_LONG, 182), + + /* set the SSH knownhost file name to use */ + CURLOPT(CURLOPT_SSH_KNOWNHOSTS, CURLOPTTYPE_STRINGPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CURLOPT(CURLOPT_SSH_KEYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CURLOPT(CURLOPT_SSH_KEYDATA, CURLOPTTYPE_CBPOINT, 185), + + /* set the SMTP mail originator */ + CURLOPT(CURLOPT_MAIL_FROM, CURLOPTTYPE_STRINGPOINT, 186), + + /* set the list of SMTP mail receiver(s) */ + CURLOPT(CURLOPT_MAIL_RCPT, CURLOPTTYPE_SLISTPOINT, 187), + + /* FTP: send PRET before PASV */ + CURLOPT(CURLOPT_FTP_USE_PRET, CURLOPTTYPE_LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CURLOPT(CURLOPT_RTSP_REQUEST, CURLOPTTYPE_VALUES, 189), + + /* The RTSP session identifier */ + CURLOPT(CURLOPT_RTSP_SESSION_ID, CURLOPTTYPE_STRINGPOINT, 190), + + /* The RTSP stream URI */ + CURLOPT(CURLOPT_RTSP_STREAM_URI, CURLOPTTYPE_STRINGPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CURLOPT(CURLOPT_RTSP_TRANSPORT, CURLOPTTYPE_STRINGPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_CLIENT_CSEQ, CURLOPTTYPE_LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CURLOPT(CURLOPT_RTSP_SERVER_CSEQ, CURLOPTTYPE_LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CURLOPT(CURLOPT_INTERLEAVEDATA, CURLOPTTYPE_CBPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CURLOPT(CURLOPT_INTERLEAVEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CURLOPT(CURLOPT_WILDCARDMATCH, CURLOPTTYPE_LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CURLOPT(CURLOPT_CHUNK_BGN_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CURLOPT(CURLOPT_CHUNK_END_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CURLOPT(CURLOPT_FNMATCH_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CURLOPT(CURLOPT_CHUNK_DATA, CURLOPTTYPE_CBPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CURLOPT(CURLOPT_FNMATCH_DATA, CURLOPTTYPE_CBPOINT, 202), + + /* send linked-list of name:port:address sets */ + CURLOPT(CURLOPT_RESOLVE, CURLOPTTYPE_SLISTPOINT, 203), + + /* Set a username for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 204), + + /* Set a password for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CURLOPT(CURLOPT_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 206), + + /* Set to 1 to enable the "TE:" header in HTTP requests to ask for + compressed transfer-encoded responses. Set to 0 to disable the use of TE: + in outgoing requests. The current default is 0, but it might change in a + future libcurl release. + + libcurl will ask for the compressed methods it knows of, and if that + isn't any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CURLOPT(CURLOPT_TRANSFER_ENCODING, CURLOPTTYPE_LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CURLOPT(CURLOPT_CLOSESOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 208), + CURLOPT(CURLOPT_CLOSESOCKETDATA, CURLOPTTYPE_CBPOINT, 209), + + /* allow GSSAPI credential delegation */ + CURLOPT(CURLOPT_GSSAPI_DELEGATION, CURLOPTTYPE_VALUES, 210), + + /* Set the name servers to use for DNS resolution */ + CURLOPT(CURLOPT_DNS_SERVERS, CURLOPTTYPE_STRINGPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of milliseconds. */ + CURLOPT(CURLOPT_ACCEPTTIMEOUT_MS, CURLOPTTYPE_LONG, 212), + + /* Set TCP keepalive */ + CURLOPT(CURLOPT_TCP_KEEPALIVE, CURLOPTTYPE_LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CURLOPT(CURLOPT_TCP_KEEPIDLE, CURLOPTTYPE_LONG, 214), + CURLOPT(CURLOPT_TCP_KEEPINTVL, CURLOPTTYPE_LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CURLOPT(CURLOPT_SSL_OPTIONS, CURLOPTTYPE_VALUES, 216), + + /* Set the SMTP auth originator */ + CURLOPT(CURLOPT_MAIL_AUTH, CURLOPTTYPE_STRINGPOINT, 217), + + /* Enable/disable SASL initial response */ + CURLOPT(CURLOPT_SASL_IR, CURLOPTTYPE_LONG, 218), + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_xferinfo_callback + * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ + CURLOPT(CURLOPT_XFERINFOFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CURLOPT(CURLOPT_XOAUTH2_BEARER, CURLOPTTYPE_STRINGPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_INTERFACE, CURLOPTTYPE_STRINGPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP4, CURLOPTTYPE_STRINGPOINT, 222), + + /* Set the local IPv6 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CURLOPT(CURLOPT_DNS_LOCAL_IP6, CURLOPTTYPE_STRINGPOINT, 223), + + /* Set authentication options directly */ + CURLOPT(CURLOPT_LOGIN_OPTIONS, CURLOPTTYPE_STRINGPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CURLOPT(CURLOPT_SSL_ENABLE_NPN, CURLOPTTYPE_LONG, 225), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CURLOPT(CURLOPT_SSL_ENABLE_ALPN, CURLOPTTYPE_LONG, 226), + + /* Time to wait for a response to a HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CURLOPT(CURLOPT_EXPECT_100_TIMEOUT_MS, CURLOPTTYPE_LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CURLOPT(CURLOPT_PROXYHEADER, CURLOPTTYPE_SLISTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CURLOPT(CURLOPT_HEADEROPT, CURLOPTTYPE_VALUES, 229), + + /* The public key in DER form used to validate the peer public key + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 230), + + /* Path to Unix domain socket */ + CURLOPT(CURLOPT_UNIX_SOCKET_PATH, CURLOPTTYPE_STRINGPOINT, 231), + + /* Set if we should verify the certificate status. */ + CURLOPT(CURLOPT_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 232), + + /* Set if we should enable TLS false start. */ + CURLOPT(CURLOPT_SSL_FALSESTART, CURLOPTTYPE_LONG, 233), + + /* Do not squash dot-dot sequences */ + CURLOPT(CURLOPT_PATH_AS_IS, CURLOPTTYPE_LONG, 234), + + /* Proxy Service Name */ + CURLOPT(CURLOPT_PROXY_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 235), + + /* Service Name */ + CURLOPT(CURLOPT_SERVICE_NAME, CURLOPTTYPE_STRINGPOINT, 236), + + /* Wait/don't wait for pipe/mutex to clarify */ + CURLOPT(CURLOPT_PIPEWAIT, CURLOPTTYPE_LONG, 237), + + /* Set the protocol used when curl is given a URL without a protocol */ + CURLOPT(CURLOPT_DEFAULT_PROTOCOL, CURLOPTTYPE_STRINGPOINT, 238), + + /* Set stream weight, 1 - 256 (default is 16) */ + CURLOPT(CURLOPT_STREAM_WEIGHT, CURLOPTTYPE_LONG, 239), + + /* Set stream dependency on another CURL handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS, CURLOPTTYPE_OBJECTPOINT, 240), + + /* Set E-xclusive stream dependency on another CURL handle */ + CURLOPT(CURLOPT_STREAM_DEPENDS_E, CURLOPTTYPE_OBJECTPOINT, 241), + + /* Do not send any tftp option requests to the server */ + CURLOPT(CURLOPT_TFTP_NO_OPTIONS, CURLOPTTYPE_LONG, 242), + + /* Linked-list of host:port:connect-to-host:connect-to-port, + overrides the URL's host:port (only for the network layer) */ + CURLOPT(CURLOPT_CONNECT_TO, CURLOPTTYPE_SLISTPOINT, 243), + + /* Set TCP Fast Open */ + CURLOPT(CURLOPT_TCP_FASTOPEN, CURLOPTTYPE_LONG, 244), + + /* Continue to send data if the server responds early with an + * HTTP status code >= 300 */ + CURLOPT(CURLOPT_KEEP_SENDING_ON_ERROR, CURLOPTTYPE_LONG, 245), + + /* The CApath or CAfile used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO, CURLOPTTYPE_STRINGPOINT, 246), + + /* The CApath directory used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAPATH, CURLOPTTYPE_STRINGPOINT, 247), + + /* Set if we should verify the proxy in ssl handshake, + set 1 to verify. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 248), + + /* Set if we should verify the Common name from the proxy certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches + * the provided hostname. */ + CURLOPT(CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 249), + + /* What version to specifically try to use for proxy. + See CURL_SSLVERSION defines below. */ + CURLOPT(CURLOPT_PROXY_SSLVERSION, CURLOPTTYPE_VALUES, 250), + + /* Set a username for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_USERNAME, CURLOPTTYPE_STRINGPOINT, 251), + + /* Set a password for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_PASSWORD, CURLOPTTYPE_STRINGPOINT, 252), + + /* Set authentication type for authenticated TLS for proxy */ + CURLOPT(CURLOPT_PROXY_TLSAUTH_TYPE, CURLOPTTYPE_STRINGPOINT, 253), + + /* name of the file keeping your private SSL-certificate for proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERT, CURLOPTTYPE_STRINGPOINT, 254), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLCERTTYPE, CURLOPTTYPE_STRINGPOINT, 255), + + /* name of the file keeping your private SSL-key for proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEY, CURLOPTTYPE_STRINGPOINT, 256), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for + proxy */ + CURLOPT(CURLOPT_PROXY_SSLKEYTYPE, CURLOPTTYPE_STRINGPOINT, 257), + + /* password for the SSL private key for proxy */ + CURLOPT(CURLOPT_PROXY_KEYPASSWD, CURLOPTTYPE_STRINGPOINT, 258), + + /* Specify which SSL ciphers to use for proxy */ + CURLOPT(CURLOPT_PROXY_SSL_CIPHER_LIST, CURLOPTTYPE_STRINGPOINT, 259), + + /* CRL file for proxy */ + CURLOPT(CURLOPT_PROXY_CRLFILE, CURLOPTTYPE_STRINGPOINT, 260), + + /* Enable/disable specific SSL features with a bitmask for proxy, see + CURLSSLOPT_* */ + CURLOPT(CURLOPT_PROXY_SSL_OPTIONS, CURLOPTTYPE_LONG, 261), + + /* Name of pre proxy to use. */ + CURLOPT(CURLOPT_PRE_PROXY, CURLOPTTYPE_STRINGPOINT, 262), + + /* The public key in DER form used to validate the proxy public key + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_PINNEDPUBLICKEY, CURLOPTTYPE_STRINGPOINT, 263), + + /* Path to an abstract Unix domain socket */ + CURLOPT(CURLOPT_ABSTRACT_UNIX_SOCKET, CURLOPTTYPE_STRINGPOINT, 264), + + /* Suppress proxy CONNECT response headers from user callbacks */ + CURLOPT(CURLOPT_SUPPRESS_CONNECT_HEADERS, CURLOPTTYPE_LONG, 265), + + /* The request target, instead of extracted from the URL */ + CURLOPT(CURLOPT_REQUEST_TARGET, CURLOPTTYPE_STRINGPOINT, 266), + + /* bitmask of allowed auth methods for connections to SOCKS5 proxies */ + CURLOPT(CURLOPT_SOCKS5_AUTH, CURLOPTTYPE_LONG, 267), + + /* Enable/disable SSH compression */ + CURLOPT(CURLOPT_SSH_COMPRESSION, CURLOPTTYPE_LONG, 268), + + /* Post MIME data. */ + CURLOPT(CURLOPT_MIMEPOST, CURLOPTTYPE_OBJECTPOINT, 269), + + /* Time to use with the CURLOPT_TIMECONDITION. Specified in number of + seconds since 1 Jan 1970. */ + CURLOPT(CURLOPT_TIMEVALUE_LARGE, CURLOPTTYPE_OFF_T, 270), + + /* Head start in milliseconds to give happy eyeballs. */ + CURLOPT(CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, CURLOPTTYPE_LONG, 271), + + /* Function that will be called before a resolver request is made */ + CURLOPT(CURLOPT_RESOLVER_START_FUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 272), + + /* User data to pass to the resolver start callback. */ + CURLOPT(CURLOPT_RESOLVER_START_DATA, CURLOPTTYPE_CBPOINT, 273), + + /* send HAProxy PROXY protocol header? */ + CURLOPT(CURLOPT_HAPROXYPROTOCOL, CURLOPTTYPE_LONG, 274), + + /* shuffle addresses before use when DNS returns multiple */ + CURLOPT(CURLOPT_DNS_SHUFFLE_ADDRESSES, CURLOPTTYPE_LONG, 275), + + /* Specify which TLS 1.3 ciphers suites to use */ + CURLOPT(CURLOPT_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 276), + CURLOPT(CURLOPT_PROXY_TLS13_CIPHERS, CURLOPTTYPE_STRINGPOINT, 277), + + /* Disallow specifying username/login in URL. */ + CURLOPT(CURLOPT_DISALLOW_USERNAME_IN_URL, CURLOPTTYPE_LONG, 278), + + /* DNS-over-HTTPS URL */ + CURLOPT(CURLOPT_DOH_URL, CURLOPTTYPE_STRINGPOINT, 279), + + /* Preferred buffer size to use for uploads */ + CURLOPT(CURLOPT_UPLOAD_BUFFERSIZE, CURLOPTTYPE_LONG, 280), + + /* Time in ms between connection upkeep calls for long-lived connections. */ + CURLOPT(CURLOPT_UPKEEP_INTERVAL_MS, CURLOPTTYPE_LONG, 281), + + /* Specify URL using CURL URL API. */ + CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282), + + /* add trailing data just after no more data is available */ + CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283), + + /* pointer to be passed to HTTP_TRAILER_FUNCTION */ + CURLOPT(CURLOPT_TRAILERDATA, CURLOPTTYPE_CBPOINT, 284), + + /* set this to 1L to allow HTTP/0.9 responses or 0L to disallow */ + CURLOPT(CURLOPT_HTTP09_ALLOWED, CURLOPTTYPE_LONG, 285), + + /* alt-svc control bitmask */ + CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286), + + /* alt-svc cache file name to possibly read from/write to */ + CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287), + + /* maximum age (idle time) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288), + + /* SASL authorisation identity */ + CURLOPT(CURLOPT_SASL_AUTHZID, CURLOPTTYPE_STRINGPOINT, 289), + + /* allow RCPT TO command to fail for some recipients */ + CURLOPT(CURLOPT_MAIL_RCPT_ALLLOWFAILS, CURLOPTTYPE_LONG, 290), + + /* the private SSL-certificate as a "blob" */ + CURLOPT(CURLOPT_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 291), + CURLOPT(CURLOPT_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 292), + CURLOPT(CURLOPT_PROXY_SSLCERT_BLOB, CURLOPTTYPE_BLOB, 293), + CURLOPT(CURLOPT_PROXY_SSLKEY_BLOB, CURLOPTTYPE_BLOB, 294), + CURLOPT(CURLOPT_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 295), + + /* Issuer certificate for proxy */ + CURLOPT(CURLOPT_PROXY_ISSUERCERT, CURLOPTTYPE_STRINGPOINT, 296), + CURLOPT(CURLOPT_PROXY_ISSUERCERT_BLOB, CURLOPTTYPE_BLOB, 297), + + /* the EC curves requested by the TLS client (RFC 8422, 5.1); + * OpenSSL support via 'set_groups'/'set_curves': + * https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set1_groups.html + */ + CURLOPT(CURLOPT_SSL_EC_CURVES, CURLOPTTYPE_STRINGPOINT, 298), + + /* HSTS bitmask */ + CURLOPT(CURLOPT_HSTS_CTRL, CURLOPTTYPE_LONG, 299), + /* HSTS file name */ + CURLOPT(CURLOPT_HSTS, CURLOPTTYPE_STRINGPOINT, 300), + + /* HSTS read callback */ + CURLOPT(CURLOPT_HSTSREADFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 301), + CURLOPT(CURLOPT_HSTSREADDATA, CURLOPTTYPE_CBPOINT, 302), + + /* HSTS write callback */ + CURLOPT(CURLOPT_HSTSWRITEFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 303), + CURLOPT(CURLOPT_HSTSWRITEDATA, CURLOPTTYPE_CBPOINT, 304), + + /* Parameters for V4 signature */ + CURLOPT(CURLOPT_AWS_SIGV4, CURLOPTTYPE_STRINGPOINT, 305), + + /* Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYPEER, CURLOPTTYPE_LONG, 306), + + /* Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYHOST, CURLOPTTYPE_LONG, 307), + + /* Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. */ + CURLOPT(CURLOPT_DOH_SSL_VERIFYSTATUS, CURLOPTTYPE_LONG, 308), + + /* The CA certificates as "blob" used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_CAINFO_BLOB, CURLOPTTYPE_BLOB, 309), + + /* The CA certificates as "blob" used to validate the proxy certificate + this option is used only if PROXY_SSL_VERIFYPEER is true */ + CURLOPT(CURLOPT_PROXY_CAINFO_BLOB, CURLOPTTYPE_BLOB, 310), + + /* used by scp/sftp to verify the host's public key */ + CURLOPT(CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256, CURLOPTTYPE_STRINGPOINT, 311), + + /* Function that will be called immediately before the initial request + is made on a connection (after any protocol negotiation step). */ + CURLOPT(CURLOPT_PREREQFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 312), + + /* Data passed to the CURLOPT_PREREQFUNCTION callback */ + CURLOPT(CURLOPT_PREREQDATA, CURLOPTTYPE_CBPOINT, 313), + + /* maximum age (since creation) of a connection to consider it for reuse + * (in seconds) */ + CURLOPT(CURLOPT_MAXLIFETIME_CONN, CURLOPTTYPE_LONG, 314), + + /* Set MIME option flags. */ + CURLOPT(CURLOPT_MIME_OPTIONS, CURLOPTTYPE_LONG, 315), + + CURLOPT_LASTENTRY /* the last unused */ +} CURLoption; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2011 */ + +/* This was added in version 7.19.1 */ +#define CURLOPT_POST301 CURLOPT_POSTREDIR + +/* These are scheduled to disappear by 2009 */ + +/* The following were added in 7.17.0 */ +#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_FTPAPPEND CURLOPT_APPEND +#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY +#define CURLOPT_FTP_SSL CURLOPT_USE_SSL + +/* The following were added earlier */ + +#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL + +#else +/* This is set if CURL_NO_OLDIES is defined at compile-time */ +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ +#endif + + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ +#define CURL_IPRESOLVE_WHATEVER 0 /* default, uses addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* uses only IPv4 addresses/connections */ +#define CURL_IPRESOLVE_V6 2 /* uses only IPv6 addresses/connections */ + + /* three convenient "aliases" that follow the name scheme better */ +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum { + CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ + CURL_HTTP_VERSION_2_0, /* please use HTTP 2 in the request */ + CURL_HTTP_VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */ + CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE, /* please use HTTP 2 without HTTP/1.1 + Upgrade */ + CURL_HTTP_VERSION_3 = 30, /* Makes use of explicit HTTP/3 without fallback. + Use CURLOPT_ALTSVC to enable HTTP/3 upgrade */ + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + +/* Convenience definition simple because the name of the version is HTTP/2 and + not 2.0. The 2_0 version of the enum name was set while the version was + still planned to be 2.0 and we stick to it for compatibility. */ +#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0 + +/* + * Public API enums for RTSP requests + */ +enum { + CURL_RTSPREQ_NONE, /* first in list */ + CURL_RTSPREQ_OPTIONS, + CURL_RTSPREQ_DESCRIBE, + CURL_RTSPREQ_ANNOUNCE, + CURL_RTSPREQ_SETUP, + CURL_RTSPREQ_PLAY, + CURL_RTSPREQ_PAUSE, + CURL_RTSPREQ_TEARDOWN, + CURL_RTSPREQ_GET_PARAMETER, + CURL_RTSPREQ_SET_PARAMETER, + CURL_RTSPREQ_RECORD, + CURL_RTSPREQ_RECEIVE, + CURL_RTSPREQ_LAST /* last in list */ +}; + + /* These enums are for use with the CURLOPT_NETRC option. */ +enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + CURL_SSLVERSION_TLSv1_0, + CURL_SSLVERSION_TLSv1_1, + CURL_SSLVERSION_TLSv1_2, + CURL_SSLVERSION_TLSv1_3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum { + CURL_SSLVERSION_MAX_NONE = 0, + CURL_SSLVERSION_MAX_DEFAULT = (CURL_SSLVERSION_TLSv1 << 16), + CURL_SSLVERSION_MAX_TLSv1_0 = (CURL_SSLVERSION_TLSv1_0 << 16), + CURL_SSLVERSION_MAX_TLSv1_1 = (CURL_SSLVERSION_TLSv1_1 << 16), + CURL_SSLVERSION_MAX_TLSv1_2 = (CURL_SSLVERSION_TLSv1_2 << 16), + CURL_SSLVERSION_MAX_TLSv1_3 = (CURL_SSLVERSION_TLSv1_3 << 16), + + /* never use, keep last */ + CURL_SSLVERSION_MAX_LAST = (CURL_SSLVERSION_LAST << 16) +}; + +enum CURL_TLSAUTH { + CURL_TLSAUTH_NONE, + CURL_TLSAUTH_SRP, + CURL_TLSAUTH_LAST /* never use, keep last */ +}; + +/* symbols to use with CURLOPT_POSTREDIR. + CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 + can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 + | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */ + +#define CURL_REDIR_GET_ALL 0 +#define CURL_REDIR_POST_301 1 +#define CURL_REDIR_POST_302 2 +#define CURL_REDIR_POST_303 4 +#define CURL_REDIR_POST_ALL \ + (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + +/* Special size_t value signaling a null-terminated string. */ +#define CURL_ZERO_TERMINATED ((size_t) -1) + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + release */ +CURL_EXTERN int curl_strequal(const char *s1, const char *s2); +CURL_EXTERN int curl_strnequal(const char *s1, const char *s2, size_t n); + +/* Mime/form handling support. */ +typedef struct curl_mime curl_mime; /* Mime context. */ +typedef struct curl_mimepart curl_mimepart; /* Mime part context. */ + +/* CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option. */ +#define CURLMIMEOPT_FORMESCAPE (1<<0) /* Use backslash-escaping for forms. */ + +/* + * NAME curl_mime_init() + * + * DESCRIPTION + * + * Create a mime context and return its handle. The easy parameter is the + * target handle. + */ +CURL_EXTERN curl_mime *curl_mime_init(CURL *easy); + +/* + * NAME curl_mime_free() + * + * DESCRIPTION + * + * release a mime handle and its substructures. + */ +CURL_EXTERN void curl_mime_free(curl_mime *mime); + +/* + * NAME curl_mime_addpart() + * + * DESCRIPTION + * + * Append a new empty part to the given mime context and return a handle to + * the created part. + */ +CURL_EXTERN curl_mimepart *curl_mime_addpart(curl_mime *mime); + +/* + * NAME curl_mime_name() + * + * DESCRIPTION + * + * Set mime/form part name. + */ +CURL_EXTERN CURLcode curl_mime_name(curl_mimepart *part, const char *name); + +/* + * NAME curl_mime_filename() + * + * DESCRIPTION + * + * Set mime part remote file name. + */ +CURL_EXTERN CURLcode curl_mime_filename(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_type() + * + * DESCRIPTION + * + * Set mime part type. + */ +CURL_EXTERN CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype); + +/* + * NAME curl_mime_encoder() + * + * DESCRIPTION + * + * Set mime data transfer encoder. + */ +CURL_EXTERN CURLcode curl_mime_encoder(curl_mimepart *part, + const char *encoding); + +/* + * NAME curl_mime_data() + * + * DESCRIPTION + * + * Set mime part data source from memory data, + */ +CURL_EXTERN CURLcode curl_mime_data(curl_mimepart *part, + const char *data, size_t datasize); + +/* + * NAME curl_mime_filedata() + * + * DESCRIPTION + * + * Set mime part data source from named file. + */ +CURL_EXTERN CURLcode curl_mime_filedata(curl_mimepart *part, + const char *filename); + +/* + * NAME curl_mime_data_cb() + * + * DESCRIPTION + * + * Set mime part data source from callback function. + */ +CURL_EXTERN CURLcode curl_mime_data_cb(curl_mimepart *part, + curl_off_t datasize, + curl_read_callback readfunc, + curl_seek_callback seekfunc, + curl_free_callback freefunc, + void *arg); + +/* + * NAME curl_mime_subparts() + * + * DESCRIPTION + * + * Set mime part data source from subparts. + */ +CURL_EXTERN CURLcode curl_mime_subparts(curl_mimepart *part, + curl_mime *subparts); +/* + * NAME curl_mime_headers() + * + * DESCRIPTION + * + * Set mime part headers. + */ +CURL_EXTERN CURLcode curl_mime_headers(curl_mimepart *part, + struct curl_slist *headers, + int take_ownership); + +typedef enum { + CURLFORM_NOTHING, /********* the first one is unused ************/ + CURLFORM_COPYNAME, + CURLFORM_PTRNAME, + CURLFORM_NAMELENGTH, + CURLFORM_COPYCONTENTS, + CURLFORM_PTRCONTENTS, + CURLFORM_CONTENTSLENGTH, + CURLFORM_FILECONTENT, + CURLFORM_ARRAY, + CURLFORM_OBSOLETE, + CURLFORM_FILE, + + CURLFORM_BUFFER, + CURLFORM_BUFFERPTR, + CURLFORM_BUFFERLENGTH, + + CURLFORM_CONTENTTYPE, + CURLFORM_CONTENTHEADER, + CURLFORM_FILENAME, + CURLFORM_END, + CURLFORM_OBSOLETE2, + + CURLFORM_STREAM, + CURLFORM_CONTENTLEN, /* added in 7.46.0, provide a curl_off_t length */ + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +/* structure to be used as parameter for CURLFORM_ARRAY */ +struct curl_forms { + CURLformoption option; + const char *value; +}; + +/* use this for multipart formpost building */ +/* Returns code for curl_formadd() + * + * Returns: + * CURL_FORMADD_OK on success + * CURL_FORMADD_MEMORY if the FormInfo allocation fails + * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form + * CURL_FORMADD_NULL if a null pointer was given for a char + * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used + * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) + * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated + * CURL_FORMADD_MEMORY if some allocation for string copying failed. + * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array + * + ***************************************************************************/ +typedef enum { + CURL_FORMADD_OK, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + CURL_FORMADD_LAST /* last */ +} CURLFORMcode; + +/* + * NAME curl_formadd() + * + * DESCRIPTION + * + * Pretty advanced function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, + struct curl_httppost **last_post, + ...); + +/* + * callback function for curl_formget() + * The void *arg pointer will be the one passed as second argument to + * curl_formget(). + * The character buffer passed to it must not be freed. + * Should return the buffer length passed to it as the argument "len" on + * success. + */ +typedef size_t (*curl_formget_callback)(void *arg, const char *buf, + size_t len); + +/* + * NAME curl_formget() + * + * DESCRIPTION + * + * Serialize a curl_httppost struct built with curl_formadd(). + * Accepts a void pointer as second argument which will be passed to + * the curl_formget_callback function. + * Returns 0 on success. + */ +CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg, + curl_formget_callback append); +/* + * NAME curl_formfree() + * + * DESCRIPTION + * + * Free a multipart formpost previously built with curl_formadd(). + */ +CURL_EXTERN void curl_formfree(struct curl_httppost *form); + +/* + * NAME curl_getenv() + * + * DESCRIPTION + * + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is + * complete. DEPRECATED - see lib/README.curlx + */ +CURL_EXTERN char *curl_getenv(const char *variable); + +/* + * NAME curl_version() + * + * DESCRIPTION + * + * Returns a static ascii string of the libcurl version. + */ +CURL_EXTERN char *curl_version(void); + +/* + * NAME curl_easy_escape() + * + * DESCRIPTION + * + * Escapes URL strings (converts all letters consider illegal in URLs to their + * %XX versions). This function returns a new allocated string or NULL if an + * error occurred. + */ +CURL_EXTERN char *curl_easy_escape(CURL *handle, + const char *string, + int length); + +/* the previous version: */ +CURL_EXTERN char *curl_escape(const char *string, + int length); + + +/* + * NAME curl_easy_unescape() + * + * DESCRIPTION + * + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit + * versions). This function returns a new allocated string or NULL if an error + * occurred. + * Conversion Note: On non-ASCII platforms the ASCII %XX codes are + * converted into the host encoding. + */ +CURL_EXTERN char *curl_easy_unescape(CURL *handle, + const char *string, + int length, + int *outlength); + +/* the previous version */ +CURL_EXTERN char *curl_unescape(const char *string, + int length); + +/* + * NAME curl_free() + * + * DESCRIPTION + * + * Provided for de-allocation in the same translation unit that did the + * allocation. Added in libcurl 7.10 + */ +CURL_EXTERN void curl_free(void *p); + +/* + * NAME curl_global_init() + * + * DESCRIPTION + * + * curl_global_init() should be invoked exactly once for each application that + * uses libcurl and before any call of other libcurl functions. + * + * This function is not thread-safe! + */ +CURL_EXTERN CURLcode curl_global_init(long flags); + +/* + * NAME curl_global_init_mem() + * + * DESCRIPTION + * + * curl_global_init() or curl_global_init_mem() should be invoked exactly once + * for each application that uses libcurl. This function can be used to + * initialize libcurl and set user defined memory management callback + * functions. Users can implement memory management routines to check for + * memory leaks, check for mis-use of the curl library etc. User registered + * callback routines will be invoked by this library instead of the system + * memory management routines like malloc, free etc. + */ +CURL_EXTERN CURLcode curl_global_init_mem(long flags, + curl_malloc_callback m, + curl_free_callback f, + curl_realloc_callback r, + curl_strdup_callback s, + curl_calloc_callback c); + +/* + * NAME curl_global_cleanup() + * + * DESCRIPTION + * + * curl_global_cleanup() should be invoked exactly once for each application + * that uses libcurl + */ +CURL_EXTERN void curl_global_cleanup(void); + +/* linked-list structure for the CURLOPT_QUOTE option (and other) */ +struct curl_slist { + char *data; + struct curl_slist *next; +}; + +/* + * NAME curl_global_sslset() + * + * DESCRIPTION + * + * When built with multiple SSL backends, curl_global_sslset() allows to + * choose one. This function can only be called once, and it must be called + * *before* curl_global_init(). + * + * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The + * backend can also be specified via the name parameter (passing -1 as id). + * If both id and name are specified, the name will be ignored. If neither id + * nor name are specified, the function will fail with + * CURLSSLSET_UNKNOWN_BACKEND and set the "avail" pointer to the + * NULL-terminated list of available backends. + * + * Upon success, the function returns CURLSSLSET_OK. + * + * If the specified SSL backend is not available, the function returns + * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a NULL-terminated + * list of available SSL backends. + * + * The SSL backend can be set only once. If it has already been set, a + * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE. + */ + +struct curl_ssl_backend { + curl_sslbackend id; + const char *name; +}; +typedef struct curl_ssl_backend curl_ssl_backend; + +typedef enum { + CURLSSLSET_OK = 0, + CURLSSLSET_UNKNOWN_BACKEND, + CURLSSLSET_TOO_LATE, + CURLSSLSET_NO_BACKENDS /* libcurl was built without any SSL support */ +} CURLsslset; + +CURL_EXTERN CURLsslset curl_global_sslset(curl_sslbackend id, const char *name, + const curl_ssl_backend ***avail); + +/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * NAME curl_getdate() + * + * DESCRIPTION + * + * Returns the time, in seconds since 1 Jan 1970 of the time string given in + * the first argument. The time argument in the second parameter is unused + * and should be set to NULL. + */ +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); + +/* info about the certificate chain, only for OpenSSL, GnuTLS, Schannel, NSS + and GSKit builds. Asked for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ +struct curl_certinfo { + int num_of_certs; /* number of certificates with information */ + struct curl_slist **certinfo; /* for each index in this array, there's a + linked list with textual information in the + format "name: value" */ +}; + +/* Information about the SSL library used and the respective internal SSL + handle, which can be used to obtain further information regarding the + connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION. */ +struct curl_tlssessioninfo { + curl_sslbackend backend; + void *internals; +}; + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_PTR 0x400000 /* same as SLIST */ +#define CURLINFO_SOCKET 0x500000 +#define CURLINFO_OFF_T 0x600000 +#define CURLINFO_MASK 0x0fffff +#define CURLINFO_TYPEMASK 0xf00000 + +typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, + CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, + CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, + CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, + CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + CURLINFO_LASTSOCKET = CURLINFO_LONG + 29, + CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, + CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, + CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, + CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, + CURLINFO_CERTINFO = CURLINFO_PTR + 34, + CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, + CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, + CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, + CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, + CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, + CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, + CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, + CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, + CURLINFO_TLS_SESSION = CURLINFO_PTR + 43, + CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44, + CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45, + CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46, + CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47, + CURLINFO_PROTOCOL = CURLINFO_LONG + 48, + CURLINFO_SCHEME = CURLINFO_STRING + 49, + CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50, + CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51, + CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52, + CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53, + CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54, + CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55, + CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56, + CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57, + CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58, + CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59, + CURLINFO_REFERER = CURLINFO_STRING + 60, + + CURLINFO_LASTONE = 60 +} CURLINFO; + +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + +typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ + + CURLCLOSEPOLICY_OLDEST, + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ +} curl_closepolicy; + +#define CURL_GLOBAL_SSL (1<<0) /* no purpose since 7.57.0 */ +#define CURL_GLOBAL_WIN32 (1<<1) +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) +#define CURL_GLOBAL_NOTHING 0 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL +#define CURL_GLOBAL_ACK_EINTR (1<<2) + + +/***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/* Different data locks for a single share */ +typedef enum { + CURL_LOCK_DATA_NONE = 0, + /* CURL_LOCK_DATA_SHARE is used internally to say that + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, + CURL_LOCK_DATA_PSL, + CURL_LOCK_DATA_LAST +} curl_lock_data; + +/* Different lock access types */ +typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ + CURL_LOCK_ACCESS_LAST /* never use */ +} curl_lock_access; + +typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); +typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + + +typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* 4 out of memory */ + CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ + CURLSHE_LAST /* never use */ +} CURLSHcode; + +typedef enum { + CURLSHOPT_NONE, /* don't use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ + CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock + callback functions */ + CURLSHOPT_LAST /* never use */ +} CURLSHoption; + +CURL_EXTERN CURLSH *curl_share_init(void); +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, + CURLVERSION_FIFTH, + CURLVERSION_SIXTH, + CURLVERSION_SEVENTH, + CURLVERSION_EIGHTH, + CURLVERSION_NINTH, + CURLVERSION_TENTH, + CURLVERSION_LAST /* never actually use this */ +} CURLversion; + +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +#define CURLVERSION_NOW CURLVERSION_TENTH + +struct curl_version_info_data { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ + long ssl_version_num; /* not used anymore, always 0 */ + const char *libz_version; /* human readable string */ + /* protocols is terminated by an entry with a NULL protoname */ + const char * const *protocols; + + /* The fields below this were added in CURLVERSION_SECOND */ + const char *ares; + int ares_num; + + /* This field was added in CURLVERSION_THIRD */ + const char *libidn; + + /* These field were added in CURLVERSION_FOURTH */ + + /* Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + + const char *libssh_version; /* human readable string */ + + /* These fields were added in CURLVERSION_FIFTH */ + unsigned int brotli_ver_num; /* Numeric Brotli version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *brotli_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_SIXTH */ + unsigned int nghttp2_ver_num; /* Numeric nghttp2 version + (MAJOR << 16) | (MINOR << 8) | PATCH */ + const char *nghttp2_version; /* human readable string. */ + const char *quic_version; /* human readable quic (+ HTTP/3) library + + version or NULL */ + + /* These fields were added in CURLVERSION_SEVENTH */ + const char *cainfo; /* the built-in default CURLOPT_CAINFO, might + be NULL */ + const char *capath; /* the built-in default CURLOPT_CAPATH, might + be NULL */ + + /* These fields were added in CURLVERSION_EIGHTH */ + unsigned int zstd_ver_num; /* Numeric Zstd version + (MAJOR << 24) | (MINOR << 12) | PATCH */ + const char *zstd_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_NINTH */ + const char *hyper_version; /* human readable string. */ + + /* These fields were added in CURLVERSION_TENTH */ + const char *gsasl_version; /* human readable string. */ +}; +typedef struct curl_version_info_data curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* Kerberos V4 auth is supported + (deprecated) */ +#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth is supported + (deprecated) */ +#define CURL_VERSION_DEBUG (1<<6) /* Built with debug capabilities */ +#define CURL_VERSION_ASYNCHDNS (1<<7) /* Asynchronous DNS resolves */ +#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth is supported */ +#define CURL_VERSION_LARGEFILE (1<<9) /* Supports files larger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* Internationized Domain Names are + supported */ +#define CURL_VERSION_SSPI (1<<11) /* Built against Windows SSPI */ +#define CURL_VERSION_CONV (1<<12) /* Character conversions supported */ +#define CURL_VERSION_CURLDEBUG (1<<13) /* Debug memory tracking supported */ +#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ +#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegation to winbind helper + is supported */ +#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ +#define CURL_VERSION_GSSAPI (1<<17) /* Built against a GSS-API library */ +#define CURL_VERSION_KERBEROS5 (1<<18) /* Kerberos V5 auth is supported */ +#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */ +#define CURL_VERSION_PSL (1<<20) /* Mozilla's Public Suffix List, used + for cookie domain verification */ +#define CURL_VERSION_HTTPS_PROXY (1<<21) /* HTTPS-proxy support built-in */ +#define CURL_VERSION_MULTI_SSL (1<<22) /* Multiple SSL backends available */ +#define CURL_VERSION_BROTLI (1<<23) /* Brotli features are present. */ +#define CURL_VERSION_ALTSVC (1<<24) /* Alt-Svc handling built-in */ +#define CURL_VERSION_HTTP3 (1<<25) /* HTTP3 support built-in */ +#define CURL_VERSION_ZSTD (1<<26) /* zstd features are present */ +#define CURL_VERSION_UNICODE (1<<27) /* Unicode support on Windows */ +#define CURL_VERSION_HSTS (1<<28) /* HSTS is supported */ +#define CURL_VERSION_GSASL (1<<29) /* libgsasl is supported */ + + /* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); + +/* + * NAME curl_easy_strerror() + * + * DESCRIPTION + * + * The curl_easy_strerror function may be used to turn a CURLcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_easy_strerror(CURLcode); + +/* + * NAME curl_share_strerror() + * + * DESCRIPTION + * + * The curl_share_strerror function may be used to turn a CURLSHcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_share_strerror(CURLSHcode); + +/* + * NAME curl_easy_pause() + * + * DESCRIPTION + * + * The curl_easy_pause function pauses or unpauses transfers. Select the new + * state by setting the bitmask, use the convenience defines below. + * + */ +CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask); + +#define CURLPAUSE_RECV (1<<0) +#define CURLPAUSE_RECV_CONT (0) + +#define CURLPAUSE_SEND (1<<2) +#define CURLPAUSE_SEND_CONT (0) + +#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND) +#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT) + +#ifdef __cplusplus +} +#endif + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +#include "easy.h" /* nothing in curl is fun without the easy stuff */ +#include "multi.h" +#include "urlapi.h" +#include "options.h" + +/* the typechecker doesn't work in C++ (yet) */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ + ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ + !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) +#include "typecheck-gcc.h" +#else +#if defined(__STDC__) && (__STDC__ >= 1) +/* This preprocessor magic that replaces a call with the exact same call is + only done to make sure application authors pass exactly three arguments + to these functions. */ +#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param) +#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg) +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) +#endif /* __STDC__ >= 1 */ +#endif /* gcc >= 4.3 && !__cplusplus */ + +#endif /* CURLINC_CURL_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/curlver.h b/third_party/libcurl/uos/mips64/include/curl/curlver.h new file mode 100644 index 00000000..14d168e9 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/curlver.h @@ -0,0 +1,77 @@ +#ifndef CURLINC_CURLVER_H +#define CURLINC_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + +/* This is the global package copyright */ +#define LIBCURL_COPYRIGHT "1996 - 2022 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.82.0" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 82 +#define LIBCURL_VERSION_PATCH 0 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. + + Note: This define is the full hex number and _does not_ use the + CURL_VERSION_BITS() macro since curl's own configure script greps for it + and needs it to contain the full number. +*/ +#define LIBCURL_VERSION_NUM 0x075200 + +/* + * This is the date and time when the full source package was created. The + * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * + * The format of the date follows this template: + * + * "2007-11-23" + */ +#define LIBCURL_TIMESTAMP "2022-03-05" + +#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z)) +#define CURL_AT_LEAST_VERSION(x,y,z) \ + (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z)) + +#endif /* CURLINC_CURLVER_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/easy.h b/third_party/libcurl/uos/mips64/include/curl/easy.h new file mode 100644 index 00000000..2dbfb26b --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/easy.h @@ -0,0 +1,123 @@ +#ifndef CURLINC_EASY_H +#define CURLINC_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +/* Flag bits in the curl_blob struct: */ +#define CURL_BLOB_COPY 1 /* tell libcurl to copy the data */ +#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */ + +struct curl_blob { + void *data; + size_t len; + unsigned int flags; /* bit 0 is defined, the rest are reserved and should be + left zeroes */ +}; + +CURL_EXTERN CURL *curl_easy_init(void); +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +CURL_EXTERN void curl_easy_cleanup(CURL *curl); + +/* + * NAME curl_easy_getinfo() + * + * DESCRIPTION + * + * Request internal information from the curl session with this function. The + * third argument MUST be a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). The data + * pointed to will be filled in accordingly and can be relied upon only if the + * function returns CURLE_OK. This function is intended to get used *AFTER* a + * performed transfer, all results from this function are undefined until the + * transfer is completed. + */ +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); + + +/* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistent connections cannot + * be transferred. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl); + +/* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +CURL_EXTERN void curl_easy_reset(CURL *curl); + +/* + * NAME curl_easy_recv() + * + * DESCRIPTION + * + * Receives data from the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, + size_t *n); + +/* + * NAME curl_easy_send() + * + * DESCRIPTION + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, + size_t buflen, size_t *n); + + +/* + * NAME curl_easy_upkeep() + * + * DESCRIPTION + * + * Performs connection upkeep for the given session handle. + */ +CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/third_party/libcurl/uos/mips64/include/curl/mprintf.h b/third_party/libcurl/uos/mips64/include/curl/mprintf.h new file mode 100644 index 00000000..3549552d --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/mprintf.h @@ -0,0 +1,50 @@ +#ifndef CURLINC_MPRINTF_H +#define CURLINC_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ +#include "curl.h" /* for CURL_EXTERN */ + +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef __cplusplus +} +#endif + +#endif /* CURLINC_MPRINTF_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/multi.h b/third_party/libcurl/uos/mips64/include/curl/multi.h new file mode 100644 index 00000000..91cd95d3 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/multi.h @@ -0,0 +1,457 @@ +#ifndef CURLINC_MULTI_H +#define CURLINC_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2021, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +/* + This is an "external" header file. Don't give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. + + o Enable multiple simultaneous transfers in the same thread without making it + complicated for the application. + + o Enable the application to select() on its own file descriptors and curl's + file descriptors simultaneous easily. + +*/ + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_LIBCURL) || defined(CURL_STRICTER) +typedef struct Curl_multi CURLM; +#else +typedef void CURLM; +#endif + +typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or + curl_multi_socket*() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ + CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ + CURLM_ADDED_ALREADY, /* an easy handle already added to a multi handle was + attempted to get added - again */ + CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a + callback */ + CURLM_WAKEUP_FAILURE, /* wakeup is unavailable or failed */ + CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */ + CURLM_ABORTED_BY_CALLBACK, + CURLM_LAST +} CURLMcode; + +/* just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ +#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM + +/* bitmask bits for CURLMOPT_PIPELINING */ +#define CURLPIPE_NOTHING 0L +#define CURLPIPE_HTTP1 1L +#define CURLPIPE_MULTIPLEX 2L + +typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ +} CURLMSG; + +struct CURLMsg { + CURLMSG msg; /* what this message means */ + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; +}; +typedef struct CURLMsg CURLMsg; + +/* Based on poll(2) structure and values. + * We don't use pollfd and POLL* constants explicitly + * to cover platforms without poll(). */ +#define CURL_WAIT_POLLIN 0x0001 +#define CURL_WAIT_POLLPRI 0x0002 +#define CURL_WAIT_POLLOUT 0x0004 + +struct curl_waitfd { + curl_socket_t fd; + short events; + short revents; /* not supported yet */ +}; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +CURL_EXTERN CURLM *curl_multi_init(void); + +/* + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + +/* + * Name: curl_multi_wait() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_poll() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + +/* + * Name: curl_multi_wakeup() + * + * Desc: wakes up a sleeping curl_multi_poll call. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle); + + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on individual transfers even when + * this returns OK. + */ +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/* + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there's any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain + * very basic information. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, + int *msgs_in_queue); + +/* + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a null-terminated error message. + */ +CURL_EXTERN const char *curl_multi_strerror(CURLMcode); + +/* + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. + * See man page for details. + */ +#define CURL_POLL_NONE 0 +#define CURL_POLL_IN 1 +#define CURL_POLL_OUT 2 +#define CURL_POLL_INOUT 3 +#define CURL_POLL_REMOVE 4 + +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD + +#define CURL_CSELECT_IN 0x01 +#define CURL_CSELECT_OUT 0x02 +#define CURL_CSELECT_ERR 0x04 + +typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ + curl_socket_t s, /* socket */ + int what, /* see above */ + void *userp, /* private callback + pointer */ + void *socketp); /* private socket + pointer */ +/* + * Name: curl_multi_timer_callback + * + * Desc: Called by libcurl whenever the library detects a change in the + * maximum number of milliseconds the app is allowed to wait before + * curl_multi_socket() or curl_multi_perform() must be called + * (to allow libcurl's timed events to take place). + * + * Returns: The callback should return zero. + */ +typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */ + long timeout_ms, /* see above */ + void *userp); /* private callback + pointer */ + +CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle, + curl_socket_t s, + int ev_bitmask, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle, + int *running_handles); + +#ifndef CURL_ALLOW_OLD_MULTI_SOCKET +/* This macro below was added in 7.16.3 to push users who recompile to use + the new curl_multi_socket_action() instead of the old curl_multi_socket() +*/ +#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z) +#endif + +/* + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, + long *milliseconds); + +typedef enum { + /* This is the socket callback function pointer */ + CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3), + + /* This is the timer callback function pointer */ + CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7), + + /* maximum number of requests in a pipeline */ + CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10), + + /* a list of site names(+port) that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11), + + /* a list of server types that are blocked from pipelining */ + CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13), + + /* This is the server push callback function pointer */ + CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14), + + /* This is the argument passed to the server push callback */ + CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15), + + /* maximum number of concurrent streams to support on a connection */ + CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16), + + CURLMOPT_LASTENTRY /* the last unused */ +} CURLMoption; + + +/* + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle, + CURLMoption option, ...); + + +/* + * Name: curl_multi_assign() + * + * Desc: This function sets an association in the multi handle between the + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, + curl_socket_t sockfd, void *sockp); + + +/* + * Name: curl_push_callback + * + * Desc: This callback gets called when a new stream is being pushed by the + * server. It approves or denies the new stream. It can also decide + * to completely fail the connection. + * + * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT + */ +#define CURL_PUSH_OK 0 +#define CURL_PUSH_DENY 1 +#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */ + +struct curl_pushheaders; /* forward declaration only */ + +CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h, + size_t num); +CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h, + const char *name); + +typedef int (*curl_push_callback)(CURL *parent, + CURL *easy, + size_t num_headers, + struct curl_pushheaders *headers, + void *userp); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/third_party/libcurl/uos/mips64/include/curl/options.h b/third_party/libcurl/uos/mips64/include/curl/options.h new file mode 100644 index 00000000..14373b55 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/options.h @@ -0,0 +1,68 @@ +#ifndef CURLINC_OPTIONS_H +#define CURLINC_OPTIONS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2020, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + CURLOT_LONG, /* long (a range of values) */ + CURLOT_VALUES, /* (a defined set or bitmask) */ + CURLOT_OFF_T, /* curl_off_t (a range of values) */ + CURLOT_OBJECT, /* pointer (void *) */ + CURLOT_STRING, /* (char * to zero terminated buffer) */ + CURLOT_SLIST, /* (struct curl_slist *) */ + CURLOT_CBPTR, /* (void * passed as-is to a callback) */ + CURLOT_BLOB, /* blob (struct curl_blob *) */ + CURLOT_FUNCTION /* function pointer */ +} curl_easytype; + +/* Flag bits */ + +/* "alias" means it is provided for old programs to remain functional, + we prefer another name */ +#define CURLOT_FLAG_ALIAS (1<<0) + +/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size + to use for curl_easy_setopt() for the given id */ +struct curl_easyoption { + const char *name; + CURLoption id; + curl_easytype type; + unsigned int flags; +}; + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_name(const char *name); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_by_id (CURLoption id); + +CURL_EXTERN const struct curl_easyoption * +curl_easy_option_next(const struct curl_easyoption *prev); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif +#endif /* CURLINC_OPTIONS_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/stdcheaders.h b/third_party/libcurl/uos/mips64/include/curl/stdcheaders.h new file mode 100644 index 00000000..60596c75 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef CURLINC_STDCHEADERS_H +#define CURLINC_STDCHEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2020, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include + +size_t fread(void *, size_t, size_t, FILE *); +size_t fwrite(const void *, size_t, size_t, FILE *); + +int strcasecmp(const char *, const char *); +int strncasecmp(const char *, const char *, size_t); + +#endif /* CURLINC_STDCHEADERS_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/system.h b/third_party/libcurl/uos/mips64/include/curl/system.h new file mode 100644 index 00000000..038ac0b1 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/system.h @@ -0,0 +1,488 @@ +#ifndef CURLINC_SYSTEM_H +#define CURLINC_SYSTEM_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2022, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* + * Try to keep one section per platform, compiler and architecture, otherwise, + * if an existing section is reused for a different one and later on the + * original is adjusted, probably the piggybacking one can be adversely + * changed. + * + * In order to differentiate between platforms/compilers/architectures use + * only compiler built in predefined preprocessor symbols. + * + * curl_off_t + * ---------- + * + * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit + * wide signed integral data type. The width of this data type must remain + * constant and independent of any possible large file support settings. + * + * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit + * wide signed integral data type if there is no 64-bit type. + * + * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall + * only be violated if off_t is the only 64-bit data type available and the + * size of off_t is independent of large file support settings. Keep your + * build on the safe side avoiding an off_t gating. If you have a 64-bit + * off_t then take for sure that another 64-bit data type exists, dig deeper + * and you will find it. + * + */ + +#if defined(__DJGPP__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__SALFORDC__) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TURBOC__) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# elif defined(_MSC_VER) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__LCC__) +# if defined(__e2k__) /* MCST eLbrus C Compiler */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# else /* Local (or Little) C Compiler */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# endif + +#elif defined(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__CW32__) +# pragma longlong on +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__VC32__) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__MWERKS__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(_WIN32_WCE) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__MINGW32__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_WS2TCPIP_H 1 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int + +#elif defined(__OS400__) +# if defined(__ILEC400__) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__MVS__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# elif defined(_LP64) +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +#elif defined(__TINYC__) /* also known as tcc */ +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ +# if !defined(__LP64) && (defined(__ILP32) || \ + defined(__i386) || \ + defined(__sparcv8) || \ + defined(__sparcv8plus)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64) || \ + defined(__amd64) || defined(__sparcv9) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#elif defined(__xlc__) /* IBM xlc compiler */ +# if !defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) && !defined(_SCO_DS) +# if !defined(__LP64__) && \ + (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ + defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ + defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ + defined(__XTENSA__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64__) || \ + defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ + defined(__e2k__) || \ + (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ + (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +/* generic "safe guess" on old 32 bit style */ +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +#endif + +#ifdef _AIX +/* AIX needs */ +#define CURL_PULL_SYS_POLL_H +#endif + + +/* CURL_PULL_WS2TCPIP_H is defined above when inclusion of header file */ +/* ws2tcpip.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_WS2TCPIP_H +# include +# include +# include +#endif + +/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ +/* sys/types.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ +/* sys/socket.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ +/* sys/poll.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_POLL_H +# include +#endif + +/* Data type definition of curl_socklen_t. */ +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T + typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; +#endif + +/* Data type definition of curl_off_t. */ + +#ifdef CURL_TYPEOF_CURL_OFF_T + typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; +#endif + +/* + * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow + * these to be visible and exported by the external libcurl interface API, + * while also making them visible to the library internals, simply including + * curl_setup.h, without actually needing to include curl.h internally. + * If some day this section would grow big enough, all this should be moved + * to its own header file. + */ + +/* + * Figure out if we can use the ## preprocessor operator, which is supported + * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ + * or __cplusplus so we need to carefully check for them too. + */ + +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ + defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ + defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ + defined(__ILEC400__) + /* This compiler is believed to have an ISO compatible preprocessor */ +#define CURL_ISOCPP +#else + /* This compiler is believed NOT to have an ISO compatible preprocessor */ +#undef CURL_ISOCPP +#endif + +/* + * Macros for minimum-width signed and unsigned curl_off_t integer constants. + */ + +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) +# define CURLINC_OFF_T_C_HLPR2(x) x +# define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ + CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +#endif /* CURLINC_SYSTEM_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/typecheck-gcc.h b/third_party/libcurl/uos/mips64/include/curl/typecheck-gcc.h new file mode 100644 index 00000000..9e14d8a3 --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/typecheck-gcc.h @@ -0,0 +1,707 @@ +#ifndef CURLINC_TYPECHECK_GCC_H +#define CURLINC_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2021, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(curlcheck_sometype_option(_curl_opt)) + * if(!curlcheck_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define curlcheck_sometype_option, curlcheck_sometype and + * _curl_easy_setopt_err_sometype below + * + * NOTE: We use two nested 'if' statements here instead of the && operator, in + * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x + * when compiling with -Wlogical-op. + * + * To add an option that uses the same type as an existing option, you'll just + * need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ + __extension__({ \ + __typeof__(option) _curl_opt = option; \ + if(__builtin_constant_p(_curl_opt)) { \ + if(curlcheck_long_option(_curl_opt)) \ + if(!curlcheck_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(curlcheck_off_t_option(_curl_opt)) \ + if(!curlcheck_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(curlcheck_string_option(_curl_opt)) \ + if(!curlcheck_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(curlcheck_write_cb_option(_curl_opt)) \ + if(!curlcheck_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_RESOLVER_START_FUNCTION) \ + if(!curlcheck_resolver_start_callback(value)) \ + _curl_easy_setopt_err_resolver_start_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!curlcheck_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!curlcheck_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!curlcheck_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!curlcheck_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!curlcheck_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!curlcheck_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!curlcheck_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(curlcheck_conv_cb_option(_curl_opt)) \ + if(!curlcheck_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!curlcheck_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(curlcheck_cb_data_option(_curl_opt)) \ + if(!curlcheck_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!curlcheck_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!curlcheck_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(curlcheck_postfields_option(_curl_opt)) \ + if(!curlcheck_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!curlcheck_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if((_curl_opt) == CURLOPT_MIMEPOST) \ + if(!curlcheck_ptr((value), curl_mime)) \ + _curl_easy_setopt_err_curl_mimepost(); \ + if(curlcheck_slist_option(_curl_opt)) \ + if(!curlcheck_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!curlcheck_ptr((value), CURLSH)) \ + _curl_easy_setopt_err_CURLSH(); \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ + }) + +/* wraps curl_easy_getinfo() with typechecking */ +#define curl_easy_getinfo(handle, info, arg) \ + __extension__({ \ + __typeof__(info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(curlcheck_string_info(_curl_info)) \ + if(!curlcheck_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(curlcheck_long_info(_curl_info)) \ + if(!curlcheck_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(curlcheck_double_info(_curl_info)) \ + if(!curlcheck_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(curlcheck_slist_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + if(curlcheck_tlssessioninfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_tlssessioninfo *)) \ + _curl_easy_getinfo_err_curl_tlssesssioninfo(); \ + if(curlcheck_certinfo_info(_curl_info)) \ + if(!curlcheck_arr((arg), struct curl_certinfo *)) \ + _curl_easy_getinfo_err_curl_certinfo(); \ + if(curlcheck_socket_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_socket_t)) \ + _curl_easy_getinfo_err_curl_socket(); \ + if(curlcheck_off_t_info(_curl_info)) \ + if(!curlcheck_arr((arg), curl_off_t)) \ + _curl_easy_getinfo_err_curl_off_t(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ + }) + +/* + * For now, just make sure that the functions are called with three arguments + */ +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) + + +/* the actual warnings, triggered by calling the _curl_easy_setopt_err* + * functions */ + +/* To define a new warning, use _CURL_WARNING(identifier, "message") */ +#define CURLWARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +CURLWARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +CURLWARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string ('char *' or char[]) argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_resolver_start_callback, + "curl_easy_setopt expects a " + "curl_resolver_start_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +CURLWARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +CURLWARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +CURLWARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +CURLWARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a 'FILE *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a 'void *' or 'char *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a 'struct curl_httppost *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_mimepost, + "curl_easy_setopt expects a 'curl_mime *' " + "argument for this option") +CURLWARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a 'struct curl_slist *' argument for this option") +CURLWARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +CURLWARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to 'char *' for this info") +CURLWARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +CURLWARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to 'struct curl_slist *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_tlssesssioninfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_tlssessioninfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_certinfo, + "curl_easy_getinfo expects a pointer to " + "'struct curl_certinfo *' for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_socket, + "curl_easy_getinfo expects a pointer to curl_socket_t for this info") +CURLWARNING(_curl_easy_getinfo_err_curl_off_t, + "curl_easy_getinfo expects a pointer to curl_off_t for this info") + +/* groups of curl_easy_setops options that take the same type of argument */ + +/* To add a new option to one of the groups, just add + * (option) == CURLOPT_SOMETHING + * to the or-expression. If the option takes a long or curl_off_t, you don't + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define curlcheck_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define curlcheck_off_t_option(option) \ + (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB)) + +/* evaluates to true if option takes a char* argument */ +#define curlcheck_string_option(option) \ + ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_ALTSVC || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_DEFAULT_PROTOCOL || \ + (option) == CURLOPT_DNS_INTERFACE || \ + (option) == CURLOPT_DNS_LOCAL_IP4 || \ + (option) == CURLOPT_DNS_LOCAL_IP6 || \ + (option) == CURLOPT_DNS_SERVERS || \ + (option) == CURLOPT_DOH_URL || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_HSTS || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_LOGIN_OPTIONS || \ + (option) == CURLOPT_MAIL_AUTH || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PRE_PROXY || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXY_CAINFO || \ + (option) == CURLOPT_PROXY_CAPATH || \ + (option) == CURLOPT_PROXY_CRLFILE || \ + (option) == CURLOPT_PROXY_ISSUERCERT || \ + (option) == CURLOPT_PROXY_KEYPASSWD || \ + (option) == CURLOPT_PROXY_PINNEDPUBLICKEY || \ + (option) == CURLOPT_PROXY_SERVICE_NAME || \ + (option) == CURLOPT_PROXY_SSLCERT || \ + (option) == CURLOPT_PROXY_SSLCERTTYPE || \ + (option) == CURLOPT_PROXY_SSLKEY || \ + (option) == CURLOPT_PROXY_SSLKEYTYPE || \ + (option) == CURLOPT_PROXY_SSL_CIPHER_LIST || \ + (option) == CURLOPT_PROXY_TLS13_CIPHERS || \ + (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_PROXY_TLSAUTH_TYPE || \ + (option) == CURLOPT_PROXY_TLSAUTH_USERNAME || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_REQUEST_TARGET || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_SASL_AUTHZID || \ + (option) == CURLOPT_SERVICE_NAME || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_TLS13_CIPHERS || \ + (option) == CURLOPT_TLSAUTH_PASSWORD || \ + (option) == CURLOPT_TLSAUTH_TYPE || \ + (option) == CURLOPT_TLSAUTH_USERNAME || \ + (option) == CURLOPT_UNIX_SOCKET_PATH || \ + (option) == CURLOPT_URL || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_AWS_SIGV4 || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + (option) == CURLOPT_SSL_EC_CURVES || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define curlcheck_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define curlcheck_conv_cb_option(option) \ + ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) + +/* evaluates to true if option takes a data argument to pass to a callback */ +#define curlcheck_cb_data_option(option) \ + ((option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_CLOSESOCKETDATA || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + (option) == CURLOPT_HEADERDATA || \ + (option) == CURLOPT_HSTSREADDATA || \ + (option) == CURLOPT_HSTSWRITEDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PREREQDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_WRITEDATA || \ + (option) == CURLOPT_RESOLVER_START_DATA || \ + (option) == CURLOPT_TRAILERDATA || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define curlcheck_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define curlcheck_slist_option(option) \ + ((option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_HTTPHEADER || \ + (option) == CURLOPT_MAIL_RCPT || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_PROXYHEADER || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_RESOLVE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_CONNECT_TO || \ + 0) + +/* groups of curl_easy_getinfo infos that take the same type of argument */ + +/* evaluates to true if info expects a pointer to char * argument */ +#define curlcheck_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG && \ + (info) != CURLINFO_PRIVATE) + +/* evaluates to true if info expects a pointer to long argument */ +#define curlcheck_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define curlcheck_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define curlcheck_slist_info(info) \ + (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST)) + +/* true if info expects a pointer to struct curl_tlssessioninfo * argument */ +#define curlcheck_tlssessioninfo_info(info) \ + (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION)) + +/* true if info expects a pointer to struct curl_certinfo * argument */ +#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO) + +/* true if info expects a pointer to struct curl_socket_t argument */ +#define curlcheck_socket_info(info) \ + (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T) + +/* true if info expects a pointer to curl_off_t argument */ +#define curlcheck_off_t_info(info) \ + (CURLINFO_OFF_T < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the curlcheck_ptr/curlcheck_arr macros, + * otherwise define a new macro. Search for __builtin_types_compatible_p + * in the GCC manual. + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is + * the actual expression passed to the curl_easy_setopt macro. This + * means that you can only apply the sizeof and __typeof__ operators, no + * == or whatsoever. + */ + +/* XXX: should evaluate to true if expr is a pointer */ +#define curlcheck_any_ptr(expr) \ + (sizeof(expr) == sizeof(void *)) + +/* evaluates to true if expr is NULL */ +/* XXX: must not evaluate expr, so this check is not accurate */ +#define curlcheck_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define curlcheck_ptr(expr, type) \ + (curlcheck_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), type *) || \ + __builtin_types_compatible_p(__typeof__(expr), const type *)) + +/* evaluates to true if expr is one of type[], type*, NULL or const type* */ +#define curlcheck_arr(expr, type) \ + (curlcheck_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define curlcheck_string(expr) \ + (curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), signed char) || \ + curlcheck_arr((expr), unsigned char)) + +/* evaluates to true if expr is a long (no matter the signedness) + * XXX: for now, int is also accepted (and therefore short and char, which + * are promoted to int when passed to a variadic function) */ +#define curlcheck_long(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), long) || \ + __builtin_types_compatible_p(__typeof__(expr), signed long) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \ + __builtin_types_compatible_p(__typeof__(expr), int) || \ + __builtin_types_compatible_p(__typeof__(expr), signed int) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \ + __builtin_types_compatible_p(__typeof__(expr), short) || \ + __builtin_types_compatible_p(__typeof__(expr), signed short) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \ + __builtin_types_compatible_p(__typeof__(expr), char) || \ + __builtin_types_compatible_p(__typeof__(expr), signed char) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned char)) + +/* evaluates to true if expr is of type curl_off_t */ +#define curlcheck_off_t(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) + +/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ +/* XXX: also check size of an char[] array? */ +#define curlcheck_error_buffer(expr) \ + (curlcheck_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), char *) || \ + __builtin_types_compatible_p(__typeof__(expr), char[])) + +/* evaluates to true if expr is of type (const) void* or (const) FILE* */ +#if 0 +#define curlcheck_cb_data(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_ptr((expr), FILE)) +#else /* be less strict */ +#define curlcheck_cb_data(expr) \ + curlcheck_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define curlcheck_FILE(expr) \ + (curlcheck_NULL(expr) || \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *))) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define curlcheck_postfields(expr) \ + (curlcheck_ptr((expr), void) || \ + curlcheck_arr((expr), char) || \ + curlcheck_arr((expr), unsigned char)) + +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define curlcheck_cb_compatible(func, type) \ + (__builtin_types_compatible_p(__typeof__(func), type) || \ + __builtin_types_compatible_p(__typeof__(func) *, type)) + +/* evaluates to true if expr is of type curl_resolver_start_callback */ +#define curlcheck_resolver_start_callback(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_resolver_start_callback)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define curlcheck_read_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fread) *) || \ + curlcheck_cb_compatible((expr), curl_read_callback) || \ + curlcheck_cb_compatible((expr), _curl_read_callback1) || \ + curlcheck_cb_compatible((expr), _curl_read_callback2) || \ + curlcheck_cb_compatible((expr), _curl_read_callback3) || \ + curlcheck_cb_compatible((expr), _curl_read_callback4) || \ + curlcheck_cb_compatible((expr), _curl_read_callback5) || \ + curlcheck_cb_compatible((expr), _curl_read_callback6)) +typedef size_t (*_curl_read_callback1)(char *, size_t, size_t, void *); +typedef size_t (*_curl_read_callback2)(char *, size_t, size_t, const void *); +typedef size_t (*_curl_read_callback3)(char *, size_t, size_t, FILE *); +typedef size_t (*_curl_read_callback4)(void *, size_t, size_t, void *); +typedef size_t (*_curl_read_callback5)(void *, size_t, size_t, const void *); +typedef size_t (*_curl_read_callback6)(void *, size_t, size_t, FILE *); + +/* evaluates to true if expr is of type curl_write_callback or "similar" */ +#define curlcheck_write_cb(expr) \ + (curlcheck_read_cb(expr) || \ + curlcheck_cb_compatible((expr), __typeof__(fwrite) *) || \ + curlcheck_cb_compatible((expr), curl_write_callback) || \ + curlcheck_cb_compatible((expr), _curl_write_callback1) || \ + curlcheck_cb_compatible((expr), _curl_write_callback2) || \ + curlcheck_cb_compatible((expr), _curl_write_callback3) || \ + curlcheck_cb_compatible((expr), _curl_write_callback4) || \ + curlcheck_cb_compatible((expr), _curl_write_callback5) || \ + curlcheck_cb_compatible((expr), _curl_write_callback6)) +typedef size_t (*_curl_write_callback1)(const char *, size_t, size_t, void *); +typedef size_t (*_curl_write_callback2)(const char *, size_t, size_t, + const void *); +typedef size_t (*_curl_write_callback3)(const char *, size_t, size_t, FILE *); +typedef size_t (*_curl_write_callback4)(const void *, size_t, size_t, void *); +typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t, + const void *); +typedef size_t (*_curl_write_callback6)(const void *, size_t, size_t, FILE *); + +/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ +#define curlcheck_ioctl_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ioctl_callback) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback3) || \ + curlcheck_cb_compatible((expr), _curl_ioctl_callback4)) +typedef curlioerr (*_curl_ioctl_callback1)(CURL *, int, void *); +typedef curlioerr (*_curl_ioctl_callback2)(CURL *, int, const void *); +typedef curlioerr (*_curl_ioctl_callback3)(CURL *, curliocmd, void *); +typedef curlioerr (*_curl_ioctl_callback4)(CURL *, curliocmd, const void *); + +/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ +#define curlcheck_sockopt_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_sockopt_callback) || \ + curlcheck_cb_compatible((expr), _curl_sockopt_callback1) || \ + curlcheck_cb_compatible((expr), _curl_sockopt_callback2)) +typedef int (*_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); +typedef int (*_curl_sockopt_callback2)(const void *, curl_socket_t, + curlsocktype); + +/* evaluates to true if expr is of type curl_opensocket_callback or + "similar" */ +#define curlcheck_opensocket_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_opensocket_callback) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback1) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback2) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback3) || \ + curlcheck_cb_compatible((expr), _curl_opensocket_callback4)) +typedef curl_socket_t (*_curl_opensocket_callback1) + (void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback2) + (void *, curlsocktype, const struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback3) + (const void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (*_curl_opensocket_callback4) + (const void *, curlsocktype, const struct curl_sockaddr *); + +/* evaluates to true if expr is of type curl_progress_callback or "similar" */ +#define curlcheck_progress_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_progress_callback) || \ + curlcheck_cb_compatible((expr), _curl_progress_callback1) || \ + curlcheck_cb_compatible((expr), _curl_progress_callback2)) +typedef int (*_curl_progress_callback1)(void *, + double, double, double, double); +typedef int (*_curl_progress_callback2)(const void *, + double, double, double, double); + +/* evaluates to true if expr is of type curl_debug_callback or "similar" */ +#define curlcheck_debug_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_debug_callback) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback1) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback2) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback3) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback4) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback5) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback6) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback7) || \ + curlcheck_cb_compatible((expr), _curl_debug_callback8)) +typedef int (*_curl_debug_callback1) (CURL *, + curl_infotype, char *, size_t, void *); +typedef int (*_curl_debug_callback2) (CURL *, + curl_infotype, char *, size_t, const void *); +typedef int (*_curl_debug_callback3) (CURL *, + curl_infotype, const char *, size_t, void *); +typedef int (*_curl_debug_callback4) (CURL *, + curl_infotype, const char *, size_t, const void *); +typedef int (*_curl_debug_callback5) (CURL *, + curl_infotype, unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback6) (CURL *, + curl_infotype, unsigned char *, size_t, const void *); +typedef int (*_curl_debug_callback7) (CURL *, + curl_infotype, const unsigned char *, size_t, void *); +typedef int (*_curl_debug_callback8) (CURL *, + curl_infotype, const unsigned char *, size_t, const void *); + +/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ +/* this is getting even messier... */ +#define curlcheck_ssl_ctx_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback1) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback2) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback3) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback4) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback5) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback6) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback7) || \ + curlcheck_cb_compatible((expr), _curl_ssl_ctx_callback8)) +typedef CURLcode (*_curl_ssl_ctx_callback1)(CURL *, void *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback2)(CURL *, void *, const void *); +typedef CURLcode (*_curl_ssl_ctx_callback3)(CURL *, const void *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback4)(CURL *, const void *, + const void *); +#ifdef HEADER_SSL_H +/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX + * this will of course break if we're included before OpenSSL headers... + */ +typedef CURLcode (*_curl_ssl_ctx_callback5)(CURL *, SSL_CTX *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback6)(CURL *, SSL_CTX *, const void *); +typedef CURLcode (*_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX *, void *); +typedef CURLcode (*_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX *, + const void *); +#else +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; +#endif + +/* evaluates to true if expr is of type curl_conv_callback or "similar" */ +#define curlcheck_conv_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_conv_callback) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback1) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback2) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback3) || \ + curlcheck_cb_compatible((expr), _curl_conv_callback4)) +typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); +typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); +typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); +typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); + +/* evaluates to true if expr is of type curl_seek_callback or "similar" */ +#define curlcheck_seek_cb(expr) \ + (curlcheck_NULL(expr) || \ + curlcheck_cb_compatible((expr), curl_seek_callback) || \ + curlcheck_cb_compatible((expr), _curl_seek_callback1) || \ + curlcheck_cb_compatible((expr), _curl_seek_callback2)) +typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); +typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); + + +#endif /* CURLINC_TYPECHECK_GCC_H */ diff --git a/third_party/libcurl/uos/mips64/include/curl/urlapi.h b/third_party/libcurl/uos/mips64/include/curl/urlapi.h new file mode 100644 index 00000000..a475f91b --- /dev/null +++ b/third_party/libcurl/uos/mips64/include/curl/urlapi.h @@ -0,0 +1,145 @@ +#ifndef CURLINC_URLAPI_H +#define CURLINC_URLAPI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 2018 - 2021, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at https://curl.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* the error codes for the URL API */ +typedef enum { + CURLUE_OK, + CURLUE_BAD_HANDLE, /* 1 */ + CURLUE_BAD_PARTPOINTER, /* 2 */ + CURLUE_MALFORMED_INPUT, /* 3 */ + CURLUE_BAD_PORT_NUMBER, /* 4 */ + CURLUE_UNSUPPORTED_SCHEME, /* 5 */ + CURLUE_URLDECODE, /* 6 */ + CURLUE_OUT_OF_MEMORY, /* 7 */ + CURLUE_USER_NOT_ALLOWED, /* 8 */ + CURLUE_UNKNOWN_PART, /* 9 */ + CURLUE_NO_SCHEME, /* 10 */ + CURLUE_NO_USER, /* 11 */ + CURLUE_NO_PASSWORD, /* 12 */ + CURLUE_NO_OPTIONS, /* 13 */ + CURLUE_NO_HOST, /* 14 */ + CURLUE_NO_PORT, /* 15 */ + CURLUE_NO_QUERY, /* 16 */ + CURLUE_NO_FRAGMENT, /* 17 */ + CURLUE_NO_ZONEID, /* 18 */ + CURLUE_BAD_FILE_URL, /* 19 */ + CURLUE_BAD_FRAGMENT, /* 20 */ + CURLUE_BAD_HOSTNAME, /* 21 */ + CURLUE_BAD_IPV6, /* 22 */ + CURLUE_BAD_LOGIN, /* 23 */ + CURLUE_BAD_PASSWORD, /* 24 */ + CURLUE_BAD_PATH, /* 25 */ + CURLUE_BAD_QUERY, /* 26 */ + CURLUE_BAD_SCHEME, /* 27 */ + CURLUE_BAD_SLASHES, /* 28 */ + CURLUE_BAD_USER, /* 29 */ + CURLUE_LAST +} CURLUcode; + +typedef enum { + CURLUPART_URL, + CURLUPART_SCHEME, + CURLUPART_USER, + CURLUPART_PASSWORD, + CURLUPART_OPTIONS, + CURLUPART_HOST, + CURLUPART_PORT, + CURLUPART_PATH, + CURLUPART_QUERY, + CURLUPART_FRAGMENT, + CURLUPART_ZONEID /* added in 7.65.0 */ +} CURLUPart; + +#define CURLU_DEFAULT_PORT (1<<0) /* return default port number */ +#define CURLU_NO_DEFAULT_PORT (1<<1) /* act as if no port number was set, + if the port number matches the + default for the scheme */ +#define CURLU_DEFAULT_SCHEME (1<<2) /* return default scheme if + missing */ +#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */ +#define CURLU_PATH_AS_IS (1<<4) /* leave dot sequences */ +#define CURLU_DISALLOW_USER (1<<5) /* no user+password allowed */ +#define CURLU_URLDECODE (1<<6) /* URL decode on get */ +#define CURLU_URLENCODE (1<<7) /* URL encode on set */ +#define CURLU_APPENDQUERY (1<<8) /* append a form style part */ +#define CURLU_GUESS_SCHEME (1<<9) /* legacy curl-style guessing */ +#define CURLU_NO_AUTHORITY (1<<10) /* Allow empty authority when the + scheme is unknown. */ +#define CURLU_ALLOW_SPACE (1<<11) /* Allow spaces in the URL */ + +typedef struct Curl_URL CURLU; + +/* + * curl_url() creates a new CURLU handle and returns a pointer to it. + * Must be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url(void); + +/* + * curl_url_cleanup() frees the CURLU handle and related resources used for + * the URL parsing. It will not free strings previously returned with the URL + * API. + */ +CURL_EXTERN void curl_url_cleanup(CURLU *handle); + +/* + * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new + * handle must also be freed with curl_url_cleanup(). + */ +CURL_EXTERN CURLU *curl_url_dup(CURLU *in); + +/* + * curl_url_get() extracts a specific part of the URL from a CURLU + * handle. Returns error code. The returned pointer MUST be freed with + * curl_free() afterwards. + */ +CURL_EXTERN CURLUcode curl_url_get(CURLU *handle, CURLUPart what, + char **part, unsigned int flags); + +/* + * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns + * error code. The passed in string will be copied. Passing a NULL instead of + * a part string, clears that part. + */ +CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what, + const char *part, unsigned int flags); + +/* + * curl_url_strerror() turns a CURLUcode value into the equivalent human + * readable error string. This is useful for printing meaningful error + * messages. + */ +CURL_EXTERN const char *curl_url_strerror(CURLUcode); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif /* CURLINC_URLAPI_H */ diff --git a/third_party/libcurl/uos/mips64/lib/libcurl.a b/third_party/libcurl/uos/mips64/lib/libcurl.a new file mode 100644 index 0000000000000000000000000000000000000000..182ce1732098013bb32d611a1685e42c1df0338c GIT binary patch literal 1264654 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 #=W>TT7?)f4rd)1oQ!SKgIsTCVW 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⁡XZ|)R{TDE)&hXb_8-b|CL1a1Y|a^46@G5 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 Z@FX8crZ*}9qGL#Ek zr!;V0VgE7I&Thc-{5YKFzp{Ym`0)F6j4_TUO$X!SsDbS_KMLvDItB3>gMQ8VW8!!$ zj{B!;yX>)WEwc~5wE^c{@F+>XCl3G6b_UMBa4f<8h>yj72p(m!`NVc%pnhR_z!*IL z5!-%VS-?DPlRB~*502YLh}(xKZpM6RVS_D;-?P^^SVuof^#;d7?nm#i49`zj?Xgb@ zNDKW%KX6?P<@HZtpY=2JtS#&CTO6q%W7`CtFaHFzbyrvM8$aJ%Sc>%=3ZK`mti$2nbb+#^jFX#LJpKRTAesZ3%u5#T%A1jSJU%)(IAN(Ec%WNK2>!=&ER_kb+ zjjywtiCqWZRC&FZ+W^K5$HG6Nu{slrANsdo6V7MA*RR@h1I#bSY#H+5`doWnKw}uR zW+*#sf4@TIS8HCdb+kFwbMQX%7WimPwxZ|!dqB4xM&G*hTc#2?UL)i6u#2s+^B%d1 zu7fz&!Pk!_{_(V%=a^o3AM`VLZHIL$Ft1y?lcwjqsoa@%{fRMsvEG9i6YF!i4DV@R zU3&rg7Hm7N?>5kP!#`l=D$WhKIRST_hI0;h&iTKud^Ir#w(;5WfmrWh^bvi9XMyX! z2P_BaoP_-sLi;%%G3aM;S+4jmc^3C(^(<`~?ENJC`w$wASpI(Zztgk8(a-ui_w;up z@aBs4Pahx7Uuq=i?i?B_l!C5&kSh%3gTiz9;b7O}k3F_~SF16d1Ne#4QXW74FqH2G z*=SEse)u*H3kic_U*`yl28#pvQa&g9S@&7`@eHlEZb2{LdSc5~yWTwlA8{S%AL$F4 zTU%R#B0jPlltv-VfuK}?N0YauawtrV;Qwd?wwnv?NoQPdTYZAra0b{v$R`@U7oTxP z3pP>s&r>7$;mtdG@#C#_S=|m><7cRMxggkwrazg_7dP)1=zlJcPfhdpI6mIlKL8)o z7|9RWZ)tGykOiA1_bfJtH|Xpt3`4Yn+-M$iS?V9m!&9p0h<#>TbQF9@H|QQHjO26P zezF6{*|+Wk{2Bm$%A@J=$9CIn8FmET?=Qj!a4|XfU`OY0Z{8KvBfUd~;e3!9$OT<{ z;nTJFQ4!W|?keQ=Ix~iJ^m6~TlBb`3dh-r=8W#fEkM#!c%i`jmLC5D`^&W_*{ievC z{7`SHZ=17^uIn8^|BwVDmA*eG2|MeMZww1;gi6TnY8~zz8i5MCc{hFDgdDQ@z;vz= z{NSW0<6b;-P=>t6dF1lzdjs_qE8*5Hsa)XdGb!K$E!k-X9rWIwD-T(Ilg*ZQp9Kbd%a1vwnvlQQrmcrM+h+iarn)n~X zdaXEohxF5M^?*x@TbaLw^;&uy>+HJ~RE1{fX4MAZYw3dserE)KAcF6S;9U{C7{R{~ z!Qld6P5-|d!G9-$V|lCOf`2%I-ygv<5&ZE84i`sj`t$h+ z4mX_E)c;xp|9S*J9l_5<@Qc8)-p)|rT%mgI-i0aR=?^^A(CyAQLSOvB@Bg@O^w<|l zdh?}@(c(a%GuPox%-mZj-SAaQ9?}8ok`XcxE(^hffR9yE<#U zdDGpO?|#+}Z|-ZuBkoB1j0nB@gQp*>&cG*;LSb3`Kob1w=pG#@6$U$$B^TfhJhgL1 zFh(8t*8n<-?sU)L)lV@MdxuA!DuRMSu=;XPXE%Q(3C~+FZ1B}38{Suc&|!z7m9l+D;>{u4vdDpu_rB1p`t$?Wqo#UW7+Uw0@r@)3C{aF zhx0C6&O1ELS+^gr>gec)Tt578$H)j=Z&2KAId@Q1a}9vU4QL+fU8unA#z`f3$gx%i z;tX->_GKV$B97xfEW(@J_BG#)Y9mhX63M$YMdIt-IuXz|T`q9nA@<=Wo?WO}r)blZ z=?B?K2DH7O*7ytsEMjNEZQJj^!%wkul=ud>7QLNh1x8%-Jl;}#g!8*foG&tK_+2Fm zfY{#%{XZ`3zuPhf$5UKLFZP#++jmex@2t22G{*99Iog7i=QJhVX3fQZi{_$l)m-!? z;+)@%^%~~gh*Noqo&8#$WIc`-xcKFZ{XZ`6!~cZxI~(Sq{NlKP%lq9*>KlCA)h>9R z7`9Uz<{>-YyE|g%2k2x@}4Kl-A4lt!6yV_Gh&n@$-zQ=XB3$o|qwj z;Ncv*(43k0b3yBqtiPo7k}iK2jN>p%_W2zY=I4l4u5&*Ew~}=EdtszcvYx*eMtVuN zne4FrMQ6{n5Wmf{pVj&#>vLM4A~U9_^$EOg!KLK!7UE;XsX*3 zWc@|0PjMWsXnlg?wnY36&weFkl(^V|4>H?@yxYxv|j9|iPt%E zlHZKxqTi$KOTLQ4{r+=YbFp)fH~~p_LUYki6Q@-oP2<@~&6CV$G*48K{9tz9Hu!a3jYq z{&`3(@meq4Ky$HQPn`Yd^P4nrzn^T-`XuY&p-{V!UhFp!_x*3vcBG!?h~Mq`-$(o& zkB@0C=^h}y$&Xje*(=#Ur&6C zr%!7x`bOe@e)niD`u)W3_3R%c&h?Y~jR~z6J5$8do}D+eUfSbH&Be}Kgq?F*FLoA* zv!C4mT+n*4e_87jvsBPkG_}q3e}Z^5alie-!&P?SbXlL!dPz4R?q5gO6L)v%R?lxU znv0zl;_T-fjgPIweLvf@UjE*2yVi^SBJp~cJ>gT@PGZ{aH*XNX<~&(*u`{FXB-zdt z;(mMNh}`GWlX6ecFXCc9L;P;ffBt*-X^)plf4^t{pyp!#Fmb>CKSA6t-;9%Vw>GI$E_VZOFy{opI80 zdzp3Vo1?`2az9Pnug@2?odm!Cc!jt>PT@yxbCsP&RB{(J6z zIi^WZT=e{|Jp04`w~*fVzuohP^;xYK`+YiHs!j0G2+c)5PTY_G0pjfE996J`#2;{B z75j&^KFR&+QIE5oNo_~`d4sq=9?fbyiHlT@XNdc8o74Iv>-n3Jq?dFrklv5OWo;)> zL+M^2ew!DEC9O}gep%}!-71Ir74pH;+3pJaWF){8$I ziTm{-&~_4w)Gq2ZPcq*`{9ad2#D1gJC)%hS_jo)_yv5^7lx{0=zueojKFRuatrvg# zh*LF{xD~Zt_?YHm=Kyhkd^|#YgV$b;Yc6(96Ti!g+d1NX|FcM(%a`MJ(c@e$m$V&8 zcS-9LjTHZ7;(nYf3D8RHR1si**iM2tyyJ+A#52%b>}(?LmrI(sABRTboG$mn8IN;) zYtnWk-4?A+6e$j^#2@nf&uV>=^*OB<`z7Ljz9xuoa`r_(Nt{*^x8npjzua&9KkU5^ ze4JI8FMj4v+YwqB+5`u!Fw@SYBmFm&0E0w$o2HOTDS;M@ircjLuW1{b6vJ*8$5J4x z6=JEH-etXGTT0Z5;g49a$YxvqWOs4RDy#K#dox)mSXXw?fkyaInOznbDEcb zd-r<%E$=6j_dVbDInQ~{bDs16J?9MA^oCEE2cEOUzhoXEQi_+1|9gzf`2sTyBSejj z8~$~SyY{c5L*L5Ci*K0U;TPPXGq}e%H|PxB!1y`pZtxuATwWPG&$yg7F~JKl#5l*x z(2p@L^;1IsYP+`l=k0g@pSGQg)H_ufY&RThAv}H>;&jw6*qpS}cYpg49@y<+#gctf zI6NF+_DQK=oU@hTt0x#I0QKaCPx*s*zFGel!Y^d&M8a#)R6txnr5_@I;tr5cN=dxw;QAPWq=lkQ;tI zut~$`h9P@5Huz;3 z|6Tu!FRWa0ncBiY{y%+h8fQ;~3o}d99tf|0PlG5oI$=LKPfFqm+S6bN>$x)}-}TdX z{4uQ6rhT{5Si2p^+U+RTdeb`cEY^0Xdh=o_*7z?Kv{(8KSRXhmsUkLSCw<>f>s%Md z`{dr{^sWCX>;r$IIP07M_VR{*oZcYvPGv)x_DV?XfeyymAr@Nls=FjzbifNZ&(7zsR4JQ#SaI2ib5aUk$$ zF&}uO*cW(6?%kaU>?y{BGe>`foSDUQY}TyN?~4YR%j2`kMu$a?bG%xYF@wWM#YHfW zb$bK&4dQnYzZ`zO`1RpO@$APvighitP7Sii^K2nY0dXln{sLqwK&Ap@DnO5Z1PXcdsWFXKxa}#X8Y|cpmzvwY)#U z`Zro{{eYCiL%ay{0%{-lIK?@zx9}HOW1GhFpMwu*;SXt*851~{RIZu9niJwtAX>uG zke6r{Mq6q9prAF%6i<{=d7@jGeFlp&}^cxRyC~lQ=)v0GaVI zx|BCB>H>RN-usJQ;C_xrUZe)q+CGZMbI=2=Yx#jtYhK}}PzzeDJ>+$VLqUxxSr5~? zM3Pm?N%Gbr9D1i@fAV&?5!Ru-3uA{v|0v~e$kThW&k23UgVV4+nARCCj$MyEZK*{_ zYtrKQ3a`1TF0fz9PP{`wl`g~=cwr&Vw*6cAr5^F!hOpF`00Hr2Qv$RNh?fx6xg~hk z>z|^5eR3^pt$3^z&+xlIFI65WS{44UutrbmN3FkZ3k(!8 z@GG!(m-4KlC3{xyshp*EgzNlBbrhZpNra8(!W`TwxJ+>BXhi%~cnEtls5p6sAH|2t zD)SEecc?mHZ?O~nh<~cj6K7!UKG9OSL~9{YHX*)he}US-w;>nKUTxYQy-#IwCau5+dfkgP>!3qi zIX$EddGTm#5A0OSO8W0qHXyMcif3(3?s*bA@w8muEBQn2p;J`OE4#w}F|tmecxX8~ z179hGPSkEqW#hp(%4->~Gz|CAM>VL;CI~eQzs_@tSLj59R6Jw}-KxRS=&J)@&V{IqMYMdpeLGmA%7@P-V!QDMvp9 zKBeWSTbJE{_f(%zD6dt%UJY7Rw!U$BvL$k;_)v&y&F|}}8`AKPeRh+tCgb@mAJOP| zz7rVLGp@ff#$T@t5zvz!sZF8nCWAC@llc*4WM;^eY4l!|kGl)sf0^}EQ_IfbU49B;#--HmXQu(+82>m?Vd52iMxn%1OhQ`e?e ze+X+pIsV;<|9ewiXApb3_bg0xEu>W#$KSH_>9+bsg`M z>=(pWx3_L=ZmPv<4k#F)Le_O}+1w1*j5F#<5jCWUl9kd3_5Y`9KW8FprE5Qtb(GqYwU3AN&(OIJ#+*%0p{BCzJE5KKNrk_z!*X z!#?=;eefeb_zOPxKl$Ll^1-pm#ia2)+XtWHgJ0x>t2KQnrPp?~x872Tb$wlJ>yYu+ zc5lM6te!plTNN`MW`8_Wq<)^S*^8)z9GEx~J%4|2VlIYO(Wd7~1nU9LA& z5m{Fn4;AZnUg#zlmZ2_a+r-Q1s7PF^ibP&Qwqac(s6_^gy(ee#4 z&QrH0+{bNtb1utOXG1pp^;|yVhQB^visxoc zy6E$wwEgs{-~}#;^!pgs>;_n$ z0}QzNTCc5f<27dUH~N3s#!a|kOc>Io!#$#$BEq;EZkdf6K3T@y^zv-n(63=!hpX$S zddA%~lub5$xu);1=?(vGn;!EVDq=l0z0pt3rZ3m@+iiNo|53)>_&#pqhJJ)`{?^!p zd(6fS{VR;y)dR*EY@Cw^-xqL!!>5QMRqHn^TZR3VsuZhv=(#v|QVtO}SR@%7X zQ^z>-Dc5`&Y`jdj8}u3)mw$&3|4y4vx#qLg#>)m-{_Qp&qlbQ*zFgDaXVaT_9bnu| zcfCf3aYH}E^lrNAwL6R(`f*#HvLTlLge{MeKf-H7SZ{{UbbIYcx#lz5#>>W-zh2Yh z>VJVvU#{u(njSaY8m4#kv(m;ZT=>{dM%M_KYA^Z8{eZgf5S(w8De=%d<6}5;d0{}wsAwR z*Am60FJbho*Alt$O)?)h+)A6jkuz)KCR~qkH{2SVzu}|T47uTMWqMtX9S^98Y-ilH z^Sq54dG^_S%(wZEGVZp=j@$HQ^(t8LGUIN$XxyeR*YqcBdLvH{$6Uv&hxu=1+~uFM z>B}{JuT5|G>oq`{{{ZtJvgz3+#FGwxP5-P-Z}``6N8OdPmT_HQ^l`X)4G_~CK6>qr zma~D=SFhc1)3?{*uj%_3cgwMUo4%}v`R8qVqlW>TzFgBkYvW}{I9_^O&(*_oHoe)a z;3(s+9%j=AZ@9D`xS9}28#nz3Ma||e{N={h-~;~L<*_NVW+0iWz!TD=y* zwHNJAvn979qI{KSj~O;BQU~c!%dgXqnjNm~5rYwKAzbMM=s4vbR+IV9ar)g&%t|iT zKfa~Cm=D^0ec#f)b+)6_W@yq>r?i|bH3;XPWJy}kqyIjvQyfa=4C$K5c^fj8Wxts8 zT;BGkjcY&AzVV_ZZ=LN(`N2&w&sL#vxn;pTyrKO3X8lv$gEFBL<%cd7WLTd3FWx$r zm-V1;y6n>TX1tiJ?9Q_XH@&pKQht+_-GfY^$H1vkNCzFJ}-IwPIN}Y~{=-dUu=zFv?#J0XO#hraA zoX<2JVaz}nspwTW^KcpVmAqZzXGv@sq)_g&**%lpv)En6?s9gY!*1d=TJ*}o_y+17 z2oL9sWY3HRAs@-rAY)0-DC3j({&?3JxYOB9_Bjtzs_5Ieh3RjD{@X|CoSTSqUmKR%A##f%Ot}F5qKWC-F$J2Wv=D z19_3k4~bOom}n3K>f3ekm13*#!gW{&@+mpBN8iogi{DLsse|}NX50&+od;dhH|Eh% zJjm&@7>=j=_o7Mzd{e(`y7(i!+Fkf{aZFBIMT9z2FO`lXTSQ0ycTt=(pC{}t1wi4I z(i{gb(v2q`+q+cc_g3S#48I!umg9F7eplmHi{A?T-jCn)qWYX`aF2<|C|XXRUk({k z!}x{~k~~-3gLN89yIfB#ICF}?%E zH@NhztA}$h=nN(L)-ecv6d=1%+Z+;w@-Q-7LPwn;=Y)HMCceAGNd~iGj?aGb) zmff#~+Baf5aD495DQGWk?a_38Wp}sadzCQjN8%;lt4wE{)yC7G(4CE&c_`=m6Ej|y zW_tPkNlCa1O7W6#D;eiBGUIG|T#a$V9|!%)i`zU#PE?lia^>G;(;NBs+4Ke$f@@v=I=%ff2ui3=#4zRj5EFA-^Vz2#|@u-Hg4z- z*!<0R2#?zQ4WB1%-0;!g!*IOJc;g7ub3_fF=WN{YY2X&gR26N5D<_pv^5UDy_k>8h zHLr#6B$@f%$qOIWtzV6$wfsPki)VguYqIKQfo7>lK!2vrg>wn}Hhi5W5 z)|+AF@l)Qk^c3KheSYJbwVa^(J1EjKg~R#mHTMV@bHZhDPAhx;#x-BB{|mu*vc9SI zpVk5MUCYne)OTD{uZ`DzD9uLu*Z69@(7ZGa-Q#H3($ygUPyA!p0ITpsm}d}v;QmZ4 zJ4yePByRZiz$Obn=LW=lT-p})zl7iGoA&S8iw`G_;2F*Qu*(984Z z`RsXG(@$%-B7)A4{~-FB=oj|pL@Jj@KQf$*q3=lj1v)c$I{MiCfjKz;Jajkpsh%u` zw&M9g&|vR?$B75}I;zhS=RS-3?p^59QJ+S?e>ohi%0Z^5R#i70EDNHHdI)D-f9~kz z4^=m{p)cAgzKXu;*NSywf3Y5C(^Ee+3K@wumCGToCP&HdY_Uxg&kqZ4l74Y5;*dpu zI0~85===VAG$S<4~H*8*4$lKDy~k>^_ubS>82^rTMB1L z5-;$1a4ft;(x^U|2QyY{&uE<SX zrR$v3HLX?jf^}HKNxZRkych{rA}qDOQmywBQVv?5`g-|}AZ<#|n$-JGq@h#Vn}Y0z zY-I}0os5JZYHAAY*&)2@%)8~8k{maz)mJio4)&q?!eilZ%cJ2b$SMK#Jdhx0P4GnAJopTSC_q_etkmR44uxw`K~B~ zqiONBP zUJq{D3JZIe1U=D!v8N9n4T+@GXHYC@xe|VeW)8|WA!_mgv8*W|l6$bW9BCfj_6`{j zl5M_)ak|`JN$GMBf8B0vOwyCa%J}?XYpW?#w-09Fnq~ zEMA2$wl_T}{Z2vrgj@%W__Yj^UB^7(7p~4n6gK($D#E2S<1{}_)>K?TUmt|6QyCNw zX@C8JZAYoh@WfR|?Q&zVsLG6oWSN0;YNd_TimQ*##2zXXk}eCa{EKj=AfHnHr*Wxi zNVmRl(*bg;vS6YdRAs^4n6*8F>wd#SvBTJbp-OC ztZOFAi#i|Do8ezRles`y@<5#3pdL0o%RxVOr|yIiY}@T z^q6o%@EiOtj<8=~IjBC-;qJ$nDwTKSR{rk-AD!l8n@=}Uovg~Oc#y)|4cVrneu{}X zqpFTtfA^2L?%GMV1%9L}y1!mMP2S$yjXX>3J=NBuIxEIDh`k3O?wy55n9400_eQ>e zUP{NbL5sG>PTU0rBRteop z4&9h^D?0M0%GsYbQTs*dU-8rUk1Sl(twi?>a5ZlwCf%!ybVTKl>_5PcO3NqGcb4?s zmkQFH6Qx^FWLoCOW(MP;p^WyDSlBx&I3M*o^)saH;XnLv-Sg_@f!wRYC$&q6Un)oYPo3TJZ^i4uYj@!vz)OesgW~!!dj4BrL0SLfn=#~x+LHW0c1QXl zzr*22F;DbFF*TkOsdz5vVV*9F(kFvH3+?%)%XiXYJ#?7Ljj6U(uhJvtW�m6ZS>$ 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

    s-43Pp2ZaYcVO_}M1?UQO=VK_R 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�TUN3+LJN$+b^r>+>M{_lrwsM{p!A@+?<=Ct*j#J%5)f2Mt~9PZF< z%JYMazepJ$ggu1s&mlae*5%e>Z?k^TDznzQO-?LKiM~lV{f~xcR#){E+Ws5pkAWy0UwET z4bnxldmmNT=HjYQ`|mj8p{RaSk3chWcphCeP5Z^)l=AV-HBs z4d)?wxL%@)O1(TXsOwtY@i^-q>Sf93DT)3Je=~2U{$;)6THidk#n!-xz4CT(>eY-T~C^eFA|H)i7Se-+yf*5OZpj`hm5?TiN%1?;>>_|3+r2K8d0 z@Zlb#nPLeR!FxebhO>b!0nPu^82N^M$vf~YCh@z_pX)ho&&6K!0Zczs!H*VnAFpv= z-Fa7_J?`yqLBFmKeY&FhdbtaIy-xJ?TG5|xM!&EDeY~V9{l4kX?f?CR8r(kz`!3GK z-&y#B?e0GtfAjD+AAbw*_i2!b|D)j?c&wcA)!^u!RZO(FE*a0`@Qgn?axQF#42_qfhxI+7tSerXSgle&iQ? z-9CW#lUq=?cIz_Cl$82S*e%NuLaVK?1Fcif_*$htGm#lan+01q7x9YPmp*|rh>~fv ztJpHZ>?!+g{AT+zUp;+U)@y_x?geL56z%gi;~iif_PuTbr>4W~e=>jA!?Z*ntnCoL z=ixWnlB#+5JzwJ$9nJ@KzB+Q*5;eLgi@nktRdG=ads^dE64ZU_mUaN!K>r}Mbx$3$uYjJ3-*>0J*>`^}I;TF-?_ImZJBo9XinWz89fgdQyispG z&>!>hR@^hiqWUQA^jXyTMZ}#}UawV*xOug~a#9*a0Dhvk*Y&xyU|or}<48HHX;@cB)oEAgx+rLHT* z)XgQ@rKk3n>HBa;nI5@}ah1BZpJfuqnNfMPW7)dK_*>T1a!*b0LYtv^U0XsgT=R&j z?$SOjpJWrdV7_kF*lul`d=k@j9(!q4Rrb=fF~ax!E9|8i-s{ps#5dvZ!Z3qSDE$0P z@h|KT?giO$8voaYp65<`UJgC)I{o?aAb%*@m;c>6y?5QPVT0Gb^Z#Yiu`$nQHH8>&>;N zx(45laJxP_IJiC6+tsu4EvbRQ*1`7FhcmffM(%-r%N_S@e(zm(ZQZ<0sjWkO?QMhY zxm2e9rXl{N@Uhhtxmp0saNXU$s};v_^z2OG7>=EToo`8HK9)=Iu#o}%{ynWjUAuPg zN_BK~x2FcWKGvRUA8KoF&$Yv%cx}a%dIzp|zT=L&@I27oe}8*_D%Um8*4xvgMbLEj zXjyv@e`jk?t{Z|qh+{u`mO!c>aba(rJ2uoNCBL8Nh4?o9m9%%A&1p8+T^5G?#brS#i2gBOD`7Nos_xBE@ z8rI*uzJC3!>u!8gF4z7>^Qhi|4y(ckeN~JBD^Tq&eDOtv`kT^1Zxisk3ti~LEd&Ft zD1)Q653Wi)v(;=bt89*?6K7fFWfF^e6TgY)3F2xpH+2K<#Lvnz21wks&>32{3H^-F zO$v3R;01VGUS~z*d+=M!Q>9_mu*lr`|9{_^Sj^l@uY}Xq{JRh1r`6#+$}yXTae9}9 z=pQPBf2s`r*)sUiGWeIv;9oC;|A#X8@0Y=UTn7J#GI+VOvMz_+ETo?`WpJLAwGche z%32YZ30=rAf0i|%BH8?lJ(>q!FF9^SrT|m z`_mi>)rL=g;fsy29NBOt~TVV#@tuQqdFiz zET6nQ4@YtEvG`%Z^?+jJ41{x0ddPEDo@b&s_*nb}!R3gGrShm!upeH6(>>~|UU2$R zT#mj^aM?rc@F5>}e4h6CINaM42l=fZeL?88ejvZaF9*J2TQ*hZ@YqL*v3%)wg!=R5lK0`hq$$q6y3$AZSZ$X|Xqd3xQaa%RY>uQ^i6;fpi zUSsh}!KJ!!@+1Wh?PsmvHof&GeX3q?wy$wHy*2psHI{y(Pw(Pw^69J38-D6u!KLQG zSi8AeeB7OtG$Hs^hRn(HtdF~RUl2UBTf3)5a7Uk%riS!29DfWv=u2=%UoUtnkY}Th zJNkm)p*-V0?�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≤E8vgnK{S2;7}Iy?FV}A`|6)EATG@e=Fi11Hbd(=kvss z)q^Jek4XAAg0>X2Es&YdpZk|QWxsZtnI}8u4{z$GoZT| zX?zxI{4Si3k^1P7=l0r8o(IhOL%x+)pkIML=3LQNc`fSY+polP8vX@W_Ej!`|2qhO z=S`>wz}|IJUnTaM#&@hU{=3#0eLV*MHvD#?%(esj%EVNBG5E~&$jf$d7Sip<^Ofn| z23opTqHcBJ{!+M|f+ax5vS;{5f$anD6>xXLy%H|N%0R<<(fZ}^{5yax`*LLd+3{_v z7V&KG;qp5`Pu?e2^i^I1ot^<~ z1F#DC-v$3U@ZTad=K`w$b`h|vfz`l|@qfvs@SltEz}ZOeuqVCGL9P_i!n$BQKO^OJ zv8Cu6x^{gZGEkNk$nOH-{bA7s_FZdvo_KAWjDHSf>!F8_dGt_?^d5ET9LOF;-@nQe zUWss)*F3n(;hqI|spz~PY1{I{p5z6eU0PFqI?4cRy6`M3DvzT4?gq`Ibf5Y=#Jd>r zPDMV;Ay*mv$KYpP%7E3P9NrALuSeexc(FMBiOj!o_w`I+#V4qi`3 z&GWAWv>)~G8iLMd3a?Vs?>3gqjp=)chp<8O!m zT>QQY9_Io3Jb286|2>Y!zO3yNqR*Q?;R>k(%;%dx%kfPdaeGjo%HVH<{}lK;!T;~z zpN`)W$_V#8aEswy4wv!YE@gTE{mVOnJ%K)KKH}|ye*)yZ7k>8355u3qFM|H`tH7xL zyWsx{e$@XzqhERqXmz776IkUq!5k0Ja){Jse6A-K20y&vvIiBlwTnC`y={{--75tsGx zNARzP{~7qX=Jv<%{{X*bz@CQtee|{8hkF1nZ|-Q#!f#)_%BAr`Vd==b(fiP%pwlkGOynt&TPnW1nw8{y!i#<@;Uws_}_^! z!!O}KB)r%sDE0V8#*Lo7wDU>uVc$SLKZabVLa+Y<_Y}C4pZeV=^1Tc`eD1vhzILu?jpRGy`t?}Jf1DbKBjBYu4Cc#BVQC+a$1NsehGL#g1T1+_W`(+VYA48H~eQq zc8-%P5k3>YM#wW0*cS9DXTpE0N9XQ&{gQe1ep1r9#nC*DXZp-dXO~4(-S61P&cwOv zvvBTuQ|IZS#(4Dka3}X4brj74K6CdfiT`cLF$Z=2!Ei>`5AWDu|5lS0(#}2}ZR#ur zpN%Lp%mK`YyX!-q{GNigaGjIIjIG~`@WUbVJbgv&sK(mc@+!zMscfOTQpasn9{_d? zHWjW%z7xcF_H8Aewcn|zn;I|L@X@L6>+{@waf=gX5054m<+kowXEMJDZ z4el4Dt!F~@6?X2V&uv1YVsauvE+tTo>c)mxB-e;lCei->V1@BBPp!xl)W9=C4 z$d%hvqn5j^sB7165YM*bYfvwkpMf)WRGw61>&Ag>49~WIg3NY2@`p2aRNFHBsgB>s zXzB&X^^8mFK(-(8KIMt`Glai_KI&)4$1yyg{vG}&9lgoN6X3T~#wq`b@Lz$RyuXh) zmm=?nfc;#sL%^Pq=iCp0e>1@A0q{D4y2yUH3S+-V;2yOS0z?b8QR}q)bH>PnLFxEw; z8^JUACg2m`e#XgsAlrlI?b|*4H$v9S&`$mlawFmxH_&tVl`UKol&|Vh9eUtR# z9g@bANOuA-ru99M-<0vb>`Kt|OfvQ4WytV2;=c&D5AJW_GENI|OI9>QQR)8Jp@S z&mLrZstrBgY4)fk^u7eXgT96RWqPTKfJgmgBM;@vzoO!Mb>F%#d%wtc2xa*)aFdS% z*+0CJk^8>%i?5_mo@QQZ7@*P3=R-|Xz_<`(U__uic3T^pz z=iisj=W8o&%Qxz0Xa#h1*vWv|=c!%U&*-^$&b>XJ<^F)P(3^e{x{6^=`X@z=m~viP zp`y|9NeS#b#jIKt=ET0^c#ORp@?Dbeg##{(@{T>TyW{4Wy*Cj4Vdw{QAr)(j8g-rS zEb7X9!_jo*ppUGbBcL93B5XK@w>*7~rOz<|)6clLBsh>AMmaWk^g;c90W@259W{N~ z=i%=Wza3*>PEo%bZ}joom%RYGA?Mo3UA-Me>0RH)96jzcT|TFy~e=mj_uoie~Oc+cL5zQutnpc7nJpzY5gnA= zACIzZ?#%TRm+S8i_0`*B^OSE`of9PmtP)BU(f%InmXSwu`BamE{yT^VJ;fa ze+ggC=YJsFjydc8)ztfE1L17IpQ66)H%Jq2J?820x-Q?WNb@lG+xk|8{;JLK8*9JO9VQ?B zP8O!(3CDXW+c)~`Yy|t38&C#Cs6QRh%{CW@-(qSj-(&TLdDX2FR)=R*-MwM7Y0fJi z$nHI%y!A3C$AN4a>einl6!+NAK9Af{!A8jDK zfZy@vOI@_>@#COb5H@>lz5QbJbkonQc6l)Q9xm$cJvd?3X3p8}FRSa^Usl^WTvXl% ztZ$j4J&+xO+-2j)c@X%)6J`z8O)l5(9s3_??qpdkMqFUf0j~qu29!t4#UIl*-yf;( zMJ_EvUxoaS0HZ#b54N3J`0MqU_CR(3?dDh@{O#~pU>=|8Wf1;?3y0p3{t=Hq2LE%; z&-bRTjf*4eNBEA!Z#fvVunz2+4I0yKDVLGsbYMgB+-2C`!QUY14uJ2!I=%<82jPFx z<4?i=g!3DIQ{msK$6&^P0{j_|zX<+*k3R%|h3>caW%s;h+E)U4d3D&z>Ukbw9-i|R z$6T1nhkO2@Juv)*0^!}58)o=(g~Bmc%kZo({P8S4RbpylX~pESE|pM43l!`mU_Y^b z?xRez6;sOxCs!=h`){i!CU;Yh-vf_|seI<{%YH)gbrktL;CP#SMer)+= zlh3!{uNVCwTz`*QezeDAYvP32=!fp~*oqkY_GI_F^7|9%73jHdGp6Gl z$R<#pSED>kJw1@!3I7!ye;oeHJpR3?mlr!f@+0{iK>2>w$u?Gg`>!){ce^mkJr-W~ z5fk1S2%jr_g)W zZ$l^(jziw`n(5D%Pg=k0y^hAj=eIG=o94r{daTIuVVOm1YCA6nEz6Vn8yzwAItKX{ zIvz&;i{L-xX@Bp4KP~dBaBb!9MjG|=qzB{B^Icq%KGWk|-u?@W-sT3v89yiSdl7%O zFZ@6@j{fc$V79z_;QxX18~ILwzh^r8A>%KFe?ZsAv3~oB5$Z_B7s&q<&{T(K-bE=H zkI&^tM2<#0U!n-7p3Jo``;h3T0{VIFB^zeO;olfB&*K!r{@}tG6XP7z$GgDG%Abb6 z&-wRdzW}*dKI{+K7utUCIUgTS|Bd>`{ySSBob{LCPy51keZliVCmF~aS>t~G_cix=k z*wH>$S-&|3?E@{xk(9#5|1z)vsgE2NTq)(2M!DUAFmJilOS$nq@^dcCj3+LVc+H5{ z1!a^&~VwCDS0$2i|VJMjIp`}Xm_e=f)O&*k#{vlZ!d z$oEg?w@l<$D3c{lhOzoU`B>hIT^QvbEAN<;_d%5Rm5$~R-XFtfg+@}kPvASjS(xQ3 zl5t_#q%M?2H`+uO>Mh>~szy^TuKliywTr-6MhT38t6jL!AICX-W|XN}gHcu28HKJn z&N&=z?$!Mdu(J^d{tWYJ`@#K#CO_o?ez2L`44W*K4}{p)tk3a%3#$>D`Oby)Y`RZ7 z8F6|iv96eUHy!>)87H)3T*x|Y+Tp(JzE@3ucM$#92`;Sz*$(tC|I0(ieAwq7^HLY9 z>-@J@{dpla{0EyClYi#%MPM1-4;guW2fvbeiw)5Aa)f24%-qcO&v^^n_x%bqWA*ny zwi@!VPTT$?1^;G`zY6|M&TrEB5qRwNJZ~052Zw<57PAfV!gCbySf>qNQy*@5_4U_> zhn<|`*M~hWoayb$wu-*1QIGF+Vf(U;f>!~*+k;aF+u%Q_^*1(uQ;l|4jkc1qESPACz7r%5M@8)+zlwnYH^W#N+n|%jezjSD+p?;GL@s--}Eg_(7H~ z-ud+V`XRIz@~jn}59_t0cjg)}@1WBJ-2(72?|(+Vx4~Z}^_%jZ2mg_2WBvX-_=m*r z+WRA>y;mTNam< zIk9cvugB9E8?nFR^W})}Aa|B+Kk6^*v?&|U_!Hwq(r112WBH7Bn|wZ9C>-N*J};i~ zh40T^jJY1pXAFlDqX%4=C*7Dy_fb#SM@0uiD5Jd&A8V@$ZB=>NYWEt`R__HZ+bZAP zr;T6?dhgOslW$Xxb|8GOuIFRvGhfX2S6n)b;R(l@9){mhAiR5x3Evb5PuV=6zxDGRy668;?oZR}7*H2bYP{C`_d?C* zq_R2%do@+B=4q3rrhGV5KH4U{Ny}%}a`EpBqy>M$v?9u+_5K3sU4a))O&j$ac@NVS9|$ggY++E&RJCBJ3^T@ecSya5-kxH0Z1N?#{8o z`3PH#va7;;@_CX5`wOi3%5&YDJeN_|OgQ^PeyrzBjV64XVqOj)|@4*+U@W?Xk8$dlZ=XR7~T{`!1Bv5xN)ZO_iwG(UAzm`v_d-9Xe&)2K3=M&1> zOSHDl`nZ=t_8$yI8ZeJx{b!>=axVfg)*yR@AP=vRH@)e8b64m;6%Koh$b@`kep^E+ zgmKUMX^!Skol7v$XR8Tn3dHw^r;ZC(K3hnr7J>LmU9@NsP*_G>cn!CYsf!oA=NeQS zb@jqUS6);Hyk+g2+EuGQvZCce2D^*-M1@i4L@+MGHe~!J;5QM!7=GM~#O=9mbLro> ztsrCtd6f;v^vFfTQ~atzD!>fjUK>J{HUixLFWCy34SC`o+3f9{0{F!R@T&^o9|BHW zHC8Ws;OBKCe#D1FUyH@%9=!47`Ah-)HsMpviim6LT;qNP&Uk$IGBO@MPym0r0RFQA z_zMMaREBZWEiHhbQ2>8?0lcOF{=owHhYR2zD}ZBz)VT8ha{;`+0RC73{5u8kpBKQ7 z7QiQtk)PBS2H7z(`WEo5qHMgvV@u4*)ps96rON-nhLi4(I<8h3gcWK+I zrASC zR;^r1lSwTrn^rZiSh;MCj@7YbP21X4YgTwX>qKEUuDG#f339q*&AO!!X053TV-uV3DAU6Q4q(%9yOqd)(E@SwsmWkLpVO$Y)P5?l40wLHlQZMYgeyq z`RF?IhPC0{m!^te%t)G%Wt>fLHUmet_AnV^MV)m$a75apgh&O0F{!A zI{l0Yeo{bAEV$8^;7-nz;6a;Kbza;f&t49)aFrRy>0!W+JN~gELm0FnHN%fP`bB~V z`7ie4j^5gM5}O)M9&6)Ca7VvK_ypy7%8xtx{Zi3H!A{TCMp6);A+{lc0S6D|sQ~*CJ z6;^C=Ir=?*<5~{i>&Klw4+_rlFfLb54*PLOk45bI62^`{HfMWrM}NH^cl2!q@Xi8w zN-Acs{%jOHC{MjqaN8g9orl*V!TFwt%jLJhPhV>3ul3Wrd^P&%OYE4YS#ZgQtqJgDca;Qs1}Z^BXmgZ*liA9wOB z@>f__9~KK9e2!f2#~q)wg3G(Q({raEcl14iCjxrjF8JvNck=8PJgB#)q@e`yLxRr? z@PFEmJ9(Zfz~==&?&yyR9xRs`Qjvr5Y%hTCDS+=6+}}MZ^;7}+Lw?-JsiY#$3g{u~ z#~po};6eG<7Qj3FxZ|_Sj|)4ca7c%~g83RLKtDq&R8SslfYDbFUr+$Qy#T(w0KTUH zzCB^m4VHVIR9G3-NcNPv-j7RjRjN^N&i~+Ydh7OAe5beD3*g%e;Cl+-Yo#It_10Yg z-z#{zk<+#7hyA#df4&d~`PUV|>m_DTpHpU=1cQ8L2p*)bFF?P@k2^VED8MIuhDle3 zL9QHo{J1N}hXoJH`CI{fZN>Qc>MnraUI2fp06rpkP(N$W96#L-KkoFi%a2R;FuyB! zu>DRs%kU54iv$nqCoQ-n=<3x*Kkno?B)Altqd#1L|BxSde1-*=;&FV`*+zcB9etwG z;K6ju1s8QYJ{5l4@o5u0sE5Ry@yn&$k2^k3$$VXq&(nU~(U;9L{Qbp=buWTTz8w9c z0{C*l0y|eY17Cbmk>-FP~&lbU@IGsFO{kWswE_iU9 zw#$z@`u&0@OuiidgMQr6KPR|6#vJ{z0{Dm@cYLB%CP5kAIX*Ez?&z_JPG7-tSs=JA z7tyOq`RN^>MSl8{gkh^11V7vOojlk3amQz^pTDE;@bfRV{5$>hj!%!^(rg@`+Xa{5 zm&3OR{-%JOTm87>zen)kyvNgm2kYUGA9s9?2rhaqk^VrvAhlyi3NG?H ze2?HkIrj@L98mbN24jDVENx7@q=_j5v$4BEd|Es9e+0ew){^37OcCB-z$ncKfpYg{i{f$Vh%B<|3P#akg_Lt#&O-mSv#kzTS|!2Wzaq-WyhT^;Vx0R@K)| z!k*;I@Vi`9pF08W#o)DcgmGWYuP=>aJyJR}rv>NIhT7FV;D1+k_ydzv$6IjX@7kJM z9&f(l7RF7sKOXA%*9q$J#~$xo-}Y4J-p3~>tl7yb^^NT8_!TNycC$)0ZV9cw=dxRP zPV?-tHZ>dRMuwX@=QOMeJwEhA=N$NFm$mA>y=m148Fn;3o8N(V*xuY{YKj(AhjAWs z_+G4$|3e{@5;r(yL0jI-dtIj_DAEbDtvAW1|RV)^Y%33E7o9g=TIowqaw+U zL?k&d5K11*gp%#)Pz8ar z{%m;tkqx)Z?teM7_oXRn_TGJ}_Vb^=C0SJ)O2!{m<^BJH8k+q1@by#F`geckmgM4( zglG4EKfL$Npso5<1Fm_vm>wMKLvZSu@=;=9O_&S^(%+^l|%i?p?>91 zzjCNwIn=Kl>KAQqqOA@^dc%(_du(=i!K~|Qnz;|)#*>T6@4h;MVSCreaAlGD@+(dA z*Pj+%uwnO(<__3q`T9?4=Ev2Bk%U@5QVp6DK0IN;$^}IWPP{6zVCVzk1;%KO%lGQ_PwT&7JKc-5wgXQc{ERmRzYCGmN`E9_?(NhO-($pG;sK-9fV! zya!=iYZp^RtqC~IlKb-H&URWGfqjLXZzPTii z`!O4{{`1pq*%~{u%+Y4-4~&%mFwcE!SGWEI>+~oe%K&><%CA=gx+J(}4?B@ve?=Wu z;T(FU{t59Pf^PTZ6VNej^wNHBJ#?+l81ET?ZRWH}_Gh5G>E#XTcC2yaqvb)JKduj) zhqFcNRn6d>c$n_!Y@9(l2j`BS0{g_^lVcdyH_j_t8a_KcD?GWZ3g>(dgj4E_xyf`R z+H9lxE!OqVNpyw(BR{0e3F}*-*Nk3cpHk1X!WLC@Ab$?h1g~%nZ1pDa`Jo1N;M+Om zi+O;}(Fb$LM-KTI*VZrB6Y~6e%a>`K0KViwzV#|KO5Qv(p1i4D6UKV;$J3y$?V3e@ z{qM?NgnfNnH;bp`0=*Xp{VDf{+dZ62$Cg(E%E`9bjFgwz!?Sf6+wK;WjVZgne6lB_ z+wch=E?U5LOdT)#)sFeLE#G+Z#PVLWHPknh?KZ5*M4U9**Mf;SXL~?-+cw+uhTYFM zvwgE|@6@)2x1k=;7Iy}9;%?N99ol|#3VhJ6a~G+mN^4U#GJG-GLjvvR0&^xc&++D3 zS$z((#qflLu92@C@{xmVuCMAZwAM49f06nre5L-#TF-pLu;*M#JUEYAYZ>JGcK}Xv zpnt7s6>xv}Cw*%{8;%QijNFYszJIN0|Lcg~3z`&u3H-d*mU*A4q5rnJw|$iE_g@`& zknWD3J@{+7AK3Ta3+VoS+V9^_cYD{nHq-slhh}`8?v{Hd9;O@mzj_$3OJo-DjPki|?4jI)`U!9`) ztg8IAo~F2`d+lY!vtR4Kp6*Y3UcQO$)mOc93*8%^IA{FUz|Mj z1l>z+yZc9UuWEX70^Mb2o~iqb4U@ik2L08izhy4nksB-DO?Ud#>TBp;yJk`g-Tyu5 z!#cgW-`)2Q^lzwKt@ZHLBj4_$|MJ#1>-5_{d-*>4w_Vlt9lEC++5B&G%O~9V4BZWH zJ@FXb_RNRlbWeJ0yPjr)*=KS1}z zRdbiq{m-t?t);uFX-5a$l8%GjbYtP~Y^3{2{!tda`j57T?Q~z-_VS~2|EuGpS}*Ev zd@b)Jp#I~z(aaV*C`Zd3toZVhgVu&8s3h3O&`^;>J*%n zgLs9mO_;Mb!TNu^wZ#mGc;)fY7kPYRw{QGhQM}cUb46hBKX^3*&=oKc@DcdAhH|mw zYed3tETFHXxM!};u5}j8VmxiG2B`;v68d*s)f2#`*Y zzg^2VT}wOmZMjOCfZ!M^nrpe>!F&xAz~>90mEX3{YA;Uxi$CSXA-~O6ogXi?c)j3K zycu>xAKYfXQ!^G&>LMJ?*4}l_DVoe?7F0yS+%K@ z+%-yh+W@O4>n}9-Js=%nz37pHIHqIuUnUG@3vSgdu*w9|wRkZ7N(7MSpBul>+_z1? z!X_-Pm0!C1f^**oMSh!4%f`mHIL8f^m!+XQB=HBlAnv7mbtngc#8M71H!)6%;_5Yy zo_8h7VET)JjhBAL5=wmQ1Zg=wAac@AKE42`3-Pp5q`Y=z?hk2i|J*D=Xs$R^gc+XR+)^i*8V@`zUX~}#% z_O8}rj-vs4R~KXNY9scpo`$`v%dvOWoXxX-BhTh}vz!4GQ@3rLsuCxq)V5_f3#sxQ zTFz~dp(_^|-htN<%;i@UsW}x3k@LRn99U460%WBmbnEx%u z+;$9el@VPI+w;%lxi3Gm8#=BiQ;o3W94SwzTG$>(t@4NmN@C-plQ_CpF)f@R8 zW1^~^JB)q&kR^|A2A>!%V}t0ToYoeN(}{`8_7o}q4?T~G8Dh-CK9o-*zO@gbFf$2z zbC`m_sc4X4T6sUtY=TZPgcxtnGQW+cKp!53jSy^=gPo7w+HkV>YR+gOU&Xuid>Qh} zx>kXF|2Ov5QzcLR$@}fMfr>`eIX_&gLtA*0aLa*d`P_0KB zXWig4WI61fh0CKjsx-7U1)IOa$vL9Uqe2MM(d<*m;agZ_phakLY<Bda{{PtArSi=!Ccwf!cR10vkGy@H zaPQn_)p6l|{wxeX|34Xy7=NYfZ+vcxS}Hu3R5Y#<-}s!7o%!&yi*SWV;NsYWb3^uO zlN(N8>PBe;#N}9jJe(7n zP0L%n^xjRxp1rZ$BJADa>S4QTnQ12*IO5YM)0o##S3osGKem{-?K&s>VFsoM3-rN~@>t+6tNG&aVU z*-tme(jdhmcv8HoLvHl&(~~X+W%|;%C*7>z6O3!cP|x{sH@7w{O~=w#3EhYvFSU3j zhd#LC#&Pmj`Ee(IgWxihcl3>Z+|l<4u0Py(_P6nS7capbeZSyZ!5;nW@!}r+Opzz7 zD8|WC;>R8T8G;Ar#1eko(c3vB42F0){*^*6xTBvhcu=3!e%#S77Cg94(-uYcy4=q}W8}j^f0q zYrp-g7x`^IEpFpm{2ByUUY3S#qr}g6LEHz5LtPDq=>@Oul#%f8B^0P_>^|uBXNviPkUiMo_!VBWw z%5PmhkH?#X>lOKf^4fToE&a#k9azTZUjo^Wvq*yS7n*~M%SV#pK!O1;R)HR0_W`L6 zDh$^~+g8xckq1dp$N|>7%$AO zV`MnZ<}v{~U;aeOBU6 zgdZQ@&p&lsd;o#VrT;fR=fQ5ryPjvQC!d&K_V~tb-}sydpGwDHs;X{|c z#F1BT1yi{`+|5bU2`)n)$7ieHdJe!NXU2oe1_?b)`|*@6e(>5hBJGsz#<=T!>NKR14%cS4)K>nA0BE59_mg71WOj>+azq92$4 zYY95;-Y)x$Dm*s8gW{RPu6 z^iEbL??Im&i>mK}@$pV}?i+b0J7<2CES-4$>muxT5;VzlN=uQ#*m{Zz1uJ(z)-i8^ z?}qfBY4(6)h0-#>b4dX89RKv=wYWrqZVLj&>$5WwAy{5Eo|oTvt+!tY>=>ILX85!E|5JVTUP&m}(u3(2>a)KsgzK!J z;s)cR&pz*hH?WrN+zYDbn@;=n_u0LCFyca9T%TQnVZ5Es;+z@gn)1z&zKwQIIOksW z=fj=AcImY_=`=X-oM5}=C|ZsIi#+>Gi1sicj8uuMz-!IIYau4i%`6%Z1sGr-T z;my-<&oX2Fx&M-9XvCsLX8jf#FwyMQ! z`Pq8tt$QZkeR;j#x+e`g#l3EACHH@_?!=`H)`jXZ5e2yoYnGdg=-uf7< zPt*_juwHQwH~Dj|+*lo}GH1f{X0*QEq~}aoZ*R>ZO_O$NEN#}IVEtkGcFmeM9_tP3 z&>xF~b&%QbMQeMDu#S=X>W!v$k)NG+94|j+F8Iz|CfWd9AYT>87xIR5^qes3KGv&& zAM5JOLGmQOF*%N(uT55GBIaxrsqf%%40V`surBj+T&Fletq0Ey;5ln>0_Ku*cM5yF ztB{up)cxylR+%Zc+fkR(;w22V+mI;mXY+}#LVQ+D0W z$(<>DPs`wS{?6QV3VNy@2q&w|9&pypl(c`&H!oE0jmM(xt@Gmh!d20AIL-T} z(dy{ZQI^AG*Jmu|?yOK6$nn2Ub~VQ_O#!+i_t0rh9%k=oFvum+Y`y^4(P1s!!1>@V2Qu`VR0 z-iCT(&Nwptqttc%Y^bfAhw`73m>G^LoKMX2i*Qzuk!xEzqFUqg;u|o6UxsP6SoteR zD}=hr@U)t^fM-)q*LE%XR6hT;=6R{2P{)N6@#b@Bd`=Z6Lse}rX--NkQ>UZ z`#W#EsCpLin0n1J5^;|E-co_~l|UP0f5HBv8tu>ajX0;dH<=!SEfL7xGoaH=_NowV z1K7GlSwgCOv+Y-igNJ-uc>sOl{pc6Q`W1dZp)8CSM!XlXhB<-yA5k;AX3JXb6IG;m z4zS;1Z8iDzMwf2lT5FsM8=naGSF+|hr0Y-3?qBF~V_o8v`9@S_?$&y)g3j!7TK4x( z($8CyKI)}@22hq{B8B!fww~MMuV(jC!kcH;llQOl;bQWC9(V+2Rvmg3-zB3D=gXq_ z1{wXf?#pmKcUs#5LH*>KZu3o&?QDDVmgt1m2}$&;^n|22Ohe8Rz;~J&_`{% z%#aW2l&uSy$Q$8J4q4(B4V4 z`X>5p+UR&tKX=fY`cPI22A-~&zc@-;CLDipJXO=27Jnu>T|d`}vCQ-sE77R?jULd% zqQyE~$_nA8&1*l-tn3d(2d~iI;`qE-pT1o8^_z3=K%f0~Rf@8^8u1n6P2;`urV^IP zsc4&!OXH`Yf99BiWjBK7TS)acht)TmnNAV=4b~B)bDH$WT&ImZqkpBHjc=m9KZO1j zHiOXTLJt^M+>f%Pogh=D4N~uIdh8dHdsFK9{5r@`gLG<iM;rs&@1V?kaJ*vcitWcMP=8p@ zl3UV{b{qb>a|@8?WbXj#*$^^8dpLLEUBr$hGOALytrY0p9t6Daq@asCbL^LC-$kjq z^gAKXDQbN@h36c9rVimb3fj1uIjUfD2d>U1%YyX}-@)aXHFFfQp&T1V6DVt&Z(FwP zC)mH*aUS(e{^a><=#c!6q8tnl?^w%UNBAuC^2wkbZV7c|8$4|>jy*GDee=RB$7VRg z4t>Q1%j(f4Q_$aH=#gbwrf$n7#1=|S+e69dwpfPylTnA`YA43hd?wzVgUtfG(#qJ@ z$^QiEB->af!u(X}@968HhnutXC$J|67}`dv1ZhGqk--x%_T#vZe#njS2kbjZ{cn`| zugAfjG}w(~vZ&Lj)}X8ll#@8UMT zd3Uxv9`VT?Yf09t&~w0W_9VtuV|pe&sA(^2NhXH$*r5uxeIh6~xVbMNjAcfd;;5G< zzdP_O`dW_oMC6NfHec-9n78i=Pm90Iw2>C|kwRVUjc(hx)6@Pq2I#@_Z!g+dzj`#E z!E%gcgJEfjq z(eE%d%?aJMx=`mHL_6ks6|U=fXjw|``An?v+|w=+^GZ4K-hpx90Ny(q@mxsDa{>KV zI;C#KyAWi}^+szpO+h^?3)P{&dlc_%(eh+y|MV%UuCh}NOz)lk&fUDf1J4H9%VXa= z91nwgH~P>nxafCeKOocO#b?AT(8p)hzUjTu^e(1Tjqwor!!UG{gWht`59}sA1iMKO z=AgG6bd-aRa?nu@IzoPjA_LMdEDeRrQ=xs+-59580AsQQgfRX6+rXP?{JH$A^ZU+d zhFzCf=;ND`$q%C1-}C<*m>ub^By!KbCH9$fYLF8jMVA>bzLLgR;Et%*}yKzmU45 zneSYa__lT*V;YwP)0Jo&P2PLkLY$q>H9wS z7NjR*cKt5IaRlcZSQm#do}monWBP)|@Vj-~J9B@oY~&x0)?{BrpOA&FeuR2Sopnzv z-}I#F(q*pY4%DmE|D}5M9WB4~y@51N_zTjo^`Hs$fcZ&GeVf+5(c2K(ehTleHI+H! zdnEsCGv-4oGib+Ab)+?l`;Ugw@oP{gi$L=Usr%&f)jZqUow@Fbvo>|BM(F3xTy?l+ zGv^Vzz>8ywgVCDJ3(;SZ{${n*>5y&G)?4bY4gIDmPt^MSz{!7Z8M5ZA!ya1pL9qX( z`ykqs9IyYedRZgSL_1F161@atfhU?{(S=&Zz0uV6hw(cYO=YOF@40nb~;FLxny1`O{D;qvQ{ z57f6lZ~yP*jrE@8KXAO2dIa|@kEh@=%*OM^sRe#O;#j>rB6I6=juz^N_ie+f)NSnN zAIN8<@0vAu6ZrH-8}UvfeHO~{USRflF<$zVYloyCRnKj{2Kj74Uvw#4OP~BB`l&_T zrhY6f-$PCQRLJP@?)((gA&%>)!|y?VC#dIIU&=q9~$xz<71_o({XD z=fL*pNwA?CQX86+dpW20QtKr3d@;rmpy>n6#g*^HHx)y(1J9|KT3^mTf079&9~pO4 zWzhEzg&REM%QWmoPKUh%$^$&d`KONSP(?5%J57B-*RgrkFY(+%zL)B8)_C=ZFBqG~$v3`CvZ02#ZR^T_iPVvCb>-yPkjw@)?exHX&hM(gfi z+DVLO_C{;&I)?g28PH~K`*OYu<-8#m#{G4O`$g@)6Z5^%+ZMwA1^5kZxV#_yzKitv zj5T9h>VxCji*@@p{W8X1qbY5FfbzpKr|x5@J<8pu<=)Y}8!{Munzk}S{c5AP{<1xl zA}-rgRQ+=ErqS&sm!geh>~Py>aep1|arXLcJ-A5Nx@ zIw2=%S!S#^{rRCd>(MI6#=6wN_fU+17h_Dzd3wHo9h%sUK6dM}MvQfLVl13dk75k` z&3q5W!fA|!J1|CW$9Q--#>4uZ4d0!3uDVj0%$Cpu{rs|XU@`QIT4$ICdpr6A@Pj`2 z{?4(H!kE_dL5DCWtm}%rI}-Q$*)InDsmYPSGOYcNOl&>hCd4`F=#AjZdgFg|_&syS^nysiNcj1BNU-IGh! zbBr8oxl9cpobS4y$t4#L0K2T^3^joMgL3d!(`?^iG44e;p5;;x(P!qV2h5Y`aXk73 z?Kk}Z`5PVKJtE9Lqf7K(row|UJp0+sIR41z&781(##{d6w-z*vOZoXtIC*p^{4=OVef6=>ng5$(K$!5 zEx?dtvo}$wLv}z16k^%J7*MI399uTXsY4WO61AbVKF*P)qK{L3fXMT&InOp!X?%%F zX|HH`x2MJs-CmL^#1P#+lIl4Q^{+3l&rNx`y1kC2U&?L#T3)ZqOCut03o*kKZtGQn^I#)?kpNvg4*lhA7cuE?S=hWJ(E-bDgn{r@&0Q_p!(zW4d z;uO_RUB{HV9rw-p0o`9}6YnGWm!5NB&K_%rdaS1)cjdPD4$c1{)+ZLOBL37SS3qyn z2B}Tbb4f~(!tZ{gHi`B@?Md|1h(7mb$Vc(1ZpykH)u#pY3#LAaPK(L^0!*IAQ6EG) zn69es{v4OvgPPaluwhI2|0~MBPS=!OgfuB1m_s!Ef8bYAA4N^$@lsSo-$!Mj)c=Wi zMxV>$oxnYc=dTybx+guSBAwE+s(SQ2^bA6mSD~n%l>&nfsvb4_JY#R1#C4Fl>oDxF zE`Pdj)^V4fNzvNv^7d!O=?eOKRp;HbzX|k*bC(}D-4H6??}gVW$(Yb9bua zSX=w+3o8)51J^WGc!yfR_$!I$D#x`>tI_^8Hhvv@N38{)-^MeP=k)s}8>hdH=dRzt z8uP*hvN?soUn-3!zEPt240Me?^2_KWU%+_ti&$@deja+qI@B@L!!KZsr`$eO%hMzs=ybIX z9xhP&m#Y`?Iq8e*DeshDk{f*jQiYcZ)CbZfU6VfO{J#Tx2i9aqIFbiyA8EehPlEagpGb7pB^V+ zf9bcCUL`pzADP$Lmpt(Xd;7f6-aGDhWsMNxo%nl~73Ph;TYDq^ZxsLH(qAs0yKj2_ zqUCq@WzQ^&@9MV^&EC~d$K{*Ab%d$rcbPV(k_YX(Iqxt;c&`2)(ZbZHO(hZkiYFOxBy&r1N;P41zl+MrM`tIh|J<*;I z-M%F~oJkMAFCKm$k!I)zN3{Ecds^?=a|ec5`e@m)tCcQ3a`zoS4`Izegm<*H(x(?n zX91bGb8sXY9mtL4vC&N~8x8l5hs;X z{=t!4)X~+2J+7l{ZlE`p)r78_@7}X#*KQL+*cH#{F-8{+KoF~;4eA~%Q{RKp za1ZnrX%R#y%a_w(5!OdtgV`Jj%*R%@IJ!Cpx^jJeIeWhuA1HMUWTWnmUZ6`k_~6!^ zyW*fOhb5w@zOQ3=B+3m94Gz7BlG?s?&sI6VPCT`H=P&Fax`+!nA^-&~<%_c}*Dd;2 zsSoz{=Ndke8yZGsqImJ}?a@ses7}+7?lW1^a^G?Hhdy|_6gr);N}%%>jSNP5m!)X9 zYp7$St0(Fl?e5MEy_@Re2I4~%fX-B2bpD_1SWK84--Ywv;&Q&kz>ioFW^WvlC84&% zPXD<3F~GbXlawXh+6D={+#Yb(FntfsbY%3eQX6q5K6?0xYx$n_{fx`I^_Z&agN!-R zw_>D6$7XX<9XJy{&Uhc=WRD47WPF-&JmWO!(lR5C1^tT=HqM$4l@X3cj)w(YjnAyq zuxjM2e~Iz4s|?=5_}3V3#ekZQQ|6@3;!OM_?mXI<|35HZ&u_@JrBFBYb4| zi~+UgGq&0QSh&*%$wmC9ILbMu-@*9g6$UuW>HY%ajadDlL%yHv6h7A){4sOVzvcGY z>jypUp3<%<+@EsasT0M;f9u3bcG-i^+dRYst7t0Y9Yc_FIjYnrD&YU70$!|uKU)F+ zQU(0~u7G1QTvpEiRsp{h74WZC!2hBGzEA=GhYENIdsI$N+H0;HeoF=Xo(gzR1$?jqUZ{Y7 zssjE*1^jar@c*L%K34&Mr2_unE8r_&$II#Mrz+sLRKP!60srL+_*ez}*DK&hE8x#p z!2hHI{*4Owf31Lj7dY+Dk-5$oO4#<0`HqpE z4ZXud9UE?HvSLuqOu)+9ORPJF`}7c8>%s8o$Y#lr5cX0S7#_(F4dyp&x{1?Z*@wFF zBYQ^%U68h3z|6*gS-zPa>>b#rHtcG?m3K#pZ@QW%%@1U|%`Jpt3f4QJkaT<9ZBv(a zSE1Ne^_m=rXkUjh*BHum@6C@4nG_7WjsdNE)^sj*3+#qQOt^QTdywVoif_mAz)&wX zVKLjZ&_=H)-=V=i17JF?K--raFkwy}m5X@}XM6X-gHnI4zbpSBk&Ym0m-eSL+&3~f z%>I-BWOFpFG|`YHnx_wR^v7jg+Hh8D5%t$lBeZl2NnkJ9VKD1Q(Z-`M)fTFmd(Ac* zBvMxoE2}q4xx>7CWUre%mB8MmySc1)zjt`=*4@oJcka~^6U+W3*@ki*RJjSk8|1K&f_YU?W?z(R|?NIK4Ude%uJZy8XgQVyfYqV)*Ye3!H zbJ*@UpWB-o>@=Y4OQf@jRitcRZfLKz4oi-wFbq&CwqH#x+f$9l_N%F9oXzx=9JG5j z3m=(Z(Y%Ka;UjoKqh?PITm~Fehxnq-oaN;YHO@GXyhEWEyU+A#!Ke8`Zbo3E(~e7?rGl#9%(Uy9=>7r_@@{x;nj z&49i~(1%S|=CQ(G=I8e^y*`1z;917?;#+JlNpPh1z*j$FaLTMx9M(S z+?O-Mxa3RhORGz7`G`M2rVoXF%;Ur5uMSnJ(ZdvnUy9?@NXgp4bk2f*S%Q|>2YmV(M9tz&dIIYLwuzJqAc-q{? zlU2rjyL7Aqe!|5qpOmbp8OAo+!xaD)wF#oIOW*3^mi}HBxAfyKZt2f5ev2p1cU;`k zpJ)75kG_W2X&JZlvPbf59(};{j9dD4#zmj9{@WABp-;ib7;p0UA9iuee~NK@b3%vJ z&$NqM`WG0N`ja>D)U3)`8|UgOY@ z;9D4HyKK|VySU|lD9#7tTUk#ZXZ)v3{_VK;uuC5b{bMd3Nd13;@!Jg_D^Jm-4~2e; zaZcBcpQl|uR{j?l{~3?}tczRvlZlylydiVjw8Qx14jGOza&ZW0}>RtL!=+`s8)#Ja}#VwyL zjNf4B?KrUD@((6io^i%me#_^uOCJjTV~qRqOffF{m*<7g#Bu0f@R#FwO#h26ZuP&K zAJzH#Z)AL%r=JYtqW>w*?{*KLX1vA4L!oc=aG}q-c+kUqdR*L&m-<{hSYY}*<9_`a zap^;$-|y1f@|tz&@x8q{PPp{8ex7vc?R@iVF1_Wy;L-QM^n@!mAf5oK_h5kD( zz2#rS0!w*`p7HURJ{S)Lk6hg9A0Jf2>GAD>IqF^9mhXBOw|p91+?L~J7Y|M{|0c%$ za@^w5heDrm>8&1G828&(tBYIuHpcz-o@ZS2Im>d6csK{u7+?7E?|11#;ZyK%;d994 zW96Lm=%u|(xwzH;Gaf$8@=v?CEteNOTTN&*jvHJ8GomdBWP!NCR{ueT>Mmv z{PI4_QKlE1)uN{3>B62%KYPr@L&0Bg@j&{8Sr-olKgsxZBeyND1sAvF1*aqWko=mE zQtMsZj;o7|OTL=4VzFMq_zo}KX_r0}`eQD=m8Y6}V&QKV*dY(&n>_waE^hhsczn+C zdg~bDcX)jEGk&LsKjz|=|7pg3JFvhw%O6U8c*Vn|KAdy;SpM622G!!pv&Y3P{b9!a zd`-BxrGJ8Pzn&~IF8Y`C?(>ZA@Z_oCnj!fW`qhjxy-oLCmp+KNT-sfFTW|YZ`cUZe zF1_V{f^ol|oOE$ZuXvy&`E6%;Rx|GFvzBqL_JORU*1LEp_!f_U5A)A3&ib+W-R{zd zLchzUxAMQ_(g*b38Xcz@_v`1&E`2EU=UsZszYbs9(INV2;f&Wa?#tik(uYFd#dl}#1@o9JIL!s|+=`H_pmp*7^{)ZX&%XiYH z4~4$y(p&z=T>7A$`OmoYR&TQ|eJJ!NU3$wubG1>x2R%LPadAsO!T1i3ev)x%7iU?{ zqDyc2)bfI&l#A%0o^fAqyFB^~^KWI`w^w^ydfSfLJY2>J?JgfH=LF-vejaoA1SvK+ zlZ^ZNDZ2Eb&`-JaHr++WeLX0CASQa2@~vT<=`EivjBD|*9wqNdx5ROb&jmlkc#~JY zkGZ(zf0XgNJo;lUZs}iO{6il72^Y8YUt`?wM_zJqOMja2R*(P7E^g_YcwjF5g^csJ zxVRnvXBcO5X8E+b^me_p&Bg6{>Aj5m>!pVnU)B%0eC#~sl!wbY;ma;=*RK{C=i!Kz zzn(sD!0};ovi4*>)-M@&-iYyTvkU0VBFHzGA`vJ@8@J(-0Gp##cjFladAuE$M`m- z58LkYE^g%+cX3NU$++KspKx)@r^qmT;|4EZFEH+x`z+%kzu4guF1?liq)Tt@_SYES zYSOjk^^%KQKBpP?<&3U14B9+Cb&Ru|q12Olm)`Qvxb%VOc{}6F%EhI(<+6wIZJs=B zE^gD!ySUZEh>KhL!!B;=CtTdpPcxn*dFZ(zhmXZ^dTz+!7veb9IpsO*2^Y8Hjh7hr z#~bGv_s1LSuQQ7A?d>kcf1c$uR7$nRamXq76yv{O0NWl*}q z3jHe{F7&P3;oM@PTmARAxYhq*7q|42E^g_k829VBJdyR&UCl8Ww|w$^<@1?kT=a8_ z^>Bjm9bUdpy7ZyYf6b-mkcmvc%$83|MSM$e>Gv}pKE>g750`pa@bFeM>qluHjpPpX824=D~tbhlY^nIhIc= z5?O)x#&5p8Fdse+%R79=*uf z=(!?G^D zR@!5YL$55J@^ER_wH_||jXd18Q^wiut(EuATReIWs#Xt|_R{9zVjm=ZQ{U8DY1es= zUhLSIhfBLFc(~ZN@d|j+!>2g>dd@6=fPRpN2I)&G^0j=^h9-8GY%mV!+emQ3(BKBW z7t9aQcQR!?!XKGNe$5zH=E(5*oYzxH{o>o&mu58rLNEBl&zP&(26JA66QxsQf=cS+ z^^8|BE~iGiQReW|Uk@7M`Mt)!32`qk<4aT0ulHmS`MEn$@5lWc%lOi4WBDbY!bai? zz8g1$m(b8T&+!Y~K;$0jI)2c4Upf7^_8O`MW={I2w(O_h2CQ8A=lqNtcFSnHIsPWT zFDHp#;}wjgFKK?9<9pe}gK)!XRv7ZxFaJ^CRJ;xB$oaJz}(Ag)Dka()t6IbWvJ z9N*WM#1pm@UZ#6s(r$~KVd}20!=L0|^mhp`Uw431`>phg?@3mev;6w$lU~ZjpBpeS zz913#?8k>M(_5ONrK54_GBVfZ_twpu^&R-1X7V@h%T(&nN~H=JEk_1r`Ii4_QpJzP z|1>`2&yD0edWW!6!0Ywg|Ek?k>%NofGwPLdWSr1az;Da%#x08Px1Y>X6z9s1e*^AP zd;VVIlZk{)%fo(%SP+U}p;blWC<`_0?#lXn;iF!r&w zdo5nl+>gCwXBw&H9X#C7_%JH)iNkAD=lVB6i^&qRru#I27+m#_V1jk<7{_J?oLd%a%! z8?=A6*#~ypqyJBWW~}7v@#h}>81`iStwbjkle$-RHav~}kM9L`qsAVZ|3zH?bfOb0 z2@k>7zy}_MACX6!?!Hu|TeqR8;K#T1(*3K{PV8mef_VhAqPTXDY$4RMcKbM6MT=LmRzF%&D z{7)pVJ3=y%3~Bhm!=B;RuPvopjdH14ORZ!3k(D|g`6SqW1o9tAC%&?_O0^>XSVyP?p-r8mrB-)|p=5E#tY!~}ig5RxlZ3fa= zUg%S*>i$lBW$h*K$5g92vEO|a%4hrGl-hJbB@Tkm4Hw|^@fq5;S@X*j;ZI{$``RPf zu~&BL!-!K-&8SZgVSoK=kdtILn`o##h_-O;g_OGP0__t_z9POC z|6Anu;f|Cz=Y4EdA%%s!*z*{VHg7p>USn)W1rXM*0ur~F=b<{s^Hi1sh4J45-} zSlg+{9~t>n#Qh6zHlMP8vhg+c_pC2t9^Q-^rk4cJ)|Gk_c-tKO!0_5rP60=)b(fLx}^Qu zNtaZ2o<`llHFSMM>+`cE@}X(UXbsE%^$SLR@~cAiF$I1fLprFRTE2_1OZR$q>0aVZthj(>t;FwJEi?IEZN3C)A=IbJY-(Mm0ot z!e>b_+0gXYSd%mUj@od(06B=}A8{rdl0=?N+c$cM=l2TSBRgnhBtINW`B{Z~@5H@w z`mChOk9p-nGF)x>Q~Gqk)_e8s70`*F1!}u%kT$j7Cvhg5@Lk+Dw!y@QJ>@pto}{+$ zKJ9BsssC~zqkY)?=NLaq&$Ph|B1?Uz>!rMsZ>P68axUE?zfRPqByK$3mvQeB+#~;b zN!^za|ITO1I^Lj25yFYTL3z{>{465`X@_yj@!ocLmCECGMViKj~B zr5bEeCI*xI%sXLU{@1p+HsITZee->$wEuehYs6WA2=S5>5Vmdv- zcA?01Na{vh_6G2w{*w6U@f_-%>33$65pU=|nCA)nU$|OX2T!nH8V7rMXm3Rtsy;-z}C$*oIhVeDY--PZE z*5yp){`cq;rQA(@{}at$+wEAnNL^p;)%DvUKiMCt>ov#|mHQQ_>s03z>N*5XQGFNt zOR~jnRe!9`Kd9}wu~nCGolmG$kN)L_1#QE0xu}&WTNyXZCjUM1@NVdk_@i&0-xwXh zoZ<-T_3;vHUWx22+1)p?xpq#$c30Z-lNYvYduI8kwxhg{Vk|&5_VN-Xg4JLK{p}t+`zh+ybN<6*qgU}m|;i%4$-KKi3G!O0P@Q6wr`OQmF zFHpaZB=mI^+AVnD`V!QYmAJ0Lbq(qZ#`I{vT(?k<#TNVZrz%!|KF#t!#_~T0xv70) z{DVH}?dY?r>i!8B>@Vu0Qk16~;hRv>iI-s$=+Fi<-9hM^Y*&Ewgc8n4y{|k7eNo$@HufBNQ5&Oi582T43`T9Q5r30UQ%7lCV^)_9+TlL3F=sEB{_gy1 z8Qrg)M;xlJ#KV-e(&dc3*EMfyQ{+n?9wyKapU`zsp*_{8uj;-(gdC)AN{?($yv!(% zG?x1W(xCAi>0i^K=EUs=(R`9=pab|e+*Ws)+Ft*a*9yTumbPWV6aDy!Gnc9r7_*LJ ztz#AXvg4&cd~MYlw1?7X5f}cd^f-vd=3jm7ILmqDnXlm9@^ScV@=L(i={&pr?iYby zLHdNPp!tj$*BH6ub%oNr26X82*k-P&Ye@Y$2)9o(q}E^!cthJM1a zm((t(4N#pWAKH`(rF*pw(|C#wSH4dp-4xPIs!P!iuBzLqGHWoVZfJ+i!h8WbhA;4F z6_rDxq3Lh553{DkXE2xe%=}?0tNI1aGu>FgIAQ^9q`JFG{aSY`<_D&{K2yT=d;^AI zNaOdvjW{ic>&wv(Im|rCm2V$#np+IIMZoOkl+M}DQzo}gb>_9oDp_V41GfL{*!Mx5WF)uCemHQo*hq>7Oq2{04 zy*WL6I~?Hkoi#Zs8tl727Y%lkhaz*d@D|O{4e8+(oQ?UxkyzKJhp)xW zp~xn!<=kNS>=_)4`Ua7RzRMDi!b4I-+bP4{P{+Ux@SrrDdv`p)w>R`IXV!@Ced2!rUG){ZOte*Ly!@menYv@W6B*ycS8em1uczfV6BB+|@TY zEFOe(TcILV|P*7Zw z?BojNN1mrdtI%05oLP-zBT`^bF6z?TUT^q8=1=5UVo&7+efCG>iHg%l2~nfS_L6@l zNJMpPsG&DIY&8D8>*byS?Wl|ku6#iayY9G9bzM5DTRU6t-%M?{Ucat}+Qbbi`yQ(4 zn*NqI+v=C-mwb<*NmG5t9`qfZs0_M^%FgG*)Yh@F`@WH$=zYge3tcYJnWmbHmXR87YOMEW>)fDxJH1;sc!<|K0BL)( zwqf=Tye?-J?9Sc0x3=z#;M|~rofP3Y2~X1Ua^n5uf~{i&UKsL(LU%ADsJ<{K@a3kR%h~ul#>jzOFRVA!Z*3^0 zV96#M1E#$-m=ay0r{a5Ha47q_3gWqrdfy+O^PA{Xi110*?DW$j{l1*;U1ilSE%CpSWJAOSB61 zNU2{W)vz2F(cj&oHCoQTTAkZ$n?8)nt3o>LyCWKTFmKw7rPCd~--{BbAI&jpdW9cN z;%}wuXn+=+X?qn+4i!BZzY>4+?h_XL)EfLb$DPg1w@3B&3=T(48*bjvxZ$>jo8Ftv z=H6q1YU|rTy>DPtCFs4BYK+v&A9SNy{e7w2-71=nmpQ5wrmJO+%I^l!n@7u!a{m5^ zGC^-IVJ1fhPj>b758of$oO~%`bw#=@>A`NXew`oekzHwsCh)m~fD6~fz z8XWCqt8ZXKvUe2TX}aKs$~YuqpF`TSi*~8AH{aLM%Z`f3S4=$Ior9-V&D7zjJ<%8k zHo1=B2jP8bNc*ETM5d!5UpwUR$T+FGa5XgoKTLxIDhvJ5L1rTEN2ZU$I5Zyn zp7gYVMYr^Np*gq-;2je>f>v&~t37;<@rZFQBg-e_(uYF7-KDo*r?fN9)rCx_KKfi- zzh6W*iZ1^kqp6iT$~fCsE6*_(x9Q5elAPaA_$)9z*=ih?&v#th@@Zs!kd2Si(+U zsBgnz=}$5}o*1|M#UG03GvabO%JhO8c1p?juYz;E zQ}h6d4#uq?pJ^8l=9vF6#{Ke|ap^;$f5D}<@}Fm%#s@g8eyXbtz__Jf$GFH}V0py< z$U96l%csEfj9Wh9mqhrCn|NxH>HT~?sN1K5*%+JoPSa>(zRXkJz_Hm)`Peb?Jjewhwt14+S5oz-Qd0x9xYrrMGfUy7Xa@ z_49;FZ{?iz=$Txdtbm_l{AxpJ)17m1%O4NU^}*Y~S^8=hxAfxgM#{H^^@bM=^x>Cp zE#p$YLch+XxBMGj`k=`CH@kQ!cvA&FEiQean2-3`@#SoF=|iF4Q-Ob4OR8kB6K3@W*3#u_%sPK4XkqJ##r0Ts$0O{29jm{`Z)RTmItj zM)V`|a`9gyxad>-*Z8=Uw6C{nt^rIR3ZELreZB2x+?W55i(C1haQO!^UYYUmmK8?7 z;=jh9kDOkiQ{(r`hbz!exVYti zjB$})f9i!S%`ooE|AI>&3jM50Z~4zL?$_tDE^g`1yZi&O%Z#r_8yy zm2-h{zrBdx9KXH1!t|o&G0xX_7{A6eZ*Kiq^VJJHN-=KJtzlg9D}1sp9!xWT@pt3v zP5jyjAE6&(KEB@YBCr3 zS%i@|4_!0hZ$#j%ctn#Hea$2mhh4B;j~L{`P8xj@XL1{p3NQ~sc%g#z2(#9;+D_79v|u7+g*Cg=P{Q)C~$q4WZc(((WMWCe#)h{ z{7*6N>+L0vkJyblm)`Qx54KR{eLIli4#!{Lz)Q#a@aea>xaHr*xG$&pPqF38c1HZC z`0Y1efzJrz!bj}km`iWvDKhToYu2T=<$l8BFXL_T!{W<1=h6o!IbWwM@IUL)heChO zrML1+K{4Avo}1Qih8Pb8U(dL&|3=0|Z!*8w?9$tG#h;7Mr^VwV^-cV|`1;AZ^ug>3 zQ=j@Oq?>o?L!saA;z2uSq~P+g<#@=Y4~2f*rMLM#>e2@VmUGIbxBQ=R=|iEPcIhpD zlWQeUn)&I6QW4+a;fuvHjO%p_`?Q=voDAXG)h{u`^}ynXc^=K>VR517anCY5Vt&Fu z!+NOqaN*Nf0dJ~+XDZ+=9{w0>qSeF4WPah{<7{u+JzV7MsetD_e3J7k>ky&`Suc=r zhv0{JePo>VEx631@DY_h1n=P*H0j~fTmgz6F6mBrxcG&g_V8KeGvnbASAr0??-AwFfD&70+x;j3A;FLHy6Re}}wZ*0B6kWBExH&qi# zN9=~!gX|e!U6VUm@b^qTY`? zH=6jChAzbKm*i7!N_@e0}w$@_*>8Lj+`zy9X z+VJhTQ?Bpo;TU2gg@MEud?#)QFQK7xAs&cbm+QMOCcaO5FL)Ey7)ygL3mlI4EGLOC z=NxX7v)x6G;Fp)gi}Nejil>>Nh9gkFQ?Bo+WV>Z7{YL528joLhC}|m6Q{NareEDI! zZ#MfR#`jE&U%$2YZCrnH{S#ojhlhWxEw_4W?^{&Hw`_N5P}-!Ni+u4$wv%k(57Tz@ zV^R@oSwC6HcE9<(Z|Q5*rDM4rcWw8k+ittnP`~-TZ|8Vmgpp?>6 z9<~h&k5{e7elIoZ=~Cgc1EGAnZb&4-ocb5LN zi(7j6x{}SWWXG19pKcSEr~k}1!#MNdCw|x|$fdXGioC2>+dW2ngZng#|7h06e|XE` zluuGkrS*Vz)*Gv1SzDm>glha{gn-Y}1mfu7_*DPsQtGwLr>|$+pVJk+bU~&Mu1^wF z>v2Uqzt{Mc*1{!y?v`wNBEN`NX)RplqmoZyAn^sSv=+X=31lQ9pINOICHquP|FvA8 zjZ8`UCoAly-v&(b!le2XE!Frqyo|P+EERv zi6`e@#jSGd8511euP+i$I8wM=R*MYEvp=!}WFvh2Ra(zz<$_}0hLYSe{Z$$h%Qr!f z*qG+RmmljHP0Po@mDe+FzOB(X^@-m6m{{H`_s7K37}I9d(b7lMEcRo^e#)s?rSLLG zjrOrnEYY59Y3z|7spiu+)*r-slID$^RVu6Pd%bEtd}IA}*h{$>+*sSIZd2{LxN6jn z)0FHJe)$Wa$zn`w-VUl)PadW?*K(M&Q=^ivr860vx1E+WUoIIw3Nl2@ zKTdDjCC;WU3&R6QRj-3BXx|b^A9v#iNU-cUHE617k=sW>l&G>r~a|MdGfIZ5; zv@e}%N1Y~~%o~~@{^yw20`#7W%_C|thoJcbzQo0Tm`|17t`?Byta=B^CEd1wbTLkE zFX;X1YSd>x9U=Wl9ZuaC9ZJ+;UO|!>**agt-fsBIK&B&@+uZkBq&gw*5zHU%d#xVV zkPYSa$GB(aHxcB8+@PmFqNDkSi9<9Lhxkx@ic5KCx?QjR4f2e=-ocypaoB#E{7}@YEcj6#x*${6XHzqZItBcv;Lm|DBSXvS zdUYq_-+}l$PD8fygj3!l)pNdH?K@wix*>n=d`ca}`2gvG>T^sF+fkRZ>MVSKh;EfC zApeGj>ND|!e-MiqeVB3}-OJpLbo+iT)1QsCp%V7`elL78(7D`PHr+F;(rrcT|3^B( z{;ldL^7Rz*W#+Y%-rM180%4SW-#6=3pB{Q)kN$5)svF_lH)~Y(o2WnEtVJFT{_tz{ z>LJK{2zBZp>cOt_6rbkCN<9NTP@7$vBNJ}+zBU-O@t4^DK?-f^?JB41O0D|LX^NXt ze+6CdgI=Ek-v!ivYEOoz*>m$@$TX|tMCy>M`l#N<2?$76ENG4As}>*99KDRUz~UCJ9BjI-2AMH*fHUSo!Fo*P^GcE+{* z@!{=;;RpM%1s&$FBSYrgBUeB0_qu+FK6oSKkE&j!IqO0-D}Ya|2Mbo3v!a97hqMDK z2TI2u^H-X)Mk`Ew|JP5y(wz0p#;-JImH6CkSusR@Zmt#I-;(#RWo{}AB);IgaYJ|s z4V~LL|Ajb+Yp*!eU5sTsI{E&#opI7XwPip3N^{nQ3i|hDl{u?zFr1#m_sh!<4}hL{ zHgY^U$#*M}0DPA8<@^Bfa&y)cS7<*yi6?9+?8{E~B91@F5y*~{4t@PqnzPQZ;k<{K z#STCHN^{n8#2Ck~nUnqX<8Q>6TgW=>eZr>8sVZ z!Dj)logK<9l&aFvx~lzeQ@z|@JzPlO*~i=TIP}RvN&P9@ytk)*ue2>)!t;%a=)bedytRfz_*p=e|@SO<-1S?KN4hCApgNS zO5evR&UcUw%_)heP78c5e0QI zY5iRZ{rPl8reb@N$o>A-_m7Aa!{REDE*Z#t5WG;u~a%zc(r88l+x0P z;OEWo{bP@Bq~4e>M#fvpmvJTBNR+5I=kxDU2Smp5=huBsw=7Dy z4>CUO;RVKPxTVV2=n=-nVhT>17j|_F=j37GP{#v%M+Qgpc{}Gf$xy#gTo!& zIog_#BDyz5h6c)lKFfiTK|IPv8hR5$u)-$!9ep-5V1kf&9qU8SJz{g7`Zyk&^E5KP z8gX&hx!-0Nw{srRlU_86@n6mQ(|C+O9A4?e=a1JB;<)86`d&+SWBlPnL?0TD@kfWP z4;mxku<|#$xaDui?1N9P4H$Fr4VKg58OF6fW5cy}#yMR}Utrvy%M}?%r$UFNpVdLT zr>(^o7}xoY(fPzx-wkpo~rdS|rr$j z#PQ$koNtU1n&o)Zj;Kid^xJ@WN$41}enJ{uPTS4#sb7d65d9D(cw^>u#!E6&-tLHutqo^g9gXaDG&N1=D`K96T6#^)!!8<&nERD}mmQye@q zBOXZqNLgA4uM+k2tJHo~^{lz7^!s{a?y5I<&fwmsc4EieZ;e^4!Ye;#u&+2-S{mKP z$E+iKhn^4k_JVF*R{_U6&zjE|5#cywPU>fHF2{$)xaDvfgJ!XBH@~lj?X3|qqtCAX zjy~+MO>eGs<>dhaMxWSDTjToGwJtZ*J(SC7NyJuZ4aCM?WXtK$cx>#&6McEh&yKw^ zn%b^^TZQg&@iYfjfiLt}DweM3N8_<{4>LWFv240CjI+)x&ak}fX3clRH~cZ&Px=_k z?^OIcR%u;*fyW4QtT(C`)IUkRsb##<7%Ss$Ov5ZB`#S9ZRGEVxx zs4-SKp}@n3D~_?4Fyi#(B=O~3ag45y z_-QYE#0&pBFZ?@R__w|Aqh9zCFZ}CX_+c-6zzhGX7yh^xzTXQEdEo&s{L5ar+Y5Jk z;a~E?zu<*G;)U<_!gqP$4|w4_yzn+J{5~&yyBEII3vcqm8@%w1Uif-1e61J0#tUEV zg|G6$YrXIlUieZkywVFNz3>J2*p0WB?|NbK{Tsjksu%t{FZ?%N_^-Y2x4iHfFZ`EY z_#0mM>t6WJyzrlT;TOH|aWDL3FZ@Sd_<1kA7ybh;{InN7;)JWV;CU0jZ(ub_cthBrg%AM^*S8riJzfq=jm0Zi2D1;WomZ{GJ}5i=kT6G5_!Tq>c_D5 z_64ldJ&Sd^&tqNDtkq>`t?o_GkhP??Z{C|gKC#Z2ZlXNCm=)P6FO)w&KYxa2{v_uq zt#itUIb_Z6yn5I7vF4{zum3&l5BvVRoHfS`vL`6H?Ue}a@?_9am3SeKQ>Q)+xy~^6{#7wzdE}5 zXs#D-dkum#;ECMeTf4{?Fk~6%rLU3)aj$<6&csQK(V;GrI7si<(|UWf2Oljn3;O8P zM2IDr?HK9Me&v~-m_toaE5{OAa)PcuVvPnz&FZGlKMVKEq*vqqSbr|vdiRb!aDv<4 z50BkiXOsgSj~%H-ty_2R=FIu{N6O)wHr+-U%@5*jXRZrIE6f*;%26WSz57u5B&ild zD;`BmUvMKqVr)3*s5^#+P&xQ^%bq>0o1$)b87Cd!4Qo75=R?caC4~-mfk=jYUc+at zrq~nvRvbF*7}74ViN-K+;}7Mq(_s#ddF!F0yV;fdd$fr7y11*in+jJ){_rT3E^85@ zqhb%>o^3-Uvdt0b;8l9K17#ru+`hm@Y`#qYT(*ei9d~RSPxo3>D({qzj_t0R! z&XAwhhfqrJQ;zlM!6B;Rd(hIT4t!9JE(HhcPgka>^+R{>VbSzW|Nh-OcKi45 z#v2fLA0DbhLG827d1D+op9DYGys!>b`5ux{b&&*T7#o`Q&3_WPGyyQR|=`8JsKpOAp92_DY zK^NE!AyzFQNnc+l{6!;*KDJs@X_F%c`=CrjB%>X54DHiS&ow>Q56X#dTZ3RIiX&Ii zInLo-qy3%m5{@c?tROpGBg0V-YFmHDSa1Jmf7H=GIEwv3)z$%ctG{mmT8&$Fc2`ds z9~1$NydUi7qs{|)iAoZsUX8HZ-WehXk%47>s&QsdGca>tX10 zt)`l<%YW!W_z6W8_Q7Z9QtzS@hL3EGki}R|3yo!S-5sNS#;793Qah3^5vFcgL`z4G zz)3u5&Sd1UVZo5*LsswsxT)t>Z|QVnw3J#*)ymcUf!>iGUBOM`)hXl45?CbI2iP)O zui=V5TC!D|t~cLf4JH93NYu3yo4VoMyIUZR?y~O7E!D{n{hSeFxg5l(d8=j<)#p1# zdfu=581#Wdz59AbhTm`O&piXED}(z6dOuD@Jfth2wvEk$XvqV5%pf+pVaEUrCDeg5 zKgjh;Tk~PWj&fsN*ztkQj#{!CBuF1@Hbx=ZC>nv6%4@g>W{aA+R-abL;J^SXFsipL zFRGSgSDP`s(Mgug(t7UPkhh(~!=t3do?O>`QO7>`zr`LT%M`mL(QZ@-vDz3Qb)9iXY~khHXoEr5JI3WMaiAI^zMVtUL$)HO_Uvwrns?`Zg+`_rqe2KhuDHLW54|znFmh_TVGQB4(WAkK!S5L$ugGM! zFm^!Gg8EGb=|dht(%b`cXRYv3UiP3sVH@M7w6C`x1`~r>2x|LJ-5y6f(alHH?y`e9 zGY&SQ=6g|7vr*m>D594^V5|jW5HK=296_bVB2X^w*t&Dq4k@SIre5jcM|@bdvBJ1& zYwOOX4vRV&h@tHh86wokW&IAU^(bobzz7dmmSS6*4U;RwA4N7`9`M8fQyFo(A?Kc7Nj|*2YSDfI$L$mz%X9!G`%Kx=;;QPXloz*O=IAO z97Xz_%zha8-o2>r)D6|YCmJ3kv!Hekm>QyQN0h!9F$zvzt79LJYtp17fO)Vz+!mqMwJLKztHfP8eI<9=8RT}@H7*>W^v0=BzF zk2|?Prre`n?7`cul=C5|uJ1vr3TTu|`GuBoe<{Crm^qtnU^(3ubk8i4G8({WzLGB! zUvh``0XgnjE(VPgdRfIc(5UKA0Z&^wT)nFOhaCZ#gm(bAxt zQS{M(8MMgUvIBOss~2xt$c@h2$OAd_!;KhKWusefx#i|tI6BHDHtVG6D2C=}n>3H% ziluF~8COyI!)Vf&W6~v3q4B=13G1W&LG%oLz4zsy?ao|R2X)Xij2i9i>>cirwy1N1 z#JBR0+vZ0Klm%-><)%i~(Kj4d6pE3$5K3K-EKucpdOLeDX5@IWaT%!_20R|!YBApI zbxg9{I%j(BB+?=s=8OAe)R)}_PG$JOAZE)t!6gZWuc;)%WpC4Zgq|S!afvS#Z5bRB z35=%w8%uIx{v zb@ljM+MRBi&}J{0u6S*Tw>oLpx-v&;sZN~QTc@`)@RkPN(!jq$4g5sBGyCSh&!Q6e z!F?CTU(I;MS|y&HVmQ6a7JtX~#0qosU5uaP@OpmP>So5pSLDlvT;0j|0=*cAV>6!C z(DC#5BmT9liahh7H3B@OT6T<8z&}|5|BVVby{oJHJiM)|=Ls}Or*FZ`_&zpua4|jp z_2}^6VhL$>LVNdu-@xErTGi1D5_|WK<@Z_Yy+b4imK6B|vi{+L{1EzUdehGwx};+7 z-pV_T8jrnuOW*0y!Rif6$n4V@!|h%k875e1&cPHFG!B_hG9C)vW^T*(LBRymx4U>K zxD057KRzJjSf<`SK3O?@QLB#YEE*=U#>EgjTe*3xT;-TPEE*^*v z>uDDc1)p*8V4V5Sx_Bt~Nf!^=nf{cEhl0w^J#vv)q2=drzSkyw;HZ*}od@HQ6@7HW(!Dn1NXkq$U7Y_wL>Eb~>)1PwjQ1Cey4^m9O z;Nqd+XI(rv%k|-$i-&?Qx_EGk>G2YTKBT+^uW|7}_QOcIcqn+Siw9H8KXUO*B#Q)1PzkQ1C?;55}3EKDdkPUvT-}oXLVV zzDRlWg3EX1Lf^<2^o3rWzu@&Q9@H?sd_T^?Q1B*?evZeb85a))Z*lRU$n>o)9tz&( z;(>fi+3w<@;5{xLv@-v^i-&@bxp>gT^aU3W1s`|upqA+;Ts#zf(!~SuIb3w{Q1B@i z4;HFTIZeBGDEN$v2l7qKtc!<&pLFqHocW(}@lfzN7Y}-ve!;~*Ar{CtWP;jwBQr}vcKJw@VuXpjFiRl|%JQQ5) zqVTU}`iw^}c#De%GXD{KEcq3@&7+t3Si6gdf=fRj^7I%pqVgWS;A1WxG%&>Zi%0k9bKfBf0TyIXfxE&wPxwsu4F1WZIAD(q_ zTmR3wxUK(-jO%aZWA$Ig`x=kc|9~sL)c*q4|8*{I`}ZcsIT>4@GcIoHbE}I7i>yzX zuP~ob@E(sor5mzRc^3}_FSxj^&*Ls`$4iqg9*8gcqKk)uPrG=~%JR&(cqsTu7Y`OV zzcOEx{0hFn^x8hg%Ij<#kCoSX#`zS;xVf6=!HkE3M~wUBRp;Wiyqa7*I7=T#f)i`Z7v>6GJU&?hl0yIUgST?^m&h7aM_ng=%<*z;L!^{?&855(@(f~ zDEOp{2aQZ$bn#H|DHjhiOh4`7q2Mzv9<(w2tc!<&pLFqHhUrhacqsUsiw8YSzu@Ab z;AdStNHP667Y_wrbn)Pvbo{(-B=ukL8W#^vF@4I#L&0lZJeXnn$i+j!>s>r3GJT_q zhl0z#N>YCcOfT!fBER4*E}x*C>04bq6uiyFgBGT5ckxj09v2VlnO@f0L>|G%Jos9tu9?;z1kJPrG<1_>7AO5!27QcqsTu7Y`QL zKA&>&Q1Cey4`!Ht!No(t&$@Vk4Py0i&c#E)7hOD9k+FU$sZY$N!_>~_0n2THbLyYsl#PXkDT=G@V z0u)_(%jX#vw|rixfS+`6%SWD5@qozk*~3?&Pm$+d#+lyo$ujQeEAQf#{*a4vNVIDA zMv~dDiue{6x5YDzbG5g4JLBB^EnZ-ptC__aRt8wRTIOkNo-Ho(G3IOW@fC(cEi)26 zV~j^0-otpkhqp1_=;1Al%e+(gH!+^^=<6A8@$g#4TRpsn@iq^a^@w&4mvxOE50~|k zyobv=%b17H@Vu$u;Zux{d-x>d6COU!_@sxAF<$iW8P4yNhqp2Pw1>AaKI7p{jL&+w z@IUF{^-O=t!)qCz^Y9wR7d(8C=N)G~T+%(~;j*5&=;3qBNAWt1)GOgr@F~U@JbaSzvmQRq_&ExWdl*-2Z_MqrtJ@eC zJ0y69@svm3!~K-lGoerM05bCE>lqh&DfCT@H+u9fjEg-M`ZmTh9(@nvEgn9`c&mqx zGv4OmlZ>}}_!Q$k9zMf(-osBaKIY+bj2Apy)(yu!T-MhnJiL_`vL-!T)(49oF6)3( z9xm&B(;gnxn1Y}2aGAf&dbrF3PkOk_Cr^2}%uDAye1_+T3m!hj_*oC1Wc-|mk2AjL z;bV*|uD?>RdKj1Sm*8!Tr#$)=#$_BQ^i7P*^8vx@8JF>(;I)i5di-k`m+_|1%lc8q zqnCB477v&8tX2<~b+I-NpW$+E_wXskrQM4>lZ@v*`f-o*I7(4MtJgYblsR;L02sK2LZv>=fg2 zsvd@9M~FyfI^K`J8%=y2mY+qIU-Buq#20)wZU`@-p>v9#cNXIyuDP08^e)CS z7BLqK&E`DDIO(5Ey`O#?uyW~7bNU?Jo_yMFj=#xLm-P2xk3xP1A^yjS7RKTf3$QuJ>4>C<{vx%f?Yn~1;r z2Jx{c@2$5QHwXIH?6+Il@4-!*#kJj=-;=kAbpRVx$Y^;o(8X$%sP}}c7|bM-Nn3PF z7eCT(kjj-hl|{MIAe;wkULLEKSp-9H@!uLr&2kf{Qapf&!|0|)2Jgd{H?P+_j^xHh z)CTI-)P_!cfV<&?J6m^e;E#$q)X~}7-Pf@XH}lycwV^+o>m1#;0qCupe~A4a^;y&o zP@kM5{V^6nw=1>cF=!YfW$hzDZVo(b3fO)nAI55KF;x}PmCYF{IJ*TOn)@GA`(P`|HnJK$Z=CM*E_QHbe_*951nKb%`L9B;(f*Lt2Wqv?PP%@4p7y&Wf2RKf`$)puU3aMj zhoGwJKm+{PU!gkj*y-_k_?ujdv_Ri_fzFT*`*t3ihdkK(@>%SC`FZSpIX$05oEq$7 z*-HCfHWsi~XR%85(@cT~{91xXGvum!H`eJItBw2$;HBx#21rf*RMFVk0PdajIy%>Gs_>j8vMrM}j0 znLff?9K@b;%kW?0vFF_KVjSPM8Q)^qVN|A%GzS&gYC1?CI4r&NH9p>F z=wK=IVd?WOZuw6z?(;e2;+CFa5oF1X|I7G(|B?Csllmw5_v>J#dAzK*o#Tj9zEqW^ z-pH8XddB@0JK=Xe%*RiEJ@fot<5!x;OZxSkuAD@E5%2xDQEp5meX``!k1u$odHg9( zAd-lD_AOYYdHgIBN;;%}vQ8qu;BCMpFPwxvoht{Hp+%=yc1$JlBh78;N7%}F5Vy*W zsZ!j+{PLD~!jZyDjZsjgA_jXn0=0883V!}8jj3cEeA^OBedVWLX-qZ8`v1fm#NW7S z^G!Eh#Fz^6;ENtpWmp$0V`Hkf=E0_5Dvt?PcqJ$F&|;aR%GNCRX8C#WgV-6je=qil zym`})?QB?S->=jje2rvW71)s9mfwv#6yLYq85_gB@Z-NVA1-gZ3$EI1$hTcT>GNT~ zzWDjCWV=r?;Tz9~H{Z<0_)V>0Zn~wZ$t!lhOTHx1g#s9u`Rw$%x-&{0n4e5k1zYExed+wzgLN=4tX- z(J=K@l};5^dR(beX;q!cS#u$&_F;~_Et^m`b^mkeo*+F9+VSg?yVRej(nXU00OrR= z-h`^_z6U-i$hQT}eXB7oDwS5&(H#A96|N;;vp^qhsNIHMFI%K}eL^*7|EctF&`{ru z4Pg?|JBV9{Qb!ezCrA4C@PD!1}_oSYP=3 zJai178Vgl+&R`Ziur$JCKjx-bha52M^(%qsN|&a|%b6#RBX$qS`dv!oNHK2yRU z)=|E-emBarA+c zNNKqq!&=als4Jx7$502AYDl3^;QNt@Qt2NiN=Pp~Ih*WJ$FE8ki^+2cf2MQh2A&L~sTC z(0sL8^=MM9d=$?{P}a#un{HpFnl`Oe>88I@>Bi&8)8q5Srd9ikjVt$;O5biQm0oO& z^FE69KspB@j)&(zh_I>86kaa(#gq@lkLS5f^QO8a`CQ6ly*j?(qq-d&oL@{`seV_} zc0o@|ax_e=MMYZKO*|zJN@b2*oJ=&HNIu#Py_l5m8LVW}E__(get)+IY&v>1`1b&c^CgSG0Uo9OEL?;yQRpgW6 zQZBJ(%09-UodBoaoIM`T3wP{J3veI zUDBnsT+ub%H}!+!(s5vZu}D>NTehKi0CbPfXLMQ*qwmEk^gn)S-}oiu19aUM>bH&G zC+g=OpKrb7^QD$crg87X6V!iyLZR=eSL!!vj_#Yhs-B0Vd=}0AsE}_1aow?@P3rc+pkGiYsu4H@n zVYYWWa3(&Ga~?9zBaictbN>Hl?|tCox~e$YiesiWEN_ug}_=3Q$@pugSy^z+%5$Zy{FoqO)N=bn4+pZDH9 zkaG%hPC?Eo$Ug;HSyJ| zc+xrtYgHU5jS+yU}X+4*(z)D2>r+2EkcCWuof z)W;vAU#8p%bt8Q9V^fvtiLGgrTPdT1cS9dPZMl+OnM|LLa!HxK4cn-Zaxw1|%FVLg z2+S{|@zvSjc79gsb+S6UH&m-Llb!{DHvZ;)|=9un>lQ$tv zpkCB^RqCZlm8{nBy;kh|aIhlvVfcW?+>horE`J63Sb6;GL25za$yBm%IFnC*I7DIW`**xNSDRr(` zsLm{SLO*L^%~Q4&7f!}0$Jyfa66S5>YRFDy_eQ6WzqVn&jv}aem^Mn zyAQffH%xF4p$rfHV!K_ppZUzTX%+lEXlWnNtM=Dcc9U*h&dU3F&{5vk;@2hos?<|k z=c%f?OY@i1eG3@tiBh~3Z9So$KpQgSZ=QJ^itRbaSaGAZYY%>*w&`G@zGA3Q6Gy+* ziGJ%S{^r*q<{HM{m&c52z<8}jedb*Jj-H`sYnux3J3c>jp@_CqTv#_=duQRl)vhai z1Lv>R{%qm5Yu6T@sa;?AdTmQ#0<_sh524RCK5D#nL+*EK@60_kzjMgWEs!?%+qIi= z->BV~o4EGQOV=T8-1xN{E>VvcV|54E=J344#E(Or+$42k>JxTQ(!LU)(`i@-NQeGR z(zOLwOFEPV_VnXp%NdQ)m;Hm9DgGc=+J65Gx@O+5RZo8fI_C9SbblcHvWxbdqYrtT z?x*n{66#8ojGxn~2~~vcCs7w#ciCwbs`aUK2J@ksy!uzPnRla|T*7%7&adL!jI&ao zf<5x@2RVfJd)tlR&+(j6dodP3Z>#oVeAbL}e|%*L4HIFWj) zDxR;aQo)MrwcJdDek)79=(n=yzBRA;e{S?}H0Sf7Y=5eCKs_t<7sa63q@hn@Y-%G5 z`~>dW{`hiv$cOEKFza&xO;& z6PR}vl(k1bgDn<=I<^hW=MKlzQ-_&fpq@UAv3kPjPh@Y%20F%KiLJ6Mv$i<_pijBaxVjgzIqvv)9 z-zfG6UoW-=n12UfF17?GirL^x#fISNVkUU1Xy*MR1^VLC*P8f^qp`!q4;xq36e@R^#Jv%!hzIGCW@UWHoG?WZI)w|m@;Dy1%1|B9ZW)}sN09}JUr0jj6&>Alo5S)%*K{1 z#E;h=(f7!Y^^<|Dl<#=$$jp)CQ)8_aS52829^#6aU#{z+>towVl0fRO6F>Nx=oQN-xxg_UhTBdL! z9*bqGkSF+%*IJneO~n7$wI9lRWYU(QC^*Z&y2JB^)RE-K7}L|&+jjwywMU@$pzg-n z!blJ9C)F*JFBU`0W6b#EQ0(v&>kW02QL)2cygkUK60xVAWSW?|rjF&yVQxuXoQ@TW zEdPY){D$N13J=R|VPs@x{qs2sqg4{9_s<}qiq(8$vTcJxK=~j zVzHtQ?PMyQ3Inv2DYUaGv=_FkDYTg>w3#WinJKiHDYTg>v@tyv%?HnJrJlcu@d9~g z=Fi8N`RG(WHj4K*CPYUn_<6LMw?jvin{`E*^RSISDrRfWpbSjABGrMpOIA@n%5(-g zC(WT))#Mr22F8KV#vZgq^!I_WW$Jz$bi~iczJzmQE`2Bul|NOaji-n6>O$DjmPqgpf(rX%DA3j#w@ws8h#Q8X70?%_RQum`@ zVE#&7iTY)kKPmdA?nhAm7}|!_y(UDN;4h1#C3Nw5}75!!udMc=oX6 zBK1L=_U-*N?vb80bOmT>QyjZ2i=DiB{MwH0@oRIFH(@<5f%=W9J(yQ^%qaD_0{L+* znCJDyTbIPt-`v2y8f{?;c0Yx7Fts4qvjlcOHLde)-2ea0WK;A@yv7>E{z7;Wyg*7=Qnk$nu*a%LV3hZO7zO>YJ#8Tz3)IzlYy9)i>kanL;WV zu%B6ry6Bpr|Aeg-NPknpM^*yFx*=CCHQ)qK6AIAYG3)T@n+C71K z9l!RYGwIC}`n|VQ@SE@(UvvJP`lP(?Lf?pc(2=Jv;rS|f(w@dguf=>QfX))gBR95U z^j_#|98#+ms%R?M6Hs_xuh5&KJ>#|-$Jc00S4a;MZE zbuv%=?u|vY^p<&ehOl0bdG<^d)!S~N&0fTZUMpJGgY(iqFZI`@@|N1uCCF4>-uZRE ztc*QvIytP9#3`k}FeqWwQM zMgLGNR-x=zvuQXHtjN5G356XWsNje2`E0|sU9%qzX88PqDX<1onV1YPwqZS-k6&H4 z7~`E}Y~+h<*WY|qp}mh3t=-a|%GqrN>^7#1&0Z)bAWyTlTc)ASj@Nc!y-5YMQ*B?c z{VB-7awn13IsLl>V>YGO4iY8&io$O`=)O}zmrRTt_ze6S(^M6k@qCN#fMQ&iD2$yJ z-n>V;|15M1LC11)E!EdI(^9r%sxUSlN#DGGQ1|gl{b**kF8{Tpu9E7`V>)djd+hU) zHkoMN-!180*6AP%>N5$NLMi`L^ZrFb_dU?Do|B84k0n#tV~=`twRopimkD0#hHn#47if=*?>y#g4t(<--~V3BYdxNn^sl09T$f>;J!@r0o|Nfhl6EER zW3P;}7qUHLPC^}+XL#{Cg>ldguX3%DzM(L7J?N8Fg|Q0gzD@Hm^_{@={Uz6|o6RNH zw8c#&*Woz_1XBjBJD>rn|=I0x??6^MgO19sKAsf)V?#hc*8OFv$ujT`&#PS@j?G~tMIu= z_@o`5yq1@1>e_CV;q#UfKGy%G8`@%~uUVU8IZ4lU`}dIBj3FMIy1rpk%=bNi|Eg)5 z^f`Zd$@rWkY;`_lpqv%RE17D7O~KF4JftzDF}9KB{Xcru&|Re6BtQr3pI$X||ERI- zG0H=Gx4O4&I2DY1FVUkCFRrm)$R(Ddk_l{mObJS+jZ)kd7GuWw(YwzB~b9x|LzoseN*ckE(-?|_+9-_`8#O>n9B~~$ zTVwC<%?RrqWSm zw!n?+?_RS3Rb=BTM(AeA5KlJTcyHr9t((^0b2nq%cQQ2bj;+f>G1yJL+q+iu?HaW5 zZCZQR-D_dNYwua7p^f)$Y~_zNjrVMzVXwVsgTYxi9CzQNZ>#3_uG#Q&xNg+{Dz)Cg zYK_#xn){d<=|vN3b*(6M=Nb*Gjg96Ei`PHaHnr%K8=4HGjrX>;ZdkiNlSY7ntODPIBSMDH*EkDoLe>_oj#lE zb?eOeeS*JllexZ&_}a~z&``oP8=KazXa0BHbLTzxqG*lxZCZ<5n>I*!o7aY$)^30- zYfM2QfAhV_*_=b9X=O6{i{=pav4$0dYbFZCcF3Q%?^zdaSle_D#Z{ZuG_7gc7~Z>{ z7dQ+fU0#$M_cz_At?jm3Z_gmro$Gb$g&p1&wo++#uQ8UV^V!(CcCGNaYu#Py%l)v-Axd`M|4R z_pT-}LU%(&voPLA8#6pxg^WV7r3T+nBzvA|5u*+~M6bJztIjBAnd&B+i$km|2v;kCefmDue%a8T|P&_#c(Q&z8Zt=r@=Ae_ICs$1->V^*k3J zEL_ZqzqJg`xTbUQd3PCnLmB)7W$+zk@CVA^pDKfYrVPHn4E|eX@ZT4M%3Lf{`6r6%J>S#{MeF1w01Rs*~u0Qa3=^I9Tk(Un;E73=39i=ZVF*2 zJGbWsbV@fVGsz5<;kl!0Yu{k63CU{t_nAPj1KWBB2DfzY?CRRmzD>S)?c}BT{IzpC z(7sM{(cfn&9@yDCC=|Ury8F7-_O9&%U4#70c3amD!+AEkE6a8HSGHTW^bYiOzT+KR z1_nCYcXXR9I46^zot-9Y9h}yP+1}qzRyOEtXZt`GJ`sg-pu54HJ39LxlzUx+yZW~b z?rh&N(A~AuU_1Ko5;UXL_HW%eaBn|$+K>Y5>}nU5ytA=uu(|Jn9ozcab4`7_7)#!y z8pI4G*V`?!3FW>0m(g`@>+RYxxWy=_yBFH%Gany|ZhP8ywWZHT>76`}M{&oeAh<8*u_*5392eZ`Eh}a=sYF9e?|MvB*cH-m- z1-JSs2><3Nz2k59d9m_adOJVx`P=wumcOu9yQBHy-9vNaqj*)D;Csu+vpUmliEf(DO54BPHYD*tR>76{eD1Fs=;olRbcjes{rLVU1{ZV?yKOd#9x*+`b zdN`(f`q<~;7lr;{6tA{?9`|s|ry#g*x2K}GE7uv1kIna7l-`x=l`?oz=EJtWPK*4D zqjGC~W27f7vJ3cQ99vc3RkKL|NZdawmKcqwu!K*FK z7kPPv`d{VvX9T~_;Ew<5DDLR(KF&)$`Zl5W^|mdFJH7P_E+@x-TmaFV!%qn=@;f=t z3U2j~6+N6QL;p&YzS`1XiqgA$7t0c%G83yK5Tti z`ewm>`)Q5hPEH$7>3XkT4hp^Cj(${dU!N~TaYz5M;I_PZDc6N4y{ngm{1X0-Pf~DO zUdtyX_;sHAwNc#hsTbV0LmRJ2a7W)7&9^EP`8Nw*=jChTI9WL@eOr{?@y`qHm)FK| zvV5%l91?n8&Vt}p&otFHcr*$=A`h2=3Rfjd$zY;if3PtKZFn3%%ptQzqa3C?9A4 zHV&?z?@*N9<(n^)?|#9pK5adYmg2BC`+VbADGqzH_<6yteuiVlP+s=%g5VdTc(ujx zabFgB@js3}C%Cl}IjbJQZTq$Dad#B2 zw)l|XQaqP$KFZ&%#})(^c^v&{l-~KJO7GT<&j@byZ=a*S zSc*gc7M~Ve7`yfJY|2!KKYy|DR{ipT8W8;;tT#L~&Q%6N20Ny&(4X zjNqYXKc}Mf)t3H+D81u`vDm}=1-Eg6 zEuR{}Ydrdl;I$rpQS=i=@oGz7@8MRSt$b*-tjpY#T}nRg8Oz-h~kdVF~NO1nGn3*)58l< z-0?XtxUc^jX`o^TZv2U_bM+y(8-Ln(uC`t04VlUaAg5}JH$?eV+4YTV6tA}UU4r}1 z-8M&YSFRqx-)7`+dVX2(WgdP(@S8mRl_>7`C&i=r@+=nI&o_+Xj!%!^%e{PuqPU|! zBKQiA{zMda^e+f*+xsD@xU(K^*eUgr;I`gv|MhYdcm3M^vI2FpC(ky)eLeR_aVO_) z!B={G4n}cDKPtFiU&jQuC`YD=FK++WA2iPBfK2>)8aef`u&>8maM@+iHNf0f|A zUuuZrjy^AVy;tx1qqw6VEyL%c;J*LAB)HX&?FW_qf|L92=)>_}EV$MGZqZLla9=;Q zQTl32&oBFV2)*N9FSxItZhER%ArDS}TiQ?53 z9~a!}&7{WnDp7jJ=ZF-@(jStH&U?7!(;zQ6`0{KP-14#X$IH;4h~l&I3mzSYVoxH$ z#jRJJmJD8s;_i7$QeFV@<+)36U;g`}xRa+%a9^IGGW7W}^aa6hF>*Xl!%Jquiez|Jo#TK7WeH3?mGJ^YjPDkmTy`72Tj?ar__|(e; z^fpfqtD?Bm!!v^W@}G|4F5edf_vKH>1jX{P>x7G=c(uj#C*qJ%mT8#T>{b;~vnx8uybhg-cBJlu|pCOq8M%e05vd2v31S1wM9f86Kcr^O!) zdw8qhhdf+KdoFnRwD2GG@Z;jgk9+vA;Nu=XF8#`chc^iS(;j|E+QS(S-zWH458o~L zw1@Wye%`}33x2`Fj|(m^zIoP10uw_3-n8Tm4%;7X%;o=r0OB;oaJ!CL0;b-r(W(J;&HiJFC^L`u;16q4OdmN~LUUOYL1#0u_(t5fyh=&iLb>v8iWxi7yYXu-{cnE1 zA(;?L>VH1|to%0r&A_}Ybc(j?^y#vHeA;eFFY`i2Z_}r2`;t30f6M0+lHS*!jqmLX z=hy!(q@Sz&H7pp89?6L1=OowWZ_EEFU?lPFr(YIy{ED^dkwhPR@b6st=kGK3&rA84 zKj%a?z0LnufieFK{z{K&S?CK(LHxFQv**LW=8B6&qvYZ1%ce7T4L@J^I-R7qev<=P z%IwR(0GO{krcbWqzt~I1WA5iqz08%qXNyj*zGP1BUq3zKV!izx;q38R@u6>h`)v)Y zH2Ld~ty2GClRer`KC6FbRcUM$rT3DpU7buEKWAgBFy0F4TgO(xj_gy|Q%CRh*`i~r zykoKzXYN7Mf|x42mk!OIG_9{A#>&OmVSKh{VudR8+%X&D#qPh1{ZsdI@8D#~9=9pA z_gqXpzq|(f*fL-4b9A5VU;7^HD|IXO-?=53SpC;G?9DaQCDeC!@6Eju!~Smg{iB)+ z^@l&)n|q7Oar1F?#~V>&7@+UQ%iAl$hgHKn5;%WKHQXU*dp;yd*BZ#klYDs6V0Us1?ukFm; zv8F;@#79A&yl@mtKNT_Rk9^33vfcq%zYAWJm-{YKF3Q1uCb79;suuNkt?E^;#KKr5 z=zq`ADs^V&*{xx0cCTOVHI?F?gt6nr`WW`;jy-MmhR)~J9f+Zl!k*pp)JXkx+Z|c{vCl&TL8%v|^P5g#n4DwAujw#4B1-YAWAFYQcWw z&9R3L25Q4F;+qVsN3bog+FF+$Zp1#UKgfJo{R3(R@io*=?19HoVKm+amJw3Smq%;t zp>xO8KGbPjfxnq9raB7Eu{{TQ9W2EzTPlZp@kz6Pb4MW)TX3K?Rxw$l5<0#P_YSvZ zAYYd6$Cbt8{4m-t54%5U2sxkEd-}3I$>UDiRp%%Ea>hIGHF%EA~fhj#WNk>Z|Jc5nCs+Md*3CX4%aPuMW{MYO%!A)9Y|Ujt74`2N-S)~AZx zr&{k7E_~S!U{6pq`n|Bt=X2KAGB0DR*sl+M-tMo4Wyi63Xk)WJ=_$xO>z9~@zA9ZG z226)OMc-%oqzdEoT`cJY{6)s|7a@E^3jU%2{-Pdx1J}TR*uD5arhUdE+Gi{kpMmzO zea3aK+h=6;9%{bN_*In0`U}_2_9+E9^#00_a|-gH%{>kO@f7@rDQ^~jgL~+G1ai=h zx!=93uP_UpNqxOeUepWuy-)Zx$ATwVmsr+^Z_lFb1(WPwOxwHM*4gfm=26D$s(_AG z$0`mqz^0d_*1}h3t5`PjNU1p5Ok=Jgrm*)V*7;%`eDy4)Vqe-ypWhIhe_$BxoaxzT zUYGe6_Em0D%No83oy;3+Q`0HjztpDMv>#-hUtj+O_JKC~)%$Jl%c_@)+|T^*6gF~A zQI{+qeO_Ge-TN8%lQxv;$NNP34&R@Y`VzzUsxj{S&Ao?zTwO8$7L>m^HXk}#XM8(j zCS^`yPV`s0EO9kmh5Zayy;GgUH4ocQ+qRbtY=6UkX<1E&YJnbTQ?XYLf9cDzCRVY%9Y)BbEeyw7r&>(}F>vO%Uq-q%y^zbYDeuR}Vsk2}_65o-ee zq-e*9Kdm1_FZ;j5j~#~}%a-^t%GVHMY=cMPGfv?Ar;{OkS-MbA*ymhrMoa+iGs>}1 z3;bLLd(?Am#BmaJT%$fVxdHwtnOHiLitn6!m&z_l=d;>wRZv;C7WY(8t=sV?{7$H& zSdQQx@uBu@+=I4XEuFj=yI$KF_lriXwz0>t?|Kqv`eYTb-*^Y~dNs!JYHW2ZK9-GD z>OEMo&E*rh_|gLt6^(eUJFCZHFnGr}<}$~px-O+h!X{V!8D@TXsbKb;+qaV*vfpGvz{!rh=euVd~z1`@gd-KP!76Q_s`|bx8ew6*%tCFy`M+miM3PF)w+19z5VLXZ{ZM zXk!QdK7J#Llx_#iOUtU;;_GP>ZNalh&vEV<*mdaHbqez@&bvzIKy8(K&($FAB>M%% zK7^O+u9x}He$_ap^`i5CY-*lr&KsGsg*B*`E3tq7-8e7CnQ}H<9UMsP4Tf+Y1CJ@> zkC+wEKl*6SEm%)_Jd8e?w5;32-j3HrKdhQ%u8{6N2fe)(f40X}iu;3de7>iiw#GTb z3c=<9s{+Qk!BSxJ)!v4mg*-3-*zt6HVJgR@>T?+9Un^;TqiFan1Kl;4tHqF}*-OJd zaG~0REtd8+kk2|?lMnm<8^UGxG7Pz-!hg&n_>k$!(OSKewgCUj zv0@5wSX<$T8?Nqv-!n0tRHAW+aw{Q%M7%@}W z#SwA-Mwb5${f*j#SdmAEu;XIxVtobTPpk#aNF=rd)BGdaG}Gax$}Z}doChD=gm_5^ z5T*BVrhaC}&uGEW4P??|OUR7*=2zhxzXIR*W%$MubB;CJ#4q||k5>_sienGv%efEp zozb#$Y!yrfuwRZBc@GYB^5Rup@ROZ6?(O{}bp-KVnl80fHlL%639KhD#)yg`He5Z{ z!L%>ko1?sc%y=z~PXIdNuosMP+3#e7)v+ado=Ts5srX#?N{oqa8r`KXslt+UA&W5| zWAbu7Ne+1Z*m)Ix=5GJ4qte zN)uvq{RPHc+;{roRa+;g)%Q~9x6qDf^T?tOjGToy(jebQrl=3bVoJuoymfUf0Xt!x z{UEm@vreT?%Qy?M7~iM$M_CV|Ugm@D;qFp?lrdCu;dZXw2HlwP;+=ZTv$oT-S(|V3YUugHvj@pd27t{mCxIc-_FdcoK8BYacOiLcG-{vka6M6l# z_S+gmJRQU%p#B;6GL3jeD=_}H`k&P~%Ww3~ea&@U9?v3n@5B#G+f_FsrCCq z)q?)rtn;w#B{5%mlj_humHwyHZvGK_bX&V&zsL10J74|pxW{^-jkDion_mFCVw;r<+k$urPQBXu>UFI>v;`*49A)D(0Mmco2%hkbPue*U^LdZPxQ<|B#&JDwb}S#m zS`cEN={f#e)jG)fsdLw$?a^nw0b>@FJTE^OEQvvaZM!PCyirZHw=TY3iTS*9OO z={^K|?+b4G&7Thc@p;<**YM_A?VfY3=#vhiFB(Rl!@ek)ct8BBjf47E2ih?9XMLpi zaoy#m$<64axX#V~mVS2>{Z%3M_2NGCS9$bTyU}0uqmN@<^`PHcCi6P$-|E35RNp&b zV&xr~T86#sza~D6G`QbAU;7pMY&F8XBmL2E7SGwTOSs;p)c3Le)q$mf#^qm7In-$| zk{;GF!Ea;($c6p#pFwQ0uTDX}Dabbk`KBP>6l9x1*``n)=zcnW9DSBqSNWdU>Gv={ zF!|T0mk!Y0OXFFwPdcpQ0zNkN{UZ8KNb;1Y&@r8pNHS>K2W1_2U=oXlj&?B zP96!Y4d+q!+LjSRBg2@eu%g;nKD8>=ftVf5^>2vfG3J|(xj;Agof?j*Zw{-a358?m-(?yrvJ#xj;xueTUH3k*C^2Z*@=eg{!k<{EJw3m?XML>_&j>3`FR z%NF2%dNd!b9Q`oXp`Y%)DYYs1J76nXzk{}mG{cWzFMjl=NQ3@3Mm^NTzEEU3oN@nW zRiH+?R}61ZH?=$xOsf!YhO_TBF>6)~e+P4>#@wGFKKY8#lbUB3JF4TRfJXPt@Y6v( zFs7T2c57^JBK{ciKp8de#i9uQ9QVFfOsralarJjG9!K1t`rp;##fQ-`)rn6(rm$7quf8Yhi0ezctb2K%+? zjZCj+ju!@;$J_?F7Ax94V_zPDKZhq!ccMM<*+$o+0c$7^yHmwlt0yNCi)KeJT zfU%PvvuU~h67ht-h5SzqGkrq62pxkSF~rjiFTwsW&d|1$$NKG7y)MAK{|0SxWoi>_ zc7yr>ep`R6^Oo4OtgG+oIx+dXdIf*du|6pi>CQU3$EGT@e`>>h6YpagVpn}1eHwhB zE(hhSfZeH*_+U5FM`$}B??OQP)8&Qi4H)y$esEu*y=nWjwoD$`MW--U-aE8SVjA6r z_*TpVW6`*!BkyYt=oZIcPGmo%De?X8GCt?nIfNaAjuyH6P`r{qyRf0-Br$8S7-mG8a->e*XN;HD;3i>L} z&mV#0`%Igx8;8)7i9L>P zy!by*2J$8qW4JTA@uUm4rQeqp@dNFH7&qcbWXIpzcRh{?{u1YsIc9M#|TAnS8Gm+a?;j=J;jlqx#ES zR=%kIOYb-J?by-PIoR8Wa3!VTM6fTh1`u9kAnfkj84e6$?_UH_d1tt(Z?Jt^m=3q) zmWMmL26sNl$TZvAcbi|L!3|xVUA-Ug%7xq72L{9DHJjFi{q3C}1=kL|()dv(Y2Vu3 zyW?h`e%Fq!-TjaVN#{znJT$iv2gPwB3maU8F;O6M_&|H_AZaMN%W+N9&)pn`8z6IU z*8rm5q;qPpd$51Y&fRx}z1+2U2MVUcw2Os zI0grLKhcFVil~o{Z6DPLjfbIVG{25r-Pl1|GaKMm*jiC`18$Q}msfAy-QBx$00oSe z+sd`0cc7<>S*^F#W9)EyduLDYjxMPz+;{cD5)Ab8?Hm+)Guat_x@t`zp7*wIL&aiu z>W~#_Oq1sP5jF;tA6tJ*;GTEYrw85^e!P9#t}gx4Fznp{q!;m^XwB4sp+GUhduBPJ zUW|Ui-T}0Pom;6DY-Y{of_PB<{g6`^5BfGCl}hNf>RbXaE=@4dwe#b+x3lYGySfH+ zU@FO|G#9-UIKx)4eSrVA*_cf(q3Flvi*3ONX!JY#w(Ek(Z7W}B<&W2aCd381|r#;ZcJ> z;=A<~Uxt`H=8FB17W#cc_JXjyU2yx3KPFlFc#q)r-P*?utTqa6_iDvtOdlT<{P;q1 zZRz_2w|mstZxx0F--j1C^&#>+V(}{tJZ(;hoo&k7BOf1PVNM@k75t*$X9fQQ!Ow_d zj#QW%7_=L`VOGlHC38}Lk2Cezc8vk>08bzDAQ$oeYt41D$a$sU_M6C2b6fxW?;%FX z8zFzG%~r>q~69DDP|}<8$$(=Qs#<(B2in6P^cp4 zYj9_uL_g7SQw9;t=59n|;Xt3UQSiUvy0iU(ErWd+OLhrB@@5?w$HbLElo=P}1)}8; z{Uz7sN1Jg$UYvj%InXyHgN?vAI(xccE0_v>oTEbquj%aBDe-U+M+PHNe5nSp2Cdw% zsLKM%P`J`KGLgtHr9#XZPevlh*n6`gx;Qlh{asx-BdO-*BFDh~*@rBajs(pGfqSvX zpB#EY8NW5oz5nE>m$R&eU`^8;!*aHK?6~D%DGojsKO%T&&Tg-b@hHw=kUmby`8soU z^!wm{c_hsV@41+RF`RfTH77^^cocX13sFARmd_EvulM+jMsdf-`xexyQDwAZ6y7t_ zhofI5xX6#^Cgx}pT%S-ccD$D>#i37&9}#@1N$$#fTyU$OGs6E=6tA}U3sF8!PWu$s z^1%>GA1yNe^z+>$xTW7G`Q9I;cl_I;^wpL=FL<3vKU=OS?)cbmnQgvS&I?igZf}}b z1ebbo{4Yi6t1TZq4Ah5Tj|ssgU$@6io8Z3uLs8txzfbV%z49K6;*S18l#i2tafM+} zXHJeDpDpRb=f66NJNh2Mg^%N(kK&Hr#{3Y#(H|6g!5#hMg5O}oa`dB7+|eHw+}7`D zlTMuw+^@%HqV%p_CZhCdVWZAO>8m!&4I67j?A+0xi_%wH`U`^V=7jcZ=Vh;y;%L7X zw;vnZa@9!t@?(nF^4gdpe!HukX9N~L)s|14;J*Cz9=+wiTyQNv_N3k?dT5B^uAQzH ze1V~J`e}>OS6P3xJBn9Zd`NJamO4JerS#CJozL1>BU(=OFG6=#&c1$L5?u6CW&Pg8 zDDM0rUR=?ciaYvRsX*U9*w_q`%*7a6CG@_Y8w3}6x3{&8<>2e{{wRIbX0d-8%fZ)YPn5pe z(%V=LLhs78SLl6xJ|4v#{ixveo}N!caYuhT%E#5qOHtg>Ux@N?^hq&%$=A`>2rl*F z@JzI!I6e(g+|g$RzriclT~XZ8ZxYzMWt2 z=q>+O1lRJH_*?yfKI9VI`CA*)Ld?kN$Ht;?e8jJ1MN^KC;LU=|JizhUTuKjp+Vwyi zi$e2(J}urO^l#HzoQ>)DqTtI6E?3wqFp9f;Ul!cSZ_=rx23!d@hY>47cPP<3^Egn7J+~gs+qklBbUoXuITFPkJw8g(hn2^!n@mUfJH5RWrFVP5 z+daoce#if!(A#>n_HTP8o3CA$Su87ALSJp^Q-WJNwDh%tOExawdckk=^tn9Br>a3R zS{23J9@DF%d>sGgDDL!gR~bH=qV$f>{Zaa=R*|PoaK9h1d#PJJSo&>IddGiIaDSa} zRB&4_cK&-TidS3wxZqMy$3G)2-`3-9t53mw`Bz8j-ColC0+ol*JN}Og?$>W2%E#5C z-820*!_L)tAC46myy%%UGB@D63^(%StYpTZ|#$B za`W)zw0n_T{kMpmt35szZxP&=XImNE?p^NB3l0grKQFL*my052^)K|k9ojw3SDE5D zdb_8&;I3Zm9_0c!yhff&`{TE|DDLR(UgTD9r%nDUBlN!AHVAI(#nP{i(mVbwg8Sud zi}I1?-g8EH^zr{5A}VeIL1X5KN00qbx7=F+`~r&f5yXYc_#$- z^>ZppUv2rE_HfJRg(x4VxATIF7*%#1>6Iv6ZSjkO%QV38QSv^5rRcXt%8ws<~@SJ~$`j|+agN$&J; zEQ-7Go{8d)-o_pfK91hT9`MJjsW+Jn{qb|1;C_2q6~!I@tl$lv{4G)3(Qg*~9Ugry ziaYwfg4_DF?|~ikaJz@^ArDVVy*%#W^@1M}+%NBFl)l>XKkng{{|OJb{B2AH;qS_I zR_O2W^l%}HJNk^oND#o`4TAgqa&r`S^mhqv^?BOluUZB7`<=~EdbiGbf0W+w&kO!e zuUw;oulDd0QQYx4B{*JT=HcvoI*L2`^Mb$AqrVWv9leb$;kUb0wT6M;j_wlN>g~KZ z##X_7`?)`gyL{WCe5x&<9>IP2`=j(#d9m9;54ZKWTX4S~^HKV0%V%$t-pRSoqqqEr z1^4AVD7dJl%Jvt9C|+%GY=ox|zaJSF-1jFFf{XrLthiHAdME#jg8P1EI*L2`i-P<0 zs6S|dq=Gy81V0qPVdb&@yjJjco7>KAZR`-i9iN6MpQ_WMz}15L^_Y#)S6lk#D81vK z6Z{rWp8hEA=xuBTDOc4+k!OFDzbn_U;8qWo-o|ba`5ph!GJKAEe5{{85yh+aN&jwR ztJr)kJ`v^b@;&46vF~BL7^QdRnvT*}Tl$xxcvXYQbG{6pm!tI6mj0C}y^}K`@AF#y zj|=~#hg*BIF<^W(|n^Md_X14hpX2!8qK$7yWoCj&ZofPn6Glj^2>D=aN!AN(s4LE(mrDVOGvU80?elHV@w{1bGj)>wyIixAXA{ z54Y>{(;jZ?*S^o?NZriC- zu!w8zO^PeGD;L|CrQ$CfZr4wxom_^?w9?@PS)d3d1EZhH#lwQvd-w&xWgg}Dw8`@l z8OJ!>%4y{nc`HZ7A4cU@mG=2#RDM-y^%Ip}RoeQB%Bd=?Jw)YHl~(^zIaQ_Ab2d_5 zRk>TPTgu>V9xj(k{ofcHP8Ix-m8-T;e#ptzvqj&GA2f}u1>}4|26PQl(KI(UA!|R@ zE;uhFF2e}?GDjh_zoKV9|K+$%oJv)(R zd~N<#|DOUzS$zAsAo&mDUg=@eTWk-0%$0xsenW9V2$?^-Hk;n&|Es{5e+GZ0N50-% zg{2^VTfN!yVPJE`*eFPPUtczzWy@<{_q=yp(r4xwN&^m<}!+};q*9enA*!@g^a_LI+Qv9bt(c%>@0*Jer` z-O7D6xwi)Qm#xO0Jhvp{h+ko1G<zGgqscRPn|@aWBjiaPEi6 zSQh`vSQa&Lb$v|^dO!R{{ONr>?B1E&vm;bT%$^>ouX=U()8s+g5PV2aUflbGX|Rvn z>Kkuq%#CB0tM4DhzTh~o3?EiM+}N1oKBmi3dyvo3;+wIDNR4{3_`_nb`cMC$aTV!4 zwZx=bc&u?1>9BtrzVSHx>7;t{)4Si6P}etnUv;G7tN-}Dopm+p`)XzV5gm_XyuLy` zgmOIhp842Y{0PdjRb5O4_}ziLrsE;x;{J}8t_iR=Qe&6zBmEPf9>0q6tOMTUWMVa!lk1;Fu9&ouOG-Vh&7$l-*&rzS7};wBkv%xF;K8Z4 zOfxRy82%*p|DAus&B9}!Or9<~;`T*-?@nCzavq4wxxVct6)fd4Vj`8;;np6<3>*PKTTkt`o{?Jd( zecieC2MrD3TyJ-G^lHnl0kE^aT9*)WWSfmVD>Ws@9NFTsc3{6nbBYOtz<0=>?o4T7{I=;s54Y*ch7;o6fT3^<1K+Bz;~I z&@Zs9`{ge;W*inpb52uw`1zL`GmeY?|6^%l{PxqYy!Gvw%g2dkRA_MX@6W6<(b#Tn zxc#=D(YIg!m{DyrLX?gfuR=?jYs|>K*g2LfRQ^M5cAxfaz zw5nBA!J*2`@OFT+h5&|3yq|9zwaz~rYFsQ zaCz+Y-lq2j<(}w=Dwj@@=L+l%iQhBiOa621^KN-_T$w7_3z%^;xTh-1!#$57r)rqL z_wgDTFH;u$o_aI(`&(2KsQN2{8KfsY@@j(~rsEtl+I{j2pW4+e@!@maR}lNuVedi2 z7s7sd=+AVFJH}H;@0$Q;?v;obY?;vPby}arK6hC$_h52G&Ci3TbNKmUXI-E=@#&q} zQ!lAflYd`Sc+&`b(yVuxLMe*5_H7CP>%R&@W%f5590bk$ZGZ% zw0DQ0r-{mk_P3Sjig7iv*hjGe<*A3hdQi5_>MO-o_2psYunSe?9hW5?byTkNtO7pI1vUJ=F2ra&N}(n+|;}_>yW{l1CjvmdSk3 znE8<2-_qwFGn7H8?95LhN9lf^h04#!9;XG}eyMBjeF|NzW*eQTWUL_WX{m_mJxlT4 z_DsW~H%?|2Rp>Yx-1Gc0y%w@+J=!pFrH)`%S)A53PUr-!uNe-?cBH_%O5%HK{KDp0d~fIo~s$lnk` z?~TLhY#Ywc=N6$XM(&ZrF;zGm;4hB91pX@UHxGaF@t4Hk0{%f43vs6I$&YaZ%-*vF z?7`Zm(kL(MW5vFurd^I^)lKR%y8I20w_e&P^m!nSa;| zwd|-5;+R(#OZCIL=Un^s*Zpih*8Z8#dm+c0keA83EnwTx`DU`%OVhNS72#(TW#@k9 zKPT18 z^<2DZ|8RWmx#sV-X^}!n_Cj#~@ zvKKS_B=4L3m8Jc{U%p+1uxsq|i`4b7LFCE3U15u}d$cm;ZsbA#&2~urGLJLCyvg0j z$Lfxl&V%)g{Im_yCtKfuey-FOzQ;IiW$v-=)<~N%wp>tWWe;1MhP-Uv+!yu_b-j(i z-guy_UVh(lJkb|cK7@EUCf-2`v5rdhR7A|G-!3-kKB_b?BZmsUT*9YX6`&I=xK})c zPgmN|zs=JzczP;61^+)AbAaQC8pL{Iy)CQnQt(4a$3BYt^x9ZE({YX^$d7$B@39>4 zx$qTc4`$v&S&=SLH(1q#A?iazI2YL7Scl8%4`aXVg6?xny2qw4R=^$lWA;yb&JC)= z`*ZO|*y%jjX}5yRtLw1d1Us$5y<^Oqyv#9wwT@NN@GrRh7w9b1V~94`Xmf02|2`>W ziyl8czLoaKc2%vKGsEiZ#oZVm^k8hzhH*nH?Di1!kXK(V_G8Sj8RLk$ifa$(F~ji! z;*?Fm_fD%b>Z#lZV-Kb3D%99Av?2Pb55}4hcO_BBefw4A$;mCS#hCi`?dc0`F~+ER zE;xBL_1PRdiTF`XnJpM&#MF0gL%Yem4B9|_`?kMPZC7z`|7mq{a(#@ptkk~Pi<2#Z z>D%hBcy97t@iyR(O^wD*KAJ$usc#i*et(Dkqyu%Z`{Gq6CtohE zhpwA*e*-(Zc-5&H$~{t?xJH++!L)PkdH?IQ!3$a5#{Fz1bsvKFV)V6GUoPfQPp02v zU*0wXUzn>0PM?w1fotX+5 zLr$ybFyBCo$eKIVqJ}2*Pl%&Pxmd^ZbR8EE!{X%Rt1@oa##SIieWkXN?AI?SMM zdob=_sKTq$h&6yc#ToC}^!rk0zl6LNtC7$CoYXIE191y7mvkMmeLgvLO)!nxF!dFm z-!yc4yiLo|AA4?ciO5=|rk5b@&g$WKVsfwA3%fa5R~LR#rF6`&PL!QKtBt-hlK&2* zN4r5j9gloe?1Fq*SFC5|`w-$U(WZgV)WcTS=(0n$E1p9ggD=K4^j{6?FvjnP!K)M- z0rrH!8nWoOYz(6b#9nv~?FsSGV(bS^y9iPCpRxRrE))CaWKxZ8h5k&u9O!LHJX_0p ztB*BR&EU*-nNjm5*-oyHO`tzKsmG!jbyW8!98X*u!@l0gkL6)rl$XC+5Lcj8U5_?s zWI^0eEsLdL+BMLN(a~cVyQe2x)eSP9HSO*#qC?8DLF$eAi$ibA<=WU<0{w2YZa35F z`N_8+J`80zeHGeI*sR{DPU-7B+S3vpL&A*1R_gX+_voJpD&Z?A4}9PheB=~--V}Tx zV(@%<3jS~k{t$DGr!m)f3i8g*B@5#JX=Btg{D3ZN1NMohpZj5KkM`{>Gxd`~ePRrn z!g-4MF$UdFlc)8wPtG(|9gimtFdo2(_&mh#JURK58TvKG--C z^3(*`1m&TwDbsBz2jjZHen);9*{J{H@e0IWL2LynH)F8;Jo>=ipcyf*vv^8m+6ddd z-H)IBq|)&slzLTVYqXDnkD?D?dC0f4O!V>psOdR|n6qj^G?`i27dA#s!iKQ z5o-wa0kjvk%g@g|r2QfL>biJLD}GJPBQn{qvgJfBDW;#u3Z zZR^a8v1{wÖkRj1MS1a3psrp$jp8E6lmL%d_k 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, et al. +# +# This software is licensed as described in the file COPYING, which +# you should have received as part of this distribution. The terms +# are also available at https://curl.se/docs/copyright.html. +# +# You may opt to use, copy, modify, merge, publish, distribute and/or sell +# copies of the Software, and permit persons to whom the Software is +# furnished to do so, under the terms of the COPYING file. +# +# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +# KIND, either express or implied. +# +########################################################################### + +# This should most probably benefit from getting a "Requires:" field added +# dynamically by configure. +# +prefix=/home/huagao/sane/code_app/third_party/libcurl/uos/mips64/curl-7.82.0/release +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include +supported_protocols="DICT FILE FTP GOPHER HTTP IMAP MQTT POP3 RTSP SMTP TELNET TFTP" +supported_features="AsynchDNS IPv6 Largefile UnixSockets alt-svc libz" + +Name: libcurl +URL: https://curl.se/ +Description: Library to transfer files with ftp, http, etc. +Version: 7.82.0 +Libs: -L${libdir} -lcurl -lz -pthread +Libs.private: -lz -pthread +Cflags: -I${includedir} -DCURL_STATICLIB