Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

10 files changed, 424 insertions, 424 deletions

diff --git a/contrib/libs/curl/include/README.md b/contrib/libs/curl/include/README.md
index bd28a30e85..2b99e435a0 100644
--- a/contrib/libs/curl/include/README.md
+++ b/contrib/libs/curl/include/README.md
@@ -1,14 +1,14 @@
-# include
-
-Public include files for libcurl, external users.
-
-They're all placed in the curl subdirectory here for better fit in any kind of
-environment. You must include files from here using...
-
-    #include <curl/curl.h>
-
-... style and point the compiler's include path to the directory holding the
-curl subdirectory. It makes it more likely to survive future modifications.
-
-The public curl include files can be shared freely between different platforms
-and different architectures.
+# include 
+ 
+Public include files for libcurl, external users. 
+ 
+They're all placed in the curl subdirectory here for better fit in any kind of 
+environment. You must include files from here using... 
+ 
+    #include <curl/curl.h> 
+ 
+... style and point the compiler's include path to the directory holding the 
+curl subdirectory. It makes it more likely to survive future modifications. 
+ 
+The public curl include files can be shared freely between different platforms 
+and different architectures. 
diff --git a/contrib/libs/curl/include/curl/curl.h b/contrib/libs/curl/include/curl/curl.h
index 8efbe22885..a1eb532776 100644
--- a/contrib/libs/curl/include/curl/curl.h
+++ b/contrib/libs/curl/include/curl/curl.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_CURL_H
-#define CURLINC_CURL_H
+#ifndef CURLINC_CURL_H 
+#define CURLINC_CURL_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -59,7 +59,7 @@
 #include <time.h>
 
 #if defined(CURL_WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)
-#if !(defined(_WINSOCK_H) || \
+#if !(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 */
@@ -91,11 +91,11 @@
 #include <support/SupportDefs.h>
 #endif
 
-/* Compatibility for non-Clang compilers */
-#ifndef __has_declspec_attribute
-#  define __has_declspec_attribute(x) 0
-#endif
-
+/* Compatibility for non-Clang compilers */ 
+#ifndef __has_declspec_attribute 
+#  define __has_declspec_attribute(x) 0 
+#endif 
+ 
 #ifdef  __cplusplus
 extern "C" {
 #endif
@@ -115,8 +115,8 @@ typedef void CURLSH;
 #ifdef CURL_STATICLIB
 #  define CURL_EXTERN
 #elif defined(CURL_WIN32) || defined(__SYMBIAN32__) || \
-     (__has_declspec_attribute(dllexport) && \
-      __has_declspec_attribute(dllimport))
+     (__has_declspec_attribute(dllexport) && \ 
+      __has_declspec_attribute(dllimport)) 
 #  if defined(BUILDING_LIBCURL)
 #    define CURL_EXTERN  __declspec(dllexport)
 #  else
@@ -151,7 +151,7 @@ typedef enum {
   CURLSSLBACKEND_POLARSSL = 6,
   CURLSSLBACKEND_WOLFSSL = 7,
   CURLSSLBACKEND_SCHANNEL = 8,
-  CURLSSLBACKEND_SECURETRANSPORT = 9,
+  CURLSSLBACKEND_SECURETRANSPORT = 9, 
   CURLSSLBACKEND_AXTLS = 10, /* never used since 7.63.0 */
   CURLSSLBACKEND_MBEDTLS = 11,
   CURLSSLBACKEND_MESALINK = 12,
@@ -161,10 +161,10 @@ typedef enum {
 /* aliases for library clones and renames */
 #define CURLSSLBACKEND_LIBRESSL CURLSSLBACKEND_OPENSSL
 #define CURLSSLBACKEND_BORINGSSL CURLSSLBACKEND_OPENSSL
-
-/* deprecated names: */
+ 
+/* deprecated names: */ 
 #define CURLSSLBACKEND_CYASSL CURLSSLBACKEND_WOLFSSL
-#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT
+#define CURLSSLBACKEND_DARWINSSL CURLSSLBACKEND_SECURETRANSPORT 
 
 struct curl_httppost {
   struct curl_httppost *next;       /* next entry in the list */
@@ -215,17 +215,17 @@ struct curl_httppost {
    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 */
+/* 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. */
+/* 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,
@@ -290,11 +290,11 @@ typedef enum {
 #define CURLFINFOFLAG_KNOWN_SIZE        (1<<6)
 #define CURLFINFOFLAG_KNOWN_HLINKCOUNT  (1<<7)
 
-/* Information about a single file, used when doing FTP wildcard matching */
+/* Information about a single file, used when doing FTP wildcard matching */ 
 struct curl_fileinfo {
   char *filename;
   curlfiletype filetype;
-  time_t time; /* always zero! */
+  time_t time; /* always zero! */ 
   unsigned int perm;
   int uid;
   int gid;
@@ -369,21 +369,21 @@ typedef int (*curl_seek_callback)(void *instream,
    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
-
+/* 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 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 */
@@ -606,8 +606,8 @@ typedef enum {
                                     */
   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_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 */
@@ -736,10 +736,10 @@ typedef enum {
 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 *ssl_ctx, /* actually an OpenSSL 
+                                                            or WolfSSL SSL_CTX, 
+                                                            or an mbedTLS 
+                                                          mbedtls_ssl_config */ 
                                           void *userptr);
 
 typedef enum {
@@ -948,12 +948,12 @@ typedef enum {
 #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)
-
+/* 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;
@@ -1037,8 +1037,8 @@ typedef CURLSTScode (*curl_hstswrite_callback)(CURL *easy,
 #define CURLOPTTYPE_STRINGPOINT CURLOPTTYPE_OBJECTPOINT
 
 /* 'struct curl_slist *' argument */
-#define CURLOPTTYPE_SLISTPOINT  CURLOPTTYPE_OBJECTPOINT
-
+#define CURLOPTTYPE_SLISTPOINT  CURLOPTTYPE_OBJECTPOINT 
+ 
 /* 'void *' argument passed untouched to callback */
 #define CURLOPTTYPE_CBPOINT     CURLOPTTYPE_OBJECTPOINT
 
@@ -1430,9 +1430,9 @@ typedef enum {
      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. */
+  /* 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
@@ -1686,7 +1686,7 @@ typedef enum {
 
   /* 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. */
+     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 */
@@ -2019,27 +2019,27 @@ typedef enum {
   /* Specify URL using CURL URL API. */
   CURLOPT(CURLOPT_CURLU, CURLOPTTYPE_OBJECTPOINT, 282),
 
-  /* add trailing data just after no more data is available */
+  /* add trailing data just after no more data is available */ 
   CURLOPT(CURLOPT_TRAILERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 283),
-
-  /* pointer to be passed to HTTP_TRAILER_FUNCTION */
+ 
+  /* 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 */
+ 
+  /* 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 */
+ 
+  /* alt-svc control bitmask */ 
   CURLOPT(CURLOPT_ALTSVC_CTRL, CURLOPTTYPE_LONG, 286),
-
-  /* alt-svc cache file name to possibly read from/write to */
+ 
+  /* alt-svc cache file name to possibly read from/write to */ 
   CURLOPT(CURLOPT_ALTSVC, CURLOPTTYPE_STRINGPOINT, 287),
-
-  /* maximum age of a connection to consider it for reuse (in seconds) */
+ 
+  /* maximum age of a connection to consider it for reuse (in seconds) */ 
   CURLOPT(CURLOPT_MAXAGE_CONN, CURLOPTTYPE_LONG, 288),
-
-  /* SASL authorisation identity */
+ 
+  /* 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),
 
@@ -2126,8 +2126,8 @@ enum {
   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_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 */
 };
 
@@ -2651,8 +2651,8 @@ CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
  */
 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 */
+/* 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
@@ -2743,7 +2743,7 @@ typedef enum {
   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_RETRY_AFTER      = CURLINFO_OFF_T + 57, 
   CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58,
   CURLINFO_PROXY_ERROR      = CURLINFO_LONG + 59,
 
@@ -2846,7 +2846,7 @@ typedef enum {
   CURLVERSION_THIRD,
   CURLVERSION_FOURTH,
   CURLVERSION_FIFTH,
-  CURLVERSION_SIXTH,
+  CURLVERSION_SIXTH, 
   CURLVERSION_SEVENTH,
   CURLVERSION_EIGHTH,
   CURLVERSION_LAST /* never actually use this */
@@ -2890,12 +2890,12 @@ struct curl_version_info_data {
                                   (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_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
@@ -2940,8 +2940,8 @@ typedef struct curl_version_info_data curl_version_info_data;
 #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_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 */
@@ -3026,4 +3026,4 @@ CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
 #endif /* __STDC__ >= 1 */
 #endif /* gcc >= 4.3 && !__cplusplus */
 
-#endif /* CURLINC_CURL_H */
+#endif /* CURLINC_CURL_H */ 
diff --git a/contrib/libs/curl/include/curl/curlver.h b/contrib/libs/curl/include/curl/curlver.h
index 0acb5a8cbf..417e3683ab 100644
--- a/contrib/libs/curl/include/curl/curlver.h
+++ b/contrib/libs/curl/include/curl/curlver.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_CURLVER_H
-#define CURLINC_CURLVER_H
+#ifndef CURLINC_CURLVER_H 
+#define CURLINC_CURLVER_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -70,8 +70,8 @@
  */
 #define LIBCURL_TIMESTAMP "2020-12-09"
 
-#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z))
+#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 */
+#endif /* CURLINC_CURLVER_H */ 
diff --git a/contrib/libs/curl/include/curl/easy.h b/contrib/libs/curl/include/curl/easy.h
index 2dbfb26b5b..07997940fd 100644
--- a/contrib/libs/curl/include/curl/easy.h
+++ b/contrib/libs/curl/include/curl/easy.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_EASY_H
-#define CURLINC_EASY_H
+#ifndef CURLINC_EASY_H 
+#define CURLINC_EASY_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
diff --git a/contrib/libs/curl/include/curl/mprintf.h b/contrib/libs/curl/include/curl/mprintf.h
index 3549552dba..78e16245e4 100644
--- a/contrib/libs/curl/include/curl/mprintf.h
+++ b/contrib/libs/curl/include/curl/mprintf.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_MPRINTF_H
-#define CURLINC_MPRINTF_H
+#ifndef CURLINC_MPRINTF_H 
+#define CURLINC_MPRINTF_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -47,4 +47,4 @@ CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
 }
 #endif
 
-#endif /* CURLINC_MPRINTF_H */
+#endif /* CURLINC_MPRINTF_H */ 
diff --git a/contrib/libs/curl/include/curl/multi.h b/contrib/libs/curl/include/curl/multi.h
index 37f9829b3b..d22c0e3db6 100644
--- a/contrib/libs/curl/include/curl/multi.h
+++ b/contrib/libs/curl/include/curl/multi.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_MULTI_H
-#define CURLINC_MULTI_H
+#ifndef CURLINC_MULTI_H 
+#define CURLINC_MULTI_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -175,20 +175,20 @@ CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
                                       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_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()
  *
diff --git a/contrib/libs/curl/include/curl/stdcheaders.h b/contrib/libs/curl/include/curl/stdcheaders.h
index 60596c7568..059261f56b 100644
--- a/contrib/libs/curl/include/curl/stdcheaders.h
+++ b/contrib/libs/curl/include/curl/stdcheaders.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_STDCHEADERS_H
-#define CURLINC_STDCHEADERS_H
+#ifndef CURLINC_STDCHEADERS_H 
+#define CURLINC_STDCHEADERS_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -30,4 +30,4 @@ 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 */
+#endif /* CURLINC_STDCHEADERS_H */ 
diff --git a/contrib/libs/curl/include/curl/system.h b/contrib/libs/curl/include/curl/system.h
index faf8fcf84f..1ee5f96d78 100644
--- a/contrib/libs/curl/include/curl/system.h
+++ b/contrib/libs/curl/include/curl/system.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_SYSTEM_H
-#define CURLINC_SYSTEM_H
+#ifndef CURLINC_SYSTEM_H 
+#define CURLINC_SYSTEM_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -484,21 +484,21 @@
  */
 
 #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)
+#  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
+#    define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix 
 #  else
-#    define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
+#    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)
+#  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 */
+#endif /* CURLINC_SYSTEM_H */ 
diff --git a/contrib/libs/curl/include/curl/typecheck-gcc.h b/contrib/libs/curl/include/curl/typecheck-gcc.h
index 6d84150dc2..3fc8cae8cb 100644
--- a/contrib/libs/curl/include/curl/typecheck-gcc.h
+++ b/contrib/libs/curl/include/curl/typecheck-gcc.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_TYPECHECK_GCC_H
-#define CURLINC_TYPECHECK_GCC_H
+#ifndef CURLINC_TYPECHECK_GCC_H 
+#define CURLINC_TYPECHECK_GCC_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -25,10 +25,10 @@
 /* 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))
+ *   if(curlcheck_sometype_option(_curl_opt)) 
+ *     if(!curlcheck_sometype(value)) 
  *       _curl_easy_setopt_err_sometype();
- * block and define curlcheck_sometype_option, curlcheck_sometype and
+ * 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
@@ -38,115 +38,115 @@
  * 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);                       \
-    })
+#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_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)
@@ -156,83 +156,83 @@
  * functions */
 
 /* To define a new warning, use _CURL_WARNING(identifier, "message") */
-#define CURLWARNING(id, message)                                        \
-  static void __attribute__((__warning__(message)))                     \
-  __attribute__((__unused__)) __attribute__((__noinline__))             \
+#define CURLWARNING(id, message)                                        \ 
+  static void __attribute__((__warning__(message)))                     \ 
+  __attribute__((__unused__)) __attribute__((__noinline__))             \ 
   id(void) { __asm__(""); }
 
-CURLWARNING(_curl_easy_setopt_err_long,
+CURLWARNING(_curl_easy_setopt_err_long, 
   "curl_easy_setopt expects a long argument for this option")
-CURLWARNING(_curl_easy_setopt_err_curl_off_t,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+CURLWARNING(_curl_easy_setopt_err_FILE, 
   "curl_easy_setopt expects a 'FILE *' argument for this option")
-CURLWARNING(_curl_easy_setopt_err_postfields,
+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,
+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,
+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,
+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,
+CURLWARNING(_curl_easy_setopt_err_CURLSH, 
   "curl_easy_setopt expects a CURLSH* argument for this option")
 
-CURLWARNING(_curl_easy_getinfo_err_string,
+CURLWARNING(_curl_easy_getinfo_err_string, 
   "curl_easy_getinfo expects a pointer to 'char *' for this info")
-CURLWARNING(_curl_easy_getinfo_err_long,
+CURLWARNING(_curl_easy_getinfo_err_long, 
   "curl_easy_getinfo expects a pointer to long for this info")
-CURLWARNING(_curl_easy_getinfo_err_double,
+CURLWARNING(_curl_easy_getinfo_err_double, 
   "curl_easy_getinfo expects a pointer to double for this info")
-CURLWARNING(_curl_easy_getinfo_err_curl_slist,
+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,
+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,
+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,
+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,
+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 */
@@ -244,17 +244,17 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
  */
 
 /* evaluates to true if option takes a long argument */
-#define curlcheck_long_option(option)                   \
+#define curlcheck_long_option(option)                   \ 
   (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
 
-#define curlcheck_off_t_option(option)          \
+#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)                                       \
+#define curlcheck_string_option(option)                                       \ 
   ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET ||                                \
    (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
-   (option) == CURLOPT_ALTSVC ||                                              \
+   (option) == CURLOPT_ALTSVC ||                                              \ 
    (option) == CURLOPT_CAINFO ||                                              \
    (option) == CURLOPT_CAPATH ||                                              \
    (option) == CURLOPT_COOKIE ||                                              \
@@ -302,18 +302,18 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    (option) == CURLOPT_PROXY_SSLKEY ||                                        \
    (option) == CURLOPT_PROXY_SSLKEYTYPE ||                                    \
    (option) == CURLOPT_PROXY_SSL_CIPHER_LIST ||                               \
-   (option) == CURLOPT_PROXY_TLS13_CIPHERS ||                                 \
+   (option) == CURLOPT_PROXY_TLS13_CIPHERS ||                                 \ 
    (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD ||                              \
-   (option) == CURLOPT_PROXY_TLSAUTH_TYPE ||                                  \
+   (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_REQUEST_TARGET ||                                      \ 
    (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
    (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
    (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
-   (option) == CURLOPT_SASL_AUTHZID ||                                        \
+   (option) == CURLOPT_SASL_AUTHZID ||                                        \ 
    (option) == CURLOPT_SERVICE_NAME ||                                        \
    (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
    (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
@@ -326,7 +326,7 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    (option) == CURLOPT_SSLKEY ||                                              \
    (option) == CURLOPT_SSLKEYTYPE ||                                          \
    (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
-   (option) == CURLOPT_TLS13_CIPHERS ||                                       \
+   (option) == CURLOPT_TLS13_CIPHERS ||                                       \ 
    (option) == CURLOPT_TLSAUTH_PASSWORD ||                                    \
    (option) == CURLOPT_TLSAUTH_TYPE ||                                        \
    (option) == CURLOPT_TLSAUTH_USERNAME ||                                    \
@@ -340,18 +340,18 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    0)
 
 /* evaluates to true if option takes a curl_write_callback argument */
-#define curlcheck_write_cb_option(option)                               \
-  ((option) == CURLOPT_HEADERFUNCTION ||                                \
+#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 ||                    \
+#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)                                      \
+#define curlcheck_cb_data_option(option)                                      \ 
   ((option) == CURLOPT_CHUNK_DATA ||                                          \
    (option) == CURLOPT_CLOSESOCKETDATA ||                                     \
    (option) == CURLOPT_DEBUGDATA ||                                           \
@@ -370,17 +370,17 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    (option) == CURLOPT_SSL_CTX_DATA ||                                        \
    (option) == CURLOPT_WRITEDATA ||                                           \
    (option) == CURLOPT_RESOLVER_START_DATA ||                                 \
-   (option) == CURLOPT_TRAILERDATA ||                                         \
+   (option) == CURLOPT_TRAILERDATA ||                                         \ 
    0)
 
 /* evaluates to true if option takes a POST data argument (void* or char*) */
-#define curlcheck_postfields_option(option)                                   \
+#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)                                        \
+#define curlcheck_slist_option(option)                                        \ 
   ((option) == CURLOPT_HTTP200ALIASES ||                                      \
    (option) == CURLOPT_HTTPHEADER ||                                          \
    (option) == CURLOPT_MAIL_RCPT ||                                           \
@@ -390,7 +390,7 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    (option) == CURLOPT_QUOTE ||                                               \
    (option) == CURLOPT_RESOLVE ||                                             \
    (option) == CURLOPT_TELNETOPTIONS ||                                       \
-   (option) == CURLOPT_CONNECT_TO ||                                          \
+   (option) == CURLOPT_CONNECT_TO ||                                          \ 
    0)
 
 /* groups of curl_easy_getinfo infos that take the same type of argument */
@@ -401,36 +401,36 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    (info) != CURLINFO_PRIVATE)
 
 /* evaluates to true if info expects a pointer to long argument */
-#define curlcheck_long_info(info)                       \
+#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)                     \
+#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)                                      \
+#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)                              \
+#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)
+#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)                     \
+#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)              \
+#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,
+/* 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
@@ -440,35 +440,35 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
  */
 
 /* XXX: should evaluate to true if expr is a pointer */
-#define curlcheck_any_ptr(expr)                 \
+#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)                                            \
+#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 *) ||            \
+#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) ||                                       \
+#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))
+#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)                                                  \
+#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) ||           \
@@ -483,59 +483,59 @@ CURLWARNING(_curl_easy_getinfo_err_curl_off_t,
    __builtin_types_compatible_p(__typeof__(expr), unsigned char))
 
 /* evaluates to true if expr is of type curl_off_t */
-#define curlcheck_off_t(expr)                                   \
+#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 *) ||            \
+#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))
+#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)
+#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) ||                                              \
+#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))
+#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) ||              \
+#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))
+#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))
+#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 *);
@@ -544,16 +544,16 @@ 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))
+#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 *);
@@ -564,37 +564,37 @@ typedef size_t (*_curl_write_callback5)(const void *, size_t, size_t,
 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))
+#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))
+#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))
+#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)
@@ -605,28 +605,28 @@ 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))
+#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))
+#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 *,
@@ -646,17 +646,17 @@ typedef int (*_curl_debug_callback8) (CURL *,
 
 /* 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))
+#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 *);
@@ -679,26 +679,26 @@ 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))
+#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))
+#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 */
+#endif /* CURLINC_TYPECHECK_GCC_H */ 
diff --git a/contrib/libs/curl/include/curl/urlapi.h b/contrib/libs/curl/include/curl/urlapi.h
index 7343cb659e..6465f33ec6 100644
--- a/contrib/libs/curl/include/curl/urlapi.h
+++ b/contrib/libs/curl/include/curl/urlapi.h
@@ -1,5 +1,5 @@
-#ifndef CURLINC_URLAPI_H
-#define CURLINC_URLAPI_H
+#ifndef CURLINC_URLAPI_H 
+#define CURLINC_URLAPI_H 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
@@ -22,8 +22,8 @@
  *
  ***************************************************************************/
 
-#include "curl.h"
-
+#include "curl.h" 
+ 
 #ifdef  __cplusplus
 extern "C" {
 #endif
@@ -60,8 +60,8 @@ typedef enum {
   CURLUPART_PORT,
   CURLUPART_PATH,
   CURLUPART_QUERY,
-  CURLUPART_FRAGMENT,
-  CURLUPART_ZONEID /* added in 7.65.0 */
+  CURLUPART_FRAGMENT, 
+  CURLUPART_ZONEID /* added in 7.65.0 */ 
 } CURLUPart;
 
 #define CURLU_DEFAULT_PORT (1<<0)       /* return default port number */
@@ -122,4 +122,4 @@ CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
 } /* end of extern "C" */
 #endif
 
-#endif /* CURLINC_URLAPI_H */
+#endif /* CURLINC_URLAPI_H */