Added Xcode project for iOS build
authorEdouard Tisserant
Mon, 24 Aug 2015 17:23:37 +0200
changeset 340ff99a398d872
parent 339 a6485dc4f7af
child 341 ae6b1ac5193e
Added Xcode project for iOS build
build-mac/build-libcurl-ios.sh
build-mac/curl/curl.h
build-mac/curl/curlbuild.h
build-mac/curl/curlbuild32.h
build-mac/curl/curlbuild64.h
build-mac/curl/curlbuild_.h
build-mac/curl/curlrules.h
build-mac/curl/curlver.h
build-mac/curl/easy.h
build-mac/curl/mprintf.h
build-mac/curl/multi.h
build-mac/curl/stdcheaders.h
build-mac/curl/typecheck-gcc.h
build-mac/pEpEngine.xcodeproj/project.pbxproj
build-mac/pEpEngine.xcodeproj/project.xcworkspace/contents.xcworkspacedata
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/build-mac/build-libcurl-ios.sh	Mon Aug 24 17:23:37 2015 +0200
     1.3 @@ -0,0 +1,53 @@
     1.4 +#!/bin/bash
     1.5 +
     1.6 +export IPHONEOS_DEPLOYMENT_TARGET="6.0"
     1.7 +export CC="/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
     1.8 +
     1.9 +ARCH="armv7"
    1.10 +export CFLAGS="-arch ${ARCH} -pipe -Os -gdwarf-2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.11 +export LDFLAGS="-arch ${ARCH} -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.12 +make distclean
    1.13 +./configure --disable-shared --enable-static --host="${ARCH}-apple-darwin" --enable-threaded-resolver --with-darwinssl
    1.14 +make -j `sysctl -n hw.logicalcpu_max`
    1.15 +cp lib/.libs/libcurl.a "${HOME}/Desktop/libcurl-${ARCH}.a"
    1.16 +cp include/curl/curlbuild.h ~/Desktop/curlbuild32.h
    1.17 +
    1.18 +ARCH="armv7s"
    1.19 +export CFLAGS="-arch ${ARCH} -pipe -Os -gdwarf-2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.20 +export LDFLAGS="-arch ${ARCH} -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.21 +make distclean
    1.22 +./configure --disable-shared --enable-static --host="${ARCH}-apple-darwin" --enable-threaded-resolver --with-darwinssl
    1.23 +make -j `sysctl -n hw.logicalcpu_max`
    1.24 +cp lib/.libs/libcurl.a "${HOME}/Desktop/libcurl-${ARCH}.a"
    1.25 +
    1.26 +ARCH="arm64"
    1.27 +export IPHONEOS_DEPLOYMENT_TARGET="7.0"
    1.28 +export CFLAGS="-arch ${ARCH} -pipe -Os -gdwarf-2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.29 +export LDFLAGS="-arch ${ARCH} -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
    1.30 +make distclean
    1.31 +./configure --disable-shared --enable-static --host="aarch64-apple-darwin" --enable-threaded-resolver --with-darwinssl
    1.32 +make -j `sysctl -n hw.logicalcpu_max`
    1.33 +cp lib/.libs/libcurl.a "${HOME}/Desktop/libcurl-${ARCH}.a"
    1.34 +cp include/curl/curlbuild.h ~/Desktop/curlbuild64.h
    1.35 +
    1.36 +ARCH="i386"
    1.37 +export IPHONEOS_DEPLOYMENT_TARGET="6.0"
    1.38 +export CFLAGS="-arch ${ARCH} -pipe -Os -gdwarf-2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
    1.39 +export CPPFLAGS="-D__IPHONE_OS_VERSION_MIN_REQUIRED=${IPHONEOS_DEPLOYMENT_TARGET%%.*}0000"
    1.40 +export LDFLAGS="-arch ${ARCH} -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
    1.41 +make distclean
    1.42 +./configure --disable-shared --enable-static --host="${ARCH}-apple-darwin" --enable-threaded-resolver --with-darwinssl
    1.43 +make -j `sysctl -n hw.logicalcpu_max`
    1.44 +cp lib/.libs/libcurl.a "${HOME}/Desktop/libcurl-${ARCH}.a"
    1.45 +
    1.46 +ARCH="x86_64"
    1.47 +export IPHONEOS_DEPLOYMENT_TARGET="7.0"
    1.48 +export CFLAGS="-arch ${ARCH} -pipe -Os -gdwarf-2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
    1.49 +export CPPFLAGS="-D__IPHONE_OS_VERSION_MIN_REQUIRED=${IPHONEOS_DEPLOYMENT_TARGET%%.*}0000"
    1.50 +export LDFLAGS="-arch ${ARCH} -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
    1.51 +make distclean
    1.52 +./configure --disable-shared --enable-static --host="${ARCH}-apple-darwin" --enable-threaded-resolver --with-darwinssl
    1.53 +make -j `sysctl -n hw.logicalcpu_max`
    1.54 +cp lib/.libs/libcurl.a "${HOME}/Desktop/libcurl-${ARCH}.a"
    1.55 +
    1.56 +lipo -create -output "${HOME}/Desktop/libcurl.a" "${HOME}/Desktop/libcurl-armv7.a" "${HOME}/Desktop/libcurl-armv7s.a" "${HOME}/Desktop/libcurl-arm64.a" "${HOME}/Desktop/libcurl-i386.a" "${HOME}/Desktop/libcurl-x86_64.a"
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/build-mac/curl/curl.h	Mon Aug 24 17:23:37 2015 +0200
     2.3 @@ -0,0 +1,2376 @@
     2.4 +#ifndef __CURL_CURL_H
     2.5 +#define __CURL_CURL_H
     2.6 +/***************************************************************************
     2.7 + *                                  _   _ ____  _
     2.8 + *  Project                     ___| | | |  _ \| |
     2.9 + *                             / __| | | | |_) | |
    2.10 + *                            | (__| |_| |  _ <| |___
    2.11 + *                             \___|\___/|_| \_\_____|
    2.12 + *
    2.13 + * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
    2.14 + *
    2.15 + * This software is licensed as described in the file COPYING, which
    2.16 + * you should have received as part of this distribution. The terms
    2.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
    2.18 + *
    2.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    2.20 + * copies of the Software, and permit persons to whom the Software is
    2.21 + * furnished to do so, under the terms of the COPYING file.
    2.22 + *
    2.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    2.24 + * KIND, either express or implied.
    2.25 + *
    2.26 + ***************************************************************************/
    2.27 +
    2.28 +/*
    2.29 + * If you have libcurl problems, all docs and details are found here:
    2.30 + *   http://curl.haxx.se/libcurl/
    2.31 + *
    2.32 + * curl-library mailing list subscription and unsubscription web interface:
    2.33 + *   http://cool.haxx.se/mailman/listinfo/curl-library/
    2.34 + */
    2.35 +
    2.36 +#include "curlver.h"         /* libcurl version defines   */
    2.37 +#include "curlbuild.h"       /* libcurl build definitions */
    2.38 +#include "curlrules.h"       /* libcurl rules enforcement */
    2.39 +
    2.40 +/*
    2.41 + * Define WIN32 when build target is Win32 API
    2.42 + */
    2.43 +
    2.44 +#if (defined(_WIN32) || defined(__WIN32__)) && \
    2.45 +     !defined(WIN32) && !defined(__SYMBIAN32__)
    2.46 +#define WIN32
    2.47 +#endif
    2.48 +
    2.49 +#include <stdio.h>
    2.50 +#include <limits.h>
    2.51 +
    2.52 +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2)
    2.53 +/* Needed for __FreeBSD_version symbol definition */
    2.54 +#include <osreldate.h>
    2.55 +#endif
    2.56 +
    2.57 +/* The include stuff here below is mainly for time_t! */
    2.58 +#include <sys/types.h>
    2.59 +#include <time.h>
    2.60 +
    2.61 +#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)
    2.62 +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || defined(__LWIP_OPT_H__))
    2.63 +/* The check above prevents the winsock2 inclusion if winsock.h already was
    2.64 +   included, since they can't co-exist without problems */
    2.65 +#include <winsock2.h>
    2.66 +#include <ws2tcpip.h>
    2.67 +#endif
    2.68 +#endif
    2.69 +
    2.70 +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
    2.71 +   libc5-based Linux systems. Only include it on systems that are known to
    2.72 +   require it! */
    2.73 +#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
    2.74 +    defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
    2.75 +    defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
    2.76 +   (defined(__FreeBSD_version) && (__FreeBSD_version < 800000))
    2.77 +#include <sys/select.h>
    2.78 +#endif
    2.79 +
    2.80 +#if !defined(WIN32) && !defined(_WIN32_WCE)
    2.81 +#include <sys/socket.h>
    2.82 +#endif
    2.83 +
    2.84 +#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__)
    2.85 +#include <sys/time.h>
    2.86 +#endif
    2.87 +
    2.88 +#ifdef __BEOS__
    2.89 +#include <support/SupportDefs.h>
    2.90 +#endif
    2.91 +
    2.92 +#ifdef  __cplusplus
    2.93 +extern "C" {
    2.94 +#endif
    2.95 +
    2.96 +typedef void CURL;
    2.97 +
    2.98 +/*
    2.99 + * libcurl external API function linkage decorations.
   2.100 + */
   2.101 +
   2.102 +#ifdef CURL_STATICLIB
   2.103 +#  define CURL_EXTERN
   2.104 +#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)
   2.105 +#  if defined(BUILDING_LIBCURL)
   2.106 +#    define CURL_EXTERN  __declspec(dllexport)
   2.107 +#  else
   2.108 +#    define CURL_EXTERN  __declspec(dllimport)
   2.109 +#  endif
   2.110 +#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS)
   2.111 +#  define CURL_EXTERN CURL_EXTERN_SYMBOL
   2.112 +#else
   2.113 +#  define CURL_EXTERN
   2.114 +#endif
   2.115 +
   2.116 +#ifndef curl_socket_typedef
   2.117 +/* socket typedef */
   2.118 +#if defined(WIN32) && !defined(__LWIP_OPT_H__)
   2.119 +typedef SOCKET curl_socket_t;
   2.120 +#define CURL_SOCKET_BAD INVALID_SOCKET
   2.121 +#else
   2.122 +typedef int curl_socket_t;
   2.123 +#define CURL_SOCKET_BAD -1
   2.124 +#endif
   2.125 +#define curl_socket_typedef
   2.126 +#endif /* curl_socket_typedef */
   2.127 +
   2.128 +struct curl_httppost {
   2.129 +  struct curl_httppost *next;       /* next entry in the list */
   2.130 +  char *name;                       /* pointer to allocated name */
   2.131 +  long namelength;                  /* length of name length */
   2.132 +  char *contents;                   /* pointer to allocated data contents */
   2.133 +  long contentslength;              /* length of contents field */
   2.134 +  char *buffer;                     /* pointer to allocated buffer contents */
   2.135 +  long bufferlength;                /* length of buffer field */
   2.136 +  char *contenttype;                /* Content-Type */
   2.137 +  struct curl_slist* contentheader; /* list of extra headers for this form */
   2.138 +  struct curl_httppost *more;       /* if one field name has more than one
   2.139 +                                       file, this link should link to following
   2.140 +                                       files */
   2.141 +  long flags;                       /* as defined below */
   2.142 +#define HTTPPOST_FILENAME (1<<0)    /* specified content is a file name */
   2.143 +#define HTTPPOST_READFILE (1<<1)    /* specified content is a file name */
   2.144 +#define HTTPPOST_PTRNAME (1<<2)     /* name is only stored pointer
   2.145 +                                       do not free in formfree */
   2.146 +#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer
   2.147 +                                       do not free in formfree */
   2.148 +#define HTTPPOST_BUFFER (1<<4)      /* upload file from buffer */
   2.149 +#define HTTPPOST_PTRBUFFER (1<<5)   /* upload file from pointer contents */
   2.150 +#define HTTPPOST_CALLBACK (1<<6)    /* upload file contents by using the
   2.151 +                                       regular read callback to get the data
   2.152 +                                       and pass the given pointer as custom
   2.153 +                                       pointer */
   2.154 +
   2.155 +  char *showfilename;               /* The file name to show. If not set, the
   2.156 +                                       actual file name will be used (if this
   2.157 +                                       is a file part) */
   2.158 +  void *userp;                      /* custom pointer used for
   2.159 +                                       HTTPPOST_CALLBACK posts */
   2.160 +};
   2.161 +
   2.162 +/* This is the CURLOPT_PROGRESSFUNCTION callback proto. It is now considered
   2.163 +   deprecated but was the only choice up until 7.31.0 */
   2.164 +typedef int (*curl_progress_callback)(void *clientp,
   2.165 +                                      double dltotal,
   2.166 +                                      double dlnow,
   2.167 +                                      double ultotal,
   2.168 +                                      double ulnow);
   2.169 +
   2.170 +/* This is the CURLOPT_XFERINFOFUNCTION callback proto. It was introduced in
   2.171 +   7.32.0, it avoids floating point and provides more detailed information. */
   2.172 +typedef int (*curl_xferinfo_callback)(void *clientp,
   2.173 +                                      curl_off_t dltotal,
   2.174 +                                      curl_off_t dlnow,
   2.175 +                                      curl_off_t ultotal,
   2.176 +                                      curl_off_t ulnow);
   2.177 +
   2.178 +#ifndef CURL_MAX_WRITE_SIZE
   2.179 +  /* Tests have proven that 20K is a very bad buffer size for uploads on
   2.180 +     Windows, while 16K for some odd reason performed a lot better.
   2.181 +     We do the ifndef check to allow this value to easier be changed at build
   2.182 +     time for those who feel adventurous. The practical minimum is about
   2.183 +     400 bytes since libcurl uses a buffer of this size as a scratch area
   2.184 +     (unrelated to network send operations). */
   2.185 +#define CURL_MAX_WRITE_SIZE 16384
   2.186 +#endif
   2.187 +
   2.188 +#ifndef CURL_MAX_HTTP_HEADER
   2.189 +/* The only reason to have a max limit for this is to avoid the risk of a bad
   2.190 +   server feeding libcurl with a never-ending header that will cause reallocs
   2.191 +   infinitely */
   2.192 +#define CURL_MAX_HTTP_HEADER (100*1024)
   2.193 +#endif
   2.194 +
   2.195 +/* This is a magic return code for the write callback that, when returned,
   2.196 +   will signal libcurl to pause receiving on the current transfer. */
   2.197 +#define CURL_WRITEFUNC_PAUSE 0x10000001
   2.198 +
   2.199 +typedef size_t (*curl_write_callback)(char *buffer,
   2.200 +                                      size_t size,
   2.201 +                                      size_t nitems,
   2.202 +                                      void *outstream);
   2.203 +
   2.204 +
   2.205 +
   2.206 +/* enumeration of file types */
   2.207 +typedef enum {
   2.208 +  CURLFILETYPE_FILE = 0,
   2.209 +  CURLFILETYPE_DIRECTORY,
   2.210 +  CURLFILETYPE_SYMLINK,
   2.211 +  CURLFILETYPE_DEVICE_BLOCK,
   2.212 +  CURLFILETYPE_DEVICE_CHAR,
   2.213 +  CURLFILETYPE_NAMEDPIPE,
   2.214 +  CURLFILETYPE_SOCKET,
   2.215 +  CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */
   2.216 +
   2.217 +  CURLFILETYPE_UNKNOWN /* should never occur */
   2.218 +} curlfiletype;
   2.219 +
   2.220 +#define CURLFINFOFLAG_KNOWN_FILENAME    (1<<0)
   2.221 +#define CURLFINFOFLAG_KNOWN_FILETYPE    (1<<1)
   2.222 +#define CURLFINFOFLAG_KNOWN_TIME        (1<<2)
   2.223 +#define CURLFINFOFLAG_KNOWN_PERM        (1<<3)
   2.224 +#define CURLFINFOFLAG_KNOWN_UID         (1<<4)
   2.225 +#define CURLFINFOFLAG_KNOWN_GID         (1<<5)
   2.226 +#define CURLFINFOFLAG_KNOWN_SIZE        (1<<6)
   2.227 +#define CURLFINFOFLAG_KNOWN_HLINKCOUNT  (1<<7)
   2.228 +
   2.229 +/* Content of this structure depends on information which is known and is
   2.230 +   achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man
   2.231 +   page for callbacks returning this structure -- some fields are mandatory,
   2.232 +   some others are optional. The FLAG field has special meaning. */
   2.233 +struct curl_fileinfo {
   2.234 +  char *filename;
   2.235 +  curlfiletype filetype;
   2.236 +  time_t time;
   2.237 +  unsigned int perm;
   2.238 +  int uid;
   2.239 +  int gid;
   2.240 +  curl_off_t size;
   2.241 +  long int hardlinks;
   2.242 +
   2.243 +  struct {
   2.244 +    /* If some of these fields is not NULL, it is a pointer to b_data. */
   2.245 +    char *time;
   2.246 +    char *perm;
   2.247 +    char *user;
   2.248 +    char *group;
   2.249 +    char *target; /* pointer to the target filename of a symlink */
   2.250 +  } strings;
   2.251 +
   2.252 +  unsigned int flags;
   2.253 +
   2.254 +  /* used internally */
   2.255 +  char * b_data;
   2.256 +  size_t b_size;
   2.257 +  size_t b_used;
   2.258 +};
   2.259 +
   2.260 +/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */
   2.261 +#define CURL_CHUNK_BGN_FUNC_OK      0
   2.262 +#define CURL_CHUNK_BGN_FUNC_FAIL    1 /* tell the lib to end the task */
   2.263 +#define CURL_CHUNK_BGN_FUNC_SKIP    2 /* skip this chunk over */
   2.264 +
   2.265 +/* if splitting of data transfer is enabled, this callback is called before
   2.266 +   download of an individual chunk started. Note that parameter "remains" works
   2.267 +   only for FTP wildcard downloading (for now), otherwise is not used */
   2.268 +typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,
   2.269 +                                        void *ptr,
   2.270 +                                        int remains);
   2.271 +
   2.272 +/* return codes for CURLOPT_CHUNK_END_FUNCTION */
   2.273 +#define CURL_CHUNK_END_FUNC_OK      0
   2.274 +#define CURL_CHUNK_END_FUNC_FAIL    1 /* tell the lib to end the task */
   2.275 +
   2.276 +/* If splitting of data transfer is enabled this callback is called after
   2.277 +   download of an individual chunk finished.
   2.278 +   Note! After this callback was set then it have to be called FOR ALL chunks.
   2.279 +   Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.
   2.280 +   This is the reason why we don't need "transfer_info" parameter in this
   2.281 +   callback and we are not interested in "remains" parameter too. */
   2.282 +typedef long (*curl_chunk_end_callback)(void *ptr);
   2.283 +
   2.284 +/* return codes for FNMATCHFUNCTION */
   2.285 +#define CURL_FNMATCHFUNC_MATCH    0 /* string corresponds to the pattern */
   2.286 +#define CURL_FNMATCHFUNC_NOMATCH  1 /* pattern doesn't match the string */
   2.287 +#define CURL_FNMATCHFUNC_FAIL     2 /* an error occurred */
   2.288 +
   2.289 +/* callback type for wildcard downloading pattern matching. If the
   2.290 +   string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */
   2.291 +typedef int (*curl_fnmatch_callback)(void *ptr,
   2.292 +                                     const char *pattern,
   2.293 +                                     const char *string);
   2.294 +
   2.295 +/* These are the return codes for the seek callbacks */
   2.296 +#define CURL_SEEKFUNC_OK       0
   2.297 +#define CURL_SEEKFUNC_FAIL     1 /* fail the entire transfer */
   2.298 +#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
   2.299 +                                    libcurl might try other means instead */
   2.300 +typedef int (*curl_seek_callback)(void *instream,
   2.301 +                                  curl_off_t offset,
   2.302 +                                  int origin); /* 'whence' */
   2.303 +
   2.304 +/* This is a return code for the read callback that, when returned, will
   2.305 +   signal libcurl to immediately abort the current transfer. */
   2.306 +#define CURL_READFUNC_ABORT 0x10000000
   2.307 +/* This is a return code for the read callback that, when returned, will
   2.308 +   signal libcurl to pause sending data on the current transfer. */
   2.309 +#define CURL_READFUNC_PAUSE 0x10000001
   2.310 +
   2.311 +typedef size_t (*curl_read_callback)(char *buffer,
   2.312 +                                      size_t size,
   2.313 +                                      size_t nitems,
   2.314 +                                      void *instream);
   2.315 +
   2.316 +typedef enum  {
   2.317 +  CURLSOCKTYPE_IPCXN,  /* socket created for a specific IP connection */
   2.318 +  CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */
   2.319 +  CURLSOCKTYPE_LAST    /* never use */
   2.320 +} curlsocktype;
   2.321 +
   2.322 +/* The return code from the sockopt_callback can signal information back
   2.323 +   to libcurl: */
   2.324 +#define CURL_SOCKOPT_OK 0
   2.325 +#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return
   2.326 +                                CURLE_ABORTED_BY_CALLBACK */
   2.327 +#define CURL_SOCKOPT_ALREADY_CONNECTED 2
   2.328 +
   2.329 +typedef int (*curl_sockopt_callback)(void *clientp,
   2.330 +                                     curl_socket_t curlfd,
   2.331 +                                     curlsocktype purpose);
   2.332 +
   2.333 +struct curl_sockaddr {
   2.334 +  int family;
   2.335 +  int socktype;
   2.336 +  int protocol;
   2.337 +  unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it
   2.338 +                           turned really ugly and painful on the systems that
   2.339 +                           lack this type */
   2.340 +  struct sockaddr addr;
   2.341 +};
   2.342 +
   2.343 +typedef curl_socket_t
   2.344 +(*curl_opensocket_callback)(void *clientp,
   2.345 +                            curlsocktype purpose,
   2.346 +                            struct curl_sockaddr *address);
   2.347 +
   2.348 +typedef int
   2.349 +(*curl_closesocket_callback)(void *clientp, curl_socket_t item);
   2.350 +
   2.351 +typedef enum {
   2.352 +  CURLIOE_OK,            /* I/O operation successful */
   2.353 +  CURLIOE_UNKNOWNCMD,    /* command was unknown to callback */
   2.354 +  CURLIOE_FAILRESTART,   /* failed to restart the read */
   2.355 +  CURLIOE_LAST           /* never use */
   2.356 +} curlioerr;
   2.357 +
   2.358 +typedef enum  {
   2.359 +  CURLIOCMD_NOP,         /* no operation */
   2.360 +  CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
   2.361 +  CURLIOCMD_LAST         /* never use */
   2.362 +} curliocmd;
   2.363 +
   2.364 +typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
   2.365 +                                         int cmd,
   2.366 +                                         void *clientp);
   2.367 +
   2.368 +/*
   2.369 + * The following typedef's are signatures of malloc, free, realloc, strdup and
   2.370 + * calloc respectively.  Function pointers of these types can be passed to the
   2.371 + * curl_global_init_mem() function to set user defined memory management
   2.372 + * callback routines.
   2.373 + */
   2.374 +typedef void *(*curl_malloc_callback)(size_t size);
   2.375 +typedef void (*curl_free_callback)(void *ptr);
   2.376 +typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
   2.377 +typedef char *(*curl_strdup_callback)(const char *str);
   2.378 +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
   2.379 +
   2.380 +/* the kind of data that is passed to information_callback*/
   2.381 +typedef enum {
   2.382 +  CURLINFO_TEXT = 0,
   2.383 +  CURLINFO_HEADER_IN,    /* 1 */
   2.384 +  CURLINFO_HEADER_OUT,   /* 2 */
   2.385 +  CURLINFO_DATA_IN,      /* 3 */
   2.386 +  CURLINFO_DATA_OUT,     /* 4 */
   2.387 +  CURLINFO_SSL_DATA_IN,  /* 5 */
   2.388 +  CURLINFO_SSL_DATA_OUT, /* 6 */
   2.389 +  CURLINFO_END
   2.390 +} curl_infotype;
   2.391 +
   2.392 +typedef int (*curl_debug_callback)
   2.393 +       (CURL *handle,      /* the handle/transfer this concerns */
   2.394 +        curl_infotype type, /* what kind of data */
   2.395 +        char *data,        /* points to the data */
   2.396 +        size_t size,       /* size of the data pointed to */
   2.397 +        void *userptr);    /* whatever the user please */
   2.398 +
   2.399 +/* All possible error codes from all sorts of curl functions. Future versions
   2.400 +   may return other values, stay prepared.
   2.401 +
   2.402 +   Always add new return codes last. Never *EVER* remove any. The return
   2.403 +   codes must remain the same!
   2.404 + */
   2.405 +
   2.406 +typedef enum {
   2.407 +  CURLE_OK = 0,
   2.408 +  CURLE_UNSUPPORTED_PROTOCOL,    /* 1 */
   2.409 +  CURLE_FAILED_INIT,             /* 2 */
   2.410 +  CURLE_URL_MALFORMAT,           /* 3 */
   2.411 +  CURLE_NOT_BUILT_IN,            /* 4 - [was obsoleted in August 2007 for
   2.412 +                                    7.17.0, reused in April 2011 for 7.21.5] */
   2.413 +  CURLE_COULDNT_RESOLVE_PROXY,   /* 5 */
   2.414 +  CURLE_COULDNT_RESOLVE_HOST,    /* 6 */
   2.415 +  CURLE_COULDNT_CONNECT,         /* 7 */
   2.416 +  CURLE_FTP_WEIRD_SERVER_REPLY,  /* 8 */
   2.417 +  CURLE_REMOTE_ACCESS_DENIED,    /* 9 a service was denied by the server
   2.418 +                                    due to lack of access - when login fails
   2.419 +                                    this is not returned. */
   2.420 +  CURLE_FTP_ACCEPT_FAILED,       /* 10 - [was obsoleted in April 2006 for
   2.421 +                                    7.15.4, reused in Dec 2011 for 7.24.0]*/
   2.422 +  CURLE_FTP_WEIRD_PASS_REPLY,    /* 11 */
   2.423 +  CURLE_FTP_ACCEPT_TIMEOUT,      /* 12 - timeout occurred accepting server
   2.424 +                                    [was obsoleted in August 2007 for 7.17.0,
   2.425 +                                    reused in Dec 2011 for 7.24.0]*/
   2.426 +  CURLE_FTP_WEIRD_PASV_REPLY,    /* 13 */
   2.427 +  CURLE_FTP_WEIRD_227_FORMAT,    /* 14 */
   2.428 +  CURLE_FTP_CANT_GET_HOST,       /* 15 */
   2.429 +  CURLE_HTTP2,                   /* 16 - A problem in the http2 framing layer.
   2.430 +                                    [was obsoleted in August 2007 for 7.17.0,
   2.431 +                                    reused in July 2014 for 7.38.0] */
   2.432 +  CURLE_FTP_COULDNT_SET_TYPE,    /* 17 */
   2.433 +  CURLE_PARTIAL_FILE,            /* 18 */
   2.434 +  CURLE_FTP_COULDNT_RETR_FILE,   /* 19 */
   2.435 +  CURLE_OBSOLETE20,              /* 20 - NOT USED */
   2.436 +  CURLE_QUOTE_ERROR,             /* 21 - quote command failure */
   2.437 +  CURLE_HTTP_RETURNED_ERROR,     /* 22 */
   2.438 +  CURLE_WRITE_ERROR,             /* 23 */
   2.439 +  CURLE_OBSOLETE24,              /* 24 - NOT USED */
   2.440 +  CURLE_UPLOAD_FAILED,           /* 25 - failed upload "command" */
   2.441 +  CURLE_READ_ERROR,              /* 26 - couldn't open/read from file */
   2.442 +  CURLE_OUT_OF_MEMORY,           /* 27 */
   2.443 +  /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
   2.444 +           instead of a memory allocation error if CURL_DOES_CONVERSIONS
   2.445 +           is defined
   2.446 +  */
   2.447 +  CURLE_OPERATION_TIMEDOUT,      /* 28 - the timeout time was reached */
   2.448 +  CURLE_OBSOLETE29,              /* 29 - NOT USED */
   2.449 +  CURLE_FTP_PORT_FAILED,         /* 30 - FTP PORT operation failed */
   2.450 +  CURLE_FTP_COULDNT_USE_REST,    /* 31 - the REST command failed */
   2.451 +  CURLE_OBSOLETE32,              /* 32 - NOT USED */
   2.452 +  CURLE_RANGE_ERROR,             /* 33 - RANGE "command" didn't work */
   2.453 +  CURLE_HTTP_POST_ERROR,         /* 34 */
   2.454 +  CURLE_SSL_CONNECT_ERROR,       /* 35 - wrong when connecting with SSL */
   2.455 +  CURLE_BAD_DOWNLOAD_RESUME,     /* 36 - couldn't resume download */
   2.456 +  CURLE_FILE_COULDNT_READ_FILE,  /* 37 */
   2.457 +  CURLE_LDAP_CANNOT_BIND,        /* 38 */
   2.458 +  CURLE_LDAP_SEARCH_FAILED,      /* 39 */
   2.459 +  CURLE_OBSOLETE40,              /* 40 - NOT USED */
   2.460 +  CURLE_FUNCTION_NOT_FOUND,      /* 41 */
   2.461 +  CURLE_ABORTED_BY_CALLBACK,     /* 42 */
   2.462 +  CURLE_BAD_FUNCTION_ARGUMENT,   /* 43 */
   2.463 +  CURLE_OBSOLETE44,              /* 44 - NOT USED */
   2.464 +  CURLE_INTERFACE_FAILED,        /* 45 - CURLOPT_INTERFACE failed */
   2.465 +  CURLE_OBSOLETE46,              /* 46 - NOT USED */
   2.466 +  CURLE_TOO_MANY_REDIRECTS ,     /* 47 - catch endless re-direct loops */
   2.467 +  CURLE_UNKNOWN_OPTION,          /* 48 - User specified an unknown option */
   2.468 +  CURLE_TELNET_OPTION_SYNTAX ,   /* 49 - Malformed telnet option */
   2.469 +  CURLE_OBSOLETE50,              /* 50 - NOT USED */
   2.470 +  CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint
   2.471 +                                     wasn't verified fine */
   2.472 +  CURLE_GOT_NOTHING,             /* 52 - when this is a specific error */
   2.473 +  CURLE_SSL_ENGINE_NOTFOUND,     /* 53 - SSL crypto engine not found */
   2.474 +  CURLE_SSL_ENGINE_SETFAILED,    /* 54 - can not set SSL crypto engine as
   2.475 +                                    default */
   2.476 +  CURLE_SEND_ERROR,              /* 55 - failed sending network data */
   2.477 +  CURLE_RECV_ERROR,              /* 56 - failure in receiving network data */
   2.478 +  CURLE_OBSOLETE57,              /* 57 - NOT IN USE */
   2.479 +  CURLE_SSL_CERTPROBLEM,         /* 58 - problem with the local certificate */
   2.480 +  CURLE_SSL_CIPHER,              /* 59 - couldn't use specified cipher */
   2.481 +  CURLE_SSL_CACERT,              /* 60 - problem with the CA cert (path?) */
   2.482 +  CURLE_BAD_CONTENT_ENCODING,    /* 61 - Unrecognized/bad encoding */
   2.483 +  CURLE_LDAP_INVALID_URL,        /* 62 - Invalid LDAP URL */
   2.484 +  CURLE_FILESIZE_EXCEEDED,       /* 63 - Maximum file size exceeded */
   2.485 +  CURLE_USE_SSL_FAILED,          /* 64 - Requested FTP SSL level failed */
   2.486 +  CURLE_SEND_FAIL_REWIND,        /* 65 - Sending the data requires a rewind
   2.487 +                                    that failed */
   2.488 +  CURLE_SSL_ENGINE_INITFAILED,   /* 66 - failed to initialise ENGINE */
   2.489 +  CURLE_LOGIN_DENIED,            /* 67 - user, password or similar was not
   2.490 +                                    accepted and we failed to login */
   2.491 +  CURLE_TFTP_NOTFOUND,           /* 68 - file not found on server */
   2.492 +  CURLE_TFTP_PERM,               /* 69 - permission problem on server */
   2.493 +  CURLE_REMOTE_DISK_FULL,        /* 70 - out of disk space on server */
   2.494 +  CURLE_TFTP_ILLEGAL,            /* 71 - Illegal TFTP operation */
   2.495 +  CURLE_TFTP_UNKNOWNID,          /* 72 - Unknown transfer ID */
   2.496 +  CURLE_REMOTE_FILE_EXISTS,      /* 73 - File already exists */
   2.497 +  CURLE_TFTP_NOSUCHUSER,         /* 74 - No such user */
   2.498 +  CURLE_CONV_FAILED,             /* 75 - conversion failed */
   2.499 +  CURLE_CONV_REQD,               /* 76 - caller must register conversion
   2.500 +                                    callbacks using curl_easy_setopt options
   2.501 +                                    CURLOPT_CONV_FROM_NETWORK_FUNCTION,
   2.502 +                                    CURLOPT_CONV_TO_NETWORK_FUNCTION, and
   2.503 +                                    CURLOPT_CONV_FROM_UTF8_FUNCTION */
   2.504 +  CURLE_SSL_CACERT_BADFILE,      /* 77 - could not load CACERT file, missing
   2.505 +                                    or wrong format */
   2.506 +  CURLE_REMOTE_FILE_NOT_FOUND,   /* 78 - remote file not found */
   2.507 +  CURLE_SSH,                     /* 79 - error from the SSH layer, somewhat
   2.508 +                                    generic so the error message will be of
   2.509 +                                    interest when this has happened */
   2.510 +
   2.511 +  CURLE_SSL_SHUTDOWN_FAILED,     /* 80 - Failed to shut down the SSL
   2.512 +                                    connection */
   2.513 +  CURLE_AGAIN,                   /* 81 - socket is not ready for send/recv,
   2.514 +                                    wait till it's ready and try again (Added
   2.515 +                                    in 7.18.2) */
   2.516 +  CURLE_SSL_CRL_BADFILE,         /* 82 - could not load CRL file, missing or
   2.517 +                                    wrong format (Added in 7.19.0) */
   2.518 +  CURLE_SSL_ISSUER_ERROR,        /* 83 - Issuer check failed.  (Added in
   2.519 +                                    7.19.0) */
   2.520 +  CURLE_FTP_PRET_FAILED,         /* 84 - a PRET command failed */
   2.521 +  CURLE_RTSP_CSEQ_ERROR,         /* 85 - mismatch of RTSP CSeq numbers */
   2.522 +  CURLE_RTSP_SESSION_ERROR,      /* 86 - mismatch of RTSP Session Ids */
   2.523 +  CURLE_FTP_BAD_FILE_LIST,       /* 87 - unable to parse FTP file list */
   2.524 +  CURLE_CHUNK_FAILED,            /* 88 - chunk callback reported error */
   2.525 +  CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the
   2.526 +                                    session will be queued */
   2.527 +  CURLE_SSL_PINNEDPUBKEYNOTMATCH, /* 90 - specified pinned public key did not
   2.528 +                                     match */
   2.529 +  CURLE_SSL_INVALIDCERTSTATUS,   /* 91 - invalid certificate status */
   2.530 +  CURL_LAST /* never use! */
   2.531 +} CURLcode;
   2.532 +
   2.533 +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
   2.534 +                          the obsolete stuff removed! */
   2.535 +
   2.536 +/* Previously obsolete error code re-used in 7.38.0 */
   2.537 +#define CURLE_OBSOLETE16 CURLE_HTTP2
   2.538 +
   2.539 +/* Previously obsolete error codes re-used in 7.24.0 */
   2.540 +#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED
   2.541 +#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT
   2.542 +
   2.543 +/*  compatibility with older names */
   2.544 +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING
   2.545 +
   2.546 +/* The following were added in 7.21.5, April 2011 */
   2.547 +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION
   2.548 +
   2.549 +/* The following were added in 7.17.1 */
   2.550 +/* These are scheduled to disappear by 2009 */
   2.551 +#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION
   2.552 +
   2.553 +/* The following were added in 7.17.0 */
   2.554 +/* These are scheduled to disappear by 2009 */
   2.555 +#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */
   2.556 +#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46
   2.557 +#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44
   2.558 +#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10
   2.559 +#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16
   2.560 +#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32
   2.561 +#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29
   2.562 +#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12
   2.563 +#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20
   2.564 +#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40
   2.565 +#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24
   2.566 +#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57
   2.567 +#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN
   2.568 +
   2.569 +#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED
   2.570 +#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE
   2.571 +#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR
   2.572 +#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL
   2.573 +#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS
   2.574 +#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR
   2.575 +#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED
   2.576 +
   2.577 +/* The following were added earlier */
   2.578 +
   2.579 +#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT
   2.580 +
   2.581 +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
   2.582 +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
   2.583 +#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED
   2.584 +
   2.585 +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
   2.586 +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME
   2.587 +
   2.588 +/* This was the error code 50 in 7.7.3 and a few earlier versions, this
   2.589 +   is no longer used by libcurl but is instead #defined here only to not
   2.590 +   make programs break */
   2.591 +#define CURLE_ALREADY_COMPLETE 99999
   2.592 +
   2.593 +/* Provide defines for really old option names */
   2.594 +#define CURLOPT_FILE CURLOPT_WRITEDATA /* name changed in 7.9.7 */
   2.595 +#define CURLOPT_INFILE CURLOPT_READDATA /* name changed in 7.9.7 */
   2.596 +#define CURLOPT_WRITEHEADER CURLOPT_HEADERDATA
   2.597 +
   2.598 +/* Since long deprecated options with no code in the lib that does anything
   2.599 +   with them. */
   2.600 +#define CURLOPT_WRITEINFO CURLOPT_OBSOLETE40
   2.601 +#define CURLOPT_CLOSEPOLICY CURLOPT_OBSOLETE72
   2.602 +
   2.603 +#endif /*!CURL_NO_OLDIES*/
   2.604 +
   2.605 +/* This prototype applies to all conversion callbacks */
   2.606 +typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
   2.607 +
   2.608 +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl,    /* easy handle */
   2.609 +                                          void *ssl_ctx, /* actually an
   2.610 +                                                            OpenSSL SSL_CTX */
   2.611 +                                          void *userptr);
   2.612 +
   2.613 +typedef enum {
   2.614 +  CURLPROXY_HTTP = 0,   /* added in 7.10, new in 7.19.4 default is to use
   2.615 +                           CONNECT HTTP/1.1 */
   2.616 +  CURLPROXY_HTTP_1_0 = 1,   /* added in 7.19.4, force to use CONNECT
   2.617 +                               HTTP/1.0  */
   2.618 +  CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
   2.619 +                           in 7.10 */
   2.620 +  CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
   2.621 +  CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
   2.622 +  CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
   2.623 +                                   host name rather than the IP address. added
   2.624 +                                   in 7.18.0 */
   2.625 +} curl_proxytype;  /* this enum was added in 7.10 */
   2.626 +
   2.627 +/*
   2.628 + * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options:
   2.629 + *
   2.630 + * CURLAUTH_NONE         - No HTTP authentication
   2.631 + * CURLAUTH_BASIC        - HTTP Basic authentication (default)
   2.632 + * CURLAUTH_DIGEST       - HTTP Digest authentication
   2.633 + * CURLAUTH_NEGOTIATE    - HTTP Negotiate (SPNEGO) authentication
   2.634 + * CURLAUTH_GSSNEGOTIATE - Alias for CURLAUTH_NEGOTIATE (deprecated)
   2.635 + * CURLAUTH_NTLM         - HTTP NTLM authentication
   2.636 + * CURLAUTH_DIGEST_IE    - HTTP Digest authentication with IE flavour
   2.637 + * CURLAUTH_NTLM_WB      - HTTP NTLM authentication delegated to winbind helper
   2.638 + * CURLAUTH_ONLY         - Use together with a single other type to force no
   2.639 + *                         authentication or just that single type
   2.640 + * CURLAUTH_ANY          - All fine types set
   2.641 + * CURLAUTH_ANYSAFE      - All fine types except Basic
   2.642 + */
   2.643 +
   2.644 +#define CURLAUTH_NONE         ((unsigned long)0)
   2.645 +#define CURLAUTH_BASIC        (((unsigned long)1)<<0)
   2.646 +#define CURLAUTH_DIGEST       (((unsigned long)1)<<1)
   2.647 +#define CURLAUTH_NEGOTIATE    (((unsigned long)1)<<2)
   2.648 +/* Deprecated since the advent of CURLAUTH_NEGOTIATE */
   2.649 +#define CURLAUTH_GSSNEGOTIATE CURLAUTH_NEGOTIATE
   2.650 +#define CURLAUTH_NTLM         (((unsigned long)1)<<3)
   2.651 +#define CURLAUTH_DIGEST_IE    (((unsigned long)1)<<4)
   2.652 +#define CURLAUTH_NTLM_WB      (((unsigned long)1)<<5)
   2.653 +#define CURLAUTH_ONLY         (((unsigned long)1)<<31)
   2.654 +#define CURLAUTH_ANY          (~CURLAUTH_DIGEST_IE)
   2.655 +#define CURLAUTH_ANYSAFE      (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))
   2.656 +
   2.657 +#define CURLSSH_AUTH_ANY       ~0     /* all types supported by the server */
   2.658 +#define CURLSSH_AUTH_NONE      0      /* none allowed, silly but complete */
   2.659 +#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
   2.660 +#define CURLSSH_AUTH_PASSWORD  (1<<1) /* password */
   2.661 +#define CURLSSH_AUTH_HOST      (1<<2) /* host key files */
   2.662 +#define CURLSSH_AUTH_KEYBOARD  (1<<3) /* keyboard interactive */
   2.663 +#define CURLSSH_AUTH_AGENT     (1<<4) /* agent (ssh-agent, pageant...) */
   2.664 +#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
   2.665 +
   2.666 +#define CURLGSSAPI_DELEGATION_NONE        0      /* no delegation (default) */
   2.667 +#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */
   2.668 +#define CURLGSSAPI_DELEGATION_FLAG        (1<<1) /* delegate always */
   2.669 +
   2.670 +#define CURL_ERROR_SIZE 256
   2.671 +
   2.672 +enum curl_khtype {
   2.673 +  CURLKHTYPE_UNKNOWN,
   2.674 +  CURLKHTYPE_RSA1,
   2.675 +  CURLKHTYPE_RSA,
   2.676 +  CURLKHTYPE_DSS
   2.677 +};
   2.678 +
   2.679 +struct curl_khkey {
   2.680 +  const char *key; /* points to a zero-terminated string encoded with base64
   2.681 +                      if len is zero, otherwise to the "raw" data */
   2.682 +  size_t len;
   2.683 +  enum curl_khtype keytype;
   2.684 +};
   2.685 +
   2.686 +/* this is the set of return values expected from the curl_sshkeycallback
   2.687 +   callback */
   2.688 +enum curl_khstat {
   2.689 +  CURLKHSTAT_FINE_ADD_TO_FILE,
   2.690 +  CURLKHSTAT_FINE,
   2.691 +  CURLKHSTAT_REJECT, /* reject the connection, return an error */
   2.692 +  CURLKHSTAT_DEFER,  /* do not accept it, but we can't answer right now so
   2.693 +                        this causes a CURLE_DEFER error but otherwise the
   2.694 +                        connection will be left intact etc */
   2.695 +  CURLKHSTAT_LAST    /* not for use, only a marker for last-in-list */
   2.696 +};
   2.697 +
   2.698 +/* this is the set of status codes pass in to the callback */
   2.699 +enum curl_khmatch {
   2.700 +  CURLKHMATCH_OK,       /* match */
   2.701 +  CURLKHMATCH_MISMATCH, /* host found, key mismatch! */
   2.702 +  CURLKHMATCH_MISSING,  /* no matching host/key found */
   2.703 +  CURLKHMATCH_LAST      /* not for use, only a marker for last-in-list */
   2.704 +};
   2.705 +
   2.706 +typedef int
   2.707 +  (*curl_sshkeycallback) (CURL *easy,     /* easy handle */
   2.708 +                          const struct curl_khkey *knownkey, /* known */
   2.709 +                          const struct curl_khkey *foundkey, /* found */
   2.710 +                          enum curl_khmatch, /* libcurl's view on the keys */
   2.711 +                          void *clientp); /* custom pointer passed from app */
   2.712 +
   2.713 +/* parameter for the CURLOPT_USE_SSL option */
   2.714 +typedef enum {
   2.715 +  CURLUSESSL_NONE,    /* do not attempt to use SSL */
   2.716 +  CURLUSESSL_TRY,     /* try using SSL, proceed anyway otherwise */
   2.717 +  CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
   2.718 +  CURLUSESSL_ALL,     /* SSL for all communication or fail */
   2.719 +  CURLUSESSL_LAST     /* not an option, never use */
   2.720 +} curl_usessl;
   2.721 +
   2.722 +/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */
   2.723 +
   2.724 +/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the
   2.725 +   name of improving interoperability with older servers. Some SSL libraries
   2.726 +   have introduced work-arounds for this flaw but those work-arounds sometimes
   2.727 +   make the SSL communication fail. To regain functionality with those broken
   2.728 +   servers, a user can this way allow the vulnerability back. */
   2.729 +#define CURLSSLOPT_ALLOW_BEAST (1<<0)
   2.730 +
   2.731 +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
   2.732 +                          the obsolete stuff removed! */
   2.733 +
   2.734 +/* Backwards compatibility with older names */
   2.735 +/* These are scheduled to disappear by 2009 */
   2.736 +
   2.737 +#define CURLFTPSSL_NONE CURLUSESSL_NONE
   2.738 +#define CURLFTPSSL_TRY CURLUSESSL_TRY
   2.739 +#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL
   2.740 +#define CURLFTPSSL_ALL CURLUSESSL_ALL
   2.741 +#define CURLFTPSSL_LAST CURLUSESSL_LAST
   2.742 +#define curl_ftpssl curl_usessl
   2.743 +#endif /*!CURL_NO_OLDIES*/
   2.744 +
   2.745 +/* parameter for the CURLOPT_FTP_SSL_CCC option */
   2.746 +typedef enum {
   2.747 +  CURLFTPSSL_CCC_NONE,    /* do not send CCC */
   2.748 +  CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
   2.749 +  CURLFTPSSL_CCC_ACTIVE,  /* Initiate the shutdown */
   2.750 +  CURLFTPSSL_CCC_LAST     /* not an option, never use */
   2.751 +} curl_ftpccc;
   2.752 +
   2.753 +/* parameter for the CURLOPT_FTPSSLAUTH option */
   2.754 +typedef enum {
   2.755 +  CURLFTPAUTH_DEFAULT, /* let libcurl decide */
   2.756 +  CURLFTPAUTH_SSL,     /* use "AUTH SSL" */
   2.757 +  CURLFTPAUTH_TLS,     /* use "AUTH TLS" */
   2.758 +  CURLFTPAUTH_LAST /* not an option, never use */
   2.759 +} curl_ftpauth;
   2.760 +
   2.761 +/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
   2.762 +typedef enum {
   2.763 +  CURLFTP_CREATE_DIR_NONE,  /* do NOT create missing dirs! */
   2.764 +  CURLFTP_CREATE_DIR,       /* (FTP/SFTP) if CWD fails, try MKD and then CWD
   2.765 +                               again if MKD succeeded, for SFTP this does
   2.766 +                               similar magic */
   2.767 +  CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
   2.768 +                               again even if MKD failed! */
   2.769 +  CURLFTP_CREATE_DIR_LAST   /* not an option, never use */
   2.770 +} curl_ftpcreatedir;
   2.771 +
   2.772 +/* parameter for the CURLOPT_FTP_FILEMETHOD option */
   2.773 +typedef enum {
   2.774 +  CURLFTPMETHOD_DEFAULT,   /* let libcurl pick */
   2.775 +  CURLFTPMETHOD_MULTICWD,  /* single CWD operation for each path part */
   2.776 +  CURLFTPMETHOD_NOCWD,     /* no CWD at all */
   2.777 +  CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
   2.778 +  CURLFTPMETHOD_LAST       /* not an option, never use */
   2.779 +} curl_ftpmethod;
   2.780 +
   2.781 +/* bitmask defines for CURLOPT_HEADEROPT */
   2.782 +#define CURLHEADER_UNIFIED  0
   2.783 +#define CURLHEADER_SEPARATE (1<<0)
   2.784 +
   2.785 +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
   2.786 +#define CURLPROTO_HTTP   (1<<0)
   2.787 +#define CURLPROTO_HTTPS  (1<<1)
   2.788 +#define CURLPROTO_FTP    (1<<2)
   2.789 +#define CURLPROTO_FTPS   (1<<3)
   2.790 +#define CURLPROTO_SCP    (1<<4)
   2.791 +#define CURLPROTO_SFTP   (1<<5)
   2.792 +#define CURLPROTO_TELNET (1<<6)
   2.793 +#define CURLPROTO_LDAP   (1<<7)
   2.794 +#define CURLPROTO_LDAPS  (1<<8)
   2.795 +#define CURLPROTO_DICT   (1<<9)
   2.796 +#define CURLPROTO_FILE   (1<<10)
   2.797 +#define CURLPROTO_TFTP   (1<<11)
   2.798 +#define CURLPROTO_IMAP   (1<<12)
   2.799 +#define CURLPROTO_IMAPS  (1<<13)
   2.800 +#define CURLPROTO_POP3   (1<<14)
   2.801 +#define CURLPROTO_POP3S  (1<<15)
   2.802 +#define CURLPROTO_SMTP   (1<<16)
   2.803 +#define CURLPROTO_SMTPS  (1<<17)
   2.804 +#define CURLPROTO_RTSP   (1<<18)
   2.805 +#define CURLPROTO_RTMP   (1<<19)
   2.806 +#define CURLPROTO_RTMPT  (1<<20)
   2.807 +#define CURLPROTO_RTMPE  (1<<21)
   2.808 +#define CURLPROTO_RTMPTE (1<<22)
   2.809 +#define CURLPROTO_RTMPS  (1<<23)
   2.810 +#define CURLPROTO_RTMPTS (1<<24)
   2.811 +#define CURLPROTO_GOPHER (1<<25)
   2.812 +#define CURLPROTO_SMB    (1<<26)
   2.813 +#define CURLPROTO_SMBS   (1<<27)
   2.814 +#define CURLPROTO_ALL    (~0) /* enable everything */
   2.815 +
   2.816 +/* long may be 32 or 64 bits, but we should never depend on anything else
   2.817 +   but 32 */
   2.818 +#define CURLOPTTYPE_LONG          0
   2.819 +#define CURLOPTTYPE_OBJECTPOINT   10000
   2.820 +#define CURLOPTTYPE_FUNCTIONPOINT 20000
   2.821 +#define CURLOPTTYPE_OFF_T         30000
   2.822 +
   2.823 +/* name is uppercase CURLOPT_<name>,
   2.824 +   type is one of the defined CURLOPTTYPE_<type>
   2.825 +   number is unique identifier */
   2.826 +#ifdef CINIT
   2.827 +#undef CINIT
   2.828 +#endif
   2.829 +
   2.830 +#ifdef CURL_ISOCPP
   2.831 +#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu
   2.832 +#else
   2.833 +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
   2.834 +#define LONG          CURLOPTTYPE_LONG
   2.835 +#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
   2.836 +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
   2.837 +#define OFF_T         CURLOPTTYPE_OFF_T
   2.838 +#define CINIT(name,type,number) CURLOPT_/**/name = type + number
   2.839 +#endif
   2.840 +
   2.841 +/*
   2.842 + * This macro-mania below setups the CURLOPT_[what] enum, to be used with
   2.843 + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what]
   2.844 + * word.
   2.845 + */
   2.846 +
   2.847 +typedef enum {
   2.848 +  /* This is the FILE * or void * the regular output should be written to. */
   2.849 +  CINIT(WRITEDATA, OBJECTPOINT, 1),
   2.850 +
   2.851 +  /* The full URL to get/put */
   2.852 +  CINIT(URL, OBJECTPOINT, 2),
   2.853 +
   2.854 +  /* Port number to connect to, if other than default. */
   2.855 +  CINIT(PORT, LONG, 3),
   2.856 +
   2.857 +  /* Name of proxy to use. */
   2.858 +  CINIT(PROXY, OBJECTPOINT, 4),
   2.859 +
   2.860 +  /* "user:password;options" to use when fetching. */
   2.861 +  CINIT(USERPWD, OBJECTPOINT, 5),
   2.862 +
   2.863 +  /* "user:password" to use with proxy. */
   2.864 +  CINIT(PROXYUSERPWD, OBJECTPOINT, 6),
   2.865 +
   2.866 +  /* Range to get, specified as an ASCII string. */
   2.867 +  CINIT(RANGE, OBJECTPOINT, 7),
   2.868 +
   2.869 +  /* not used */
   2.870 +
   2.871 +  /* Specified file stream to upload from (use as input): */
   2.872 +  CINIT(READDATA, OBJECTPOINT, 9),
   2.873 +
   2.874 +  /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
   2.875 +   * bytes big. If this is not used, error messages go to stderr instead: */
   2.876 +  CINIT(ERRORBUFFER, OBJECTPOINT, 10),
   2.877 +
   2.878 +  /* Function that will be called to store the output (instead of fwrite). The
   2.879 +   * parameters will use fwrite() syntax, make sure to follow them. */
   2.880 +  CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
   2.881 +
   2.882 +  /* Function that will be called to read the input (instead of fread). The
   2.883 +   * parameters will use fread() syntax, make sure to follow them. */
   2.884 +  CINIT(READFUNCTION, FUNCTIONPOINT, 12),
   2.885 +
   2.886 +  /* Time-out the read operation after this amount of seconds */
   2.887 +  CINIT(TIMEOUT, LONG, 13),
   2.888 +
   2.889 +  /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
   2.890 +   * how large the file being sent really is. That allows better error
   2.891 +   * checking and better verifies that the upload was successful. -1 means
   2.892 +   * unknown size.
   2.893 +   *
   2.894 +   * For large file support, there is also a _LARGE version of the key
   2.895 +   * which takes an off_t type, allowing platforms with larger off_t
   2.896 +   * sizes to handle larger files.  See below for INFILESIZE_LARGE.
   2.897 +   */
   2.898 +  CINIT(INFILESIZE, LONG, 14),
   2.899 +
   2.900 +  /* POST static input fields. */
   2.901 +  CINIT(POSTFIELDS, OBJECTPOINT, 15),
   2.902 +
   2.903 +  /* Set the referrer page (needed by some CGIs) */
   2.904 +  CINIT(REFERER, OBJECTPOINT, 16),
   2.905 +
   2.906 +  /* Set the FTP PORT string (interface name, named or numerical IP address)
   2.907 +     Use i.e '-' to use default address. */
   2.908 +  CINIT(FTPPORT, OBJECTPOINT, 17),
   2.909 +
   2.910 +  /* Set the User-Agent string (examined by some CGIs) */
   2.911 +  CINIT(USERAGENT, OBJECTPOINT, 18),
   2.912 +
   2.913 +  /* If the download receives less than "low speed limit" bytes/second
   2.914 +   * during "low speed time" seconds, the operations is aborted.
   2.915 +   * You could i.e if you have a pretty high speed connection, abort if
   2.916 +   * it is less than 2000 bytes/sec during 20 seconds.
   2.917 +   */
   2.918 +
   2.919 +  /* Set the "low speed limit" */
   2.920 +  CINIT(LOW_SPEED_LIMIT, LONG, 19),
   2.921 +
   2.922 +  /* Set the "low speed time" */
   2.923 +  CINIT(LOW_SPEED_TIME, LONG, 20),
   2.924 +
   2.925 +  /* Set the continuation offset.
   2.926 +   *
   2.927 +   * Note there is also a _LARGE version of this key which uses
   2.928 +   * off_t types, allowing for large file offsets on platforms which
   2.929 +   * use larger-than-32-bit off_t's.  Look below for RESUME_FROM_LARGE.
   2.930 +   */
   2.931 +  CINIT(RESUME_FROM, LONG, 21),
   2.932 +
   2.933 +  /* Set cookie in request: */
   2.934 +  CINIT(COOKIE, OBJECTPOINT, 22),
   2.935 +
   2.936 +  /* This points to a linked list of headers, struct curl_slist kind. This
   2.937 +     list is also used for RTSP (in spite of its name) */
   2.938 +  CINIT(HTTPHEADER, OBJECTPOINT, 23),
   2.939 +
   2.940 +  /* This points to a linked list of post entries, struct curl_httppost */
   2.941 +  CINIT(HTTPPOST, OBJECTPOINT, 24),
   2.942 +
   2.943 +  /* name of the file keeping your private SSL-certificate */
   2.944 +  CINIT(SSLCERT, OBJECTPOINT, 25),
   2.945 +
   2.946 +  /* password for the SSL or SSH private key */
   2.947 +  CINIT(KEYPASSWD, OBJECTPOINT, 26),
   2.948 +
   2.949 +  /* send TYPE parameter? */
   2.950 +  CINIT(CRLF, LONG, 27),
   2.951 +
   2.952 +  /* send linked-list of QUOTE commands */
   2.953 +  CINIT(QUOTE, OBJECTPOINT, 28),
   2.954 +
   2.955 +  /* send FILE * or void * to store headers to, if you use a callback it
   2.956 +     is simply passed to the callback unmodified */
   2.957 +  CINIT(HEADERDATA, OBJECTPOINT, 29),
   2.958 +
   2.959 +  /* point to a file to read the initial cookies from, also enables
   2.960 +     "cookie awareness" */
   2.961 +  CINIT(COOKIEFILE, OBJECTPOINT, 31),
   2.962 +
   2.963 +  /* What version to specifically try to use.
   2.964 +     See CURL_SSLVERSION defines below. */
   2.965 +  CINIT(SSLVERSION, LONG, 32),
   2.966 +
   2.967 +  /* What kind of HTTP time condition to use, see defines */
   2.968 +  CINIT(TIMECONDITION, LONG, 33),
   2.969 +
   2.970 +  /* Time to use with the above condition. Specified in number of seconds
   2.971 +     since 1 Jan 1970 */
   2.972 +  CINIT(TIMEVALUE, LONG, 34),
   2.973 +
   2.974 +  /* 35 = OBSOLETE */
   2.975 +
   2.976 +  /* Custom request, for customizing the get command like
   2.977 +     HTTP: DELETE, TRACE and others
   2.978 +     FTP: to use a different list command
   2.979 +     */
   2.980 +  CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),
   2.981 +
   2.982 +  /* HTTP request, for odd commands like DELETE, TRACE and others */
   2.983 +  CINIT(STDERR, OBJECTPOINT, 37),
   2.984 +
   2.985 +  /* 38 is not used */
   2.986 +
   2.987 +  /* send linked-list of post-transfer QUOTE commands */
   2.988 +  CINIT(POSTQUOTE, OBJECTPOINT, 39),
   2.989 +
   2.990 +  CINIT(OBSOLETE40, OBJECTPOINT, 40), /* OBSOLETE, do not use! */
   2.991 +
   2.992 +  CINIT(VERBOSE, LONG, 41),      /* talk a lot */
   2.993 +  CINIT(HEADER, LONG, 42),       /* throw the header out too */
   2.994 +  CINIT(NOPROGRESS, LONG, 43),   /* shut off the progress meter */
   2.995 +  CINIT(NOBODY, LONG, 44),       /* use HEAD to get http document */
   2.996 +  CINIT(FAILONERROR, LONG, 45),  /* no output on http error codes >= 400 */
   2.997 +  CINIT(UPLOAD, LONG, 46),       /* this is an upload */
   2.998 +  CINIT(POST, LONG, 47),         /* HTTP POST method */
   2.999 +  CINIT(DIRLISTONLY, LONG, 48),  /* bare names when listing directories */
  2.1000 +
  2.1001 +  CINIT(APPEND, LONG, 50),       /* Append instead of overwrite on upload! */
  2.1002 +
  2.1003 +  /* Specify whether to read the user+password from the .netrc or the URL.
  2.1004 +   * This must be one of the CURL_NETRC_* enums below. */
  2.1005 +  CINIT(NETRC, LONG, 51),
  2.1006 +
  2.1007 +  CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */
  2.1008 +
  2.1009 +  CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
  2.1010 +  CINIT(PUT, LONG, 54),          /* HTTP PUT */
  2.1011 +
  2.1012 +  /* 55 = OBSOLETE */
  2.1013 +
  2.1014 +  /* DEPRECATED
  2.1015 +   * Function that will be called instead of the internal progress display
  2.1016 +   * function. This function should be defined as the curl_progress_callback
  2.1017 +   * prototype defines. */
  2.1018 +  CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
  2.1019 +
  2.1020 +  /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
  2.1021 +     callbacks */
  2.1022 +  CINIT(PROGRESSDATA, OBJECTPOINT, 57),
  2.1023 +#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA
  2.1024 +
  2.1025 +  /* We want the referrer field set automatically when following locations */
  2.1026 +  CINIT(AUTOREFERER, LONG, 58),
  2.1027 +
  2.1028 +  /* Port of the proxy, can be set in the proxy string as well with:
  2.1029 +     "[host]:[port]" */
  2.1030 +  CINIT(PROXYPORT, LONG, 59),
  2.1031 +
  2.1032 +  /* size of the POST input data, if strlen() is not good to use */
  2.1033 +  CINIT(POSTFIELDSIZE, LONG, 60),
  2.1034 +
  2.1035 +  /* tunnel non-http operations through a HTTP proxy */
  2.1036 +  CINIT(HTTPPROXYTUNNEL, LONG, 61),
  2.1037 +
  2.1038 +  /* Set the interface string to use as outgoing network interface */
  2.1039 +  CINIT(INTERFACE, OBJECTPOINT, 62),
  2.1040 +
  2.1041 +  /* Set the krb4/5 security level, this also enables krb4/5 awareness.  This
  2.1042 +   * is a string, 'clear', 'safe', 'confidential' or 'private'.  If the string
  2.1043 +   * is set but doesn't match one of these, 'private' will be used.  */
  2.1044 +  CINIT(KRBLEVEL, OBJECTPOINT, 63),
  2.1045 +
  2.1046 +  /* Set if we should verify the peer in ssl handshake, set 1 to verify. */
  2.1047 +  CINIT(SSL_VERIFYPEER, LONG, 64),
  2.1048 +
  2.1049 +  /* The CApath or CAfile used to validate the peer certificate
  2.1050 +     this option is used only if SSL_VERIFYPEER is true */
  2.1051 +  CINIT(CAINFO, OBJECTPOINT, 65),
  2.1052 +
  2.1053 +  /* 66 = OBSOLETE */
  2.1054 +  /* 67 = OBSOLETE */
  2.1055 +
  2.1056 +  /* Maximum number of http redirects to follow */
  2.1057 +  CINIT(MAXREDIRS, LONG, 68),
  2.1058 +
  2.1059 +  /* Pass a long set to 1 to get the date of the requested document (if
  2.1060 +     possible)! Pass a zero to shut it off. */
  2.1061 +  CINIT(FILETIME, LONG, 69),
  2.1062 +
  2.1063 +  /* This points to a linked list of telnet options */
  2.1064 +  CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
  2.1065 +
  2.1066 +  /* Max amount of cached alive connections */
  2.1067 +  CINIT(MAXCONNECTS, LONG, 71),
  2.1068 +
  2.1069 +  CINIT(OBSOLETE72, LONG, 72), /* OBSOLETE, do not use! */
  2.1070 +
  2.1071 +  /* 73 = OBSOLETE */
  2.1072 +
  2.1073 +  /* Set to explicitly use a new connection for the upcoming transfer.
  2.1074 +     Do not use this unless you're absolutely sure of this, as it makes the
  2.1075 +     operation slower and is less friendly for the network. */
  2.1076 +  CINIT(FRESH_CONNECT, LONG, 74),
  2.1077 +
  2.1078 +  /* Set to explicitly forbid the upcoming transfer's connection to be re-used
  2.1079 +     when done. Do not use this unless you're absolutely sure of this, as it
  2.1080 +     makes the operation slower and is less friendly for the network. */
  2.1081 +  CINIT(FORBID_REUSE, LONG, 75),
  2.1082 +
  2.1083 +  /* Set to a file name that contains random data for libcurl to use to
  2.1084 +     seed the random engine when doing SSL connects. */
  2.1085 +  CINIT(RANDOM_FILE, OBJECTPOINT, 76),
  2.1086 +
  2.1087 +  /* Set to the Entropy Gathering Daemon socket pathname */
  2.1088 +  CINIT(EGDSOCKET, OBJECTPOINT, 77),
  2.1089 +
  2.1090 +  /* Time-out connect operations after this amount of seconds, if connects are
  2.1091 +     OK within this time, then fine... This only aborts the connect phase. */
  2.1092 +  CINIT(CONNECTTIMEOUT, LONG, 78),
  2.1093 +
  2.1094 +  /* Function that will be called to store headers (instead of fwrite). The
  2.1095 +   * parameters will use fwrite() syntax, make sure to follow them. */
  2.1096 +  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
  2.1097 +
  2.1098 +  /* Set this to force the HTTP request to get back to GET. Only really usable
  2.1099 +     if POST, PUT or a custom request have been used first.
  2.1100 +   */
  2.1101 +  CINIT(HTTPGET, LONG, 80),
  2.1102 +
  2.1103 +  /* Set if we should verify the Common name from the peer certificate in ssl
  2.1104 +   * handshake, set 1 to check existence, 2 to ensure that it matches the
  2.1105 +   * provided hostname. */
  2.1106 +  CINIT(SSL_VERIFYHOST, LONG, 81),
  2.1107 +
  2.1108 +  /* Specify which file name to write all known cookies in after completed
  2.1109 +     operation. Set file name to "-" (dash) to make it go to stdout. */
  2.1110 +  CINIT(COOKIEJAR, OBJECTPOINT, 82),
  2.1111 +
  2.1112 +  /* Specify which SSL ciphers to use */
  2.1113 +  CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),
  2.1114 +
  2.1115 +  /* Specify which HTTP version to use! This must be set to one of the
  2.1116 +     CURL_HTTP_VERSION* enums set below. */
  2.1117 +  CINIT(HTTP_VERSION, LONG, 84),
  2.1118 +
  2.1119 +  /* Specifically switch on or off the FTP engine's use of the EPSV command. By
  2.1120 +     default, that one will always be attempted before the more traditional
  2.1121 +     PASV command. */
  2.1122 +  CINIT(FTP_USE_EPSV, LONG, 85),
  2.1123 +
  2.1124 +  /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
  2.1125 +  CINIT(SSLCERTTYPE, OBJECTPOINT, 86),
  2.1126 +
  2.1127 +  /* name of the file keeping your private SSL-key */
  2.1128 +  CINIT(SSLKEY, OBJECTPOINT, 87),
  2.1129 +
  2.1130 +  /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
  2.1131 +  CINIT(SSLKEYTYPE, OBJECTPOINT, 88),
  2.1132 +
  2.1133 +  /* crypto engine for the SSL-sub system */
  2.1134 +  CINIT(SSLENGINE, OBJECTPOINT, 89),
  2.1135 +
  2.1136 +  /* set the crypto engine for the SSL-sub system as default
  2.1137 +     the param has no meaning...
  2.1138 +   */
  2.1139 +  CINIT(SSLENGINE_DEFAULT, LONG, 90),
  2.1140 +
  2.1141 +  /* Non-zero value means to use the global dns cache */
  2.1142 +  CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */
  2.1143 +
  2.1144 +  /* DNS cache timeout */
  2.1145 +  CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
  2.1146 +
  2.1147 +  /* send linked-list of pre-transfer QUOTE commands */
  2.1148 +  CINIT(PREQUOTE, OBJECTPOINT, 93),
  2.1149 +
  2.1150 +  /* set the debug function */
  2.1151 +  CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
  2.1152 +
  2.1153 +  /* set the data for the debug function */
  2.1154 +  CINIT(DEBUGDATA, OBJECTPOINT, 95),
  2.1155 +
  2.1156 +  /* mark this as start of a cookie session */
  2.1157 +  CINIT(COOKIESESSION, LONG, 96),
  2.1158 +
  2.1159 +  /* The CApath directory used to validate the peer certificate
  2.1160 +     this option is used only if SSL_VERIFYPEER is true */
  2.1161 +  CINIT(CAPATH, OBJECTPOINT, 97),
  2.1162 +
  2.1163 +  /* Instruct libcurl to use a smaller receive buffer */
  2.1164 +  CINIT(BUFFERSIZE, LONG, 98),
  2.1165 +
  2.1166 +  /* Instruct libcurl to not use any signal/alarm handlers, even when using
  2.1167 +     timeouts. This option is useful for multi-threaded applications.
  2.1168 +     See libcurl-the-guide for more background information. */
  2.1169 +  CINIT(NOSIGNAL, LONG, 99),
  2.1170 +
  2.1171 +  /* Provide a CURLShare for mutexing non-ts data */
  2.1172 +  CINIT(SHARE, OBJECTPOINT, 100),
  2.1173 +
  2.1174 +  /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
  2.1175 +     CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */
  2.1176 +  CINIT(PROXYTYPE, LONG, 101),
  2.1177 +
  2.1178 +  /* Set the Accept-Encoding string. Use this to tell a server you would like
  2.1179 +     the response to be compressed. Before 7.21.6, this was known as
  2.1180 +     CURLOPT_ENCODING */
  2.1181 +  CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102),
  2.1182 +
  2.1183 +  /* Set pointer to private data */
  2.1184 +  CINIT(PRIVATE, OBJECTPOINT, 103),
  2.1185 +
  2.1186 +  /* Set aliases for HTTP 200 in the HTTP Response header */
  2.1187 +  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
  2.1188 +
  2.1189 +  /* Continue to send authentication (user+password) when following locations,
  2.1190 +     even when hostname changed. This can potentially send off the name
  2.1191 +     and password to whatever host the server decides. */
  2.1192 +  CINIT(UNRESTRICTED_AUTH, LONG, 105),
  2.1193 +
  2.1194 +  /* Specifically switch on or off the FTP engine's use of the EPRT command (
  2.1195 +     it also disables the LPRT attempt). By default, those ones will always be
  2.1196 +     attempted before the good old traditional PORT command. */
  2.1197 +  CINIT(FTP_USE_EPRT, LONG, 106),
  2.1198 +
  2.1199 +  /* Set this to a bitmask value to enable the particular authentications
  2.1200 +     methods you like. Use this in combination with CURLOPT_USERPWD.
  2.1201 +     Note that setting multiple bits may cause extra network round-trips. */
  2.1202 +  CINIT(HTTPAUTH, LONG, 107),
  2.1203 +
  2.1204 +  /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
  2.1205 +     in second argument. The function must be matching the
  2.1206 +     curl_ssl_ctx_callback proto. */
  2.1207 +  CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
  2.1208 +
  2.1209 +  /* Set the userdata for the ssl context callback function's third
  2.1210 +     argument */
  2.1211 +  CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
  2.1212 +
  2.1213 +  /* FTP Option that causes missing dirs to be created on the remote server.
  2.1214 +     In 7.19.4 we introduced the convenience enums for this option using the
  2.1215 +     CURLFTP_CREATE_DIR prefix.
  2.1216 +  */
  2.1217 +  CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
  2.1218 +
  2.1219 +  /* Set this to a bitmask value to enable the particular authentications
  2.1220 +     methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
  2.1221 +     Note that setting multiple bits may cause extra network round-trips. */
  2.1222 +  CINIT(PROXYAUTH, LONG, 111),
  2.1223 +
  2.1224 +  /* FTP option that changes the timeout, in seconds, associated with
  2.1225 +     getting a response.  This is different from transfer timeout time and
  2.1226 +     essentially places a demand on the FTP server to acknowledge commands
  2.1227 +     in a timely manner. */
  2.1228 +  CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
  2.1229 +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
  2.1230 +
  2.1231 +  /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
  2.1232 +     tell libcurl to resolve names to those IP versions only. This only has
  2.1233 +     affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
  2.1234 +  CINIT(IPRESOLVE, LONG, 113),
  2.1235 +
  2.1236 +  /* Set this option to limit the size of a file that will be downloaded from
  2.1237 +     an HTTP or FTP server.
  2.1238 +
  2.1239 +     Note there is also _LARGE version which adds large file support for
  2.1240 +     platforms which have larger off_t sizes.  See MAXFILESIZE_LARGE below. */
  2.1241 +  CINIT(MAXFILESIZE, LONG, 114),
  2.1242 +
  2.1243 +  /* See the comment for INFILESIZE above, but in short, specifies
  2.1244 +   * the size of the file being uploaded.  -1 means unknown.
  2.1245 +   */
  2.1246 +  CINIT(INFILESIZE_LARGE, OFF_T, 115),
  2.1247 +
  2.1248 +  /* Sets the continuation offset.  There is also a LONG version of this;
  2.1249 +   * look above for RESUME_FROM.
  2.1250 +   */
  2.1251 +  CINIT(RESUME_FROM_LARGE, OFF_T, 116),
  2.1252 +
  2.1253 +  /* Sets the maximum size of data that will be downloaded from
  2.1254 +   * an HTTP or FTP server.  See MAXFILESIZE above for the LONG version.
  2.1255 +   */
  2.1256 +  CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
  2.1257 +
  2.1258 +  /* Set this option to the file name of your .netrc file you want libcurl
  2.1259 +     to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
  2.1260 +     a poor attempt to find the user's home directory and check for a .netrc
  2.1261 +     file in there. */
  2.1262 +  CINIT(NETRC_FILE, OBJECTPOINT, 118),
  2.1263 +
  2.1264 +  /* Enable SSL/TLS for FTP, pick one of:
  2.1265 +     CURLUSESSL_TRY     - try using SSL, proceed anyway otherwise
  2.1266 +     CURLUSESSL_CONTROL - SSL for the control connection or fail
  2.1267 +     CURLUSESSL_ALL     - SSL for all communication or fail
  2.1268 +  */
  2.1269 +  CINIT(USE_SSL, LONG, 119),
  2.1270 +
  2.1271 +  /* The _LARGE version of the standard POSTFIELDSIZE option */
  2.1272 +  CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
  2.1273 +
  2.1274 +  /* Enable/disable the TCP Nagle algorithm */
  2.1275 +  CINIT(TCP_NODELAY, LONG, 121),
  2.1276 +
  2.1277 +  /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
  2.1278 +  /* 123 OBSOLETE. Gone in 7.16.0 */
  2.1279 +  /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
  2.1280 +  /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
  2.1281 +  /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
  2.1282 +  /* 127 OBSOLETE. Gone in 7.16.0 */
  2.1283 +  /* 128 OBSOLETE. Gone in 7.16.0 */
  2.1284 +
  2.1285 +  /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
  2.1286 +     can be used to change libcurl's default action which is to first try
  2.1287 +     "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
  2.1288 +     response has been received.
  2.1289 +
  2.1290 +     Available parameters are:
  2.1291 +     CURLFTPAUTH_DEFAULT - let libcurl decide
  2.1292 +     CURLFTPAUTH_SSL     - try "AUTH SSL" first, then TLS
  2.1293 +     CURLFTPAUTH_TLS     - try "AUTH TLS" first, then SSL
  2.1294 +  */
  2.1295 +  CINIT(FTPSSLAUTH, LONG, 129),
  2.1296 +
  2.1297 +  CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
  2.1298 +  CINIT(IOCTLDATA, OBJECTPOINT, 131),
  2.1299 +
  2.1300 +  /* 132 OBSOLETE. Gone in 7.16.0 */
  2.1301 +  /* 133 OBSOLETE. Gone in 7.16.0 */
  2.1302 +
  2.1303 +  /* zero terminated string for pass on to the FTP server when asked for
  2.1304 +     "account" info */
  2.1305 +  CINIT(FTP_ACCOUNT, OBJECTPOINT, 134),
  2.1306 +
  2.1307 +  /* feed cookies into cookie engine */
  2.1308 +  CINIT(COOKIELIST, OBJECTPOINT, 135),
  2.1309 +
  2.1310 +  /* ignore Content-Length */
  2.1311 +  CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
  2.1312 +
  2.1313 +  /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
  2.1314 +     response. Typically used for FTP-SSL purposes but is not restricted to
  2.1315 +     that. libcurl will then instead use the same IP address it used for the
  2.1316 +     control connection. */
  2.1317 +  CINIT(FTP_SKIP_PASV_IP, LONG, 137),
  2.1318 +
  2.1319 +  /* Select "file method" to use when doing FTP, see the curl_ftpmethod
  2.1320 +     above. */
  2.1321 +  CINIT(FTP_FILEMETHOD, LONG, 138),
  2.1322 +
  2.1323 +  /* Local port number to bind the socket to */
  2.1324 +  CINIT(LOCALPORT, LONG, 139),
  2.1325 +
  2.1326 +  /* Number of ports to try, including the first one set with LOCALPORT.
  2.1327 +     Thus, setting it to 1 will make no additional attempts but the first.
  2.1328 +  */
  2.1329 +  CINIT(LOCALPORTRANGE, LONG, 140),
  2.1330 +
  2.1331 +  /* no transfer, set up connection and let application use the socket by
  2.1332 +     extracting it with CURLINFO_LASTSOCKET */
  2.1333 +  CINIT(CONNECT_ONLY, LONG, 141),
  2.1334 +
  2.1335 +  /* Function that will be called to convert from the
  2.1336 +     network encoding (instead of using the iconv calls in libcurl) */
  2.1337 +  CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
  2.1338 +
  2.1339 +  /* Function that will be called to convert to the
  2.1340 +     network encoding (instead of using the iconv calls in libcurl) */
  2.1341 +  CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
  2.1342 +
  2.1343 +  /* Function that will be called to convert from UTF8
  2.1344 +     (instead of using the iconv calls in libcurl)
  2.1345 +     Note that this is used only for SSL certificate processing */
  2.1346 +  CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
  2.1347 +
  2.1348 +  /* if the connection proceeds too quickly then need to slow it down */
  2.1349 +  /* limit-rate: maximum number of bytes per second to send or receive */
  2.1350 +  CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
  2.1351 +  CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
  2.1352 +
  2.1353 +  /* Pointer to command string to send if USER/PASS fails. */
  2.1354 +  CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147),
  2.1355 +
  2.1356 +  /* callback function for setting socket options */
  2.1357 +  CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
  2.1358 +  CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
  2.1359 +
  2.1360 +  /* set to 0 to disable session ID re-use for this transfer, default is
  2.1361 +     enabled (== 1) */
  2.1362 +  CINIT(SSL_SESSIONID_CACHE, LONG, 150),
  2.1363 +
  2.1364 +  /* allowed SSH authentication methods */
  2.1365 +  CINIT(SSH_AUTH_TYPES, LONG, 151),
  2.1366 +
  2.1367 +  /* Used by scp/sftp to do public/private key authentication */
  2.1368 +  CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152),
  2.1369 +  CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153),
  2.1370 +
  2.1371 +  /* Send CCC (Clear Command Channel) after authentication */
  2.1372 +  CINIT(FTP_SSL_CCC, LONG, 154),
  2.1373 +
  2.1374 +  /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
  2.1375 +  CINIT(TIMEOUT_MS, LONG, 155),
  2.1376 +  CINIT(CONNECTTIMEOUT_MS, LONG, 156),
  2.1377 +
  2.1378 +  /* set to zero to disable the libcurl's decoding and thus pass the raw body
  2.1379 +     data to the application even when it is encoded/compressed */
  2.1380 +  CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
  2.1381 +  CINIT(HTTP_CONTENT_DECODING, LONG, 158),
  2.1382 +
  2.1383 +  /* Permission used when creating new files and directories on the remote
  2.1384 +     server for protocols that support it, SFTP/SCP/FILE */
  2.1385 +  CINIT(NEW_FILE_PERMS, LONG, 159),
  2.1386 +  CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
  2.1387 +
  2.1388 +  /* Set the behaviour of POST when redirecting. Values must be set to one
  2.1389 +     of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
  2.1390 +  CINIT(POSTREDIR, LONG, 161),
  2.1391 +
  2.1392 +  /* used by scp/sftp to verify the host's public key */
  2.1393 +  CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162),
  2.1394 +
  2.1395 +  /* Callback function for opening socket (instead of socket(2)). Optionally,
  2.1396 +     callback is able change the address or refuse to connect returning
  2.1397 +     CURL_SOCKET_BAD.  The callback should have type
  2.1398 +     curl_opensocket_callback */
  2.1399 +  CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
  2.1400 +  CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
  2.1401 +
  2.1402 +  /* POST volatile input fields. */
  2.1403 +  CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
  2.1404 +
  2.1405 +  /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */
  2.1406 +  CINIT(PROXY_TRANSFER_MODE, LONG, 166),
  2.1407 +
  2.1408 +  /* Callback function for seeking in the input stream */
  2.1409 +  CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
  2.1410 +  CINIT(SEEKDATA, OBJECTPOINT, 168),
  2.1411 +
  2.1412 +  /* CRL file */
  2.1413 +  CINIT(CRLFILE, OBJECTPOINT, 169),
  2.1414 +
  2.1415 +  /* Issuer certificate */
  2.1416 +  CINIT(ISSUERCERT, OBJECTPOINT, 170),
  2.1417 +
  2.1418 +  /* (IPv6) Address scope */
  2.1419 +  CINIT(ADDRESS_SCOPE, LONG, 171),
  2.1420 +
  2.1421 +  /* Collect certificate chain info and allow it to get retrievable with
  2.1422 +     CURLINFO_CERTINFO after the transfer is complete. */
  2.1423 +  CINIT(CERTINFO, LONG, 172),
  2.1424 +
  2.1425 +  /* "name" and "pwd" to use when fetching. */
  2.1426 +  CINIT(USERNAME, OBJECTPOINT, 173),
  2.1427 +  CINIT(PASSWORD, OBJECTPOINT, 174),
  2.1428 +
  2.1429 +    /* "name" and "pwd" to use with Proxy when fetching. */
  2.1430 +  CINIT(PROXYUSERNAME, OBJECTPOINT, 175),
  2.1431 +  CINIT(PROXYPASSWORD, OBJECTPOINT, 176),
  2.1432 +
  2.1433 +  /* Comma separated list of hostnames defining no-proxy zones. These should
  2.1434 +     match both hostnames directly, and hostnames within a domain. For
  2.1435 +     example, local.com will match local.com and www.local.com, but NOT
  2.1436 +     notlocal.com or www.notlocal.com. For compatibility with other
  2.1437 +     implementations of this, .local.com will be considered to be the same as
  2.1438 +     local.com. A single * is the only valid wildcard, and effectively
  2.1439 +     disables the use of proxy. */
  2.1440 +  CINIT(NOPROXY, OBJECTPOINT, 177),
  2.1441 +
  2.1442 +  /* block size for TFTP transfers */
  2.1443 +  CINIT(TFTP_BLKSIZE, LONG, 178),
  2.1444 +
  2.1445 +  /* Socks Service */
  2.1446 +  CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179),
  2.1447 +
  2.1448 +  /* Socks Service */
  2.1449 +  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
  2.1450 +
  2.1451 +  /* set the bitmask for the protocols that are allowed to be used for the
  2.1452 +     transfer, which thus helps the app which takes URLs from users or other
  2.1453 +     external inputs and want to restrict what protocol(s) to deal
  2.1454 +     with. Defaults to CURLPROTO_ALL. */
  2.1455 +  CINIT(PROTOCOLS, LONG, 181),
  2.1456 +
  2.1457 +  /* set the bitmask for the protocols that libcurl is allowed to follow to,
  2.1458 +     as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
  2.1459 +     to be set in both bitmasks to be allowed to get redirected to. Defaults
  2.1460 +     to all protocols except FILE and SCP. */
  2.1461 +  CINIT(REDIR_PROTOCOLS, LONG, 182),
  2.1462 +
  2.1463 +  /* set the SSH knownhost file name to use */
  2.1464 +  CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183),
  2.1465 +
  2.1466 +  /* set the SSH host key callback, must point to a curl_sshkeycallback
  2.1467 +     function */
  2.1468 +  CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
  2.1469 +
  2.1470 +  /* set the SSH host key callback custom pointer */
  2.1471 +  CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
  2.1472 +
  2.1473 +  /* set the SMTP mail originator */
  2.1474 +  CINIT(MAIL_FROM, OBJECTPOINT, 186),
  2.1475 +
  2.1476 +  /* set the SMTP mail receiver(s) */
  2.1477 +  CINIT(MAIL_RCPT, OBJECTPOINT, 187),
  2.1478 +
  2.1479 +  /* FTP: send PRET before PASV */
  2.1480 +  CINIT(FTP_USE_PRET, LONG, 188),
  2.1481 +
  2.1482 +  /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
  2.1483 +  CINIT(RTSP_REQUEST, LONG, 189),
  2.1484 +
  2.1485 +  /* The RTSP session identifier */
  2.1486 +  CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190),
  2.1487 +
  2.1488 +  /* The RTSP stream URI */
  2.1489 +  CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191),
  2.1490 +
  2.1491 +  /* The Transport: header to use in RTSP requests */
  2.1492 +  CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192),
  2.1493 +
  2.1494 +  /* Manually initialize the client RTSP CSeq for this handle */
  2.1495 +  CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
  2.1496 +
  2.1497 +  /* Manually initialize the server RTSP CSeq for this handle */
  2.1498 +  CINIT(RTSP_SERVER_CSEQ, LONG, 194),
  2.1499 +
  2.1500 +  /* The stream to pass to INTERLEAVEFUNCTION. */
  2.1501 +  CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
  2.1502 +
  2.1503 +  /* Let the application define a custom write method for RTP data */
  2.1504 +  CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
  2.1505 +
  2.1506 +  /* Turn on wildcard matching */
  2.1507 +  CINIT(WILDCARDMATCH, LONG, 197),
  2.1508 +
  2.1509 +  /* Directory matching callback called before downloading of an
  2.1510 +     individual file (chunk) started */
  2.1511 +  CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),
  2.1512 +
  2.1513 +  /* Directory matching callback called after the file (chunk)
  2.1514 +     was downloaded, or skipped */
  2.1515 +  CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),
  2.1516 +
  2.1517 +  /* Change match (fnmatch-like) callback for wildcard matching */
  2.1518 +  CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),
  2.1519 +
  2.1520 +  /* Let the application define custom chunk data pointer */
  2.1521 +  CINIT(CHUNK_DATA, OBJECTPOINT, 201),
  2.1522 +
  2.1523 +  /* FNMATCH_FUNCTION user pointer */
  2.1524 +  CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
  2.1525 +
  2.1526 +  /* send linked-list of name:port:address sets */
  2.1527 +  CINIT(RESOLVE, OBJECTPOINT, 203),
  2.1528 +
  2.1529 +  /* Set a username for authenticated TLS */
  2.1530 +  CINIT(TLSAUTH_USERNAME, OBJECTPOINT, 204),
  2.1531 +
  2.1532 +  /* Set a password for authenticated TLS */
  2.1533 +  CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205),
  2.1534 +
  2.1535 +  /* Set authentication type for authenticated TLS */
  2.1536 +  CINIT(TLSAUTH_TYPE, OBJECTPOINT, 206),
  2.1537 +
  2.1538 +  /* Set to 1 to enable the "TE:" header in HTTP requests to ask for
  2.1539 +     compressed transfer-encoded responses. Set to 0 to disable the use of TE:
  2.1540 +     in outgoing requests. The current default is 0, but it might change in a
  2.1541 +     future libcurl release.
  2.1542 +
  2.1543 +     libcurl will ask for the compressed methods it knows of, and if that
  2.1544 +     isn't any, it will not ask for transfer-encoding at all even if this
  2.1545 +     option is set to 1.
  2.1546 +
  2.1547 +  */
  2.1548 +  CINIT(TRANSFER_ENCODING, LONG, 207),
  2.1549 +
  2.1550 +  /* Callback function for closing socket (instead of close(2)). The callback
  2.1551 +     should have type curl_closesocket_callback */
  2.1552 +  CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),
  2.1553 +  CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),
  2.1554 +
  2.1555 +  /* allow GSSAPI credential delegation */
  2.1556 +  CINIT(GSSAPI_DELEGATION, LONG, 210),
  2.1557 +
  2.1558 +  /* Set the name servers to use for DNS resolution */
  2.1559 +  CINIT(DNS_SERVERS, OBJECTPOINT, 211),
  2.1560 +
  2.1561 +  /* Time-out accept operations (currently for FTP only) after this amount
  2.1562 +     of miliseconds. */
  2.1563 +  CINIT(ACCEPTTIMEOUT_MS, LONG, 212),
  2.1564 +
  2.1565 +  /* Set TCP keepalive */
  2.1566 +  CINIT(TCP_KEEPALIVE, LONG, 213),
  2.1567 +
  2.1568 +  /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */
  2.1569 +  CINIT(TCP_KEEPIDLE, LONG, 214),
  2.1570 +  CINIT(TCP_KEEPINTVL, LONG, 215),
  2.1571 +
  2.1572 +  /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */
  2.1573 +  CINIT(SSL_OPTIONS, LONG, 216),
  2.1574 +
  2.1575 +  /* Set the SMTP auth originator */
  2.1576 +  CINIT(MAIL_AUTH, OBJECTPOINT, 217),
  2.1577 +
  2.1578 +  /* Enable/disable SASL initial response */
  2.1579 +  CINIT(SASL_IR, LONG, 218),
  2.1580 +
  2.1581 +  /* Function that will be called instead of the internal progress display
  2.1582 +   * function. This function should be defined as the curl_xferinfo_callback
  2.1583 +   * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */
  2.1584 +  CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219),
  2.1585 +
  2.1586 +  /* The XOAUTH2 bearer token */
  2.1587 +  CINIT(XOAUTH2_BEARER, OBJECTPOINT, 220),
  2.1588 +
  2.1589 +  /* Set the interface string to use as outgoing network
  2.1590 +   * interface for DNS requests.
  2.1591 +   * Only supported by the c-ares DNS backend */
  2.1592 +  CINIT(DNS_INTERFACE, OBJECTPOINT, 221),
  2.1593 +
  2.1594 +  /* Set the local IPv4 address to use for outgoing DNS requests.
  2.1595 +   * Only supported by the c-ares DNS backend */
  2.1596 +  CINIT(DNS_LOCAL_IP4, OBJECTPOINT, 222),
  2.1597 +
  2.1598 +  /* Set the local IPv4 address to use for outgoing DNS requests.
  2.1599 +   * Only supported by the c-ares DNS backend */
  2.1600 +  CINIT(DNS_LOCAL_IP6, OBJECTPOINT, 223),
  2.1601 +
  2.1602 +  /* Set authentication options directly */
  2.1603 +  CINIT(LOGIN_OPTIONS, OBJECTPOINT, 224),
  2.1604 +
  2.1605 +  /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */
  2.1606 +  CINIT(SSL_ENABLE_NPN, LONG, 225),
  2.1607 +
  2.1608 +  /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */
  2.1609 +  CINIT(SSL_ENABLE_ALPN, LONG, 226),
  2.1610 +
  2.1611 +  /* Time to wait for a response to a HTTP request containing an
  2.1612 +   * Expect: 100-continue header before sending the data anyway. */
  2.1613 +  CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227),
  2.1614 +
  2.1615 +  /* This points to a linked list of headers used for proxy requests only,
  2.1616 +     struct curl_slist kind */
  2.1617 +  CINIT(PROXYHEADER, OBJECTPOINT, 228),
  2.1618 +
  2.1619 +  /* Pass in a bitmask of "header options" */
  2.1620 +  CINIT(HEADEROPT, LONG, 229),
  2.1621 +
  2.1622 +  /* The public key in DER form used to validate the peer public key
  2.1623 +     this option is used only if SSL_VERIFYPEER is true */
  2.1624 +  CINIT(PINNEDPUBLICKEY, OBJECTPOINT, 230),
  2.1625 +
  2.1626 +  /* Path to Unix domain socket */
  2.1627 +  CINIT(UNIX_SOCKET_PATH, OBJECTPOINT, 231),
  2.1628 +
  2.1629 +  /* Set if we should verify the certificate status. */
  2.1630 +  CINIT(SSL_VERIFYSTATUS, LONG, 232),
  2.1631 +
  2.1632 +  /* Set if we should enable TLS false start. */
  2.1633 +  CINIT(SSL_FALSESTART, LONG, 233),
  2.1634 +
  2.1635 +  /* Do not squash dot-dot sequences */
  2.1636 +  CINIT(PATH_AS_IS, LONG, 234),
  2.1637 +
  2.1638 +  /* Proxy Service Name */
  2.1639 +  CINIT(PROXY_SERVICE_NAME, OBJECTPOINT, 235),
  2.1640 +
  2.1641 +  /* Service Name */
  2.1642 +  CINIT(SERVICE_NAME, OBJECTPOINT, 236),
  2.1643 +
  2.1644 +  /* Wait/don't wait for pipe/mutex to clarify */
  2.1645 +  CINIT(PIPEWAIT, LONG, 237),
  2.1646 +
  2.1647 +  CURLOPT_LASTENTRY /* the last unused */
  2.1648 +} CURLoption;
  2.1649 +
  2.1650 +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
  2.1651 +                          the obsolete stuff removed! */
  2.1652 +
  2.1653 +/* Backwards compatibility with older names */
  2.1654 +/* These are scheduled to disappear by 2011 */
  2.1655 +
  2.1656 +/* This was added in version 7.19.1 */
  2.1657 +#define CURLOPT_POST301 CURLOPT_POSTREDIR
  2.1658 +
  2.1659 +/* These are scheduled to disappear by 2009 */
  2.1660 +
  2.1661 +/* The following were added in 7.17.0 */
  2.1662 +#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
  2.1663 +#define CURLOPT_FTPAPPEND CURLOPT_APPEND
  2.1664 +#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
  2.1665 +#define CURLOPT_FTP_SSL CURLOPT_USE_SSL
  2.1666 +
  2.1667 +/* The following were added earlier */
  2.1668 +
  2.1669 +#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
  2.1670 +#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
  2.1671 +
  2.1672 +#else
  2.1673 +/* This is set if CURL_NO_OLDIES is defined at compile-time */
  2.1674 +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */
  2.1675 +#endif
  2.1676 +
  2.1677 +
  2.1678 +  /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
  2.1679 +     name resolves addresses using more than one IP protocol version, this
  2.1680 +     option might be handy to force libcurl to use a specific IP version. */
  2.1681 +#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
  2.1682 +                                     versions that your system allows */
  2.1683 +#define CURL_IPRESOLVE_V4       1 /* resolve to IPv4 addresses */
  2.1684 +#define CURL_IPRESOLVE_V6       2 /* resolve to IPv6 addresses */
  2.1685 +
  2.1686 +  /* three convenient "aliases" that follow the name scheme better */
  2.1687 +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
  2.1688 +
  2.1689 +  /* These enums are for use with the CURLOPT_HTTP_VERSION option. */
  2.1690 +enum {
  2.1691 +  CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
  2.1692 +                             like the library to choose the best possible
  2.1693 +                             for us! */
  2.1694 +  CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */
  2.1695 +  CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */
  2.1696 +  CURL_HTTP_VERSION_2_0,  /* please use HTTP 2.0 in the request */
  2.1697 +
  2.1698 +  CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
  2.1699 +};
  2.1700 +
  2.1701 +/* Convenience definition simple because the name of the version is HTTP/2 and
  2.1702 +   not 2.0. The 2_0 version of the enum name was set while the version was
  2.1703 +   still planned to be 2.0 and we stick to it for compatibility. */
  2.1704 +#define CURL_HTTP_VERSION_2 CURL_HTTP_VERSION_2_0
  2.1705 +
  2.1706 +/*
  2.1707 + * Public API enums for RTSP requests
  2.1708 + */
  2.1709 +enum {
  2.1710 +    CURL_RTSPREQ_NONE, /* first in list */
  2.1711 +    CURL_RTSPREQ_OPTIONS,
  2.1712 +    CURL_RTSPREQ_DESCRIBE,
  2.1713 +    CURL_RTSPREQ_ANNOUNCE,
  2.1714 +    CURL_RTSPREQ_SETUP,
  2.1715 +    CURL_RTSPREQ_PLAY,
  2.1716 +    CURL_RTSPREQ_PAUSE,
  2.1717 +    CURL_RTSPREQ_TEARDOWN,
  2.1718 +    CURL_RTSPREQ_GET_PARAMETER,
  2.1719 +    CURL_RTSPREQ_SET_PARAMETER,
  2.1720 +    CURL_RTSPREQ_RECORD,
  2.1721 +    CURL_RTSPREQ_RECEIVE,
  2.1722 +    CURL_RTSPREQ_LAST /* last in list */
  2.1723 +};
  2.1724 +
  2.1725 +  /* These enums are for use with the CURLOPT_NETRC option. */
  2.1726 +enum CURL_NETRC_OPTION {
  2.1727 +  CURL_NETRC_IGNORED,     /* The .netrc will never be read.
  2.1728 +                           * This is the default. */
  2.1729 +  CURL_NETRC_OPTIONAL,    /* A user:password in the URL will be preferred
  2.1730 +                           * to one in the .netrc. */
  2.1731 +  CURL_NETRC_REQUIRED,    /* A user:password in the URL will be ignored.
  2.1732 +                           * Unless one is set programmatically, the .netrc
  2.1733 +                           * will be queried. */
  2.1734 +  CURL_NETRC_LAST
  2.1735 +};
  2.1736 +
  2.1737 +enum {
  2.1738 +  CURL_SSLVERSION_DEFAULT,
  2.1739 +  CURL_SSLVERSION_TLSv1, /* TLS 1.x */
  2.1740 +  CURL_SSLVERSION_SSLv2,
  2.1741 +  CURL_SSLVERSION_SSLv3,
  2.1742 +  CURL_SSLVERSION_TLSv1_0,
  2.1743 +  CURL_SSLVERSION_TLSv1_1,
  2.1744 +  CURL_SSLVERSION_TLSv1_2,
  2.1745 +
  2.1746 +  CURL_SSLVERSION_LAST /* never use, keep last */
  2.1747 +};
  2.1748 +
  2.1749 +enum CURL_TLSAUTH {
  2.1750 +  CURL_TLSAUTH_NONE,
  2.1751 +  CURL_TLSAUTH_SRP,
  2.1752 +  CURL_TLSAUTH_LAST /* never use, keep last */
  2.1753 +};
  2.1754 +
  2.1755 +/* symbols to use with CURLOPT_POSTREDIR.
  2.1756 +   CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303
  2.1757 +   can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302
  2.1758 +   | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */
  2.1759 +
  2.1760 +#define CURL_REDIR_GET_ALL  0
  2.1761 +#define CURL_REDIR_POST_301 1
  2.1762 +#define CURL_REDIR_POST_302 2
  2.1763 +#define CURL_REDIR_POST_303 4
  2.1764 +#define CURL_REDIR_POST_ALL \
  2.1765 +    (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303)
  2.1766 +
  2.1767 +typedef enum {
  2.1768 +  CURL_TIMECOND_NONE,
  2.1769 +
  2.1770 +  CURL_TIMECOND_IFMODSINCE,
  2.1771 +  CURL_TIMECOND_IFUNMODSINCE,
  2.1772 +  CURL_TIMECOND_LASTMOD,
  2.1773 +
  2.1774 +  CURL_TIMECOND_LAST
  2.1775 +} curl_TimeCond;
  2.1776 +
  2.1777 +
  2.1778 +/* curl_strequal() and curl_strnequal() are subject for removal in a future
  2.1779 +   libcurl, see lib/README.curlx for details */
  2.1780 +CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);
  2.1781 +CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);
  2.1782 +
  2.1783 +/* name is uppercase CURLFORM_<name> */
  2.1784 +#ifdef CFINIT
  2.1785 +#undef CFINIT
  2.1786 +#endif
  2.1787 +
  2.1788 +#ifdef CURL_ISOCPP
  2.1789 +#define CFINIT(name) CURLFORM_ ## name
  2.1790 +#else
  2.1791 +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
  2.1792 +#define CFINIT(name) CURLFORM_/**/name
  2.1793 +#endif
  2.1794 +
  2.1795 +typedef enum {
  2.1796 +  CFINIT(NOTHING),        /********* the first one is unused ************/
  2.1797 +
  2.1798 +  /*  */
  2.1799 +  CFINIT(COPYNAME),
  2.1800 +  CFINIT(PTRNAME),
  2.1801 +  CFINIT(NAMELENGTH),
  2.1802 +  CFINIT(COPYCONTENTS),
  2.1803 +  CFINIT(PTRCONTENTS),
  2.1804 +  CFINIT(CONTENTSLENGTH),
  2.1805 +  CFINIT(FILECONTENT),
  2.1806 +  CFINIT(ARRAY),
  2.1807 +  CFINIT(OBSOLETE),
  2.1808 +  CFINIT(FILE),
  2.1809 +
  2.1810 +  CFINIT(BUFFER),
  2.1811 +  CFINIT(BUFFERPTR),
  2.1812 +  CFINIT(BUFFERLENGTH),
  2.1813 +
  2.1814 +  CFINIT(CONTENTTYPE),
  2.1815 +  CFINIT(CONTENTHEADER),
  2.1816 +  CFINIT(FILENAME),
  2.1817 +  CFINIT(END),
  2.1818 +  CFINIT(OBSOLETE2),
  2.1819 +
  2.1820 +  CFINIT(STREAM),
  2.1821 +
  2.1822 +  CURLFORM_LASTENTRY /* the last unused */
  2.1823 +} CURLformoption;
  2.1824 +
  2.1825 +#undef CFINIT /* done */
  2.1826 +
  2.1827 +/* structure to be used as parameter for CURLFORM_ARRAY */
  2.1828 +struct curl_forms {
  2.1829 +  CURLformoption option;
  2.1830 +  const char     *value;
  2.1831 +};
  2.1832 +
  2.1833 +/* use this for multipart formpost building */
  2.1834 +/* Returns code for curl_formadd()
  2.1835 + *
  2.1836 + * Returns:
  2.1837 + * CURL_FORMADD_OK             on success
  2.1838 + * CURL_FORMADD_MEMORY         if the FormInfo allocation fails
  2.1839 + * CURL_FORMADD_OPTION_TWICE   if one option is given twice for one Form
  2.1840 + * CURL_FORMADD_NULL           if a null pointer was given for a char
  2.1841 + * CURL_FORMADD_MEMORY         if the allocation of a FormInfo struct failed
  2.1842 + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
  2.1843 + * CURL_FORMADD_INCOMPLETE     if the some FormInfo is not complete (or error)
  2.1844 + * CURL_FORMADD_MEMORY         if a curl_httppost struct cannot be allocated
  2.1845 + * CURL_FORMADD_MEMORY         if some allocation for string copying failed.
  2.1846 + * CURL_FORMADD_ILLEGAL_ARRAY  if an illegal option is used in an array
  2.1847 + *
  2.1848 + ***************************************************************************/
  2.1849 +typedef enum {
  2.1850 +  CURL_FORMADD_OK, /* first, no error */
  2.1851 +
  2.1852 +  CURL_FORMADD_MEMORY,
  2.1853 +  CURL_FORMADD_OPTION_TWICE,
  2.1854 +  CURL_FORMADD_NULL,
  2.1855 +  CURL_FORMADD_UNKNOWN_OPTION,
  2.1856 +  CURL_FORMADD_INCOMPLETE,
  2.1857 +  CURL_FORMADD_ILLEGAL_ARRAY,
  2.1858 +  CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
  2.1859 +
  2.1860 +  CURL_FORMADD_LAST /* last */
  2.1861 +} CURLFORMcode;
  2.1862 +
  2.1863 +/*
  2.1864 + * NAME curl_formadd()
  2.1865 + *
  2.1866 + * DESCRIPTION
  2.1867 + *
  2.1868 + * Pretty advanced function for building multi-part formposts. Each invoke
  2.1869 + * adds one part that together construct a full post. Then use
  2.1870 + * CURLOPT_HTTPPOST to send it off to libcurl.
  2.1871 + */
  2.1872 +CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,
  2.1873 +                                      struct curl_httppost **last_post,
  2.1874 +                                      ...);
  2.1875 +
  2.1876 +/*
  2.1877 + * callback function for curl_formget()
  2.1878 + * The void *arg pointer will be the one passed as second argument to
  2.1879 + *   curl_formget().
  2.1880 + * The character buffer passed to it must not be freed.
  2.1881 + * Should return the buffer length passed to it as the argument "len" on
  2.1882 + *   success.
  2.1883 + */
  2.1884 +typedef size_t (*curl_formget_callback)(void *arg, const char *buf,
  2.1885 +                                        size_t len);
  2.1886 +
  2.1887 +/*
  2.1888 + * NAME curl_formget()
  2.1889 + *
  2.1890 + * DESCRIPTION
  2.1891 + *
  2.1892 + * Serialize a curl_httppost struct built with curl_formadd().
  2.1893 + * Accepts a void pointer as second argument which will be passed to
  2.1894 + * the curl_formget_callback function.
  2.1895 + * Returns 0 on success.
  2.1896 + */
  2.1897 +CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,
  2.1898 +                             curl_formget_callback append);
  2.1899 +/*
  2.1900 + * NAME curl_formfree()
  2.1901 + *
  2.1902 + * DESCRIPTION
  2.1903 + *
  2.1904 + * Free a multipart formpost previously built with curl_formadd().
  2.1905 + */
  2.1906 +CURL_EXTERN void curl_formfree(struct curl_httppost *form);
  2.1907 +
  2.1908 +/*
  2.1909 + * NAME curl_getenv()
  2.1910 + *
  2.1911 + * DESCRIPTION
  2.1912 + *
  2.1913 + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is
  2.1914 + * complete. DEPRECATED - see lib/README.curlx
  2.1915 + */
  2.1916 +CURL_EXTERN char *curl_getenv(const char *variable);
  2.1917 +
  2.1918 +/*
  2.1919 + * NAME curl_version()
  2.1920 + *
  2.1921 + * DESCRIPTION
  2.1922 + *
  2.1923 + * Returns a static ascii string of the libcurl version.
  2.1924 + */
  2.1925 +CURL_EXTERN char *curl_version(void);
  2.1926 +
  2.1927 +/*
  2.1928 + * NAME curl_easy_escape()
  2.1929 + *
  2.1930 + * DESCRIPTION
  2.1931 + *
  2.1932 + * Escapes URL strings (converts all letters consider illegal in URLs to their
  2.1933 + * %XX versions). This function returns a new allocated string or NULL if an
  2.1934 + * error occurred.
  2.1935 + */
  2.1936 +CURL_EXTERN char *curl_easy_escape(CURL *handle,
  2.1937 +                                   const char *string,
  2.1938 +                                   int length);
  2.1939 +
  2.1940 +/* the previous version: */
  2.1941 +CURL_EXTERN char *curl_escape(const char *string,
  2.1942 +                              int length);
  2.1943 +
  2.1944 +
  2.1945 +/*
  2.1946 + * NAME curl_easy_unescape()
  2.1947 + *
  2.1948 + * DESCRIPTION
  2.1949 + *
  2.1950 + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit
  2.1951 + * versions). This function returns a new allocated string or NULL if an error
  2.1952 + * occurred.
  2.1953 + * Conversion Note: On non-ASCII platforms the ASCII %XX codes are
  2.1954 + * converted into the host encoding.
  2.1955 + */
  2.1956 +CURL_EXTERN char *curl_easy_unescape(CURL *handle,
  2.1957 +                                     const char *string,
  2.1958 +                                     int length,
  2.1959 +                                     int *outlength);
  2.1960 +
  2.1961 +/* the previous version */
  2.1962 +CURL_EXTERN char *curl_unescape(const char *string,
  2.1963 +                                int length);
  2.1964 +
  2.1965 +/*
  2.1966 + * NAME curl_free()
  2.1967 + *
  2.1968 + * DESCRIPTION
  2.1969 + *
  2.1970 + * Provided for de-allocation in the same translation unit that did the
  2.1971 + * allocation. Added in libcurl 7.10
  2.1972 + */
  2.1973 +CURL_EXTERN void curl_free(void *p);
  2.1974 +
  2.1975 +/*
  2.1976 + * NAME curl_global_init()
  2.1977 + *
  2.1978 + * DESCRIPTION
  2.1979 + *
  2.1980 + * curl_global_init() should be invoked exactly once for each application that
  2.1981 + * uses libcurl and before any call of other libcurl functions.
  2.1982 + *
  2.1983 + * This function is not thread-safe!
  2.1984 + */
  2.1985 +CURL_EXTERN CURLcode curl_global_init(long flags);
  2.1986 +
  2.1987 +/*
  2.1988 + * NAME curl_global_init_mem()
  2.1989 + *
  2.1990 + * DESCRIPTION
  2.1991 + *
  2.1992 + * curl_global_init() or curl_global_init_mem() should be invoked exactly once
  2.1993 + * for each application that uses libcurl.  This function can be used to
  2.1994 + * initialize libcurl and set user defined memory management callback
  2.1995 + * functions.  Users can implement memory management routines to check for
  2.1996 + * memory leaks, check for mis-use of the curl library etc.  User registered
  2.1997 + * callback routines with be invoked by this library instead of the system
  2.1998 + * memory management routines like malloc, free etc.
  2.1999 + */
  2.2000 +CURL_EXTERN CURLcode curl_global_init_mem(long flags,
  2.2001 +                                          curl_malloc_callback m,
  2.2002 +                                          curl_free_callback f,
  2.2003 +                                          curl_realloc_callback r,
  2.2004 +                                          curl_strdup_callback s,
  2.2005 +                                          curl_calloc_callback c);
  2.2006 +
  2.2007 +/*
  2.2008 + * NAME curl_global_cleanup()
  2.2009 + *
  2.2010 + * DESCRIPTION
  2.2011 + *
  2.2012 + * curl_global_cleanup() should be invoked exactly once for each application
  2.2013 + * that uses libcurl
  2.2014 + */
  2.2015 +CURL_EXTERN void curl_global_cleanup(void);
  2.2016 +
  2.2017 +/* linked-list structure for the CURLOPT_QUOTE option (and other) */
  2.2018 +struct curl_slist {
  2.2019 +  char *data;
  2.2020 +  struct curl_slist *next;
  2.2021 +};
  2.2022 +
  2.2023 +/*
  2.2024 + * NAME curl_slist_append()
  2.2025 + *
  2.2026 + * DESCRIPTION
  2.2027 + *
  2.2028 + * Appends a string to a linked list. If no list exists, it will be created
  2.2029 + * first. Returns the new list, after appending.
  2.2030 + */
  2.2031 +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,
  2.2032 +                                                 const char *);
  2.2033 +
  2.2034 +/*
  2.2035 + * NAME curl_slist_free_all()
  2.2036 + *
  2.2037 + * DESCRIPTION
  2.2038 + *
  2.2039 + * free a previously built curl_slist.
  2.2040 + */
  2.2041 +CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
  2.2042 +
  2.2043 +/*
  2.2044 + * NAME curl_getdate()
  2.2045 + *
  2.2046 + * DESCRIPTION
  2.2047 + *
  2.2048 + * Returns the time, in seconds since 1 Jan 1970 of the time string given in
  2.2049 + * the first argument. The time argument in the second parameter is unused
  2.2050 + * and should be set to NULL.
  2.2051 + */
  2.2052 +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);
  2.2053 +
  2.2054 +/* info about the certificate chain, only for OpenSSL builds. Asked
  2.2055 +   for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */
  2.2056 +struct curl_certinfo {
  2.2057 +  int num_of_certs;             /* number of certificates with information */
  2.2058 +  struct curl_slist **certinfo; /* for each index in this array, there's a
  2.2059 +                                   linked list with textual information in the
  2.2060 +                                   format "name: value" */
  2.2061 +};
  2.2062 +
  2.2063 +/* enum for the different supported SSL backends */
  2.2064 +typedef enum {
  2.2065 +  CURLSSLBACKEND_NONE = 0,
  2.2066 +  CURLSSLBACKEND_OPENSSL = 1,
  2.2067 +  CURLSSLBACKEND_GNUTLS = 2,
  2.2068 +  CURLSSLBACKEND_NSS = 3,
  2.2069 +  CURLSSLBACKEND_OBSOLETE4 = 4,  /* Was QSOSSL. */
  2.2070 +  CURLSSLBACKEND_GSKIT = 5,
  2.2071 +  CURLSSLBACKEND_POLARSSL = 6,
  2.2072 +  CURLSSLBACKEND_CYASSL = 7,
  2.2073 +  CURLSSLBACKEND_SCHANNEL = 8,
  2.2074 +  CURLSSLBACKEND_DARWINSSL = 9,
  2.2075 +  CURLSSLBACKEND_AXTLS = 10
  2.2076 +} curl_sslbackend;
  2.2077 +
  2.2078 +/* Information about the SSL library used and the respective internal SSL
  2.2079 +   handle, which can be used to obtain further information regarding the
  2.2080 +   connection. Asked for with CURLINFO_TLS_SESSION. */
  2.2081 +struct curl_tlssessioninfo {
  2.2082 +  curl_sslbackend backend;
  2.2083 +  void *internals;
  2.2084 +};
  2.2085 +
  2.2086 +#define CURLINFO_STRING   0x100000
  2.2087 +#define CURLINFO_LONG     0x200000
  2.2088 +#define CURLINFO_DOUBLE   0x300000
  2.2089 +#define CURLINFO_SLIST    0x400000
  2.2090 +#define CURLINFO_MASK     0x0fffff
  2.2091 +#define CURLINFO_TYPEMASK 0xf00000
  2.2092 +
  2.2093 +typedef enum {
  2.2094 +  CURLINFO_NONE, /* first, never use this */
  2.2095 +  CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,
  2.2096 +  CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,
  2.2097 +  CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,
  2.2098 +  CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,
  2.2099 +  CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,
  2.2100 +  CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
  2.2101 +  CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,
  2.2102 +  CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,
  2.2103 +  CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,
  2.2104 +  CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,
  2.2105 +  CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,
  2.2106 +  CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,
  2.2107 +  CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,
  2.2108 +  CURLINFO_FILETIME         = CURLINFO_LONG   + 14,
  2.2109 +  CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,
  2.2110 +  CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,
  2.2111 +  CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
  2.2112 +  CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,
  2.2113 +  CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,
  2.2114 +  CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,
  2.2115 +  CURLINFO_PRIVATE          = CURLINFO_STRING + 21,
  2.2116 +  CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,
  2.2117 +  CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,
  2.2118 +  CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,
  2.2119 +  CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,
  2.2120 +  CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,
  2.2121 +  CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27,
  2.2122 +  CURLINFO_COOKIELIST       = CURLINFO_SLIST  + 28,
  2.2123 +  CURLINFO_LASTSOCKET       = CURLINFO_LONG   + 29,
  2.2124 +  CURLINFO_FTP_ENTRY_PATH   = CURLINFO_STRING + 30,
  2.2125 +  CURLINFO_REDIRECT_URL     = CURLINFO_STRING + 31,
  2.2126 +  CURLINFO_PRIMARY_IP       = CURLINFO_STRING + 32,
  2.2127 +  CURLINFO_APPCONNECT_TIME  = CURLINFO_DOUBLE + 33,
  2.2128 +  CURLINFO_CERTINFO         = CURLINFO_SLIST  + 34,
  2.2129 +  CURLINFO_CONDITION_UNMET  = CURLINFO_LONG   + 35,
  2.2130 +  CURLINFO_RTSP_SESSION_ID  = CURLINFO_STRING + 36,
  2.2131 +  CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG   + 37,
  2.2132 +  CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG   + 38,
  2.2133 +  CURLINFO_RTSP_CSEQ_RECV   = CURLINFO_LONG   + 39,
  2.2134 +  CURLINFO_PRIMARY_PORT     = CURLINFO_LONG   + 40,
  2.2135 +  CURLINFO_LOCAL_IP         = CURLINFO_STRING + 41,
  2.2136 +  CURLINFO_LOCAL_PORT       = CURLINFO_LONG   + 42,
  2.2137 +  CURLINFO_TLS_SESSION      = CURLINFO_SLIST  + 43,
  2.2138 +  /* Fill in new entries below here! */
  2.2139 +
  2.2140 +  CURLINFO_LASTONE          = 43
  2.2141 +} CURLINFO;
  2.2142 +
  2.2143 +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
  2.2144 +   CURLINFO_HTTP_CODE */
  2.2145 +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
  2.2146 +
  2.2147 +typedef enum {
  2.2148 +  CURLCLOSEPOLICY_NONE, /* first, never use this */
  2.2149 +
  2.2150 +  CURLCLOSEPOLICY_OLDEST,
  2.2151 +  CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
  2.2152 +  CURLCLOSEPOLICY_LEAST_TRAFFIC,
  2.2153 +  CURLCLOSEPOLICY_SLOWEST,
  2.2154 +  CURLCLOSEPOLICY_CALLBACK,
  2.2155 +
  2.2156 +  CURLCLOSEPOLICY_LAST /* last, never use this */
  2.2157 +} curl_closepolicy;
  2.2158 +
  2.2159 +#define CURL_GLOBAL_SSL (1<<0)
  2.2160 +#define CURL_GLOBAL_WIN32 (1<<1)
  2.2161 +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
  2.2162 +#define CURL_GLOBAL_NOTHING 0
  2.2163 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
  2.2164 +#define CURL_GLOBAL_ACK_EINTR (1<<2)
  2.2165 +
  2.2166 +
  2.2167 +/*****************************************************************************
  2.2168 + * Setup defines, protos etc for the sharing stuff.
  2.2169 + */
  2.2170 +
  2.2171 +/* Different data locks for a single share */
  2.2172 +typedef enum {
  2.2173 +  CURL_LOCK_DATA_NONE = 0,
  2.2174 +  /*  CURL_LOCK_DATA_SHARE is used internally to say that
  2.2175 +   *  the locking is just made to change the internal state of the share
  2.2176 +   *  itself.
  2.2177 +   */
  2.2178 +  CURL_LOCK_DATA_SHARE,
  2.2179 +  CURL_LOCK_DATA_COOKIE,
  2.2180 +  CURL_LOCK_DATA_DNS,
  2.2181 +  CURL_LOCK_DATA_SSL_SESSION,
  2.2182 +  CURL_LOCK_DATA_CONNECT,
  2.2183 +  CURL_LOCK_DATA_LAST
  2.2184 +} curl_lock_data;
  2.2185 +
  2.2186 +/* Different lock access types */
  2.2187 +typedef enum {
  2.2188 +  CURL_LOCK_ACCESS_NONE = 0,   /* unspecified action */
  2.2189 +  CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
  2.2190 +  CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
  2.2191 +  CURL_LOCK_ACCESS_LAST        /* never use */
  2.2192 +} curl_lock_access;
  2.2193 +
  2.2194 +typedef void (*curl_lock_function)(CURL *handle,
  2.2195 +                                   curl_lock_data data,
  2.2196 +                                   curl_lock_access locktype,
  2.2197 +                                   void *userptr);
  2.2198 +typedef void (*curl_unlock_function)(CURL *handle,
  2.2199 +                                     curl_lock_data data,
  2.2200 +                                     void *userptr);
  2.2201 +
  2.2202 +typedef void CURLSH;
  2.2203 +
  2.2204 +typedef enum {
  2.2205 +  CURLSHE_OK,  /* all is fine */
  2.2206 +  CURLSHE_BAD_OPTION, /* 1 */
  2.2207 +  CURLSHE_IN_USE,     /* 2 */
  2.2208 +  CURLSHE_INVALID,    /* 3 */
  2.2209 +  CURLSHE_NOMEM,      /* 4 out of memory */
  2.2210 +  CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */
  2.2211 +  CURLSHE_LAST        /* never use */
  2.2212 +} CURLSHcode;
  2.2213 +
  2.2214 +typedef enum {
  2.2215 +  CURLSHOPT_NONE,  /* don't use */
  2.2216 +  CURLSHOPT_SHARE,   /* specify a data type to share */
  2.2217 +  CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */
  2.2218 +  CURLSHOPT_LOCKFUNC,   /* pass in a 'curl_lock_function' pointer */
  2.2219 +  CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
  2.2220 +  CURLSHOPT_USERDATA,   /* pass in a user data pointer used in the lock/unlock
  2.2221 +                           callback functions */
  2.2222 +  CURLSHOPT_LAST  /* never use */
  2.2223 +} CURLSHoption;
  2.2224 +
  2.2225 +CURL_EXTERN CURLSH *curl_share_init(void);
  2.2226 +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
  2.2227 +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);
  2.2228 +
  2.2229 +/****************************************************************************
  2.2230 + * Structures for querying information about the curl library at runtime.
  2.2231 + */
  2.2232 +
  2.2233 +typedef enum {
  2.2234 +  CURLVERSION_FIRST,
  2.2235 +  CURLVERSION_SECOND,
  2.2236 +  CURLVERSION_THIRD,
  2.2237 +  CURLVERSION_FOURTH,
  2.2238 +  CURLVERSION_LAST /* never actually use this */
  2.2239 +} CURLversion;
  2.2240 +
  2.2241 +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by
  2.2242 +   basically all programs ever that want to get version information. It is
  2.2243 +   meant to be a built-in version number for what kind of struct the caller
  2.2244 +   expects. If the struct ever changes, we redefine the NOW to another enum
  2.2245 +   from above. */
  2.2246 +#define CURLVERSION_NOW CURLVERSION_FOURTH
  2.2247 +
  2.2248 +typedef struct {
  2.2249 +  CURLversion age;          /* age of the returned struct */
  2.2250 +  const char *version;      /* LIBCURL_VERSION */
  2.2251 +  unsigned int version_num; /* LIBCURL_VERSION_NUM */
  2.2252 +  const char *host;         /* OS/host/cpu/machine when configured */
  2.2253 +  int features;             /* bitmask, see defines below */
  2.2254 +  const char *ssl_version;  /* human readable string */
  2.2255 +  long ssl_version_num;     /* not used anymore, always 0 */
  2.2256 +  const char *libz_version; /* human readable string */
  2.2257 +  /* protocols is terminated by an entry with a NULL protoname */
  2.2258 +  const char * const *protocols;
  2.2259 +
  2.2260 +  /* The fields below this were added in CURLVERSION_SECOND */
  2.2261 +  const char *ares;
  2.2262 +  int ares_num;
  2.2263 +
  2.2264 +  /* This field was added in CURLVERSION_THIRD */
  2.2265 +  const char *libidn;
  2.2266 +
  2.2267 +  /* These field were added in CURLVERSION_FOURTH */
  2.2268 +
  2.2269 +  /* Same as '_libiconv_version' if built with HAVE_ICONV */
  2.2270 +  int iconv_ver_num;
  2.2271 +
  2.2272 +  const char *libssh_version; /* human readable string */
  2.2273 +
  2.2274 +} curl_version_info_data;
  2.2275 +
  2.2276 +#define CURL_VERSION_IPV6         (1<<0)  /* IPv6-enabled */
  2.2277 +#define CURL_VERSION_KERBEROS4    (1<<1)  /* Kerberos V4 auth is supported
  2.2278 +                                             (deprecated) */
  2.2279 +#define CURL_VERSION_SSL          (1<<2)  /* SSL options are present */
  2.2280 +#define CURL_VERSION_LIBZ         (1<<3)  /* libz features are present */
  2.2281 +#define CURL_VERSION_NTLM         (1<<4)  /* NTLM auth is supported */
  2.2282 +#define CURL_VERSION_GSSNEGOTIATE (1<<5)  /* Negotiate auth is supported
  2.2283 +                                             (deprecated) */
  2.2284 +#define CURL_VERSION_DEBUG        (1<<6)  /* Built with debug capabilities */
  2.2285 +#define CURL_VERSION_ASYNCHDNS    (1<<7)  /* Asynchronous DNS resolves */
  2.2286 +#define CURL_VERSION_SPNEGO       (1<<8)  /* SPNEGO auth is supported */
  2.2287 +#define CURL_VERSION_LARGEFILE    (1<<9)  /* Supports files larger than 2GB */
  2.2288 +#define CURL_VERSION_IDN          (1<<10) /* Internationized Domain Names are
  2.2289 +                                             supported */
  2.2290 +#define CURL_VERSION_SSPI         (1<<11) /* Built against Windows SSPI */
  2.2291 +#define CURL_VERSION_CONV         (1<<12) /* Character conversions supported */
  2.2292 +#define CURL_VERSION_CURLDEBUG    (1<<13) /* Debug memory tracking supported */
  2.2293 +#define CURL_VERSION_TLSAUTH_SRP  (1<<14) /* TLS-SRP auth is supported */
  2.2294 +#define CURL_VERSION_NTLM_WB      (1<<15) /* NTLM delegation to winbind helper
  2.2295 +                                             is suported */
  2.2296 +#define CURL_VERSION_HTTP2        (1<<16) /* HTTP2 support built-in */
  2.2297 +#define CURL_VERSION_GSSAPI       (1<<17) /* Built against a GSS-API library */
  2.2298 +#define CURL_VERSION_KERBEROS5    (1<<18) /* Kerberos V5 auth is supported */
  2.2299 +#define CURL_VERSION_UNIX_SOCKETS (1<<19) /* Unix domain sockets support */
  2.2300 +
  2.2301 + /*
  2.2302 + * NAME curl_version_info()
  2.2303 + *
  2.2304 + * DESCRIPTION
  2.2305 + *
  2.2306 + * This function returns a pointer to a static copy of the version info
  2.2307 + * struct. See above.
  2.2308 + */
  2.2309 +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
  2.2310 +
  2.2311 +/*
  2.2312 + * NAME curl_easy_strerror()
  2.2313 + *
  2.2314 + * DESCRIPTION
  2.2315 + *
  2.2316 + * The curl_easy_strerror function may be used to turn a CURLcode value
  2.2317 + * into the equivalent human readable error string.  This is useful
  2.2318 + * for printing meaningful error messages.
  2.2319 + */
  2.2320 +CURL_EXTERN const char *curl_easy_strerror(CURLcode);
  2.2321 +
  2.2322 +/*
  2.2323 + * NAME curl_share_strerror()
  2.2324 + *
  2.2325 + * DESCRIPTION
  2.2326 + *
  2.2327 + * The curl_share_strerror function may be used to turn a CURLSHcode value
  2.2328 + * into the equivalent human readable error string.  This is useful
  2.2329 + * for printing meaningful error messages.
  2.2330 + */
  2.2331 +CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
  2.2332 +
  2.2333 +/*
  2.2334 + * NAME curl_easy_pause()
  2.2335 + *
  2.2336 + * DESCRIPTION
  2.2337 + *
  2.2338 + * The curl_easy_pause function pauses or unpauses transfers. Select the new
  2.2339 + * state by setting the bitmask, use the convenience defines below.
  2.2340 + *
  2.2341 + */
  2.2342 +CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
  2.2343 +
  2.2344 +#define CURLPAUSE_RECV      (1<<0)
  2.2345 +#define CURLPAUSE_RECV_CONT (0)
  2.2346 +
  2.2347 +#define CURLPAUSE_SEND      (1<<2)
  2.2348 +#define CURLPAUSE_SEND_CONT (0)
  2.2349 +
  2.2350 +#define CURLPAUSE_ALL       (CURLPAUSE_RECV|CURLPAUSE_SEND)
  2.2351 +#define CURLPAUSE_CONT      (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT)
  2.2352 +
  2.2353 +#ifdef  __cplusplus
  2.2354 +}
  2.2355 +#endif
  2.2356 +
  2.2357 +/* unfortunately, the easy.h and multi.h include files need options and info
  2.2358 +  stuff before they can be included! */
  2.2359 +#include "easy.h" /* nothing in curl is fun without the easy stuff */
  2.2360 +#include "multi.h"
  2.2361 +
  2.2362 +/* the typechecker doesn't work in C++ (yet) */
  2.2363 +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
  2.2364 +    ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \
  2.2365 +    !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)
  2.2366 +#include "typecheck-gcc.h"
  2.2367 +#else
  2.2368 +#if defined(__STDC__) && (__STDC__ >= 1)
  2.2369 +/* This preprocessor magic that replaces a call with the exact same call is
  2.2370 +   only done to make sure application authors pass exactly three arguments
  2.2371 +   to these functions. */
  2.2372 +#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)
  2.2373 +#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)
  2.2374 +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
  2.2375 +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
  2.2376 +#endif /* __STDC__ >= 1 */
  2.2377 +#endif /* gcc >= 4.3 && !__cplusplus */
  2.2378 +
  2.2379 +#endif /* __CURL_CURL_H */
     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/build-mac/curl/curlbuild.h	Mon Aug 24 17:23:37 2015 +0200
     3.3 @@ -0,0 +1,12 @@
     3.4 +#ifdef __LP64__
     3.5 +
     3.6 +// 64-bit code
     3.7 +#include "curlbuild64.h"
     3.8 +
     3.9 +#else
    3.10 +
    3.11 +// 32-bit code
    3.12 +#include "curlbuild32.h"
    3.13 +
    3.14 +#endif
    3.15 +
     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/build-mac/curl/curlbuild32.h	Mon Aug 24 17:23:37 2015 +0200
     4.3 @@ -0,0 +1,198 @@
     4.4 +/* include/curl/curlbuild.h.  Generated from curlbuild.h.in by configure.  */
     4.5 +#ifndef __CURL_CURLBUILD_H
     4.6 +#define __CURL_CURLBUILD_H
     4.7 +/***************************************************************************
     4.8 + *                                  _   _ ____  _
     4.9 + *  Project                     ___| | | |  _ \| |
    4.10 + *                             / __| | | | |_) | |
    4.11 + *                            | (__| |_| |  _ <| |___
    4.12 + *                             \___|\___/|_| \_\_____|
    4.13 + *
    4.14 + * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
    4.15 + *
    4.16 + * This software is licensed as described in the file COPYING, which
    4.17 + * you should have received as part of this distribution. The terms
    4.18 + * are also available at http://curl.haxx.se/docs/copyright.html.
    4.19 + *
    4.20 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    4.21 + * copies of the Software, and permit persons to whom the Software is
    4.22 + * furnished to do so, under the terms of the COPYING file.
    4.23 + *
    4.24 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    4.25 + * KIND, either express or implied.
    4.26 + *
    4.27 + ***************************************************************************/
    4.28 +
    4.29 +/* ================================================================ */
    4.30 +/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
    4.31 +/* ================================================================ */
    4.32 +
    4.33 +/*
    4.34 + * NOTE 1:
    4.35 + * -------
    4.36 + *
    4.37 + * Nothing in this file is intended to be modified or adjusted by the
    4.38 + * curl library user nor by the curl library builder.
    4.39 + *
    4.40 + * If you think that something actually needs to be changed, adjusted
    4.41 + * or fixed in this file, then, report it on the libcurl development
    4.42 + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
    4.43 + *
    4.44 + * This header file shall only export symbols which are 'curl' or 'CURL'
    4.45 + * prefixed, otherwise public name space would be polluted.
    4.46 + *
    4.47 + * NOTE 2:
    4.48 + * -------
    4.49 + *
    4.50 + * Right now you might be staring at file include/curl/curlbuild.h.in or
    4.51 + * at file include/curl/curlbuild.h, this is due to the following reason:
    4.52 + *
    4.53 + * On systems capable of running the configure script, the configure process
    4.54 + * will overwrite the distributed include/curl/curlbuild.h file with one that
    4.55 + * is suitable and specific to the library being configured and built, which
    4.56 + * is generated from the include/curl/curlbuild.h.in template file.
    4.57 + *
    4.58 + */
    4.59 +
    4.60 +/* ================================================================ */
    4.61 +/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
    4.62 +/* ================================================================ */
    4.63 +
    4.64 +#ifdef CURL_SIZEOF_LONG
    4.65 +#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
    4.66 +   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
    4.67 +#endif
    4.68 +
    4.69 +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
    4.70 +#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    4.71 +   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
    4.72 +#endif
    4.73 +
    4.74 +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
    4.75 +#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    4.76 +   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
    4.77 +#endif
    4.78 +
    4.79 +#ifdef CURL_TYPEOF_CURL_OFF_T
    4.80 +#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
    4.81 +   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
    4.82 +#endif
    4.83 +
    4.84 +#ifdef CURL_FORMAT_CURL_OFF_T
    4.85 +#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
    4.86 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
    4.87 +#endif
    4.88 +
    4.89 +#ifdef CURL_FORMAT_CURL_OFF_TU
    4.90 +#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
    4.91 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
    4.92 +#endif
    4.93 +
    4.94 +#ifdef CURL_FORMAT_OFF_T
    4.95 +#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
    4.96 +   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
    4.97 +#endif
    4.98 +
    4.99 +#ifdef CURL_SIZEOF_CURL_OFF_T
   4.100 +#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
   4.101 +   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
   4.102 +#endif
   4.103 +
   4.104 +#ifdef CURL_SUFFIX_CURL_OFF_T
   4.105 +#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
   4.106 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
   4.107 +#endif
   4.108 +
   4.109 +#ifdef CURL_SUFFIX_CURL_OFF_TU
   4.110 +#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
   4.111 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
   4.112 +#endif
   4.113 +
   4.114 +/* ================================================================ */
   4.115 +/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
   4.116 +/* ================================================================ */
   4.117 +
   4.118 +/* Configure process defines this to 1 when it finds out that system  */
   4.119 +/* header file ws2tcpip.h must be included by the external interface. */
   4.120 +/* #undef CURL_PULL_WS2TCPIP_H */
   4.121 +#ifdef CURL_PULL_WS2TCPIP_H
   4.122 +#  ifndef WIN32_LEAN_AND_MEAN
   4.123 +#    define WIN32_LEAN_AND_MEAN
   4.124 +#  endif
   4.125 +#  include <windows.h>
   4.126 +#  include <winsock2.h>
   4.127 +#  include <ws2tcpip.h>
   4.128 +#endif
   4.129 +
   4.130 +/* Configure process defines this to 1 when it finds out that system   */
   4.131 +/* header file sys/types.h must be included by the external interface. */
   4.132 +#define CURL_PULL_SYS_TYPES_H 1
   4.133 +#ifdef CURL_PULL_SYS_TYPES_H
   4.134 +#  include <sys/types.h>
   4.135 +#endif
   4.136 +
   4.137 +/* Configure process defines this to 1 when it finds out that system */
   4.138 +/* header file stdint.h must be included by the external interface.  */
   4.139 +#define CURL_PULL_STDINT_H 1
   4.140 +#ifdef CURL_PULL_STDINT_H
   4.141 +#  include <stdint.h>
   4.142 +#endif
   4.143 +
   4.144 +/* Configure process defines this to 1 when it finds out that system  */
   4.145 +/* header file inttypes.h must be included by the external interface. */
   4.146 +#define CURL_PULL_INTTYPES_H 1
   4.147 +#ifdef CURL_PULL_INTTYPES_H
   4.148 +#  include <inttypes.h>
   4.149 +#endif
   4.150 +
   4.151 +/* Configure process defines this to 1 when it finds out that system    */
   4.152 +/* header file sys/socket.h must be included by the external interface. */
   4.153 +#define CURL_PULL_SYS_SOCKET_H 1
   4.154 +#ifdef CURL_PULL_SYS_SOCKET_H
   4.155 +#  include <sys/socket.h>
   4.156 +#endif
   4.157 +
   4.158 +/* Configure process defines this to 1 when it finds out that system  */
   4.159 +/* header file sys/poll.h must be included by the external interface. */
   4.160 +/* #undef CURL_PULL_SYS_POLL_H */
   4.161 +#ifdef CURL_PULL_SYS_POLL_H
   4.162 +#  include <sys/poll.h>
   4.163 +#endif
   4.164 +
   4.165 +/* The size of `long', as computed by sizeof. */
   4.166 +#define CURL_SIZEOF_LONG 4
   4.167 +
   4.168 +/* Integral data type used for curl_socklen_t. */
   4.169 +#define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
   4.170 +
   4.171 +/* The size of `curl_socklen_t', as computed by sizeof. */
   4.172 +#define CURL_SIZEOF_CURL_SOCKLEN_T 4
   4.173 +
   4.174 +/* Data type definition of curl_socklen_t. */
   4.175 +typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
   4.176 +
   4.177 +/* Signed integral data type used for curl_off_t. */
   4.178 +#define CURL_TYPEOF_CURL_OFF_T int64_t
   4.179 +
   4.180 +/* Data type definition of curl_off_t. */
   4.181 +typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
   4.182 +
   4.183 +/* curl_off_t formatting string directive without "%" conversion specifier. */
   4.184 +#define CURL_FORMAT_CURL_OFF_T "lld"
   4.185 +
   4.186 +/* unsigned curl_off_t formatting string without "%" conversion specifier. */
   4.187 +#define CURL_FORMAT_CURL_OFF_TU "llu"
   4.188 +
   4.189 +/* curl_off_t formatting string directive with "%" conversion specifier. */
   4.190 +#define CURL_FORMAT_OFF_T "%lld"
   4.191 +
   4.192 +/* The size of `curl_off_t', as computed by sizeof. */
   4.193 +#define CURL_SIZEOF_CURL_OFF_T 8
   4.194 +
   4.195 +/* curl_off_t constant suffix. */
   4.196 +#define CURL_SUFFIX_CURL_OFF_T LL
   4.197 +
   4.198 +/* unsigned curl_off_t constant suffix. */
   4.199 +#define CURL_SUFFIX_CURL_OFF_TU ULL
   4.200 +
   4.201 +#endif /* __CURL_CURLBUILD_H */
     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/build-mac/curl/curlbuild64.h	Mon Aug 24 17:23:37 2015 +0200
     5.3 @@ -0,0 +1,198 @@
     5.4 +/* include/curl/curlbuild.h.  Generated from curlbuild.h.in by configure.  */
     5.5 +#ifndef __CURL_CURLBUILD_H
     5.6 +#define __CURL_CURLBUILD_H
     5.7 +/***************************************************************************
     5.8 + *                                  _   _ ____  _
     5.9 + *  Project                     ___| | | |  _ \| |
    5.10 + *                             / __| | | | |_) | |
    5.11 + *                            | (__| |_| |  _ <| |___
    5.12 + *                             \___|\___/|_| \_\_____|
    5.13 + *
    5.14 + * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
    5.15 + *
    5.16 + * This software is licensed as described in the file COPYING, which
    5.17 + * you should have received as part of this distribution. The terms
    5.18 + * are also available at http://curl.haxx.se/docs/copyright.html.
    5.19 + *
    5.20 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    5.21 + * copies of the Software, and permit persons to whom the Software is
    5.22 + * furnished to do so, under the terms of the COPYING file.
    5.23 + *
    5.24 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    5.25 + * KIND, either express or implied.
    5.26 + *
    5.27 + ***************************************************************************/
    5.28 +
    5.29 +/* ================================================================ */
    5.30 +/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
    5.31 +/* ================================================================ */
    5.32 +
    5.33 +/*
    5.34 + * NOTE 1:
    5.35 + * -------
    5.36 + *
    5.37 + * Nothing in this file is intended to be modified or adjusted by the
    5.38 + * curl library user nor by the curl library builder.
    5.39 + *
    5.40 + * If you think that something actually needs to be changed, adjusted
    5.41 + * or fixed in this file, then, report it on the libcurl development
    5.42 + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
    5.43 + *
    5.44 + * This header file shall only export symbols which are 'curl' or 'CURL'
    5.45 + * prefixed, otherwise public name space would be polluted.
    5.46 + *
    5.47 + * NOTE 2:
    5.48 + * -------
    5.49 + *
    5.50 + * Right now you might be staring at file include/curl/curlbuild.h.in or
    5.51 + * at file include/curl/curlbuild.h, this is due to the following reason:
    5.52 + *
    5.53 + * On systems capable of running the configure script, the configure process
    5.54 + * will overwrite the distributed include/curl/curlbuild.h file with one that
    5.55 + * is suitable and specific to the library being configured and built, which
    5.56 + * is generated from the include/curl/curlbuild.h.in template file.
    5.57 + *
    5.58 + */
    5.59 +
    5.60 +/* ================================================================ */
    5.61 +/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
    5.62 +/* ================================================================ */
    5.63 +
    5.64 +#ifdef CURL_SIZEOF_LONG
    5.65 +#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
    5.66 +   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
    5.67 +#endif
    5.68 +
    5.69 +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
    5.70 +#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    5.71 +   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
    5.72 +#endif
    5.73 +
    5.74 +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
    5.75 +#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    5.76 +   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
    5.77 +#endif
    5.78 +
    5.79 +#ifdef CURL_TYPEOF_CURL_OFF_T
    5.80 +#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
    5.81 +   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
    5.82 +#endif
    5.83 +
    5.84 +#ifdef CURL_FORMAT_CURL_OFF_T
    5.85 +#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
    5.86 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
    5.87 +#endif
    5.88 +
    5.89 +#ifdef CURL_FORMAT_CURL_OFF_TU
    5.90 +#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
    5.91 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
    5.92 +#endif
    5.93 +
    5.94 +#ifdef CURL_FORMAT_OFF_T
    5.95 +#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
    5.96 +   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
    5.97 +#endif
    5.98 +
    5.99 +#ifdef CURL_SIZEOF_CURL_OFF_T
   5.100 +#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
   5.101 +   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
   5.102 +#endif
   5.103 +
   5.104 +#ifdef CURL_SUFFIX_CURL_OFF_T
   5.105 +#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
   5.106 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
   5.107 +#endif
   5.108 +
   5.109 +#ifdef CURL_SUFFIX_CURL_OFF_TU
   5.110 +#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
   5.111 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
   5.112 +#endif
   5.113 +
   5.114 +/* ================================================================ */
   5.115 +/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
   5.116 +/* ================================================================ */
   5.117 +
   5.118 +/* Configure process defines this to 1 when it finds out that system  */
   5.119 +/* header file ws2tcpip.h must be included by the external interface. */
   5.120 +/* #undef CURL_PULL_WS2TCPIP_H */
   5.121 +#ifdef CURL_PULL_WS2TCPIP_H
   5.122 +#  ifndef WIN32_LEAN_AND_MEAN
   5.123 +#    define WIN32_LEAN_AND_MEAN
   5.124 +#  endif
   5.125 +#  include <windows.h>
   5.126 +#  include <winsock2.h>
   5.127 +#  include <ws2tcpip.h>
   5.128 +#endif
   5.129 +
   5.130 +/* Configure process defines this to 1 when it finds out that system   */
   5.131 +/* header file sys/types.h must be included by the external interface. */
   5.132 +#define CURL_PULL_SYS_TYPES_H 1
   5.133 +#ifdef CURL_PULL_SYS_TYPES_H
   5.134 +#  include <sys/types.h>
   5.135 +#endif
   5.136 +
   5.137 +/* Configure process defines this to 1 when it finds out that system */
   5.138 +/* header file stdint.h must be included by the external interface.  */
   5.139 +/* #undef CURL_PULL_STDINT_H */
   5.140 +#ifdef CURL_PULL_STDINT_H
   5.141 +#  include <stdint.h>
   5.142 +#endif
   5.143 +
   5.144 +/* Configure process defines this to 1 when it finds out that system  */
   5.145 +/* header file inttypes.h must be included by the external interface. */
   5.146 +/* #undef CURL_PULL_INTTYPES_H */
   5.147 +#ifdef CURL_PULL_INTTYPES_H
   5.148 +#  include <inttypes.h>
   5.149 +#endif
   5.150 +
   5.151 +/* Configure process defines this to 1 when it finds out that system    */
   5.152 +/* header file sys/socket.h must be included by the external interface. */
   5.153 +#define CURL_PULL_SYS_SOCKET_H 1
   5.154 +#ifdef CURL_PULL_SYS_SOCKET_H
   5.155 +#  include <sys/socket.h>
   5.156 +#endif
   5.157 +
   5.158 +/* Configure process defines this to 1 when it finds out that system  */
   5.159 +/* header file sys/poll.h must be included by the external interface. */
   5.160 +/* #undef CURL_PULL_SYS_POLL_H */
   5.161 +#ifdef CURL_PULL_SYS_POLL_H
   5.162 +#  include <sys/poll.h>
   5.163 +#endif
   5.164 +
   5.165 +/* The size of `long', as computed by sizeof. */
   5.166 +#define CURL_SIZEOF_LONG 8
   5.167 +
   5.168 +/* Integral data type used for curl_socklen_t. */
   5.169 +#define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
   5.170 +
   5.171 +/* The size of `curl_socklen_t', as computed by sizeof. */
   5.172 +#define CURL_SIZEOF_CURL_SOCKLEN_T 4
   5.173 +
   5.174 +/* Data type definition of curl_socklen_t. */
   5.175 +typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
   5.176 +
   5.177 +/* Signed integral data type used for curl_off_t. */
   5.178 +#define CURL_TYPEOF_CURL_OFF_T long
   5.179 +
   5.180 +/* Data type definition of curl_off_t. */
   5.181 +typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
   5.182 +
   5.183 +/* curl_off_t formatting string directive without "%" conversion specifier. */
   5.184 +#define CURL_FORMAT_CURL_OFF_T "ld"
   5.185 +
   5.186 +/* unsigned curl_off_t formatting string without "%" conversion specifier. */
   5.187 +#define CURL_FORMAT_CURL_OFF_TU "lu"
   5.188 +
   5.189 +/* curl_off_t formatting string directive with "%" conversion specifier. */
   5.190 +#define CURL_FORMAT_OFF_T "%ld"
   5.191 +
   5.192 +/* The size of `curl_off_t', as computed by sizeof. */
   5.193 +#define CURL_SIZEOF_CURL_OFF_T 8
   5.194 +
   5.195 +/* curl_off_t constant suffix. */
   5.196 +#define CURL_SUFFIX_CURL_OFF_T L
   5.197 +
   5.198 +/* unsigned curl_off_t constant suffix. */
   5.199 +#define CURL_SUFFIX_CURL_OFF_TU UL
   5.200 +
   5.201 +#endif /* __CURL_CURLBUILD_H */
     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/build-mac/curl/curlbuild_.h	Mon Aug 24 17:23:37 2015 +0200
     6.3 @@ -0,0 +1,198 @@
     6.4 +/* include/curl/curlbuild.h.  Generated from curlbuild.h.in by configure.  */
     6.5 +#ifndef __CURL_CURLBUILD_H
     6.6 +#define __CURL_CURLBUILD_H
     6.7 +/***************************************************************************
     6.8 + *                                  _   _ ____  _
     6.9 + *  Project                     ___| | | |  _ \| |
    6.10 + *                             / __| | | | |_) | |
    6.11 + *                            | (__| |_| |  _ <| |___
    6.12 + *                             \___|\___/|_| \_\_____|
    6.13 + *
    6.14 + * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
    6.15 + *
    6.16 + * This software is licensed as described in the file COPYING, which
    6.17 + * you should have received as part of this distribution. The terms
    6.18 + * are also available at http://curl.haxx.se/docs/copyright.html.
    6.19 + *
    6.20 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    6.21 + * copies of the Software, and permit persons to whom the Software is
    6.22 + * furnished to do so, under the terms of the COPYING file.
    6.23 + *
    6.24 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    6.25 + * KIND, either express or implied.
    6.26 + *
    6.27 + ***************************************************************************/
    6.28 +
    6.29 +/* ================================================================ */
    6.30 +/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
    6.31 +/* ================================================================ */
    6.32 +
    6.33 +/*
    6.34 + * NOTE 1:
    6.35 + * -------
    6.36 + *
    6.37 + * Nothing in this file is intended to be modified or adjusted by the
    6.38 + * curl library user nor by the curl library builder.
    6.39 + *
    6.40 + * If you think that something actually needs to be changed, adjusted
    6.41 + * or fixed in this file, then, report it on the libcurl development
    6.42 + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
    6.43 + *
    6.44 + * This header file shall only export symbols which are 'curl' or 'CURL'
    6.45 + * prefixed, otherwise public name space would be polluted.
    6.46 + *
    6.47 + * NOTE 2:
    6.48 + * -------
    6.49 + *
    6.50 + * Right now you might be staring at file include/curl/curlbuild.h.in or
    6.51 + * at file include/curl/curlbuild.h, this is due to the following reason:
    6.52 + *
    6.53 + * On systems capable of running the configure script, the configure process
    6.54 + * will overwrite the distributed include/curl/curlbuild.h file with one that
    6.55 + * is suitable and specific to the library being configured and built, which
    6.56 + * is generated from the include/curl/curlbuild.h.in template file.
    6.57 + *
    6.58 + */
    6.59 +
    6.60 +/* ================================================================ */
    6.61 +/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
    6.62 +/* ================================================================ */
    6.63 +
    6.64 +#ifdef CURL_SIZEOF_LONG
    6.65 +#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
    6.66 +   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
    6.67 +#endif
    6.68 +
    6.69 +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
    6.70 +#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    6.71 +   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
    6.72 +#endif
    6.73 +
    6.74 +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
    6.75 +#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
    6.76 +   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
    6.77 +#endif
    6.78 +
    6.79 +#ifdef CURL_TYPEOF_CURL_OFF_T
    6.80 +#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
    6.81 +   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
    6.82 +#endif
    6.83 +
    6.84 +#ifdef CURL_FORMAT_CURL_OFF_T
    6.85 +#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
    6.86 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
    6.87 +#endif
    6.88 +
    6.89 +#ifdef CURL_FORMAT_CURL_OFF_TU
    6.90 +#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
    6.91 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
    6.92 +#endif
    6.93 +
    6.94 +#ifdef CURL_FORMAT_OFF_T
    6.95 +#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
    6.96 +   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
    6.97 +#endif
    6.98 +
    6.99 +#ifdef CURL_SIZEOF_CURL_OFF_T
   6.100 +#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
   6.101 +   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
   6.102 +#endif
   6.103 +
   6.104 +#ifdef CURL_SUFFIX_CURL_OFF_T
   6.105 +#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
   6.106 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
   6.107 +#endif
   6.108 +
   6.109 +#ifdef CURL_SUFFIX_CURL_OFF_TU
   6.110 +#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
   6.111 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
   6.112 +#endif
   6.113 +
   6.114 +/* ================================================================ */
   6.115 +/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
   6.116 +/* ================================================================ */
   6.117 +
   6.118 +/* Configure process defines this to 1 when it finds out that system  */
   6.119 +/* header file ws2tcpip.h must be included by the external interface. */
   6.120 +/* #undef CURL_PULL_WS2TCPIP_H */
   6.121 +#ifdef CURL_PULL_WS2TCPIP_H
   6.122 +#  ifndef WIN32_LEAN_AND_MEAN
   6.123 +#    define WIN32_LEAN_AND_MEAN
   6.124 +#  endif
   6.125 +#  include <windows.h>
   6.126 +#  include <winsock2.h>
   6.127 +#  include <ws2tcpip.h>
   6.128 +#endif
   6.129 +
   6.130 +/* Configure process defines this to 1 when it finds out that system   */
   6.131 +/* header file sys/types.h must be included by the external interface. */
   6.132 +#define CURL_PULL_SYS_TYPES_H 1
   6.133 +#ifdef CURL_PULL_SYS_TYPES_H
   6.134 +#  include <sys/types.h>
   6.135 +#endif
   6.136 +
   6.137 +/* Configure process defines this to 1 when it finds out that system */
   6.138 +/* header file stdint.h must be included by the external interface.  */
   6.139 +#define CURL_PULL_STDINT_H 1
   6.140 +#ifdef CURL_PULL_STDINT_H
   6.141 +#  include <stdint.h>
   6.142 +#endif
   6.143 +
   6.144 +/* Configure process defines this to 1 when it finds out that system  */
   6.145 +/* header file inttypes.h must be included by the external interface. */
   6.146 +#define CURL_PULL_INTTYPES_H 1
   6.147 +#ifdef CURL_PULL_INTTYPES_H
   6.148 +#  include <inttypes.h>
   6.149 +#endif
   6.150 +
   6.151 +/* Configure process defines this to 1 when it finds out that system    */
   6.152 +/* header file sys/socket.h must be included by the external interface. */
   6.153 +#define CURL_PULL_SYS_SOCKET_H 1
   6.154 +#ifdef CURL_PULL_SYS_SOCKET_H
   6.155 +#  include <sys/socket.h>
   6.156 +#endif
   6.157 +
   6.158 +/* Configure process defines this to 1 when it finds out that system  */
   6.159 +/* header file sys/poll.h must be included by the external interface. */
   6.160 +/* #undef CURL_PULL_SYS_POLL_H */
   6.161 +#ifdef CURL_PULL_SYS_POLL_H
   6.162 +#  include <sys/poll.h>
   6.163 +#endif
   6.164 +
   6.165 +/* The size of `long', as computed by sizeof. */
   6.166 +#define CURL_SIZEOF_LONG 4
   6.167 +
   6.168 +/* Integral data type used for curl_socklen_t. */
   6.169 +#define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
   6.170 +
   6.171 +/* The size of `curl_socklen_t', as computed by sizeof. */
   6.172 +#define CURL_SIZEOF_CURL_SOCKLEN_T 4
   6.173 +
   6.174 +/* Data type definition of curl_socklen_t. */
   6.175 +typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
   6.176 +
   6.177 +/* Signed integral data type used for curl_off_t. */
   6.178 +#define CURL_TYPEOF_CURL_OFF_T int64_t
   6.179 +
   6.180 +/* Data type definition of curl_off_t. */
   6.181 +typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
   6.182 +
   6.183 +/* curl_off_t formatting string directive without "%" conversion specifier. */
   6.184 +#define CURL_FORMAT_CURL_OFF_T "lld"
   6.185 +
   6.186 +/* unsigned curl_off_t formatting string without "%" conversion specifier. */
   6.187 +#define CURL_FORMAT_CURL_OFF_TU "llu"
   6.188 +
   6.189 +/* curl_off_t formatting string directive with "%" conversion specifier. */
   6.190 +#define CURL_FORMAT_OFF_T "%lld"
   6.191 +
   6.192 +/* The size of `curl_off_t', as computed by sizeof. */
   6.193 +#define CURL_SIZEOF_CURL_OFF_T 8
   6.194 +
   6.195 +/* curl_off_t constant suffix. */
   6.196 +#define CURL_SUFFIX_CURL_OFF_T LL
   6.197 +
   6.198 +/* unsigned curl_off_t constant suffix. */
   6.199 +#define CURL_SUFFIX_CURL_OFF_TU ULL
   6.200 +
   6.201 +#endif /* __CURL_CURLBUILD_H */
     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/build-mac/curl/curlrules.h	Mon Aug 24 17:23:37 2015 +0200
     7.3 @@ -0,0 +1,262 @@
     7.4 +#ifndef __CURL_CURLRULES_H
     7.5 +#define __CURL_CURLRULES_H
     7.6 +/***************************************************************************
     7.7 + *                                  _   _ ____  _
     7.8 + *  Project                     ___| | | |  _ \| |
     7.9 + *                             / __| | | | |_) | |
    7.10 + *                            | (__| |_| |  _ <| |___
    7.11 + *                             \___|\___/|_| \_\_____|
    7.12 + *
    7.13 + * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
    7.14 + *
    7.15 + * This software is licensed as described in the file COPYING, which
    7.16 + * you should have received as part of this distribution. The terms
    7.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
    7.18 + *
    7.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    7.20 + * copies of the Software, and permit persons to whom the Software is
    7.21 + * furnished to do so, under the terms of the COPYING file.
    7.22 + *
    7.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    7.24 + * KIND, either express or implied.
    7.25 + *
    7.26 + ***************************************************************************/
    7.27 +
    7.28 +/* ================================================================ */
    7.29 +/*                    COMPILE TIME SANITY CHECKS                    */
    7.30 +/* ================================================================ */
    7.31 +
    7.32 +/*
    7.33 + * NOTE 1:
    7.34 + * -------
    7.35 + *
    7.36 + * All checks done in this file are intentionally placed in a public
    7.37 + * header file which is pulled by curl/curl.h when an application is
    7.38 + * being built using an already built libcurl library. Additionally
    7.39 + * this file is also included and used when building the library.
    7.40 + *
    7.41 + * If compilation fails on this file it is certainly sure that the
    7.42 + * problem is elsewhere. It could be a problem in the curlbuild.h
    7.43 + * header file, or simply that you are using different compilation
    7.44 + * settings than those used to build the library.
    7.45 + *
    7.46 + * Nothing in this file is intended to be modified or adjusted by the
    7.47 + * curl library user nor by the curl library builder.
    7.48 + *
    7.49 + * Do not deactivate any check, these are done to make sure that the
    7.50 + * library is properly built and used.
    7.51 + *
    7.52 + * You can find further help on the libcurl development mailing list:
    7.53 + * http://cool.haxx.se/mailman/listinfo/curl-library/
    7.54 + *
    7.55 + * NOTE 2
    7.56 + * ------
    7.57 + *
    7.58 + * Some of the following compile time checks are based on the fact
    7.59 + * that the dimension of a constant array can not be a negative one.
    7.60 + * In this way if the compile time verification fails, the compilation
    7.61 + * will fail issuing an error. The error description wording is compiler
    7.62 + * dependent but it will be quite similar to one of the following:
    7.63 + *
    7.64 + *   "negative subscript or subscript is too large"
    7.65 + *   "array must have at least one element"
    7.66 + *   "-1 is an illegal array size"
    7.67 + *   "size of array is negative"
    7.68 + *
    7.69 + * If you are building an application which tries to use an already
    7.70 + * built libcurl library and you are getting this kind of errors on
    7.71 + * this file, it is a clear indication that there is a mismatch between
    7.72 + * how the library was built and how you are trying to use it for your
    7.73 + * application. Your already compiled or binary library provider is the
    7.74 + * only one who can give you the details you need to properly use it.
    7.75 + */
    7.76 +
    7.77 +/*
    7.78 + * Verify that some macros are actually defined.
    7.79 + */
    7.80 +
    7.81 +#ifndef CURL_SIZEOF_LONG
    7.82 +#  error "CURL_SIZEOF_LONG definition is missing!"
    7.83 +   Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
    7.84 +#endif
    7.85 +
    7.86 +#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
    7.87 +#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
    7.88 +   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
    7.89 +#endif
    7.90 +
    7.91 +#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
    7.92 +#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
    7.93 +   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
    7.94 +#endif
    7.95 +
    7.96 +#ifndef CURL_TYPEOF_CURL_OFF_T
    7.97 +#  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
    7.98 +   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
    7.99 +#endif
   7.100 +
   7.101 +#ifndef CURL_FORMAT_CURL_OFF_T
   7.102 +#  error "CURL_FORMAT_CURL_OFF_T definition is missing!"
   7.103 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing
   7.104 +#endif
   7.105 +
   7.106 +#ifndef CURL_FORMAT_CURL_OFF_TU
   7.107 +#  error "CURL_FORMAT_CURL_OFF_TU definition is missing!"
   7.108 +   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing
   7.109 +#endif
   7.110 +
   7.111 +#ifndef CURL_FORMAT_OFF_T
   7.112 +#  error "CURL_FORMAT_OFF_T definition is missing!"
   7.113 +   Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing
   7.114 +#endif
   7.115 +
   7.116 +#ifndef CURL_SIZEOF_CURL_OFF_T
   7.117 +#  error "CURL_SIZEOF_CURL_OFF_T definition is missing!"
   7.118 +   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing
   7.119 +#endif
   7.120 +
   7.121 +#ifndef CURL_SUFFIX_CURL_OFF_T
   7.122 +#  error "CURL_SUFFIX_CURL_OFF_T definition is missing!"
   7.123 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing
   7.124 +#endif
   7.125 +
   7.126 +#ifndef CURL_SUFFIX_CURL_OFF_TU
   7.127 +#  error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"
   7.128 +   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing
   7.129 +#endif
   7.130 +
   7.131 +/*
   7.132 + * Macros private to this header file.
   7.133 + */
   7.134 +
   7.135 +#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1
   7.136 +
   7.137 +#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
   7.138 +
   7.139 +/*
   7.140 + * Verify that the size previously defined and expected for long
   7.141 + * is the same as the one reported by sizeof() at compile time.
   7.142 + */
   7.143 +
   7.144 +typedef char
   7.145 +  __curl_rule_01__
   7.146 +    [CurlchkszEQ(long, CURL_SIZEOF_LONG)];
   7.147 +
   7.148 +/*
   7.149 + * Verify that the size previously defined and expected for
   7.150 + * curl_off_t is actually the the same as the one reported
   7.151 + * by sizeof() at compile time.
   7.152 + */
   7.153 +
   7.154 +typedef char
   7.155 +  __curl_rule_02__
   7.156 +    [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];
   7.157 +
   7.158 +/*
   7.159 + * Verify at compile time that the size of curl_off_t as reported
   7.160 + * by sizeof() is greater or equal than the one reported for long
   7.161 + * for the current compilation.
   7.162 + */
   7.163 +
   7.164 +typedef char
   7.165 +  __curl_rule_03__
   7.166 +    [CurlchkszGE(curl_off_t, long)];
   7.167 +
   7.168 +/*
   7.169 + * Verify that the size previously defined and expected for
   7.170 + * curl_socklen_t is actually the the same as the one reported
   7.171 + * by sizeof() at compile time.
   7.172 + */
   7.173 +
   7.174 +typedef char
   7.175 +  __curl_rule_04__
   7.176 +    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
   7.177 +
   7.178 +/*
   7.179 + * Verify at compile time that the size of curl_socklen_t as reported
   7.180 + * by sizeof() is greater or equal than the one reported for int for
   7.181 + * the current compilation.
   7.182 + */
   7.183 +
   7.184 +typedef char
   7.185 +  __curl_rule_05__
   7.186 +    [CurlchkszGE(curl_socklen_t, int)];
   7.187 +
   7.188 +/* ================================================================ */
   7.189 +/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
   7.190 +/* ================================================================ */
   7.191 +
   7.192 +/*
   7.193 + * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
   7.194 + * these to be visible and exported by the external libcurl interface API,
   7.195 + * while also making them visible to the library internals, simply including
   7.196 + * curl_setup.h, without actually needing to include curl.h internally.
   7.197 + * If some day this section would grow big enough, all this should be moved
   7.198 + * to its own header file.
   7.199 + */
   7.200 +
   7.201 +/*
   7.202 + * Figure out if we can use the ## preprocessor operator, which is supported
   7.203 + * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
   7.204 + * or  __cplusplus so we need to carefully check for them too.
   7.205 + */
   7.206 +
   7.207 +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
   7.208 +  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
   7.209 +  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
   7.210 +  defined(__ILEC400__)
   7.211 +  /* This compiler is believed to have an ISO compatible preprocessor */
   7.212 +#define CURL_ISOCPP
   7.213 +#else
   7.214 +  /* This compiler is believed NOT to have an ISO compatible preprocessor */
   7.215 +#undef CURL_ISOCPP
   7.216 +#endif
   7.217 +
   7.218 +/*
   7.219 + * Macros for minimum-width signed and unsigned curl_off_t integer constants.
   7.220 + */
   7.221 +
   7.222 +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)
   7.223 +#  define __CURL_OFF_T_C_HLPR2(x) x
   7.224 +#  define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x)
   7.225 +#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val) ## \
   7.226 +                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)
   7.227 +#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \
   7.228 +                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)
   7.229 +#else
   7.230 +#  ifdef CURL_ISOCPP
   7.231 +#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix
   7.232 +#  else
   7.233 +#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
   7.234 +#  endif
   7.235 +#  define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix)
   7.236 +#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)
   7.237 +#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)
   7.238 +#endif
   7.239 +
   7.240 +/*
   7.241 + * Get rid of macros private to this header file.
   7.242 + */
   7.243 +
   7.244 +#undef CurlchkszEQ
   7.245 +#undef CurlchkszGE
   7.246 +
   7.247 +/*
   7.248 + * Get rid of macros not intended to exist beyond this point.
   7.249 + */
   7.250 +
   7.251 +#undef CURL_PULL_WS2TCPIP_H
   7.252 +#undef CURL_PULL_SYS_TYPES_H
   7.253 +#undef CURL_PULL_SYS_SOCKET_H
   7.254 +#undef CURL_PULL_SYS_POLL_H
   7.255 +#undef CURL_PULL_STDINT_H
   7.256 +#undef CURL_PULL_INTTYPES_H
   7.257 +
   7.258 +#undef CURL_TYPEOF_CURL_SOCKLEN_T
   7.259 +#undef CURL_TYPEOF_CURL_OFF_T
   7.260 +
   7.261 +#ifdef CURL_NO_OLDIES
   7.262 +#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */
   7.263 +#endif
   7.264 +
   7.265 +#endif /* __CURL_CURLRULES_H */
     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/build-mac/curl/curlver.h	Mon Aug 24 17:23:37 2015 +0200
     8.3 @@ -0,0 +1,77 @@
     8.4 +#ifndef __CURL_CURLVER_H
     8.5 +#define __CURL_CURLVER_H
     8.6 +/***************************************************************************
     8.7 + *                                  _   _ ____  _
     8.8 + *  Project                     ___| | | |  _ \| |
     8.9 + *                             / __| | | | |_) | |
    8.10 + *                            | (__| |_| |  _ <| |___
    8.11 + *                             \___|\___/|_| \_\_____|
    8.12 + *
    8.13 + * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
    8.14 + *
    8.15 + * This software is licensed as described in the file COPYING, which
    8.16 + * you should have received as part of this distribution. The terms
    8.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
    8.18 + *
    8.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    8.20 + * copies of the Software, and permit persons to whom the Software is
    8.21 + * furnished to do so, under the terms of the COPYING file.
    8.22 + *
    8.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    8.24 + * KIND, either express or implied.
    8.25 + *
    8.26 + ***************************************************************************/
    8.27 +
    8.28 +/* This header file contains nothing but libcurl version info, generated by
    8.29 +   a script at release-time. This was made its own header file in 7.11.2 */
    8.30 +
    8.31 +/* This is the global package copyright */
    8.32 +#define LIBCURL_COPYRIGHT "1996 - 2015 Daniel Stenberg, <daniel@haxx.se>."
    8.33 +
    8.34 +/* This is the version number of the libcurl package from which this header
    8.35 +   file origins: */
    8.36 +#define LIBCURL_VERSION "7.43.0"
    8.37 +
    8.38 +/* The numeric version number is also available "in parts" by using these
    8.39 +   defines: */
    8.40 +#define LIBCURL_VERSION_MAJOR 7
    8.41 +#define LIBCURL_VERSION_MINOR 43
    8.42 +#define LIBCURL_VERSION_PATCH 0
    8.43 +
    8.44 +/* This is the numeric version of the libcurl version number, meant for easier
    8.45 +   parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
    8.46 +   always follow this syntax:
    8.47 +
    8.48 +         0xXXYYZZ
    8.49 +
    8.50 +   Where XX, YY and ZZ are the main version, release and patch numbers in
    8.51 +   hexadecimal (using 8 bits each). All three numbers are always represented
    8.52 +   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
    8.53 +   appears as "0x090b07".
    8.54 +
    8.55 +   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
    8.56 +   and it is always a greater number in a more recent release. It makes
    8.57 +   comparisons with greater than and less than work.
    8.58 +
    8.59 +   Note: This define is the full hex number and _does not_ use the
    8.60 +   CURL_VERSION_BITS() macro since curl's own configure script greps for it
    8.61 +   and needs it to contain the full number.
    8.62 +*/
    8.63 +#define LIBCURL_VERSION_NUM 0x072b00
    8.64 +
    8.65 +/*
    8.66 + * This is the date and time when the full source package was created. The
    8.67 + * timestamp is not stored in git, as the timestamp is properly set in the
    8.68 + * tarballs by the maketgz script.
    8.69 + *
    8.70 + * The format of the date should follow this template:
    8.71 + *
    8.72 + * "Mon Feb 12 11:35:33 UTC 2007"
    8.73 + */
    8.74 +#define LIBCURL_TIMESTAMP "Wed Jun 17 05:56:00 UTC 2015"
    8.75 +
    8.76 +#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|z)
    8.77 +#define CURL_AT_LEAST_VERSION(x,y,z) \
    8.78 +  (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
    8.79 +
    8.80 +#endif /* __CURL_CURLVER_H */
     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/build-mac/curl/easy.h	Mon Aug 24 17:23:37 2015 +0200
     9.3 @@ -0,0 +1,102 @@
     9.4 +#ifndef __CURL_EASY_H
     9.5 +#define __CURL_EASY_H
     9.6 +/***************************************************************************
     9.7 + *                                  _   _ ____  _
     9.8 + *  Project                     ___| | | |  _ \| |
     9.9 + *                             / __| | | | |_) | |
    9.10 + *                            | (__| |_| |  _ <| |___
    9.11 + *                             \___|\___/|_| \_\_____|
    9.12 + *
    9.13 + * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
    9.14 + *
    9.15 + * This software is licensed as described in the file COPYING, which
    9.16 + * you should have received as part of this distribution. The terms
    9.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
    9.18 + *
    9.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
    9.20 + * copies of the Software, and permit persons to whom the Software is
    9.21 + * furnished to do so, under the terms of the COPYING file.
    9.22 + *
    9.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
    9.24 + * KIND, either express or implied.
    9.25 + *
    9.26 + ***************************************************************************/
    9.27 +#ifdef  __cplusplus
    9.28 +extern "C" {
    9.29 +#endif
    9.30 +
    9.31 +CURL_EXTERN CURL *curl_easy_init(void);
    9.32 +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
    9.33 +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
    9.34 +CURL_EXTERN void curl_easy_cleanup(CURL *curl);
    9.35 +
    9.36 +/*
    9.37 + * NAME curl_easy_getinfo()
    9.38 + *
    9.39 + * DESCRIPTION
    9.40 + *
    9.41 + * Request internal information from the curl session with this function.  The
    9.42 + * third argument MUST be a pointer to a long, a pointer to a char * or a
    9.43 + * pointer to a double (as the documentation describes elsewhere).  The data
    9.44 + * pointed to will be filled in accordingly and can be relied upon only if the
    9.45 + * function returns CURLE_OK.  This function is intended to get used *AFTER* a
    9.46 + * performed transfer, all results from this function are undefined until the
    9.47 + * transfer is completed.
    9.48 + */
    9.49 +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
    9.50 +
    9.51 +
    9.52 +/*
    9.53 + * NAME curl_easy_duphandle()
    9.54 + *
    9.55 + * DESCRIPTION
    9.56 + *
    9.57 + * Creates a new curl session handle with the same options set for the handle
    9.58 + * passed in. Duplicating a handle could only be a matter of cloning data and
    9.59 + * options, internal state info and things like persistent connections cannot
    9.60 + * be transferred. It is useful in multithreaded applications when you can run
    9.61 + * curl_easy_duphandle() for each new thread to avoid a series of identical
    9.62 + * curl_easy_setopt() invokes in every thread.
    9.63 + */
    9.64 +CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl);
    9.65 +
    9.66 +/*
    9.67 + * NAME curl_easy_reset()
    9.68 + *
    9.69 + * DESCRIPTION
    9.70 + *
    9.71 + * Re-initializes a CURL handle to the default values. This puts back the
    9.72 + * handle to the same state as it was in when it was just created.
    9.73 + *
    9.74 + * It does keep: live connections, the Session ID cache, the DNS cache and the
    9.75 + * cookies.
    9.76 + */
    9.77 +CURL_EXTERN void curl_easy_reset(CURL *curl);
    9.78 +
    9.79 +/*
    9.80 + * NAME curl_easy_recv()
    9.81 + *
    9.82 + * DESCRIPTION
    9.83 + *
    9.84 + * Receives data from the connected socket. Use after successful
    9.85 + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
    9.86 + */
    9.87 +CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
    9.88 +                                    size_t *n);
    9.89 +
    9.90 +/*
    9.91 + * NAME curl_easy_send()
    9.92 + *
    9.93 + * DESCRIPTION
    9.94 + *
    9.95 + * Sends data over the connected socket. Use after successful
    9.96 + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
    9.97 + */
    9.98 +CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
    9.99 +                                    size_t buflen, size_t *n);
   9.100 +
   9.101 +#ifdef  __cplusplus
   9.102 +}
   9.103 +#endif
   9.104 +
   9.105 +#endif
    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/build-mac/curl/mprintf.h	Mon Aug 24 17:23:37 2015 +0200
    10.3 @@ -0,0 +1,74 @@
    10.4 +#ifndef __CURL_MPRINTF_H
    10.5 +#define __CURL_MPRINTF_H
    10.6 +/***************************************************************************
    10.7 + *                                  _   _ ____  _
    10.8 + *  Project                     ___| | | |  _ \| |
    10.9 + *                             / __| | | | |_) | |
   10.10 + *                            | (__| |_| |  _ <| |___
   10.11 + *                             \___|\___/|_| \_\_____|
   10.12 + *
   10.13 + * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
   10.14 + *
   10.15 + * This software is licensed as described in the file COPYING, which
   10.16 + * you should have received as part of this distribution. The terms
   10.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
   10.18 + *
   10.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
   10.20 + * copies of the Software, and permit persons to whom the Software is
   10.21 + * furnished to do so, under the terms of the COPYING file.
   10.22 + *
   10.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
   10.24 + * KIND, either express or implied.
   10.25 + *
   10.26 + ***************************************************************************/
   10.27 +
   10.28 +#include <stdarg.h>
   10.29 +#include <stdio.h> /* needed for FILE */
   10.30 +
   10.31 +#include "curl.h"
   10.32 +
   10.33 +#ifdef  __cplusplus
   10.34 +extern "C" {
   10.35 +#endif
   10.36 +
   10.37 +CURL_EXTERN int curl_mprintf(const char *format, ...);
   10.38 +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
   10.39 +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
   10.40 +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
   10.41 +                               const char *format, ...);
   10.42 +CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
   10.43 +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
   10.44 +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
   10.45 +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
   10.46 +                                const char *format, va_list args);
   10.47 +CURL_EXTERN char *curl_maprintf(const char *format, ...);
   10.48 +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
   10.49 +
   10.50 +#ifdef _MPRINTF_REPLACE
   10.51 +# undef printf
   10.52 +# undef fprintf
   10.53 +# undef sprintf
   10.54 +# undef vsprintf
   10.55 +# undef snprintf
   10.56 +# undef vprintf
   10.57 +# undef vfprintf
   10.58 +# undef vsnprintf
   10.59 +# undef aprintf
   10.60 +# undef vaprintf
   10.61 +# define printf curl_mprintf
   10.62 +# define fprintf curl_mfprintf
   10.63 +# define sprintf curl_msprintf
   10.64 +# define vsprintf curl_mvsprintf
   10.65 +# define snprintf curl_msnprintf
   10.66 +# define vprintf curl_mvprintf
   10.67 +# define vfprintf curl_mvfprintf
   10.68 +# define vsnprintf curl_mvsnprintf
   10.69 +# define aprintf curl_maprintf
   10.70 +# define vaprintf curl_mvaprintf
   10.71 +#endif
   10.72 +
   10.73 +#ifdef  __cplusplus
   10.74 +}
   10.75 +#endif
   10.76 +
   10.77 +#endif /* __CURL_MPRINTF_H */
    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/build-mac/curl/multi.h	Mon Aug 24 17:23:37 2015 +0200
    11.3 @@ -0,0 +1,404 @@
    11.4 +#ifndef __CURL_MULTI_H
    11.5 +#define __CURL_MULTI_H
    11.6 +/***************************************************************************
    11.7 + *                                  _   _ ____  _
    11.8 + *  Project                     ___| | | |  _ \| |
    11.9 + *                             / __| | | | |_) | |
   11.10 + *                            | (__| |_| |  _ <| |___
   11.11 + *                             \___|\___/|_| \_\_____|
   11.12 + *
   11.13 + * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
   11.14 + *
   11.15 + * This software is licensed as described in the file COPYING, which
   11.16 + * you should have received as part of this distribution. The terms
   11.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
   11.18 + *
   11.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
   11.20 + * copies of the Software, and permit persons to whom the Software is
   11.21 + * furnished to do so, under the terms of the COPYING file.
   11.22 + *
   11.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
   11.24 + * KIND, either express or implied.
   11.25 + *
   11.26 + ***************************************************************************/
   11.27 +/*
   11.28 +  This is an "external" header file. Don't give away any internals here!
   11.29 +
   11.30 +  GOALS
   11.31 +
   11.32 +  o Enable a "pull" interface. The application that uses libcurl decides where
   11.33 +    and when to ask libcurl to get/send data.
   11.34 +
   11.35 +  o Enable multiple simultaneous transfers in the same thread without making it
   11.36 +    complicated for the application.
   11.37 +
   11.38 +  o Enable the application to select() on its own file descriptors and curl's
   11.39 +    file descriptors simultaneous easily.
   11.40 +
   11.41 +*/
   11.42 +
   11.43 +/*
   11.44 + * This header file should not really need to include "curl.h" since curl.h
   11.45 + * itself includes this file and we expect user applications to do #include
   11.46 + * <curl/curl.h> without the need for especially including multi.h.
   11.47 + *
   11.48 + * For some reason we added this include here at one point, and rather than to
   11.49 + * break existing (wrongly written) libcurl applications, we leave it as-is
   11.50 + * but with this warning attached.
   11.51 + */
   11.52 +#include "curl.h"
   11.53 +
   11.54 +#ifdef  __cplusplus
   11.55 +extern "C" {
   11.56 +#endif
   11.57 +
   11.58 +typedef void CURLM;
   11.59 +
   11.60 +typedef enum {
   11.61 +  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
   11.62 +                                    curl_multi_socket*() soon */
   11.63 +  CURLM_OK,
   11.64 +  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
   11.65 +  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
   11.66 +  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
   11.67 +  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
   11.68 +  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
   11.69 +  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
   11.70 +  CURLM_ADDED_ALREADY,   /* an easy handle already added to a multi handle was
   11.71 +                            attempted to get added - again */
   11.72 +  CURLM_LAST
   11.73 +} CURLMcode;
   11.74 +
   11.75 +/* just to make code nicer when using curl_multi_socket() you can now check
   11.76 +   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
   11.77 +   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
   11.78 +#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
   11.79 +
   11.80 +/* bitmask bits for CURLMOPT_PIPELINING */
   11.81 +#define CURLPIPE_NOTHING   0L
   11.82 +#define CURLPIPE_HTTP1     1L
   11.83 +#define CURLPIPE_MULTIPLEX 2L
   11.84 +
   11.85 +typedef enum {
   11.86 +  CURLMSG_NONE, /* first, not used */
   11.87 +  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
   11.88 +                   the CURLcode of the transfer */
   11.89 +  CURLMSG_LAST /* last, not used */
   11.90 +} CURLMSG;
   11.91 +
   11.92 +struct CURLMsg {
   11.93 +  CURLMSG msg;       /* what this message means */
   11.94 +  CURL *easy_handle; /* the handle it concerns */
   11.95 +  union {
   11.96 +    void *whatever;    /* message-specific data */
   11.97 +    CURLcode result;   /* return code for transfer */
   11.98 +  } data;
   11.99 +};
  11.100 +typedef struct CURLMsg CURLMsg;
  11.101 +
  11.102 +/* Based on poll(2) structure and values.
  11.103 + * We don't use pollfd and POLL* constants explicitly
  11.104 + * to cover platforms without poll(). */
  11.105 +#define CURL_WAIT_POLLIN    0x0001
  11.106 +#define CURL_WAIT_POLLPRI   0x0002
  11.107 +#define CURL_WAIT_POLLOUT   0x0004
  11.108 +
  11.109 +struct curl_waitfd {
  11.110 +  curl_socket_t fd;
  11.111 +  short events;
  11.112 +  short revents; /* not supported yet */
  11.113 +};
  11.114 +
  11.115 +/*
  11.116 + * Name:    curl_multi_init()
  11.117 + *
  11.118 + * Desc:    inititalize multi-style curl usage
  11.119 + *
  11.120 + * Returns: a new CURLM handle to use in all 'curl_multi' functions.
  11.121 + */
  11.122 +CURL_EXTERN CURLM *curl_multi_init(void);
  11.123 +
  11.124 +/*
  11.125 + * Name:    curl_multi_add_handle()
  11.126 + *
  11.127 + * Desc:    add a standard curl handle to the multi stack
  11.128 + *
  11.129 + * Returns: CURLMcode type, general multi error code.
  11.130 + */
  11.131 +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
  11.132 +                                            CURL *curl_handle);
  11.133 +
  11.134 + /*
  11.135 +  * Name:    curl_multi_remove_handle()
  11.136 +  *
  11.137 +  * Desc:    removes a curl handle from the multi stack again
  11.138 +  *
  11.139 +  * Returns: CURLMcode type, general multi error code.
  11.140 +  */
  11.141 +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
  11.142 +                                               CURL *curl_handle);
  11.143 +
  11.144 + /*
  11.145 +  * Name:    curl_multi_fdset()
  11.146 +  *
  11.147 +  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
  11.148 +  *          poll() on. We want curl_multi_perform() called as soon as one of
  11.149 +  *          them are ready.
  11.150 +  *
  11.151 +  * Returns: CURLMcode type, general multi error code.
  11.152 +  */
  11.153 +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
  11.154 +                                       fd_set *read_fd_set,
  11.155 +                                       fd_set *write_fd_set,
  11.156 +                                       fd_set *exc_fd_set,
  11.157 +                                       int *max_fd);
  11.158 +
  11.159 +/*
  11.160 + * Name:     curl_multi_wait()
  11.161 + *
  11.162 + * Desc:     Poll on all fds within a CURLM set as well as any
  11.163 + *           additional fds passed to the function.
  11.164 + *
  11.165 + * Returns:  CURLMcode type, general multi error code.
  11.166 + */
  11.167 +CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
  11.168 +                                      struct curl_waitfd extra_fds[],
  11.169 +                                      unsigned int extra_nfds,
  11.170 +                                      int timeout_ms,
  11.171 +                                      int *ret);
  11.172 +
  11.173 + /*
  11.174 +  * Name:    curl_multi_perform()
  11.175 +  *
  11.176 +  * Desc:    When the app thinks there's data available for curl it calls this
  11.177 +  *          function to read/write whatever there is right now. This returns
  11.178 +  *          as soon as the reads and writes are done. This function does not
  11.179 +  *          require that there actually is data available for reading or that
  11.180 +  *          data can be written, it can be called just in case. It returns
  11.181 +  *          the number of handles that still transfer data in the second
  11.182 +  *          argument's integer-pointer.
  11.183 +  *
  11.184 +  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
  11.185 +  *          returns errors etc regarding the whole multi stack. There might
  11.186 +  *          still have occurred problems on invidual transfers even when this
  11.187 +  *          returns OK.
  11.188 +  */
  11.189 +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
  11.190 +                                         int *running_handles);
  11.191 +
  11.192 + /*
  11.193 +  * Name:    curl_multi_cleanup()
  11.194 +  *
  11.195 +  * Desc:    Cleans up and removes a whole multi stack. It does not free or
  11.196 +  *          touch any individual easy handles in any way. We need to define
  11.197 +  *          in what state those handles will be if this function is called
  11.198 +  *          in the middle of a transfer.
  11.199 +  *
  11.200 +  * Returns: CURLMcode type, general multi error code.
  11.201 +  */
  11.202 +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
  11.203 +
  11.204 +/*
  11.205 + * Name:    curl_multi_info_read()
  11.206 + *
  11.207 + * Desc:    Ask the multi handle if there's any messages/informationals from
  11.208 + *          the individual transfers. Messages include informationals such as
  11.209 + *          error code from the transfer or just the fact that a transfer is
  11.210 + *          completed. More details on these should be written down as well.
  11.211 + *
  11.212 + *          Repeated calls to this function will return a new struct each
  11.213 + *          time, until a special "end of msgs" struct is returned as a signal
  11.214 + *          that there is no more to get at this point.
  11.215 + *
  11.216 + *          The data the returned pointer points to will not survive calling
  11.217 + *          curl_multi_cleanup().
  11.218 + *
  11.219 + *          The 'CURLMsg' struct is meant to be very simple and only contain
  11.220 + *          very basic informations. If more involved information is wanted,
  11.221 + *          we will provide the particular "transfer handle" in that struct
  11.222 + *          and that should/could/would be used in subsequent
  11.223 + *          curl_easy_getinfo() calls (or similar). The point being that we
  11.224 + *          must never expose complex structs to applications, as then we'll
  11.225 + *          undoubtably get backwards compatibility problems in the future.
  11.226 + *
  11.227 + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
  11.228 + *          of structs. It also writes the number of messages left in the
  11.229 + *          queue (after this read) in the integer the second argument points
  11.230 + *          to.
  11.231 + */
  11.232 +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
  11.233 +                                          int *msgs_in_queue);
  11.234 +
  11.235 +/*
  11.236 + * Name:    curl_multi_strerror()
  11.237 + *
  11.238 + * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
  11.239 + *          value into the equivalent human readable error string.  This is
  11.240 + *          useful for printing meaningful error messages.
  11.241 + *
  11.242 + * Returns: A pointer to a zero-terminated error message.
  11.243 + */
  11.244 +CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
  11.245 +
  11.246 +/*
  11.247 + * Name:    curl_multi_socket() and
  11.248 + *          curl_multi_socket_all()
  11.249 + *
  11.250 + * Desc:    An alternative version of curl_multi_perform() that allows the
  11.251 + *          application to pass in one of the file descriptors that have been
  11.252 + *          detected to have "action" on them and let libcurl perform.
  11.253 + *          See man page for details.
  11.254 + */
  11.255 +#define CURL_POLL_NONE   0
  11.256 +#define CURL_POLL_IN     1
  11.257 +#define CURL_POLL_OUT    2
  11.258 +#define CURL_POLL_INOUT  3
  11.259 +#define CURL_POLL_REMOVE 4
  11.260 +
  11.261 +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
  11.262 +
  11.263 +#define CURL_CSELECT_IN   0x01
  11.264 +#define CURL_CSELECT_OUT  0x02
  11.265 +#define CURL_CSELECT_ERR  0x04
  11.266 +
  11.267 +typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
  11.268 +                                    curl_socket_t s, /* socket */
  11.269 +                                    int what,        /* see above */
  11.270 +                                    void *userp,     /* private callback
  11.271 +                                                        pointer */
  11.272 +                                    void *socketp);  /* private socket
  11.273 +                                                        pointer */
  11.274 +/*
  11.275 + * Name:    curl_multi_timer_callback
  11.276 + *
  11.277 + * Desc:    Called by libcurl whenever the library detects a change in the
  11.278 + *          maximum number of milliseconds the app is allowed to wait before
  11.279 + *          curl_multi_socket() or curl_multi_perform() must be called
  11.280 + *          (to allow libcurl's timed events to take place).
  11.281 + *
  11.282 + * Returns: The callback should return zero.
  11.283 + */
  11.284 +typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
  11.285 +                                         long timeout_ms, /* see above */
  11.286 +                                         void *userp);    /* private callback
  11.287 +                                                             pointer */
  11.288 +
  11.289 +CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
  11.290 +                                        int *running_handles);
  11.291 +
  11.292 +CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
  11.293 +                                               curl_socket_t s,
  11.294 +                                               int ev_bitmask,
  11.295 +                                               int *running_handles);
  11.296 +
  11.297 +CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
  11.298 +                                            int *running_handles);
  11.299 +
  11.300 +#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
  11.301 +/* This macro below was added in 7.16.3 to push users who recompile to use
  11.302 +   the new curl_multi_socket_action() instead of the old curl_multi_socket()
  11.303 +*/
  11.304 +#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
  11.305 +#endif
  11.306 +
  11.307 +/*
  11.308 + * Name:    curl_multi_timeout()
  11.309 + *
  11.310 + * Desc:    Returns the maximum number of milliseconds the app is allowed to
  11.311 + *          wait before curl_multi_socket() or curl_multi_perform() must be
  11.312 + *          called (to allow libcurl's timed events to take place).
  11.313 + *
  11.314 + * Returns: CURLM error code.
  11.315 + */
  11.316 +CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
  11.317 +                                         long *milliseconds);
  11.318 +
  11.319 +#undef CINIT /* re-using the same name as in curl.h */
  11.320 +
  11.321 +#ifdef CURL_ISOCPP
  11.322 +#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num
  11.323 +#else
  11.324 +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
  11.325 +#define LONG          CURLOPTTYPE_LONG
  11.326 +#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
  11.327 +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
  11.328 +#define OFF_T         CURLOPTTYPE_OFF_T
  11.329 +#define CINIT(name,type,number) CURLMOPT_/**/name = type + number
  11.330 +#endif
  11.331 +
  11.332 +typedef enum {
  11.333 +  /* This is the socket callback function pointer */
  11.334 +  CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1),
  11.335 +
  11.336 +  /* This is the argument passed to the socket callback */
  11.337 +  CINIT(SOCKETDATA, OBJECTPOINT, 2),
  11.338 +
  11.339 +    /* set to 1 to enable pipelining for this multi handle */
  11.340 +  CINIT(PIPELINING, LONG, 3),
  11.341 +
  11.342 +   /* This is the timer callback function pointer */
  11.343 +  CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4),
  11.344 +
  11.345 +  /* This is the argument passed to the timer callback */
  11.346 +  CINIT(TIMERDATA, OBJECTPOINT, 5),
  11.347 +
  11.348 +  /* maximum number of entries in the connection cache */
  11.349 +  CINIT(MAXCONNECTS, LONG, 6),
  11.350 +
  11.351 +  /* maximum number of (pipelining) connections to one host */
  11.352 +  CINIT(MAX_HOST_CONNECTIONS, LONG, 7),
  11.353 +
  11.354 +  /* maximum number of requests in a pipeline */
  11.355 +  CINIT(MAX_PIPELINE_LENGTH, LONG, 8),
  11.356 +
  11.357 +  /* a connection with a content-length longer than this
  11.358 +     will not be considered for pipelining */
  11.359 +  CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9),
  11.360 +
  11.361 +  /* a connection with a chunk length longer than this
  11.362 +     will not be considered for pipelining */
  11.363 +  CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10),
  11.364 +
  11.365 +  /* a list of site names(+port) that are blacklisted from
  11.366 +     pipelining */
  11.367 +  CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11),
  11.368 +
  11.369 +  /* a list of server types that are blacklisted from
  11.370 +     pipelining */
  11.371 +  CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12),
  11.372 +
  11.373 +  /* maximum number of open connections in total */
  11.374 +  CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13),
  11.375 +
  11.376 +  CURLMOPT_LASTENTRY /* the last unused */
  11.377 +} CURLMoption;
  11.378 +
  11.379 +
  11.380 +/*
  11.381 + * Name:    curl_multi_setopt()
  11.382 + *
  11.383 + * Desc:    Sets options for the multi handle.
  11.384 + *
  11.385 + * Returns: CURLM error code.
  11.386 + */
  11.387 +CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
  11.388 +                                        CURLMoption option, ...);
  11.389 +
  11.390 +
  11.391 +/*
  11.392 + * Name:    curl_multi_assign()
  11.393 + *
  11.394 + * Desc:    This function sets an association in the multi handle between the
  11.395 + *          given socket and a private pointer of the application. This is
  11.396 + *          (only) useful for curl_multi_socket uses.
  11.397 + *
  11.398 + * Returns: CURLM error code.
  11.399 + */
  11.400 +CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
  11.401 +                                        curl_socket_t sockfd, void *sockp);
  11.402 +
  11.403 +#ifdef __cplusplus
  11.404 +} /* end of extern "C" */
  11.405 +#endif
  11.406 +
  11.407 +#endif
    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/build-mac/curl/stdcheaders.h	Mon Aug 24 17:23:37 2015 +0200
    12.3 @@ -0,0 +1,33 @@
    12.4 +#ifndef __STDC_HEADERS_H
    12.5 +#define __STDC_HEADERS_H
    12.6 +/***************************************************************************
    12.7 + *                                  _   _ ____  _
    12.8 + *  Project                     ___| | | |  _ \| |
    12.9 + *                             / __| | | | |_) | |
   12.10 + *                            | (__| |_| |  _ <| |___
   12.11 + *                             \___|\___/|_| \_\_____|
   12.12 + *
   12.13 + * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
   12.14 + *
   12.15 + * This software is licensed as described in the file COPYING, which
   12.16 + * you should have received as part of this distribution. The terms
   12.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
   12.18 + *
   12.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
   12.20 + * copies of the Software, and permit persons to whom the Software is
   12.21 + * furnished to do so, under the terms of the COPYING file.
   12.22 + *
   12.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
   12.24 + * KIND, either express or implied.
   12.25 + *
   12.26 + ***************************************************************************/
   12.27 +
   12.28 +#include <sys/types.h>
   12.29 +
   12.30 +size_t fread (void *, size_t, size_t, FILE *);
   12.31 +size_t fwrite (const void *, size_t, size_t, FILE *);
   12.32 +
   12.33 +int strcasecmp(const char *, const char *);
   12.34 +int strncasecmp(const char *, const char *, size_t);
   12.35 +
   12.36 +#endif /* __STDC_HEADERS_H */
    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/build-mac/curl/typecheck-gcc.h	Mon Aug 24 17:23:37 2015 +0200
    13.3 @@ -0,0 +1,612 @@
    13.4 +#ifndef __CURL_TYPECHECK_GCC_H
    13.5 +#define __CURL_TYPECHECK_GCC_H
    13.6 +/***************************************************************************
    13.7 + *                                  _   _ ____  _
    13.8 + *  Project                     ___| | | |  _ \| |
    13.9 + *                             / __| | | | |_) | |
   13.10 + *                            | (__| |_| |  _ <| |___
   13.11 + *                             \___|\___/|_| \_\_____|
   13.12 + *
   13.13 + * Copyright (C) 1998 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.
   13.14 + *
   13.15 + * This software is licensed as described in the file COPYING, which
   13.16 + * you should have received as part of this distribution. The terms
   13.17 + * are also available at http://curl.haxx.se/docs/copyright.html.
   13.18 + *
   13.19 + * You may opt to use, copy, modify, merge, publish, distribute and/or sell
   13.20 + * copies of the Software, and permit persons to whom the Software is
   13.21 + * furnished to do so, under the terms of the COPYING file.
   13.22 + *
   13.23 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
   13.24 + * KIND, either express or implied.
   13.25 + *
   13.26 + ***************************************************************************/
   13.27 +
   13.28 +/* wraps curl_easy_setopt() with typechecking */
   13.29 +
   13.30 +/* To add a new kind of warning, add an
   13.31 + *   if(_curl_is_sometype_option(_curl_opt))
   13.32 + *     if(!_curl_is_sometype(value))
   13.33 + *       _curl_easy_setopt_err_sometype();
   13.34 + * block and define _curl_is_sometype_option, _curl_is_sometype and
   13.35 + * _curl_easy_setopt_err_sometype below
   13.36 + *
   13.37 + * NOTE: We use two nested 'if' statements here instead of the && operator, in
   13.38 + *       order to work around gcc bug #32061.  It affects only gcc 4.3.x/4.4.x
   13.39 + *       when compiling with -Wlogical-op.
   13.40 + *
   13.41 + * To add an option that uses the same type as an existing option, you'll just
   13.42 + * need to extend the appropriate _curl_*_option macro
   13.43 + */
   13.44 +#define curl_easy_setopt(handle, option, value)                               \
   13.45 +__extension__ ({                                                              \
   13.46 +  __typeof__ (option) _curl_opt = option;                                     \
   13.47 +  if(__builtin_constant_p(_curl_opt)) {                                       \
   13.48 +    if(_curl_is_long_option(_curl_opt))                                       \
   13.49 +      if(!_curl_is_long(value))                                               \
   13.50 +        _curl_easy_setopt_err_long();                                         \
   13.51 +    if(_curl_is_off_t_option(_curl_opt))                                      \
   13.52 +      if(!_curl_is_off_t(value))                                              \
   13.53 +        _curl_easy_setopt_err_curl_off_t();                                   \
   13.54 +    if(_curl_is_string_option(_curl_opt))                                     \
   13.55 +      if(!_curl_is_string(value))                                             \
   13.56 +        _curl_easy_setopt_err_string();                                       \
   13.57 +    if(_curl_is_write_cb_option(_curl_opt))                                   \
   13.58 +      if(!_curl_is_write_cb(value))                                           \
   13.59 +        _curl_easy_setopt_err_write_callback();                               \
   13.60 +    if((_curl_opt) == CURLOPT_READFUNCTION)                                   \
   13.61 +      if(!_curl_is_read_cb(value))                                            \
   13.62 +        _curl_easy_setopt_err_read_cb();                                      \
   13.63 +    if((_curl_opt) == CURLOPT_IOCTLFUNCTION)                                  \
   13.64 +      if(!_curl_is_ioctl_cb(value))                                           \
   13.65 +        _curl_easy_setopt_err_ioctl_cb();                                     \
   13.66 +    if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION)                                \
   13.67 +      if(!_curl_is_sockopt_cb(value))                                         \
   13.68 +        _curl_easy_setopt_err_sockopt_cb();                                   \
   13.69 +    if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION)                             \
   13.70 +      if(!_curl_is_opensocket_cb(value))                                      \
   13.71 +        _curl_easy_setopt_err_opensocket_cb();                                \
   13.72 +    if((_curl_opt) == CURLOPT_PROGRESSFUNCTION)                               \
   13.73 +      if(!_curl_is_progress_cb(value))                                        \
   13.74 +        _curl_easy_setopt_err_progress_cb();                                  \
   13.75 +    if((_curl_opt) == CURLOPT_DEBUGFUNCTION)                                  \
   13.76 +      if(!_curl_is_debug_cb(value))                                           \
   13.77 +        _curl_easy_setopt_err_debug_cb();                                     \
   13.78 +    if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION)                               \
   13.79 +      if(!_curl_is_ssl_ctx_cb(value))                                         \
   13.80 +        _curl_easy_setopt_err_ssl_ctx_cb();                                   \
   13.81 +    if(_curl_is_conv_cb_option(_curl_opt))                                    \
   13.82 +      if(!_curl_is_conv_cb(value))                                            \
   13.83 +        _curl_easy_setopt_err_conv_cb();                                      \
   13.84 +    if((_curl_opt) == CURLOPT_SEEKFUNCTION)                                   \
   13.85 +      if(!_curl_is_seek_cb(value))                                            \
   13.86 +        _curl_easy_setopt_err_seek_cb();                                      \
   13.87 +    if(_curl_is_cb_data_option(_curl_opt))                                    \
   13.88 +      if(!_curl_is_cb_data(value))                                            \
   13.89 +        _curl_easy_setopt_err_cb_data();                                      \
   13.90 +    if((_curl_opt) == CURLOPT_ERRORBUFFER)                                    \
   13.91 +      if(!_curl_is_error_buffer(value))                                       \
   13.92 +        _curl_easy_setopt_err_error_buffer();                                 \
   13.93 +    if((_curl_opt) == CURLOPT_STDERR)                                         \
   13.94 +      if(!_curl_is_FILE(value))                                               \
   13.95 +        _curl_easy_setopt_err_FILE();                                         \
   13.96 +    if(_curl_is_postfields_option(_curl_opt))                                 \
   13.97 +      if(!_curl_is_postfields(value))                                         \
   13.98 +        _curl_easy_setopt_err_postfields();                                   \
   13.99 +    if((_curl_opt) == CURLOPT_HTTPPOST)                                       \
  13.100 +      if(!_curl_is_arr((value), struct curl_httppost))                        \
  13.101 +        _curl_easy_setopt_err_curl_httpost();                                 \
  13.102 +    if(_curl_is_slist_option(_curl_opt))                                      \
  13.103 +      if(!_curl_is_arr((value), struct curl_slist))                           \
  13.104 +        _curl_easy_setopt_err_curl_slist();                                   \
  13.105 +    if((_curl_opt) == CURLOPT_SHARE)                                          \
  13.106 +      if(!_curl_is_ptr((value), CURLSH))                                      \
  13.107 +        _curl_easy_setopt_err_CURLSH();                                       \
  13.108 +  }                                                                           \
  13.109 +  curl_easy_setopt(handle, _curl_opt, value);                                 \
  13.110 +})
  13.111 +
  13.112 +/* wraps curl_easy_getinfo() with typechecking */
  13.113 +/* FIXME: don't allow const pointers */
  13.114 +#define curl_easy_getinfo(handle, info, arg)                                  \
  13.115 +__extension__ ({                                                              \
  13.116 +  __typeof__ (info) _curl_info = info;                                        \
  13.117 +  if(__builtin_constant_p(_curl_info)) {                                      \
  13.118 +    if(_curl_is_string_info(_curl_info))                                      \
  13.119 +      if(!_curl_is_arr((arg), char *))                                        \
  13.120 +        _curl_easy_getinfo_err_string();                                      \
  13.121 +    if(_curl_is_long_info(_curl_info))                                        \
  13.122 +      if(!_curl_is_arr((arg), long))                                          \
  13.123 +        _curl_easy_getinfo_err_long();                                        \
  13.124 +    if(_curl_is_double_info(_curl_info))                                      \
  13.125 +      if(!_curl_is_arr((arg), double))                                        \
  13.126 +        _curl_easy_getinfo_err_double();                                      \
  13.127 +    if(_curl_is_slist_info(_curl_info))                                       \
  13.128 +      if(!_curl_is_arr((arg), struct curl_slist *))                           \
  13.129 +        _curl_easy_getinfo_err_curl_slist();                                  \
  13.130 +  }                                                                           \
  13.131 +  curl_easy_getinfo(handle, _curl_info, arg);                                 \
  13.132 +})
  13.133 +
  13.134 +/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(),
  13.135 + * for now just make sure that the functions are called with three
  13.136 + * arguments
  13.137 + */
  13.138 +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
  13.139 +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
  13.140 +
  13.141 +
  13.142 +/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
  13.143 + * functions */
  13.144 +
  13.145 +/* To define a new warning, use _CURL_WARNING(identifier, "message") */
  13.146 +#define _CURL_WARNING(id, message)                                            \
  13.147 +  static void __attribute__((__warning__(message)))                           \
  13.148 +  __attribute__((__unused__)) __attribute__((__noinline__))                   \
  13.149 +  id(void) { __asm__(""); }
  13.150 +
  13.151 +_CURL_WARNING(_curl_easy_setopt_err_long,
  13.152 +  "curl_easy_setopt expects a long argument for this option")
  13.153 +_CURL_WARNING(_curl_easy_setopt_err_curl_off_t,
  13.154 +  "curl_easy_setopt expects a curl_off_t argument for this option")
  13.155 +_CURL_WARNING(_curl_easy_setopt_err_string,
  13.156 +              "curl_easy_setopt expects a "
  13.157 +              "string (char* or char[]) argument for this option"
  13.158 +  )
  13.159 +_CURL_WARNING(_curl_easy_setopt_err_write_callback,
  13.160 +  "curl_easy_setopt expects a curl_write_callback argument for this option")
  13.161 +_CURL_WARNING(_curl_easy_setopt_err_read_cb,
  13.162 +  "curl_easy_setopt expects a curl_read_callback argument for this option")
  13.163 +_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb,
  13.164 +  "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
  13.165 +_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb,
  13.166 +  "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
  13.167 +_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb,
  13.168 +              "curl_easy_setopt expects a "
  13.169 +              "curl_opensocket_callback argument for this option"
  13.170 +  )
  13.171 +_CURL_WARNING(_curl_easy_setopt_err_progress_cb,
  13.172 +  "curl_easy_setopt expects a curl_progress_callback argument for this option")
  13.173 +_CURL_WARNING(_curl_easy_setopt_err_debug_cb,
  13.174 +  "curl_easy_setopt expects a curl_debug_callback argument for this option")
  13.175 +_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb,
  13.176 +  "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
  13.177 +_CURL_WARNING(_curl_easy_setopt_err_conv_cb,
  13.178 +  "curl_easy_setopt expects a curl_conv_callback argument for this option")
  13.179 +_CURL_WARNING(_curl_easy_setopt_err_seek_cb,
  13.180 +  "curl_easy_setopt expects a curl_seek_callback argument for this option")
  13.181 +_CURL_WARNING(_curl_easy_setopt_err_cb_data,
  13.182 +              "curl_easy_setopt expects a "
  13.183 +              "private data pointer as argument for this option")
  13.184 +_CURL_WARNING(_curl_easy_setopt_err_error_buffer,
  13.185 +              "curl_easy_setopt expects a "
  13.186 +              "char buffer of CURL_ERROR_SIZE as argument for this option")
  13.187 +_CURL_WARNING(_curl_easy_setopt_err_FILE,
  13.188 +  "curl_easy_setopt expects a FILE* argument for this option")
  13.189 +_CURL_WARNING(_curl_easy_setopt_err_postfields,
  13.190 +  "curl_easy_setopt expects a void* or char* argument for this option")
  13.191 +_CURL_WARNING(_curl_easy_setopt_err_curl_httpost,
  13.192 +  "curl_easy_setopt expects a struct curl_httppost* argument for this option")
  13.193 +_CURL_WARNING(_curl_easy_setopt_err_curl_slist,
  13.194 +  "curl_easy_setopt expects a struct curl_slist* argument for this option")
  13.195 +_CURL_WARNING(_curl_easy_setopt_err_CURLSH,
  13.196 +  "curl_easy_setopt expects a CURLSH* argument for this option")
  13.197 +
  13.198 +_CURL_WARNING(_curl_easy_getinfo_err_string,
  13.199 +  "curl_easy_getinfo expects a pointer to char * for this info")
  13.200 +_CURL_WARNING(_curl_easy_getinfo_err_long,
  13.201 +  "curl_easy_getinfo expects a pointer to long for this info")
  13.202 +_CURL_WARNING(_curl_easy_getinfo_err_double,
  13.203 +  "curl_easy_getinfo expects a pointer to double for this info")
  13.204 +_CURL_WARNING(_curl_easy_getinfo_err_curl_slist,
  13.205 +  "curl_easy_getinfo expects a pointer to struct curl_slist * for this info")
  13.206 +
  13.207 +/* groups of curl_easy_setops options that take the same type of argument */
  13.208 +
  13.209 +/* To add a new option to one of the groups, just add
  13.210 + *   (option) == CURLOPT_SOMETHING
  13.211 + * to the or-expression. If the option takes a long or curl_off_t, you don't
  13.212 + * have to do anything
  13.213 + */
  13.214 +
  13.215 +/* evaluates to true if option takes a long argument */
  13.216 +#define _curl_is_long_option(option)                                          \
  13.217 +  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
  13.218 +
  13.219 +#define _curl_is_off_t_option(option)                                         \
  13.220 +  ((option) > CURLOPTTYPE_OFF_T)
  13.221 +
  13.222 +/* evaluates to true if option takes a char* argument */
  13.223 +#define _curl_is_string_option(option)                                        \
  13.224 +  ((option) == CURLOPT_URL ||                                                 \
  13.225 +   (option) == CURLOPT_PROXY ||                                               \
  13.226 +   (option) == CURLOPT_INTERFACE ||                                           \
  13.227 +   (option) == CURLOPT_NETRC_FILE ||                                          \
  13.228 +   (option) == CURLOPT_USERPWD ||                                             \
  13.229 +   (option) == CURLOPT_USERNAME ||                                            \
  13.230 +   (option) == CURLOPT_PASSWORD ||                                            \
  13.231 +   (option) == CURLOPT_PROXYUSERPWD ||                                        \
  13.232 +   (option) == CURLOPT_PROXYUSERNAME ||                                       \
  13.233 +   (option) == CURLOPT_PROXYPASSWORD ||                                       \
  13.234 +   (option) == CURLOPT_NOPROXY ||                                             \
  13.235 +   (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
  13.236 +   (option) == CURLOPT_REFERER ||                                             \
  13.237 +   (option) == CURLOPT_USERAGENT ||                                           \
  13.238 +   (option) == CURLOPT_COOKIE ||                                              \
  13.239 +   (option) == CURLOPT_COOKIEFILE ||                                          \
  13.240 +   (option) == CURLOPT_COOKIEJAR ||                                           \
  13.241 +   (option) == CURLOPT_COOKIELIST ||                                          \
  13.242 +   (option) == CURLOPT_FTPPORT ||                                             \
  13.243 +   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                             \
  13.244 +   (option) == CURLOPT_FTP_ACCOUNT ||                                         \
  13.245 +   (option) == CURLOPT_RANGE ||                                               \
  13.246 +   (option) == CURLOPT_CUSTOMREQUEST ||                                       \
  13.247 +   (option) == CURLOPT_SSLCERT ||                                             \
  13.248 +   (option) == CURLOPT_SSLCERTTYPE ||                                         \
  13.249 +   (option) == CURLOPT_SSLKEY ||                                              \
  13.250 +   (option) == CURLOPT_SSLKEYTYPE ||                                          \
  13.251 +   (option) == CURLOPT_KEYPASSWD ||                                           \
  13.252 +   (option) == CURLOPT_SSLENGINE ||                                           \
  13.253 +   (option) == CURLOPT_CAINFO ||                                              \
  13.254 +   (option) == CURLOPT_CAPATH ||                                              \
  13.255 +   (option) == CURLOPT_RANDOM_FILE ||                                         \
  13.256 +   (option) == CURLOPT_EGDSOCKET ||                                           \
  13.257 +   (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
  13.258 +   (option) == CURLOPT_KRBLEVEL ||                                            \
  13.259 +   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
  13.260 +   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                                  \
  13.261 +   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                                 \
  13.262 +   (option) == CURLOPT_CRLFILE ||                                             \
  13.263 +   (option) == CURLOPT_ISSUERCERT ||                                          \
  13.264 +   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
  13.265 +   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                      \
  13.266 +   (option) == CURLOPT_MAIL_FROM ||                                           \
  13.267 +   (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
  13.268 +   (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
  13.269 +   (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
  13.270 +   (option) == CURLOPT_XOAUTH2_BEARER ||                                      \
  13.271 +   (option) == CURLOPT_DNS_SERVERS ||                                         \
  13.272 +   (option) == CURLOPT_DNS_INTERFACE ||                                       \
  13.273 +   (option) == CURLOPT_DNS_LOCAL_IP4 ||                                       \
  13.274 +   (option) == CURLOPT_DNS_LOCAL_IP6 ||                                       \
  13.275 +   (option) == CURLOPT_LOGIN_OPTIONS ||                                       \
  13.276 +   (option) == CURLOPT_PROXY_SERVICE_NAME ||                                  \
  13.277 +   (option) == CURLOPT_SERVICE_NAME ||                                        \
  13.278 +   0)
  13.279 +
  13.280 +/* evaluates to true if option takes a curl_write_callback argument */
  13.281 +#define _curl_is_write_cb_option(option)                                      \
  13.282 +  ((option) == CURLOPT_HEADERFUNCTION ||                                      \
  13.283 +   (option) == CURLOPT_WRITEFUNCTION)
  13.284 +
  13.285 +/* evaluates to true if option takes a curl_conv_callback argument */
  13.286 +#define _curl_is_conv_cb_option(option)                                       \
  13.287 +  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                            \
  13.288 +   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                          \
  13.289 +   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
  13.290 +
  13.291 +/* evaluates to true if option takes a data argument to pass to a callback */
  13.292 +#define _curl_is_cb_data_option(option)                                       \
  13.293 +  ((option) == CURLOPT_WRITEDATA ||                                           \
  13.294 +   (option) == CURLOPT_READDATA ||                                            \
  13.295 +   (option) == CURLOPT_IOCTLDATA ||                                           \
  13.296 +   (option) == CURLOPT_SOCKOPTDATA ||                                         \
  13.297 +   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
  13.298 +   (option) == CURLOPT_PROGRESSDATA ||                                        \
  13.299 +   (option) == CURLOPT_HEADERDATA ||                                         \
  13.300 +   (option) == CURLOPT_DEBUGDATA ||                                           \
  13.301 +   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
  13.302 +   (option) == CURLOPT_SEEKDATA ||                                            \
  13.303 +   (option) == CURLOPT_PRIVATE ||                                             \
  13.304 +   (option) == CURLOPT_SSH_KEYDATA ||                                         \
  13.305 +   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
  13.306 +   (option) == CURLOPT_CHUNK_DATA ||                                          \
  13.307 +   (option) == CURLOPT_FNMATCH_DATA ||                                        \
  13.308 +   0)
  13.309 +
  13.310 +/* evaluates to true if option takes a POST data argument (void* or char*) */
  13.311 +#define _curl_is_postfields_option(option)                                    \
  13.312 +  ((option) == CURLOPT_POSTFIELDS ||                                          \
  13.313 +   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
  13.314 +   0)
  13.315 +
  13.316 +/* evaluates to true if option takes a struct curl_slist * argument */
  13.317 +#define _curl_is_slist_option(option)                                         \
  13.318 +  ((option) == CURLOPT_HTTPHEADER ||                                          \
  13.319 +   (option) == CURLOPT_HTTP200ALIASES ||                                      \
  13.320 +   (option) == CURLOPT_QUOTE ||                                               \
  13.321 +   (option) == CURLOPT_POSTQUOTE ||                                           \
  13.322 +   (option) == CURLOPT_PREQUOTE ||                                            \
  13.323 +   (option) == CURLOPT_TELNETOPTIONS ||                                       \
  13.324 +   (option) == CURLOPT_MAIL_RCPT ||                                           \
  13.325 +   0)
  13.326 +
  13.327 +/* groups of curl_easy_getinfo infos that take the same type of argument */
  13.328 +
  13.329 +/* evaluates to true if info expects a pointer to char * argument */
  13.330 +#define _curl_is_string_info(info)                                            \
  13.331 +  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG)
  13.332 +
  13.333 +/* evaluates to true if info expects a pointer to long argument */
  13.334 +#define _curl_is_long_info(info)                                              \
  13.335 +  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
  13.336 +
  13.337 +/* evaluates to true if info expects a pointer to double argument */
  13.338 +#define _curl_is_double_info(info)                                            \
  13.339 +  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
  13.340 +
  13.341 +/* true if info expects a pointer to struct curl_slist * argument */
  13.342 +#define _curl_is_slist_info(info)                                             \
  13.343 +  (CURLINFO_SLIST < (info))
  13.344 +
  13.345 +
  13.346 +/* typecheck helpers -- check whether given expression has requested type*/
  13.347 +
  13.348 +/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros,
  13.349 + * otherwise define a new macro. Search for __builtin_types_compatible_p
  13.350 + * in the GCC manual.
  13.351 + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
  13.352 + * the actual expression passed to the curl_easy_setopt macro. This
  13.353 + * means that you can only apply the sizeof and __typeof__ operators, no
  13.354 + * == or whatsoever.
  13.355 + */
  13.356 +
  13.357 +/* XXX: should evaluate to true iff expr is a pointer */
  13.358 +#define _curl_is_any_ptr(expr)                                                \
  13.359 +  (sizeof(expr) == sizeof(void*))
  13.360 +
  13.361 +/* evaluates to true if expr is NULL */
  13.362 +/* XXX: must not evaluate expr, so this check is not accurate */
  13.363 +#define _curl_is_NULL(expr)                                                   \
  13.364 +  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
  13.365 +
  13.366 +/* evaluates to true if expr is type*, const type* or NULL */
  13.367 +#define _curl_is_ptr(expr, type)                                              \
  13.368 +  (_curl_is_NULL(expr) ||                                                     \
  13.369 +   __builtin_types_compatible_p(__typeof__(expr), type *) ||                  \
  13.370 +   __builtin_types_compatible_p(__typeof__(expr), const type *))
  13.371 +
  13.372 +/* evaluates to true if expr is one of type[], type*, NULL or const type* */
  13.373 +#define _curl_is_arr(expr, type)                                              \
  13.374 +  (_curl_is_ptr((expr), type) ||                                              \
  13.375 +   __builtin_types_compatible_p(__typeof__(expr), type []))
  13.376 +
  13.377 +/* evaluates to true if expr is a string */
  13.378 +#define _curl_is_string(expr)                                                 \
  13.379 +  (_curl_is_arr((expr), char) ||                                              \
  13.380 +   _curl_is_arr((expr), signed char) ||                                       \
  13.381 +   _curl_is_arr((expr), unsigned char))
  13.382 +
  13.383 +/* evaluates to true if expr is a long (no matter the signedness)
  13.384 + * XXX: for now, int is also accepted (and therefore short and char, which
  13.385 + * are promoted to int when passed to a variadic function) */
  13.386 +#define _curl_is_long(expr)                                                   \
  13.387 +  (__builtin_types_compatible_p(__typeof__(expr), long) ||                    \
  13.388 +   __builtin_types_compatible_p(__typeof__(expr), signed long) ||             \
  13.389 +   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||           \
  13.390 +   __builtin_types_compatible_p(__typeof__(expr), int) ||                     \
  13.391 +   __builtin_types_compatible_p(__typeof__(expr), signed int) ||              \
  13.392 +   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||            \
  13.393 +   __builtin_types_compatible_p(__typeof__(expr), short) ||                   \
  13.394 +   __builtin_types_compatible_p(__typeof__(expr), signed short) ||            \
  13.395 +   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||          \
  13.396 +   __builtin_types_compatible_p(__typeof__(expr), char) ||                    \
  13.397 +   __builtin_types_compatible_p(__typeof__(expr), signed char) ||             \
  13.398 +   __builtin_types_compatible_p(__typeof__(expr), unsigned char))
  13.399 +
  13.400 +/* evaluates to true if expr is of type curl_off_t */
  13.401 +#define _curl_is_off_t(expr)                                                  \
  13.402 +  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
  13.403 +
  13.404 +/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
  13.405 +/* XXX: also check size of an char[] array? */
  13.406 +#define _curl_is_error_buffer(expr)                                           \
  13.407 +  (_curl_is_NULL(expr) ||                                                     \
  13.408 +   __builtin_types_compatible_p(__typeof__(expr), char *) ||                  \
  13.409 +   __builtin_types_compatible_p(__typeof__(expr), char[]))
  13.410 +
  13.411 +/* evaluates to true if expr is of type (const) void* or (const) FILE* */
  13.412 +#if 0
  13.413 +#define _curl_is_cb_data(expr)                                                \
  13.414 +  (_curl_is_ptr((expr), void) ||                                              \
  13.415 +   _curl_is_ptr((expr), FILE))
  13.416 +#else /* be less strict */
  13.417 +#define _curl_is_cb_data(expr)                                                \
  13.418 +  _curl_is_any_ptr(expr)
  13.419 +#endif
  13.420 +
  13.421 +/* evaluates to true if expr is of type FILE* */
  13.422 +#define _curl_is_FILE(expr)                                                   \
  13.423 +  (__builtin_types_compatible_p(__typeof__(expr), FILE *))
  13.424 +
  13.425 +/* evaluates to true if expr can be passed as POST data (void* or char*) */
  13.426 +#define _curl_is_postfields(expr)                                             \
  13.427 +  (_curl_is_ptr((expr), void) ||                                              \
  13.428 +   _curl_is_arr((expr), char))
  13.429 +
  13.430 +/* FIXME: the whole callback checking is messy...
  13.431 + * The idea is to tolerate char vs. void and const vs. not const
  13.432 + * pointers in arguments at least
  13.433 + */
  13.434 +/* helper: __builtin_types_compatible_p distinguishes between functions and
  13.435 + * function pointers, hide it */
  13.436 +#define _curl_callback_compatible(func, type)                                 \
  13.437 +  (__builtin_types_compatible_p(__typeof__(func), type) ||                    \
  13.438 +   __builtin_types_compatible_p(__typeof__(func), type*))
  13.439 +
  13.440 +/* evaluates to true if expr is of type curl_read_callback or "similar" */
  13.441 +#define _curl_is_read_cb(expr)                                          \
  13.442 +  (_curl_is_NULL(expr) ||                                                     \
  13.443 +   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) ||       \
  13.444 +   __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) ||      \
  13.445 +   _curl_callback_compatible((expr), _curl_read_callback1) ||                 \
  13.446 +   _curl_callback_compatible((expr), _curl_read_callback2) ||                 \
  13.447 +   _curl_callback_compatible((expr), _curl_read_callback3) ||                 \
  13.448 +   _curl_callback_compatible((expr), _curl_read_callback4) ||                 \
  13.449 +   _curl_callback_compatible((expr), _curl_read_callback5) ||                 \
  13.450 +   _curl_callback_compatible((expr), _curl_read_callback6))
  13.451 +typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*);
  13.452 +typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*);
  13.453 +typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*);
  13.454 +typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*);
  13.455 +typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*);
  13.456 +typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*);
  13.457 +
  13.458 +/* evaluates to true if expr is of type curl_write_callback or "similar" */
  13.459 +#define _curl_is_write_cb(expr)                                               \
  13.460 +  (_curl_is_read_cb(expr) ||                                            \
  13.461 +   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) ||      \
  13.462 +   __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) ||     \
  13.463 +   _curl_callback_compatible((expr), _curl_write_callback1) ||                \
  13.464 +   _curl_callback_compatible((expr), _curl_write_callback2) ||                \
  13.465 +   _curl_callback_compatible((expr), _curl_write_callback3) ||                \
  13.466 +   _curl_callback_compatible((expr), _curl_write_callback4) ||                \
  13.467 +   _curl_callback_compatible((expr), _curl_write_callback5) ||                \
  13.468 +   _curl_callback_compatible((expr), _curl_write_callback6))
  13.469 +typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*);
  13.470 +typedef size_t (_curl_write_callback2)(const char *, size_t, size_t,
  13.471 +                                       const void*);
  13.472 +typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*);
  13.473 +typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*);
  13.474 +typedef size_t (_curl_write_callback5)(const void *, size_t, size_t,
  13.475 +                                       const void*);
  13.476 +typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*);
  13.477 +
  13.478 +/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
  13.479 +#define _curl_is_ioctl_cb(expr)                                         \
  13.480 +  (_curl_is_NULL(expr) ||                                                     \
  13.481 +   __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) ||     \
  13.482 +   _curl_callback_compatible((expr), _curl_ioctl_callback1) ||                \
  13.483 +   _curl_callback_compatible((expr), _curl_ioctl_callback2) ||                \
  13.484 +   _curl_callback_compatible((expr), _curl_ioctl_callback3) ||                \
  13.485 +   _curl_callback_compatible((expr), _curl_ioctl_callback4))
  13.486 +typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*);
  13.487 +typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*);
  13.488 +typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*);
  13.489 +typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*);
  13.490 +
  13.491 +/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
  13.492 +#define _curl_is_sockopt_cb(expr)                                       \
  13.493 +  (_curl_is_NULL(expr) ||                                                     \
  13.494 +   __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) ||   \
  13.495 +   _curl_callback_compatible((expr), _curl_sockopt_callback1) ||              \
  13.496 +   _curl_callback_compatible((expr), _curl_sockopt_callback2))
  13.497 +typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
  13.498 +typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t,
  13.499 +                                      curlsocktype);
  13.500 +
  13.501 +/* evaluates to true if expr is of type curl_opensocket_callback or
  13.502 +   "similar" */
  13.503 +#define _curl_is_opensocket_cb(expr)                                    \
  13.504 +  (_curl_is_NULL(expr) ||                                                     \
  13.505 +   __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\
  13.506 +   _curl_callback_compatible((expr), _curl_opensocket_callback1) ||           \
  13.507 +   _curl_callback_compatible((expr), _curl_opensocket_callback2) ||           \
  13.508 +   _curl_callback_compatible((expr), _curl_opensocket_callback3) ||           \
  13.509 +   _curl_callback_compatible((expr), _curl_opensocket_callback4))
  13.510 +typedef curl_socket_t (_curl_opensocket_callback1)
  13.511 +  (void *, curlsocktype, struct curl_sockaddr *);
  13.512 +typedef curl_socket_t (_curl_opensocket_callback2)
  13.513 +  (void *, curlsocktype, const struct curl_sockaddr *);
  13.514 +typedef curl_socket_t (_curl_opensocket_callback3)
  13.515 +  (const void *, curlsocktype, struct curl_sockaddr *);
  13.516 +typedef curl_socket_t (_curl_opensocket_callback4)
  13.517 +  (const void *, curlsocktype, const struct curl_sockaddr *);
  13.518 +
  13.519 +/* evaluates to true if expr is of type curl_progress_callback or "similar" */
  13.520 +#define _curl_is_progress_cb(expr)                                      \
  13.521 +  (_curl_is_NULL(expr) ||                                                     \
  13.522 +   __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) ||  \
  13.523 +   _curl_callback_compatible((expr), _curl_progress_callback1) ||             \
  13.524 +   _curl_callback_compatible((expr), _curl_progress_callback2))
  13.525 +typedef int (_curl_progress_callback1)(void *,
  13.526 +    double, double, double, double);
  13.527 +typedef int (_curl_progress_callback2)(const void *,
  13.528 +    double, double, double, double);
  13.529 +
  13.530 +/* evaluates to true if expr is of type curl_debug_callback or "similar" */
  13.531 +#define _curl_is_debug_cb(expr)                                         \
  13.532 +  (_curl_is_NULL(expr) ||                                                     \
  13.533 +   __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) ||     \
  13.534 +   _curl_callback_compatible((expr), _curl_debug_callback1) ||                \
  13.535 +   _curl_callback_compatible((expr), _curl_debug_callback2) ||                \
  13.536 +   _curl_callback_compatible((expr), _curl_debug_callback3) ||                \
  13.537 +   _curl_callback_compatible((expr), _curl_debug_callback4) ||                \
  13.538 +   _curl_callback_compatible((expr), _curl_debug_callback5) ||                \
  13.539 +   _curl_callback_compatible((expr), _curl_debug_callback6) ||                \
  13.540 +   _curl_callback_compatible((expr), _curl_debug_callback7) ||                \
  13.541 +   _curl_callback_compatible((expr), _curl_debug_callback8))
  13.542 +typedef int (_curl_debug_callback1) (CURL *,
  13.543 +    curl_infotype, char *, size_t, void *);
  13.544 +typedef int (_curl_debug_callback2) (CURL *,
  13.545 +    curl_infotype, char *, size_t, const void *);
  13.546 +typedef int (_curl_debug_callback3) (CURL *,
  13.547 +    curl_infotype, const char *, size_t, void *);
  13.548 +typedef int (_curl_debug_callback4) (CURL *,
  13.549 +    curl_infotype, const char *, size_t, const void *);
  13.550 +typedef int (_curl_debug_callback5) (CURL *,
  13.551 +    curl_infotype, unsigned char *, size_t, void *);
  13.552 +typedef int (_curl_debug_callback6) (CURL *,
  13.553 +    curl_infotype, unsigned char *, size_t, const void *);
  13.554 +typedef int (_curl_debug_callback7) (CURL *,
  13.555 +    curl_infotype, const unsigned char *, size_t, void *);
  13.556 +typedef int (_curl_debug_callback8) (CURL *,
  13.557 +    curl_infotype, const unsigned char *, size_t, const void *);
  13.558 +
  13.559 +/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
  13.560 +/* this is getting even messier... */
  13.561 +#define _curl_is_ssl_ctx_cb(expr)                                       \
  13.562 +  (_curl_is_NULL(expr) ||                                                     \
  13.563 +   __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) ||   \
  13.564 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) ||              \
  13.565 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) ||              \
  13.566 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) ||              \
  13.567 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) ||              \
  13.568 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) ||              \
  13.569 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) ||              \
  13.570 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) ||              \
  13.571 +   _curl_callback_compatible((expr), _curl_ssl_ctx_callback8))
  13.572 +typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *);
  13.573 +typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
  13.574 +typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
  13.575 +typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *);
  13.576 +#ifdef HEADER_SSL_H
  13.577 +/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
  13.578 + * this will of course break if we're included before OpenSSL headers...
  13.579 + */
  13.580 +typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *);
  13.581 +typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *);
  13.582 +typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *);
  13.583 +typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX,
  13.584 +                                           const void *);
  13.585 +#else
  13.586 +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
  13.587 +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
  13.588 +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
  13.589 +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
  13.590 +#endif
  13.591 +
  13.592 +/* evaluates to true if expr is of type curl_conv_callback or "similar" */
  13.593 +#define _curl_is_conv_cb(expr)                                          \
  13.594 +  (_curl_is_NULL(expr) ||                                                     \
  13.595 +   __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) ||      \
  13.596 +   _curl_callback_compatible((expr), _curl_conv_callback1) ||                 \
  13.597 +   _curl_callback_compatible((expr), _curl_conv_callback2) ||                 \
  13.598 +   _curl_callback_compatible((expr), _curl_conv_callback3) ||                 \
  13.599 +   _curl_callback_compatible((expr), _curl_conv_callback4))
  13.600 +typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
  13.601 +typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
  13.602 +typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
  13.603 +typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
  13.604 +
  13.605 +/* evaluates to true if expr is of type curl_seek_callback or "similar" */
  13.606 +#define _curl_is_seek_cb(expr)                                          \
  13.607 +  (_curl_is_NULL(expr) ||                                                     \
  13.608 +   __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) ||      \
  13.609 +   _curl_callback_compatible((expr), _curl_seek_callback1) ||                 \
  13.610 +   _curl_callback_compatible((expr), _curl_seek_callback2))
  13.611 +typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
  13.612 +typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
  13.613 +
  13.614 +
  13.615 +#endif /* __CURL_TYPECHECK_GCC_H */
    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/build-mac/pEpEngine.xcodeproj/project.pbxproj	Mon Aug 24 17:23:37 2015 +0200
    14.3 @@ -0,0 +1,551 @@
    14.4 +// !$*UTF8*$!
    14.5 +{
    14.6 +	archiveVersion = 1;
    14.7 +	classes = {
    14.8 +	};
    14.9 +	objectVersion = 46;
   14.10 +	objects = {
   14.11 +
   14.12 +/* Begin PBXBuildFile section */
   14.13 +		649DE08B1B45C19100912F72 /* libcurl.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 649DE08A1B45C19100912F72 /* libcurl.a */; };
   14.14 +		64A826781B455D0800EECAF0 /* bloblist.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8264C1B455D0800EECAF0 /* bloblist.c */; };
   14.15 +		64A826791B455D0800EECAF0 /* cryptotech.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8264E1B455D0800EECAF0 /* cryptotech.c */; };
   14.16 +		64A8267A1B455D0800EECAF0 /* email.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826511B455D0800EECAF0 /* email.c */; };
   14.17 +		64A8267B1B455D0800EECAF0 /* etpan_mime.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826531B455D0800EECAF0 /* etpan_mime.c */; };
   14.18 +		64A8267C1B455D0800EECAF0 /* identity_list.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826551B455D0800EECAF0 /* identity_list.c */; };
   14.19 +		64A8267D1B455D0800EECAF0 /* keymanagement.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826571B455D0800EECAF0 /* keymanagement.c */; };
   14.20 +		64A8267E1B455D0800EECAF0 /* message_api.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826591B455D0800EECAF0 /* message_api.c */; };
   14.21 +		64A8267F1B455D0800EECAF0 /* message.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8265B1B455D0800EECAF0 /* message.c */; };
   14.22 +		64A826801B455D0800EECAF0 /* mime.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8265D1B455D0800EECAF0 /* mime.c */; };
   14.23 +		64A826811B455D0800EECAF0 /* pEpEngine.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826601B455D0800EECAF0 /* pEpEngine.c */; };
   14.24 +		64A826821B455D0800EECAF0 /* pgp_netpgp.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826631B455D0800EECAF0 /* pgp_netpgp.c */; };
   14.25 +		64A826831B455D0800EECAF0 /* platform_unix.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826651B455D0800EECAF0 /* platform_unix.c */; };
   14.26 +		64A826851B455D0800EECAF0 /* sqlite3.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8266B1B455D0800EECAF0 /* sqlite3.c */; };
   14.27 +		64A826861B455D0800EECAF0 /* stringlist.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8266D1B455D0800EECAF0 /* stringlist.c */; };
   14.28 +		64A826871B455D0800EECAF0 /* stringpair.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A8266F1B455D0800EECAF0 /* stringpair.c */; };
   14.29 +		64A826881B455D0800EECAF0 /* timestamp.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826711B455D0800EECAF0 /* timestamp.c */; };
   14.30 +		64A826891B455D0800EECAF0 /* trans_auto.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826731B455D0800EECAF0 /* trans_auto.c */; };
   14.31 +		64A8268A1B455D0800EECAF0 /* transport.c in Sources */ = {isa = PBXBuildFile; fileRef = 64A826751B455D0800EECAF0 /* transport.c */; };
   14.32 +		64A8268C1B455D9D00EECAF0 /* pEpEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 64A826611B455D0800EECAF0 /* pEpEngine.h */; };
   14.33 +/* End PBXBuildFile section */
   14.34 +
   14.35 +/* Begin PBXContainerItemProxy section */
   14.36 +		64289E321B8B630200FC617B /* PBXContainerItemProxy */ = {
   14.37 +			isa = PBXContainerItemProxy;
   14.38 +			containerPortal = 64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */;
   14.39 +			proxyType = 2;
   14.40 +			remoteGlobalIDString = 8DC2EF5B0486A6940098B216;
   14.41 +			remoteInfo = libetpan;
   14.42 +		};
   14.43 +		64289E341B8B630200FC617B /* PBXContainerItemProxy */ = {
   14.44 +			isa = PBXContainerItemProxy;
   14.45 +			containerPortal = 64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */;
   14.46 +			proxyType = 2;
   14.47 +			remoteGlobalIDString = C69AB10A10546FE500F32FBD;
   14.48 +			remoteInfo = "static libetpan";
   14.49 +		};
   14.50 +		64289E361B8B630200FC617B /* PBXContainerItemProxy */ = {
   14.51 +			isa = PBXContainerItemProxy;
   14.52 +			containerPortal = 64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */;
   14.53 +			proxyType = 2;
   14.54 +			remoteGlobalIDString = C682E2C015B315EF00BE9DA7;
   14.55 +			remoteInfo = "libetpan ios";
   14.56 +		};
   14.57 +		64289E3C1B8B632600FC617B /* PBXContainerItemProxy */ = {
   14.58 +			isa = PBXContainerItemProxy;
   14.59 +			containerPortal = 64DA240C1B832EA0000BEE80 /* netpgp.xcodeproj */;
   14.60 +			proxyType = 2;
   14.61 +			remoteGlobalIDString = 64AA9C201B45686800D0F542;
   14.62 +			remoteInfo = netpgp;
   14.63 +		};
   14.64 +		64289E3E1B8B638800FC617B /* PBXContainerItemProxy */ = {
   14.65 +			isa = PBXContainerItemProxy;
   14.66 +			containerPortal = 64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */;
   14.67 +			proxyType = 1;
   14.68 +			remoteGlobalIDString = C682E21815B315EF00BE9DA7;
   14.69 +			remoteInfo = "libetpan ios";
   14.70 +		};
   14.71 +		64289E401B8B638F00FC617B /* PBXContainerItemProxy */ = {
   14.72 +			isa = PBXContainerItemProxy;
   14.73 +			containerPortal = 64DA240C1B832EA0000BEE80 /* netpgp.xcodeproj */;
   14.74 +			proxyType = 1;
   14.75 +			remoteGlobalIDString = 64AA9C1F1B45686800D0F542;
   14.76 +			remoteInfo = netpgp;
   14.77 +		};
   14.78 +/* End PBXContainerItemProxy section */
   14.79 +
   14.80 +/* Begin PBXCopyFilesBuildPhase section */
   14.81 +		64796A3D1B455AA5004B1C24 /* CopyFiles */ = {
   14.82 +			isa = PBXCopyFilesBuildPhase;
   14.83 +			buildActionMask = 2147483647;
   14.84 +			dstPath = "include/$(PRODUCT_NAME)";
   14.85 +			dstSubfolderSpec = 16;
   14.86 +			files = (
   14.87 +			);
   14.88 +			runOnlyForDeploymentPostprocessing = 0;
   14.89 +		};
   14.90 +/* End PBXCopyFilesBuildPhase section */
   14.91 +
   14.92 +/* Begin PBXFileReference section */
   14.93 +		64796A3F1B455AA5004B1C24 /* libpEpEngine.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libpEpEngine.a; sourceTree = BUILT_PRODUCTS_DIR; };
   14.94 +		649DE08A1B45C19100912F72 /* libcurl.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libcurl.a; sourceTree = "<group>"; };
   14.95 +		649DE08C1B45D3B700912F72 /* build-libcurl-ios.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = "build-libcurl-ios.sh"; sourceTree = "<group>"; };
   14.96 +		64A8264C1B455D0800EECAF0 /* bloblist.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bloblist.c; path = ../src/bloblist.c; sourceTree = "<group>"; };
   14.97 +		64A8264D1B455D0800EECAF0 /* bloblist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bloblist.h; path = ../src/bloblist.h; sourceTree = "<group>"; };
   14.98 +		64A8264E1B455D0800EECAF0 /* cryptotech.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = cryptotech.c; path = ../src/cryptotech.c; sourceTree = "<group>"; };
   14.99 +		64A8264F1B455D0800EECAF0 /* cryptotech.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = cryptotech.h; path = ../src/cryptotech.h; sourceTree = "<group>"; };
  14.100 +		64A826501B455D0800EECAF0 /* dynamic_api.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = dynamic_api.h; path = ../src/dynamic_api.h; sourceTree = "<group>"; };
  14.101 +		64A826511B455D0800EECAF0 /* email.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = email.c; path = ../src/email.c; sourceTree = "<group>"; };
  14.102 +		64A826521B455D0800EECAF0 /* email.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = email.h; path = ../src/email.h; sourceTree = "<group>"; };
  14.103 +		64A826531B455D0800EECAF0 /* etpan_mime.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = etpan_mime.c; path = ../src/etpan_mime.c; sourceTree = "<group>"; };
  14.104 +		64A826541B455D0800EECAF0 /* etpan_mime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = etpan_mime.h; path = ../src/etpan_mime.h; sourceTree = "<group>"; };
  14.105 +		64A826551B455D0800EECAF0 /* identity_list.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = identity_list.c; path = ../src/identity_list.c; sourceTree = "<group>"; };
  14.106 +		64A826561B455D0800EECAF0 /* identity_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = identity_list.h; path = ../src/identity_list.h; sourceTree = "<group>"; };
  14.107 +		64A826571B455D0800EECAF0 /* keymanagement.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = keymanagement.c; path = ../src/keymanagement.c; sourceTree = "<group>"; };
  14.108 +		64A826581B455D0800EECAF0 /* keymanagement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = keymanagement.h; path = ../src/keymanagement.h; sourceTree = "<group>"; };
  14.109 +		64A826591B455D0800EECAF0 /* message_api.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = message_api.c; path = ../src/message_api.c; sourceTree = "<group>"; };
  14.110 +		64A8265A1B455D0800EECAF0 /* message_api.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = message_api.h; path = ../src/message_api.h; sourceTree = "<group>"; };
  14.111 +		64A8265B1B455D0800EECAF0 /* message.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = message.c; path = ../src/message.c; sourceTree = "<group>"; };
  14.112 +		64A8265C1B455D0800EECAF0 /* message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = message.h; path = ../src/message.h; sourceTree = "<group>"; };
  14.113 +		64A8265D1B455D0800EECAF0 /* mime.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = mime.c; path = ../src/mime.c; sourceTree = "<group>"; };
  14.114 +		64A8265E1B455D0800EECAF0 /* mime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = mime.h; path = ../src/mime.h; sourceTree = "<group>"; };
  14.115 +		64A8265F1B455D0800EECAF0 /* pEp_internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = pEp_internal.h; path = ../src/pEp_internal.h; sourceTree = "<group>"; };
  14.116 +		64A826601B455D0800EECAF0 /* pEpEngine.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pEpEngine.c; path = ../src/pEpEngine.c; sourceTree = "<group>"; };
  14.117 +		64A826611B455D0800EECAF0 /* pEpEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = pEpEngine.h; path = ../src/pEpEngine.h; sourceTree = "<group>"; };
  14.118 +		64A826621B455D0800EECAF0 /* pgp_netpgp_internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = pgp_netpgp_internal.h; path = ../src/pgp_netpgp_internal.h; sourceTree = "<group>"; };
  14.119 +		64A826631B455D0800EECAF0 /* pgp_netpgp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pgp_netpgp.c; path = ../src/pgp_netpgp.c; sourceTree = "<group>"; };
  14.120 +		64A826641B455D0800EECAF0 /* pgp_netpgp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = pgp_netpgp.h; path = ../src/pgp_netpgp.h; sourceTree = "<group>"; };
  14.121 +		64A826651B455D0800EECAF0 /* platform_unix.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = platform_unix.c; path = ../src/platform_unix.c; sourceTree = "<group>"; };
  14.122 +		64A826661B455D0800EECAF0 /* platform_unix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = platform_unix.h; path = ../src/platform_unix.h; sourceTree = "<group>"; };
  14.123 +		64A826691B455D0800EECAF0 /* platform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = platform.h; path = ../src/platform.h; sourceTree = "<group>"; };
  14.124 +		64A8266A1B455D0800EECAF0 /* resource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = resource.h; path = ../src/resource.h; sourceTree = "<group>"; };
  14.125 +		64A8266B1B455D0800EECAF0 /* sqlite3.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = sqlite3.c; path = ../src/sqlite3.c; sourceTree = "<group>"; };
  14.126 +		64A8266C1B455D0800EECAF0 /* sqlite3.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = sqlite3.h; path = ../src/sqlite3.h; sourceTree = "<group>"; };
  14.127 +		64A8266D1B455D0800EECAF0 /* stringlist.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = stringlist.c; path = ../src/stringlist.c; sourceTree = "<group>"; };
  14.128 +		64A8266E1B455D0800EECAF0 /* stringlist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = stringlist.h; path = ../src/stringlist.h; sourceTree = "<group>"; };
  14.129 +		64A8266F1B455D0800EECAF0 /* stringpair.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = stringpair.c; path = ../src/stringpair.c; sourceTree = "<group>"; };
  14.130 +		64A826701B455D0800EECAF0 /* stringpair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = stringpair.h; path = ../src/stringpair.h; sourceTree = "<group>"; };
  14.131 +		64A826711B455D0800EECAF0 /* timestamp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = timestamp.c; path = ../src/timestamp.c; sourceTree = "<group>"; };
  14.132 +		64A826721B455D0800EECAF0 /* timestamp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = timestamp.h; path = ../src/timestamp.h; sourceTree = "<group>"; };
  14.133 +		64A826731B455D0800EECAF0 /* trans_auto.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = trans_auto.c; path = ../src/trans_auto.c; sourceTree = "<group>"; };
  14.134 +		64A826741B455D0800EECAF0 /* trans_auto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = trans_auto.h; path = ../src/trans_auto.h; sourceTree = "<group>"; };
  14.135 +		64A826751B455D0800EECAF0 /* transport.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = transport.c; path = ../src/transport.c; sourceTree = "<group>"; };
  14.136 +		64A826761B455D0800EECAF0 /* transport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = transport.h; path = ../src/transport.h; sourceTree = "<group>"; };
  14.137 +		64A826771B455D0800EECAF0 /* wrappers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = wrappers.h; path = ../src/wrappers.h; sourceTree = "<group>"; };
  14.138 +		64DA240C1B832EA0000BEE80 /* netpgp.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = netpgp.xcodeproj; path = "../../netpgp/dist/netpgp-xcode/netpgp.xcodeproj"; sourceTree = "<group>"; };
  14.139 +		64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = libetpan.xcodeproj; path = "../../libetpan/build-mac/libetpan.xcodeproj"; sourceTree = "<group>"; };
  14.140 +/* End PBXFileReference section */
  14.141 +
  14.142 +/* Begin PBXFrameworksBuildPhase section */
  14.143 +		64796A3C1B455AA5004B1C24 /* Frameworks */ = {
  14.144 +			isa = PBXFrameworksBuildPhase;
  14.145 +			buildActionMask = 2147483647;
  14.146 +			files = (
  14.147 +				649DE08B1B45C19100912F72 /* libcurl.a in Frameworks */,
  14.148 +			);
  14.149 +			runOnlyForDeploymentPostprocessing = 0;
  14.150 +		};
  14.151 +/* End PBXFrameworksBuildPhase section */
  14.152 +
  14.153 +/* Begin PBXGroup section */
  14.154 +		64289E2B1B8B630200FC617B /* Products */ = {
  14.155 +			isa = PBXGroup;
  14.156 +			children = (
  14.157 +				64289E331B8B630200FC617B /* libetpan.framework */,
  14.158 +				64289E351B8B630200FC617B /* libetpan.a */,
  14.159 +				64289E371B8B630200FC617B /* libetpan-ios.a */,
  14.160 +			);
  14.161 +			name = Products;
  14.162 +			sourceTree = "<group>";
  14.163 +		};
  14.164 +		64289E391B8B632600FC617B /* Products */ = {
  14.165 +			isa = PBXGroup;
  14.166 +			children = (
  14.167 +				64289E3D1B8B632600FC617B /* libnetpgp.a */,
  14.168 +			);
  14.169 +			name = Products;
  14.170 +			sourceTree = "<group>";
  14.171 +		};
  14.172 +		64796A361B455AA5004B1C24 = {
  14.173 +			isa = PBXGroup;
  14.174 +			children = (
  14.175 +				64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */,
  14.176 +				64DA240C1B832EA0000BEE80 /* netpgp.xcodeproj */,
  14.177 +				649DE08C1B45D3B700912F72 /* build-libcurl-ios.sh */,
  14.178 +				649DE08A1B45C19100912F72 /* libcurl.a */,
  14.179 +				64A8264B1B455C5600EECAF0 /* srcref */,
  14.180 +				64796A401B455AA5004B1C24 /* Products */,
  14.181 +			);
  14.182 +			sourceTree = "<group>";
  14.183 +		};
  14.184 +		64796A401B455AA5004B1C24 /* Products */ = {
  14.185 +			isa = PBXGroup;
  14.186 +			children = (
  14.187 +				64796A3F1B455AA5004B1C24 /* libpEpEngine.a */,
  14.188 +			);
  14.189 +			name = Products;
  14.190 +			sourceTree = "<group>";
  14.191 +		};
  14.192 +		64A8264B1B455C5600EECAF0 /* srcref */ = {
  14.193 +			isa = PBXGroup;
  14.194 +			children = (
  14.195 +				64A8264C1B455D0800EECAF0 /* bloblist.c */,
  14.196 +				64A8264D1B455D0800EECAF0 /* bloblist.h */,
  14.197 +				64A8264E1B455D0800EECAF0 /* cryptotech.c */,
  14.198 +				64A8264F1B455D0800EECAF0 /* cryptotech.h */,
  14.199 +				64A826501B455D0800EECAF0 /* dynamic_api.h */,
  14.200 +				64A826511B455D0800EECAF0 /* email.c */,
  14.201 +				64A826521B455D0800EECAF0 /* email.h */,
  14.202 +				64A826531B455D0800EECAF0 /* etpan_mime.c */,
  14.203 +				64A826541B455D0800EECAF0 /* etpan_mime.h */,
  14.204 +				64A826551B455D0800EECAF0 /* identity_list.c */,
  14.205 +				64A826561B455D0800EECAF0 /* identity_list.h */,
  14.206 +				64A826571B455D0800EECAF0 /* keymanagement.c */,
  14.207 +				64A826581B455D0800EECAF0 /* keymanagement.h */,
  14.208 +				64A826591B455D0800EECAF0 /* message_api.c */,
  14.209 +				64A8265A1B455D0800EECAF0 /* message_api.h */,
  14.210 +				64A8265B1B455D0800EECAF0 /* message.c */,
  14.211 +				64A8265C1B455D0800EECAF0 /* message.h */,
  14.212 +				64A8265D1B455D0800EECAF0 /* mime.c */,
  14.213 +				64A8265E1B455D0800EECAF0 /* mime.h */,
  14.214 +				64A8265F1B455D0800EECAF0 /* pEp_internal.h */,
  14.215 +				64A826601B455D0800EECAF0 /* pEpEngine.c */,
  14.216 +				64A826611B455D0800EECAF0 /* pEpEngine.h */,
  14.217 +				64A826621B455D0800EECAF0 /* pgp_netpgp_internal.h */,
  14.218 +				64A826631B455D0800EECAF0 /* pgp_netpgp.c */,
  14.219 +				64A826641B455D0800EECAF0 /* pgp_netpgp.h */,
  14.220 +				64A826651B455D0800EECAF0 /* platform_unix.c */,
  14.221 +				64A826661B455D0800EECAF0 /* platform_unix.h */,
  14.222 +				64A826691B455D0800EECAF0 /* platform.h */,
  14.223 +				64A8266A1B455D0800EECAF0 /* resource.h */,
  14.224 +				64A8266B1B455D0800EECAF0 /* sqlite3.c */,
  14.225 +				64A8266C1B455D0800EECAF0 /* sqlite3.h */,
  14.226 +				64A8266D1B455D0800EECAF0 /* stringlist.c */,
  14.227 +				64A8266E1B455D0800EECAF0 /* stringlist.h */,
  14.228 +				64A8266F1B455D0800EECAF0 /* stringpair.c */,
  14.229 +				64A826701B455D0800EECAF0 /* stringpair.h */,
  14.230 +				64A826711B455D0800EECAF0 /* timestamp.c */,
  14.231 +				64A826721B455D0800EECAF0 /* timestamp.h */,
  14.232 +				64A826731B455D0800EECAF0 /* trans_auto.c */,
  14.233 +				64A826741B455D0800EECAF0 /* trans_auto.h */,
  14.234 +				64A826751B455D0800EECAF0 /* transport.c */,
  14.235 +				64A826761B455D0800EECAF0 /* transport.h */,
  14.236 +				64A826771B455D0800EECAF0 /* wrappers.h */,
  14.237 +			);
  14.238 +			name = srcref;
  14.239 +			sourceTree = "<group>";
  14.240 +		};
  14.241 +/* End PBXGroup section */
  14.242 +
  14.243 +/* Begin PBXHeadersBuildPhase section */
  14.244 +		64A8268B1B455D8D00EECAF0 /* Headers */ = {
  14.245 +			isa = PBXHeadersBuildPhase;
  14.246 +			buildActionMask = 2147483647;
  14.247 +			files = (
  14.248 +				64A8268C1B455D9D00EECAF0 /* pEpEngine.h in Headers */,
  14.249 +			);
  14.250 +			runOnlyForDeploymentPostprocessing = 0;
  14.251 +		};
  14.252 +/* End PBXHeadersBuildPhase section */
  14.253 +
  14.254 +/* Begin PBXNativeTarget section */
  14.255 +		64796A3E1B455AA5004B1C24 /* pEpEngine */ = {
  14.256 +			isa = PBXNativeTarget;
  14.257 +			buildConfigurationList = 64796A531B455AA5004B1C24 /* Build configuration list for PBXNativeTarget "pEpEngine" */;
  14.258 +			buildPhases = (
  14.259 +				64BDD59B1B7A2E1B00AC43AE /* Run Script */,
  14.260 +				64796A3B1B455AA5004B1C24 /* Sources */,
  14.261 +				64796A3C1B455AA5004B1C24 /* Frameworks */,
  14.262 +				64796A3D1B455AA5004B1C24 /* CopyFiles */,
  14.263 +				64A8268B1B455D8D00EECAF0 /* Headers */,
  14.264 +			);
  14.265 +			buildRules = (
  14.266 +			);
  14.267 +			dependencies = (
  14.268 +				64289E411B8B638F00FC617B /* PBXTargetDependency */,
  14.269 +				64289E3F1B8B638800FC617B /* PBXTargetDependency */,
  14.270 +			);
  14.271 +			name = pEpEngine;
  14.272 +			productName = pEpEngine;
  14.273 +			productReference = 64796A3F1B455AA5004B1C24 /* libpEpEngine.a */;
  14.274 +			productType = "com.apple.product-type.library.static";
  14.275 +		};
  14.276 +/* End PBXNativeTarget section */
  14.277 +
  14.278 +/* Begin PBXProject section */
  14.279 +		64796A371B455AA5004B1C24 /* Project object */ = {
  14.280 +			isa = PBXProject;
  14.281 +			attributes = {
  14.282 +				LastUpgradeCheck = 0630;
  14.283 +				ORGANIZATIONNAME = "Edouard Tisserant";
  14.284 +				TargetAttributes = {
  14.285 +					64796A3E1B455AA5004B1C24 = {
  14.286 +						CreatedOnToolsVersion = 6.3.2;
  14.287 +					};
  14.288 +				};
  14.289 +			};
  14.290 +			buildConfigurationList = 64796A3A1B455AA5004B1C24 /* Build configuration list for PBXProject "pEpEngine" */;
  14.291 +			compatibilityVersion = "Xcode 3.2";
  14.292 +			developmentRegion = English;
  14.293 +			hasScannedForEncodings = 0;
  14.294 +			knownRegions = (
  14.295 +				en,
  14.296 +			);
  14.297 +			mainGroup = 64796A361B455AA5004B1C24;
  14.298 +			productRefGroup = 64796A401B455AA5004B1C24 /* Products */;
  14.299 +			projectDirPath = "";
  14.300 +			projectReferences = (
  14.301 +				{
  14.302 +					ProductGroup = 64289E2B1B8B630200FC617B /* Products */;
  14.303 +					ProjectRef = 64DA24121B832EBA000BEE80 /* libetpan.xcodeproj */;
  14.304 +				},
  14.305 +				{
  14.306 +					ProductGroup = 64289E391B8B632600FC617B /* Products */;
  14.307 +					ProjectRef = 64DA240C1B832EA0000BEE80 /* netpgp.xcodeproj */;
  14.308 +				},
  14.309 +			);
  14.310 +			projectRoot = "";
  14.311 +			targets = (
  14.312 +				64796A3E1B455AA5004B1C24 /* pEpEngine */,
  14.313 +			);
  14.314 +		};
  14.315 +/* End PBXProject section */
  14.316 +
  14.317 +/* Begin PBXReferenceProxy section */
  14.318 +		64289E331B8B630200FC617B /* libetpan.framework */ = {
  14.319 +			isa = PBXReferenceProxy;
  14.320 +			fileType = wrapper.framework;
  14.321 +			path = libetpan.framework;
  14.322 +			remoteRef = 64289E321B8B630200FC617B /* PBXContainerItemProxy */;
  14.323 +			sourceTree = BUILT_PRODUCTS_DIR;
  14.324 +		};
  14.325 +		64289E351B8B630200FC617B /* libetpan.a */ = {
  14.326 +			isa = PBXReferenceProxy;
  14.327 +			fileType = archive.ar;
  14.328 +			path = libetpan.a;
  14.329 +			remoteRef = 64289E341B8B630200FC617B /* PBXContainerItemProxy */;
  14.330 +			sourceTree = BUILT_PRODUCTS_DIR;
  14.331 +		};
  14.332 +		64289E371B8B630200FC617B /* libetpan-ios.a */ = {
  14.333 +			isa = PBXReferenceProxy;
  14.334 +			fileType = archive.ar;
  14.335 +			path = "libetpan-ios.a";
  14.336 +			remoteRef = 64289E361B8B630200FC617B /* PBXContainerItemProxy */;
  14.337 +			sourceTree = BUILT_PRODUCTS_DIR;
  14.338 +		};
  14.339 +		64289E3D1B8B632600FC617B /* libnetpgp.a */ = {
  14.340 +			isa = PBXReferenceProxy;
  14.341 +			fileType = archive.ar;
  14.342 +			path = libnetpgp.a;
  14.343 +			remoteRef = 64289E3C1B8B632600FC617B /* PBXContainerItemProxy */;
  14.344 +			sourceTree = BUILT_PRODUCTS_DIR;
  14.345 +		};
  14.346 +/* End PBXReferenceProxy section */
  14.347 +
  14.348 +/* Begin PBXShellScriptBuildPhase section */
  14.349 +		64BDD59B1B7A2E1B00AC43AE /* Run Script */ = {
  14.350 +			isa = PBXShellScriptBuildPhase;
  14.351 +			buildActionMask = 2147483647;
  14.352 +			files = (
  14.353 +			);
  14.354 +			inputPaths = (
  14.355 +			);
  14.356 +			name = "Run Script";
  14.357 +			outputPaths = (
  14.358 +			);
  14.359 +			runOnlyForDeploymentPostprocessing = 0;
  14.360 +			shellPath = /bin/sh;
  14.361 +			shellScript = "mkdir -p \"$BUILT_PRODUCTS_DIR/include\"\n\ncp \"$SRCROOT/../src/\"{\\\npEpEngine.h,\\\ncryptotech.h,\\\nkeymanagement.h,\\\nmessage_api.h,\\\ndynamic_api.h,\\\nstringlist.h,\\\ntimestamp.h,\\\nidentity_list.h,\\\nbloblist.h,\\\nstringpair.h,\\\nmessage.h,\\\nmime.h} \"$BUILT_PRODUCTS_DIR/include\"\n";
  14.362 +		};
  14.363 +/* End PBXShellScriptBuildPhase section */
  14.364 +
  14.365 +/* Begin PBXSourcesBuildPhase section */
  14.366 +		64796A3B1B455AA5004B1C24 /* Sources */ = {
  14.367 +			isa = PBXSourcesBuildPhase;
  14.368 +			buildActionMask = 2147483647;
  14.369 +			files = (
  14.370 +				64A826871B455D0800EECAF0 /* stringpair.c in Sources */,
  14.371 +				64A826831B455D0800EECAF0 /* platform_unix.c in Sources */,
  14.372 +				64A8267B1B455D0800EECAF0 /* etpan_mime.c in Sources */,
  14.373 +				64A8267A1B455D0800EECAF0 /* email.c in Sources */,
  14.374 +				64A826861B455D0800EECAF0 /* stringlist.c in Sources */,
  14.375 +				64A8267E1B455D0800EECAF0 /* message_api.c in Sources */,
  14.376 +				64A826851B455D0800EECAF0 /* sqlite3.c in Sources */,
  14.377 +				64A826821B455D0800EECAF0 /* pgp_netpgp.c in Sources */,
  14.378 +				64A826891B455D0800EECAF0 /* trans_auto.c in Sources */,
  14.379 +				64A8267D1B455D0800EECAF0 /* keymanagement.c in Sources */,
  14.380 +				64A8267C1B455D0800EECAF0 /* identity_list.c in Sources */,
  14.381 +				64A8268A1B455D0800EECAF0 /* transport.c in Sources */,
  14.382 +				64A826791B455D0800EECAF0 /* cryptotech.c in Sources */,
  14.383 +				64A826781B455D0800EECAF0 /* bloblist.c in Sources */,
  14.384 +				64A826881B455D0800EECAF0 /* timestamp.c in Sources */,
  14.385 +				64A826801B455D0800EECAF0 /* mime.c in Sources */,
  14.386 +				64A8267F1B455D0800EECAF0 /* message.c in Sources */,
  14.387 +				64A826811B455D0800EECAF0 /* pEpEngine.c in Sources */,
  14.388 +			);
  14.389 +			runOnlyForDeploymentPostprocessing = 0;
  14.390 +		};
  14.391 +/* End PBXSourcesBuildPhase section */
  14.392 +
  14.393 +/* Begin PBXTargetDependency section */
  14.394 +		64289E3F1B8B638800FC617B /* PBXTargetDependency */ = {
  14.395 +			isa = PBXTargetDependency;
  14.396 +			name = "libetpan ios";
  14.397 +			targetProxy = 64289E3E1B8B638800FC617B /* PBXContainerItemProxy */;
  14.398 +		};
  14.399 +		64289E411B8B638F00FC617B /* PBXTargetDependency */ = {
  14.400 +			isa = PBXTargetDependency;
  14.401 +			name = netpgp;
  14.402 +			targetProxy = 64289E401B8B638F00FC617B /* PBXContainerItemProxy */;
  14.403 +		};
  14.404 +/* End PBXTargetDependency section */
  14.405 +
  14.406 +/* Begin XCBuildConfiguration section */
  14.407 +		64796A511B455AA5004B1C24 /* Debug */ = {
  14.408 +			isa = XCBuildConfiguration;
  14.409 +			buildSettings = {
  14.410 +				ALWAYS_SEARCH_USER_PATHS = NO;
  14.411 +				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
  14.412 +				CLANG_CXX_LIBRARY = "libc++";
  14.413 +				CLANG_ENABLE_MODULES = YES;
  14.414 +				CLANG_ENABLE_OBJC_ARC = YES;
  14.415 +				CLANG_WARN_BOOL_CONVERSION = YES;
  14.416 +				CLANG_WARN_CONSTANT_CONVERSION = YES;
  14.417 +				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
  14.418 +				CLANG_WARN_EMPTY_BODY = YES;
  14.419 +				CLANG_WARN_ENUM_CONVERSION = YES;
  14.420 +				CLANG_WARN_INT_CONVERSION = YES;
  14.421 +				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
  14.422 +				CLANG_WARN_UNREACHABLE_CODE = YES;
  14.423 +				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
  14.424 +				COPY_PHASE_STRIP = NO;
  14.425 +				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
  14.426 +				ENABLE_STRICT_OBJC_MSGSEND = YES;
  14.427 +				GCC_C_LANGUAGE_STANDARD = gnu99;
  14.428 +				GCC_DYNAMIC_NO_PIC = NO;
  14.429 +				GCC_NO_COMMON_BLOCKS = YES;
  14.430 +				GCC_OPTIMIZATION_LEVEL = 0;
  14.431 +				GCC_PREPROCESSOR_DEFINITIONS = (
  14.432 +					"DEBUG=1",
  14.433 +					"USE_NETPGP=1",
  14.434 +				);
  14.435 +				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
  14.436 +				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
  14.437 +				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
  14.438 +				GCC_WARN_UNDECLARED_SELECTOR = YES;
  14.439 +				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
  14.440 +				GCC_WARN_UNUSED_FUNCTION = YES;
  14.441 +				GCC_WARN_UNUSED_VARIABLE = YES;
  14.442 +				HEADER_SEARCH_PATHS = (
  14.443 +					"$(inherited)",
  14.444 +					"$(OPENSSL_SRC)/include",
  14.445 +					"$(SRCROOT)",
  14.446 +				);
  14.447 +				IPHONEOS_DEPLOYMENT_TARGET = 8.3;
  14.448 +				MTL_ENABLE_DEBUG_INFO = YES;
  14.449 +				ONLY_ACTIVE_ARCH = YES;
  14.450 +				SDKROOT = iphoneos;
  14.451 +			};
  14.452 +			name = Debug;
  14.453 +		};
  14.454 +		64796A521B455AA5004B1C24 /* Release */ = {
  14.455 +			isa = XCBuildConfiguration;
  14.456 +			buildSettings = {
  14.457 +				ALWAYS_SEARCH_USER_PATHS = NO;
  14.458 +				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
  14.459 +				CLANG_CXX_LIBRARY = "libc++";
  14.460 +				CLANG_ENABLE_MODULES = YES;
  14.461 +				CLANG_ENABLE_OBJC_ARC = YES;
  14.462 +				CLANG_WARN_BOOL_CONVERSION = YES;
  14.463 +				CLANG_WARN_CONSTANT_CONVERSION = YES;
  14.464 +				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
  14.465 +				CLANG_WARN_EMPTY_BODY = YES;
  14.466 +				CLANG_WARN_ENUM_CONVERSION = YES;
  14.467 +				CLANG_WARN_INT_CONVERSION = YES;
  14.468 +				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
  14.469 +				CLANG_WARN_UNREACHABLE_CODE = YES;
  14.470 +				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
  14.471 +				COPY_PHASE_STRIP = NO;
  14.472 +				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
  14.473 +				ENABLE_NS_ASSERTIONS = NO;
  14.474 +				ENABLE_STRICT_OBJC_MSGSEND = YES;
  14.475 +				GCC_C_LANGUAGE_STANDARD = gnu99;
  14.476 +				GCC_NO_COMMON_BLOCKS = YES;
  14.477 +				GCC_PREPROCESSOR_DEFINITIONS = "USE_NETPGP=1";
  14.478 +				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
  14.479 +				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
  14.480 +				GCC_WARN_UNDECLARED_SELECTOR = YES;
  14.481 +				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
  14.482 +				GCC_WARN_UNUSED_FUNCTION = YES;
  14.483 +				GCC_WARN_UNUSED_VARIABLE = YES;
  14.484 +				HEADER_SEARCH_PATHS = (
  14.485 +					"$(inherited)",
  14.486 +					"$(OPENSSL_SRC)/include",
  14.487 +					"$(SRCROOT)",
  14.488 +				);
  14.489 +				IPHONEOS_DEPLOYMENT_TARGET = 8.3;
  14.490 +				MTL_ENABLE_DEBUG_INFO = NO;
  14.491 +				SDKROOT = iphoneos;
  14.492 +				VALIDATE_PRODUCT = YES;
  14.493 +			};
  14.494 +			name = Release;
  14.495 +		};
  14.496 +		64796A541B455AA5004B1C24 /* Debug */ = {
  14.497 +			isa = XCBuildConfiguration;
  14.498 +			buildSettings = {
  14.499 +				LIBRARY_SEARCH_PATHS = (
  14.500 +					"$(inherited)",
  14.501 +					"$(USER_LIBRARY_DIR)/Developer/Xcode/DerivedData/pEp-iOS-gtbigzjcintbskexdmmkdrzxuewm/Build/Products/Debug-iphoneos",
  14.502 +					"/Users/ed/src/libetpan/build-mac/build/Debug-iphoneos",
  14.503 +					"$(PROJECT_DIR)",
  14.504 +					"/Users/ed/src/netpgp-xcode/build/Debug-iphoneos",
  14.505 +				);
  14.506 +				New_Setting = "";
  14.507 +				OTHER_LDFLAGS = "-ObjC";
  14.508 +				PRODUCT_NAME = "$(TARGET_NAME)";
  14.509 +				SKIP_INSTALL = YES;
  14.510 +			};
  14.511 +			name = Debug;
  14.512 +		};
  14.513 +		64796A551B455AA5004B1C24 /* Release */ = {
  14.514 +			isa = XCBuildConfiguration;
  14.515 +			buildSettings = {
  14.516 +				LIBRARY_SEARCH_PATHS = (
  14.517 +					"$(inherited)",
  14.518 +					"$(USER_LIBRARY_DIR)/Developer/Xcode/DerivedData/pEp-iOS-gtbigzjcintbskexdmmkdrzxuewm/Build/Products/Debug-iphoneos",
  14.519 +					"/Users/ed/src/libetpan/build-mac/build/Debug-iphoneos",
  14.520 +					"$(PROJECT_DIR)",
  14.521 +					"/Users/ed/src/netpgp-xcode/build/Debug-iphoneos",
  14.522 +				);
  14.523 +				New_Setting = "";
  14.524 +				OTHER_LDFLAGS = "-ObjC";
  14.525 +				PRODUCT_NAME = "$(TARGET_NAME)";
  14.526 +				SKIP_INSTALL = YES;
  14.527 +			};
  14.528 +			name = Release;
  14.529 +		};
  14.530 +/* End XCBuildConfiguration section */
  14.531 +
  14.532 +/* Begin XCConfigurationList section */
  14.533 +		64796A3A1B455AA5004B1C24 /* Build configuration list for PBXProject "pEpEngine" */ = {
  14.534 +			isa = XCConfigurationList;
  14.535 +			buildConfigurations = (
  14.536 +				64796A511B455AA5004B1C24 /* Debug */,
  14.537 +				64796A521B455AA5004B1C24 /* Release */,
  14.538 +			);
  14.539 +			defaultConfigurationIsVisible = 0;
  14.540 +			defaultConfigurationName = Release;
  14.541 +		};
  14.542 +		64796A531B455AA5004B1C24 /* Build configuration list for PBXNativeTarget "pEpEngine" */ = {
  14.543 +			isa = XCConfigurationList;
  14.544 +			buildConfigurations = (
  14.545 +				64796A541B455AA5004B1C24 /* Debug */,
  14.546 +				64796A551B455AA5004B1C24 /* Release */,
  14.547 +			);
  14.548 +			defaultConfigurationIsVisible = 0;
  14.549 +			defaultConfigurationName = Release;
  14.550 +		};
  14.551 +/* End XCConfigurationList section */
  14.552 +	};
  14.553 +	rootObject = 64796A371B455AA5004B1C24 /* Project object */;
  14.554 +}
    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/build-mac/pEpEngine.xcodeproj/project.xcworkspace/contents.xcworkspacedata	Mon Aug 24 17:23:37 2015 +0200
    15.3 @@ -0,0 +1,7 @@
    15.4 +<?xml version="1.0" encoding="UTF-8"?>
    15.5 +<Workspace
    15.6 +   version = "1.0">
    15.7 +   <FileRef
    15.8 +      location = "self:">
    15.9 +   </FileRef>
   15.10 +</Workspace>