From: <lin...@us...> - 2008-11-30 12:21:00
|
Revision: 5470 http://octave.svn.sourceforge.net/octave/?rev=5470&view=rev Author: lindnerb Date: 2008-11-30 12:20:50 +0000 (Sun, 30 Nov 2008) Log Message: ----------- add libcurl-7.19.0 Modified Paths: -------------- trunk/octave-forge/admin/Windows/mingw32/gcc43_build_deps.sh Added Paths: ----------- trunk/octave-forge/admin/Windows/mingw32/curl/build-7.19.0-3.sh trunk/octave-forge/admin/Windows/mingw32/curl/curl-7.19.0-3.patch Added: trunk/octave-forge/admin/Windows/mingw32/curl/build-7.19.0-3.sh =================================================================== --- trunk/octave-forge/admin/Windows/mingw32/curl/build-7.19.0-3.sh (rev 0) +++ trunk/octave-forge/admin/Windows/mingw32/curl/build-7.19.0-3.sh 2008-11-30 12:20:50 UTC (rev 5470) @@ -0,0 +1,98 @@ +#! /usr/bin/sh + +# Name of package +PKG=curl +# Version of Package +VER=7.19.0 +# Release of (this patched) package +REL=3 +# Name&Version of Package +PKGVER=${PKG}-${VER} +# Full name of this patched Package +FULLPKG=${PKGVER}-${REL} + +# Name of source file +SRCFILE=${PKGVER}.tar.bz2 +TAR_TYPE=j +# Name of Patch file +PATCHFILE=${FULLPKG}.patch + +# URL of source code file +URL="http://curl.haxx.se/download/curl-7.19.0.tar.bz2" + +# Top dir of this building process (i.e. where the patch file and source file(s) reside) +#TOPDIR=`pwd -W | sed -e 's+\([a-z]\):/+/\1/+'` +TOPDIR=`pwd` +# Directory Source code is extracted to (relative to TOPDIR) +SRCDIR=${PKGVER} +# Directory original source code is extracted to (for generating diffs) (relative to TOPDIR) +SRCDIR_ORIG=${SRCDIR}-orig + +# Make file to use +MAKEFILE="Makefile.m32" + +# Additional DIFF Flags for generating diff file +DIFF_FLAGS="-x ca-bundle.h -x libcurl.res" + +# header files to be installed +INSTALL_HEADERS="curl.h curlver.h easy.h mprintf.h stdcheaders.h types.h multi.h typecheck-gcc.h curlbuild.h curlrules.h" + +INCLUDE_DIR=include/curl + +source ../gcc43_common.sh + +# Directory the lib is built in +BUILDDIR=".build_mingw32_${VER}-${REL}_gcc${GCC_VER}${GCC_SYS}" + +mkdirs_pre() { if [ -e ${BUILDDIR} ]; then rm -rf ${BUILDDIR}; fi; } +mkdirs_post() +{ + mkdir -vp ${BUILDDIR}/lib +} + +conf() +{ + substvars ${SRCDIR}/lib/${MAKEFILE} ${BUILDDIR}/lib/${MAKEFILE} +} + +build() +{ + export ZLIB_PATH=${INCLUDE_BASE}/${INCLUDE_DEFAULT} + export CFLAGS="${GCC_ARCH_FLAGS} ${GCC_OPT_FLAGS}" + export CPP="${GCC_PREFIX}cpp${GCC_VER}${GCC_SYS}" + ( cd ${BUILDDIR}/lib && make -f Makefile.m32 ZLIB=1 ) +} + +install() +{ + install_pre + ${CP} ${CP_FLAGS} ${BUILDDIR}/lib/curl.dll ${SHAREDLIB_PATH} + ${CP} ${CP_FLAGS} ${BUILDDIR}/lib/libcurl.dll.a ${LIBRARY_PATH} + ${CP} ${CP_FLAGS} ${BUILDDIR}/lib/libcurl.a ${STATICLIBRARY_PATH} + for a in ${INSTALL_HEADERS}; do ${CP} ${CP_FLAGS} ${SRCDIR}/include/curl/$a ${INCLUDE_PATH}; done + + mkdir -vp ${LICENSE_PATH}/${PKG} + ${CP} ${CP_FLAGS} ${SRCDIR}/COPYING ${LICENSE_PATH}/${PKG} + install_post +} + +uninstall() +{ + ${RM} ${RM_FLAGS} ${SHAREDLIB_PATH}/curl.dll + ${RM} ${RM_FLAGS} ${LIBRARY_PATH}/libcurl.dll.a + ${RM} ${RM_FLAGS} ${STATICLIBRARY_PATH}/libcurl.a + for a in ${INSTALL_HEADERS}; do ${RM} ${RM_FLAGS} ${INCLUDE_PATH}/$a; done +} + +all() +{ + download + unpack + applypatch + mkdirs + conf + build + install +} + +main $* Added: trunk/octave-forge/admin/Windows/mingw32/curl/curl-7.19.0-3.patch =================================================================== --- trunk/octave-forge/admin/Windows/mingw32/curl/curl-7.19.0-3.patch (rev 0) +++ trunk/octave-forge/admin/Windows/mingw32/curl/curl-7.19.0-3.patch 2008-11-30 12:20:50 UTC (rev 5470) @@ -0,0 +1,1856 @@ +diff -urN -x '*.exe' -x '*.dll' -x '*.o' -x '*.a' -x '*.bak' -x ca-bundle.h -x libcurl.res curl-7.19.0-orig/include/curl/curl.h curl-7.19.0/include/curl/curl.h +--- curl-7.19.0-orig/include/curl/curl.h 2008-08-19 21:02:45 +0200 ++++ curl-7.19.0/include/curl/curl.h 2008-11-26 19:53:19 +0100 +@@ -58,7 +58,7 @@ + + #if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) && \ + !defined(__CYGWIN__) || defined(__MINGW32__) +-#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H)) ++#if !(defined(_WINSOCKAPI_) || (defined(_WINSOCK_H) && !defined(_WINSOCK2_H))) + /* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ + #include <winsock2.h> +diff -urN -x '*.exe' -x '*.dll' -x '*.o' -x '*.a' -x '*.bak' -x ca-bundle.h -x libcurl.res curl-7.19.0-orig/include/curl/curl.h~ curl-7.19.0/include/curl/curl.h~ +--- curl-7.19.0-orig/include/curl/curl.h~ 1970-01-01 01:00:00 +0100 ++++ curl-7.19.0/include/curl/curl.h~ 2008-08-19 21:02:45 +0200 +@@ -0,0 +1,1764 @@ ++#ifndef __CURL_CURL_H ++#define __CURL_CURL_H ++/*************************************************************************** ++ * _ _ ____ _ ++ * Project ___| | | | _ \| | ++ * / __| | | | |_) | | ++ * | (__| |_| | _ <| |___ ++ * \___|\___/|_| \_\_____| ++ * ++ * Copyright (C) 1998 - 2008, Daniel Stenberg, <da...@ha...>, et al. ++ * ++ * This software is licensed as described in the file COPYING, which ++ * you should have received as part of this distribution. The terms ++ * are also available at http://curl.haxx.se/docs/copyright.html. ++ * ++ * You may opt to use, copy, modify, merge, publish, distribute and/or sell ++ * copies of the Software, and permit persons to whom the Software is ++ * furnished to do so, under the terms of the COPYING file. ++ * ++ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY ++ * KIND, either express or implied. ++ * ++ * $Id: curl.h,v 1.364 2008-08-17 13:55:24 giva Exp $ ++ ***************************************************************************/ ++ ++/* ++ * If you have libcurl problems, all docs and details are found here: ++ * http://curl.haxx.se/libcurl/ ++ * ++ * curl-library mailing list subscription and unsubscription web interface: ++ * http://cool.haxx.se/mailman/listinfo/curl-library/ ++ */ ++ ++#include "curlver.h" /* libcurl version defines */ ++#include "curl/curlbuild.h" /* libcurl build definitions */ ++#include "curlrules.h" /* libcurl rules enforcement */ ++ ++/* ++ * Define WIN32 when build target is Win32 API ++ */ ++ ++#if (defined(_WIN32) || defined(__WIN32__)) && \ ++ !defined(WIN32) && !defined(__SYMBIAN32__) ++#define WIN32 ++#endif ++ ++#include <stdio.h> ++#include <limits.h> ++ ++/* The include stuff here below is mainly for time_t! */ ++#ifdef vms ++# include <types.h> ++# include <time.h> ++#else ++# include <sys/types.h> ++# include <time.h> ++#endif /* defined (vms) */ ++ ++#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) && \ ++ !defined(__CYGWIN__) || defined(__MINGW32__) ++#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H)) ++/* The check above prevents the winsock2 inclusion if winsock.h already was ++ included, since they can't co-exist without problems */ ++#include <winsock2.h> ++#include <ws2tcpip.h> ++#endif ++#else ++ ++/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish ++ libc5-based Linux systems. Only include it on system that are known to ++ require it! */ ++#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ ++ defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) ++#include <sys/select.h> ++#endif ++ ++#ifndef _WIN32_WCE ++#include <sys/socket.h> ++#endif ++#if !defined(WIN32) && !defined(__WATCOMC__) ++#include <sys/time.h> ++#endif ++#include <sys/types.h> ++#endif ++ ++#ifdef __BEOS__ ++#include <support/SupportDefs.h> ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef void CURL; ++ ++/* ++ * Decorate exportable functions for Win32 and Symbian OS DLL linking. ++ * This avoids using a .def file for building libcurl.dll. ++ */ ++#if (defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)) && \ ++ !defined(CURL_STATICLIB) ++#if defined(BUILDING_LIBCURL) ++#define CURL_EXTERN __declspec(dllexport) ++#else ++#define CURL_EXTERN __declspec(dllimport) ++#endif ++#else ++ ++#ifdef CURL_HIDDEN_SYMBOLS ++/* ++ * This definition is used to make external definitions visible in the ++ * shared library when symbols are hidden by default. It makes no ++ * difference when compiling applications whether this is set or not, ++ * only when compiling the library. ++ */ ++#define CURL_EXTERN CURL_EXTERN_SYMBOL ++#else ++#define CURL_EXTERN ++#endif ++#endif ++ ++#ifndef curl_socket_typedef ++/* socket typedef */ ++#ifdef WIN32 ++typedef SOCKET curl_socket_t; ++#define CURL_SOCKET_BAD INVALID_SOCKET ++#else ++typedef int curl_socket_t; ++#define CURL_SOCKET_BAD -1 ++#endif ++#define curl_socket_typedef ++#endif /* curl_socket_typedef */ ++ ++struct curl_httppost { ++ struct curl_httppost *next; /* next entry in the list */ ++ char *name; /* pointer to allocated name */ ++ long namelength; /* length of name length */ ++ char *contents; /* pointer to allocated data contents */ ++ long contentslength; /* length of contents field */ ++ char *buffer; /* pointer to allocated buffer contents */ ++ long bufferlength; /* length of buffer field */ ++ char *contenttype; /* Content-Type */ ++ struct curl_slist* contentheader; /* list of extra headers for this form */ ++ struct curl_httppost *more; /* if one field name has more than one ++ file, this link should link to following ++ files */ ++ long flags; /* as defined below */ ++#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */ ++#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */ ++#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer ++ do not free in formfree */ ++#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer ++ do not free in formfree */ ++#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ ++#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ ++#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the ++ regular read callback to get the data ++ and pass the given pointer as custom ++ pointer */ ++ ++ char *showfilename; /* The file name to show. If not set, the ++ actual file name will be used (if this ++ is a file part) */ ++ void *userp; /* custom pointer used for ++ HTTPPOST_CALLBACK posts */ ++}; ++ ++typedef int (*curl_progress_callback)(void *clientp, ++ double dltotal, ++ double dlnow, ++ double ultotal, ++ double ulnow); ++ ++#ifndef CURL_MAX_WRITE_SIZE ++ /* Tests have proven that 20K is a very bad buffer size for uploads on ++ Windows, while 16K for some odd reason performed a lot better. ++ We do the ifndef check to allow this value to easier be changed at build ++ time for those who feel adventurous. */ ++#define CURL_MAX_WRITE_SIZE 16384 ++#endif ++/* This is a magic return code for the write callback that, when returned, ++ will signal libcurl to pause receiving on the current transfer. */ ++#define CURL_WRITEFUNC_PAUSE 0x10000001 ++typedef size_t (*curl_write_callback)(char *buffer, ++ size_t size, ++ size_t nitems, ++ void *outstream); ++ ++/* This is a return code for the read callback that, when returned, will ++ signal libcurl to immediately abort the current transfer. */ ++#define CURL_READFUNC_ABORT 0x10000000 ++/* This is a return code for the read callback that, when returned, will ++ signal libcurl to pause sending data on the current transfer. */ ++#define CURL_READFUNC_PAUSE 0x10000001 ++typedef int (*curl_seek_callback)(void *instream, ++ curl_off_t offset, ++ int origin); /* 'whence' */ ++ ++typedef size_t (*curl_read_callback)(char *buffer, ++ size_t size, ++ size_t nitems, ++ void *instream); ++ ++typedef enum { ++ CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ ++ CURLSOCKTYPE_LAST /* never use */ ++} curlsocktype; ++ ++typedef int (*curl_sockopt_callback)(void *clientp, ++ curl_socket_t curlfd, ++ curlsocktype purpose); ++ ++struct curl_sockaddr { ++ int family; ++ int socktype; ++ int protocol; ++ unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it ++ turned really ugly and painful on the systems that ++ lack this type */ ++ struct sockaddr addr; ++}; ++ ++typedef curl_socket_t ++(*curl_opensocket_callback)(void *clientp, ++ curlsocktype purpose, ++ struct curl_sockaddr *address); ++ ++#ifndef CURL_NO_OLDIES ++ /* not used since 7.10.8, will be removed in a future release */ ++typedef int (*curl_passwd_callback)(void *clientp, ++ const char *prompt, ++ char *buffer, ++ int buflen); ++#endif ++ ++typedef enum { ++ CURLIOE_OK, /* I/O operation successful */ ++ CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ ++ CURLIOE_FAILRESTART, /* failed to restart the read */ ++ CURLIOE_LAST /* never use */ ++} curlioerr; ++ ++typedef enum { ++ CURLIOCMD_NOP, /* no operation */ ++ CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ ++ CURLIOCMD_LAST /* never use */ ++} curliocmd; ++ ++typedef curlioerr (*curl_ioctl_callback)(CURL *handle, ++ int cmd, ++ void *clientp); ++ ++/* ++ * The following typedef's are signatures of malloc, free, realloc, strdup and ++ * calloc respectively. Function pointers of these types can be passed to the ++ * curl_global_init_mem() function to set user defined memory management ++ * callback routines. ++ */ ++typedef void *(*curl_malloc_callback)(size_t size); ++typedef void (*curl_free_callback)(void *ptr); ++typedef void *(*curl_realloc_callback)(void *ptr, size_t size); ++typedef char *(*curl_strdup_callback)(const char *str); ++typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); ++ ++/* the kind of data that is passed to information_callback*/ ++typedef enum { ++ CURLINFO_TEXT = 0, ++ CURLINFO_HEADER_IN, /* 1 */ ++ CURLINFO_HEADER_OUT, /* 2 */ ++ CURLINFO_DATA_IN, /* 3 */ ++ CURLINFO_DATA_OUT, /* 4 */ ++ CURLINFO_SSL_DATA_IN, /* 5 */ ++ CURLINFO_SSL_DATA_OUT, /* 6 */ ++ CURLINFO_END ++} curl_infotype; ++ ++typedef int (*curl_debug_callback) ++ (CURL *handle, /* the handle/transfer this concerns */ ++ curl_infotype type, /* what kind of data */ ++ char *data, /* points to the data */ ++ size_t size, /* size of the data pointed to */ ++ void *userptr); /* whatever the user please */ ++ ++/* All possible error codes from all sorts of curl functions. Future versions ++ may return other values, stay prepared. ++ ++ Always add new return codes last. Never *EVER* remove any. The return ++ codes must remain the same! ++ */ ++ ++typedef enum { ++ CURLE_OK = 0, ++ CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ ++ CURLE_FAILED_INIT, /* 2 */ ++ CURLE_URL_MALFORMAT, /* 3 */ ++ CURLE_OBSOLETE4, /* 4 - NOT USED */ ++ CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ ++ CURLE_COULDNT_RESOLVE_HOST, /* 6 */ ++ CURLE_COULDNT_CONNECT, /* 7 */ ++ CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */ ++ CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server ++ due to lack of access - when login fails ++ this is not returned. */ ++ CURLE_OBSOLETE10, /* 10 - NOT USED */ ++ CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ ++ CURLE_OBSOLETE12, /* 12 - NOT USED */ ++ CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ ++ CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ ++ CURLE_FTP_CANT_GET_HOST, /* 15 */ ++ CURLE_OBSOLETE16, /* 16 - NOT USED */ ++ CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ ++ CURLE_PARTIAL_FILE, /* 18 */ ++ CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ ++ CURLE_OBSOLETE20, /* 20 - NOT USED */ ++ CURLE_QUOTE_ERROR, /* 21 - quote command failure */ ++ CURLE_HTTP_RETURNED_ERROR, /* 22 */ ++ CURLE_WRITE_ERROR, /* 23 */ ++ CURLE_OBSOLETE24, /* 24 - NOT USED */ ++ CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ ++ CURLE_READ_ERROR, /* 26 - couldn't open/read from file */ ++ CURLE_OUT_OF_MEMORY, /* 27 */ ++ /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error ++ instead of a memory allocation error if CURL_DOES_CONVERSIONS ++ is defined ++ */ ++ CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ ++ CURLE_OBSOLETE29, /* 29 - NOT USED */ ++ CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ ++ CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ ++ CURLE_OBSOLETE32, /* 32 - NOT USED */ ++ CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ ++ CURLE_HTTP_POST_ERROR, /* 34 */ ++ CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ ++ CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ ++ CURLE_FILE_COULDNT_READ_FILE, /* 37 */ ++ CURLE_LDAP_CANNOT_BIND, /* 38 */ ++ CURLE_LDAP_SEARCH_FAILED, /* 39 */ ++ CURLE_OBSOLETE40, /* 40 - NOT USED */ ++ CURLE_FUNCTION_NOT_FOUND, /* 41 */ ++ CURLE_ABORTED_BY_CALLBACK, /* 42 */ ++ CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ ++ CURLE_OBSOLETE44, /* 44 - NOT USED */ ++ CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ ++ CURLE_OBSOLETE46, /* 46 - NOT USED */ ++ CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ ++ CURLE_UNKNOWN_TELNET_OPTION, /* 48 - User specified an unknown option */ ++ CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ ++ CURLE_OBSOLETE50, /* 50 - NOT USED */ ++ CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint ++ wasn't verified fine */ ++ CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ ++ CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ ++ CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as ++ default */ ++ CURLE_SEND_ERROR, /* 55 - failed sending network data */ ++ CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ ++ CURLE_OBSOLETE57, /* 57 - NOT IN USE */ ++ CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ ++ CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ ++ CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ ++ CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized transfer encoding */ ++ CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ ++ CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ ++ CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ ++ CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind ++ that failed */ ++ CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ ++ CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not ++ accepted and we failed to login */ ++ CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ ++ CURLE_TFTP_PERM, /* 69 - permission problem on server */ ++ CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ ++ CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ ++ CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ ++ CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ ++ CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ ++ CURLE_CONV_FAILED, /* 75 - conversion failed */ ++ CURLE_CONV_REQD, /* 76 - caller must register conversion ++ callbacks using curl_easy_setopt options ++ CURLOPT_CONV_FROM_NETWORK_FUNCTION, ++ CURLOPT_CONV_TO_NETWORK_FUNCTION, and ++ CURLOPT_CONV_FROM_UTF8_FUNCTION */ ++ CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing ++ or wrong format */ ++ CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ ++ CURLE_SSH, /* 79 - error from the SSH layer, somewhat ++ generic so the error message will be of ++ interest when this has happened */ ++ ++ CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL ++ connection */ ++ CURLE_AGAIN, /* 81 - socket is not ready for send/recv, ++ wait till it's ready and try again (Added ++ in 7.18.2) */ ++ CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or ++ wrong format (Added in 7.19.0) */ ++ CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in ++ 7.19.0) */ ++ CURL_LAST /* never use! */ ++} CURLcode; ++ ++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all ++ the obsolete stuff removed! */ ++ ++/* Backwards compatibility with older names */ ++ ++/* The following were added in 7.17.1 */ ++/* These are scheduled to disappear by 2009 */ ++#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION ++ ++/* The following were added in 7.17.0 */ ++/* These are scheduled to disappear by 2009 */ ++#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* noone should be using this! */ ++#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 ++#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 ++#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 ++#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 ++#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 ++#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 ++#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 ++#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 ++#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 ++#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 ++#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 ++#define CURLE_URL_MALFORMAT_USER CURLE_OBSOLETE4 ++ ++#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED ++#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE ++#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR ++#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL ++#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS ++#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR ++#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED ++ ++/* The following were added earlier */ ++ ++#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT ++ ++#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR ++#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED ++#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED ++ ++#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE ++#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME ++ ++/* This was the error code 50 in 7.7.3 and a few earlier versions, this ++ is no longer used by libcurl but is instead #defined here only to not ++ make programs break */ ++#define CURLE_ALREADY_COMPLETE 99999 ++ ++#endif /*!CURL_NO_OLDIES*/ ++ ++/* This prototype applies to all conversion callbacks */ ++typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); ++ ++typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ ++ void *ssl_ctx, /* actually an ++ OpenSSL SSL_CTX */ ++ void *userptr); ++ ++typedef enum { ++ CURLPROXY_HTTP = 0, /* added in 7.10 */ ++ CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already ++ in 7.10 */ ++ CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ ++ CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ ++ CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the ++ host name rather than the IP address. added ++ in 7.18.0 */ ++} curl_proxytype; /* this enum was added in 7.10 */ ++ ++#define CURLAUTH_NONE 0 /* nothing */ ++#define CURLAUTH_BASIC (1<<0) /* Basic (default) */ ++#define CURLAUTH_DIGEST (1<<1) /* Digest */ ++#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */ ++#define CURLAUTH_NTLM (1<<3) /* NTLM */ ++#define CURLAUTH_ANY ~0 /* all types set */ ++#define CURLAUTH_ANYSAFE (~CURLAUTH_BASIC) ++ ++#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ ++#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ ++#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ ++#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ ++#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ ++#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ ++#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY ++ ++#define CURL_ERROR_SIZE 256 ++ ++/* parameter for the CURLOPT_USE_SSL option */ ++typedef enum { ++ CURLUSESSL_NONE, /* do not attempt to use SSL */ ++ CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ ++ CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ ++ CURLUSESSL_ALL, /* SSL for all communication or fail */ ++ CURLUSESSL_LAST /* not an option, never use */ ++} curl_usessl; ++ ++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all ++ the obsolete stuff removed! */ ++ ++/* Backwards compatibility with older names */ ++/* These are scheduled to disappear by 2009 */ ++ ++#define CURLFTPSSL_NONE CURLUSESSL_NONE ++#define CURLFTPSSL_TRY CURLUSESSL_TRY ++#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL ++#define CURLFTPSSL_ALL CURLUSESSL_ALL ++#define CURLFTPSSL_LAST CURLUSESSL_LAST ++#define curl_ftpssl curl_usessl ++#endif /*!CURL_NO_OLDIES*/ ++ ++/* parameter for the CURLOPT_FTP_SSL_CCC option */ ++typedef enum { ++ CURLFTPSSL_CCC_NONE, /* do not send CCC */ ++ CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ ++ CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ ++ CURLFTPSSL_CCC_LAST /* not an option, never use */ ++} curl_ftpccc; ++ ++/* parameter for the CURLOPT_FTPSSLAUTH option */ ++typedef enum { ++ CURLFTPAUTH_DEFAULT, /* let libcurl decide */ ++ CURLFTPAUTH_SSL, /* use "AUTH SSL" */ ++ CURLFTPAUTH_TLS, /* use "AUTH TLS" */ ++ CURLFTPAUTH_LAST /* not an option, never use */ ++} curl_ftpauth; ++ ++/* parameter for the CURLOPT_FTP_FILEMETHOD option */ ++typedef enum { ++ CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ ++ CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ ++ CURLFTPMETHOD_NOCWD, /* no CWD at all */ ++ CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ ++ CURLFTPMETHOD_LAST /* not an option, never use */ ++} curl_ftpmethod; ++ ++/* long may be 32 or 64 bits, but we should never depend on anything else ++ but 32 */ ++#define CURLOPTTYPE_LONG 0 ++#define CURLOPTTYPE_OBJECTPOINT 10000 ++#define CURLOPTTYPE_FUNCTIONPOINT 20000 ++#define CURLOPTTYPE_OFF_T 30000 ++ ++/* name is uppercase CURLOPT_<name>, ++ type is one of the defined CURLOPTTYPE_<type> ++ number is unique identifier */ ++#ifdef CINIT ++#undef CINIT ++#endif ++ ++#ifdef CURL_ISOCPP ++#define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number ++#else ++/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ ++#define LONG CURLOPTTYPE_LONG ++#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT ++#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT ++#define OFF_T CURLOPTTYPE_OFF_T ++#define CINIT(name,type,number) CURLOPT_/**/name = type + number ++#endif ++ ++/* ++ * This macro-mania below setups the CURLOPT_[what] enum, to be used with ++ * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] ++ * word. ++ */ ++ ++typedef enum { ++ /* This is the FILE * or void * the regular output should be written to. */ ++ CINIT(FILE, OBJECTPOINT, 1), ++ ++ /* The full URL to get/put */ ++ CINIT(URL, OBJECTPOINT, 2), ++ ++ /* Port number to connect to, if other than default. */ ++ CINIT(PORT, LONG, 3), ++ ++ /* Name of proxy to use. */ ++ CINIT(PROXY, OBJECTPOINT, 4), ++ ++ /* "name:password" to use when fetching. */ ++ CINIT(USERPWD, OBJECTPOINT, 5), ++ ++ /* "name:password" to use with proxy. */ ++ CINIT(PROXYUSERPWD, OBJECTPOINT, 6), ++ ++ /* Range to get, specified as an ASCII string. */ ++ CINIT(RANGE, OBJECTPOINT, 7), ++ ++ /* not used */ ++ ++ /* Specified file stream to upload from (use as input): */ ++ CINIT(INFILE, OBJECTPOINT, 9), ++ ++ /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE ++ * bytes big. If this is not used, error messages go to stderr instead: */ ++ CINIT(ERRORBUFFER, OBJECTPOINT, 10), ++ ++ /* Function that will be called to store the output (instead of fwrite). The ++ * parameters will use fwrite() syntax, make sure to follow them. */ ++ CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11), ++ ++ /* Function that will be called to read the input (instead of fread). The ++ * parameters will use fread() syntax, make sure to follow them. */ ++ CINIT(READFUNCTION, FUNCTIONPOINT, 12), ++ ++ /* Time-out the read operation after this amount of seconds */ ++ CINIT(TIMEOUT, LONG, 13), ++ ++ /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about ++ * how large the file being sent really is. That allows better error ++ * checking and better verifies that the upload was successful. -1 means ++ * unknown size. ++ * ++ * For large file support, there is also a _LARGE version of the key ++ * which takes an off_t type, allowing platforms with larger off_t ++ * sizes to handle larger files. See below for INFILESIZE_LARGE. ++ */ ++ CINIT(INFILESIZE, LONG, 14), ++ ++ /* POST static input fields. */ ++ CINIT(POSTFIELDS, OBJECTPOINT, 15), ++ ++ /* Set the referrer page (needed by some CGIs) */ ++ CINIT(REFERER, OBJECTPOINT, 16), ++ ++ /* Set the FTP PORT string (interface name, named or numerical IP address) ++ Use i.e '-' to use default address. */ ++ CINIT(FTPPORT, OBJECTPOINT, 17), ++ ++ /* Set the User-Agent string (examined by some CGIs) */ ++ CINIT(USERAGENT, OBJECTPOINT, 18), ++ ++ /* If the download receives less than "low speed limit" bytes/second ++ * during "low speed time" seconds, the operations is aborted. ++ * You could i.e if you have a pretty high speed connection, abort if ++ * it is less than 2000 bytes/sec during 20 seconds. ++ */ ++ ++ /* Set the "low speed limit" */ ++ CINIT(LOW_SPEED_LIMIT, LONG, 19), ++ ++ /* Set the "low speed time" */ ++ CINIT(LOW_SPEED_TIME, LONG, 20), ++ ++ /* Set the continuation offset. ++ * ++ * Note there is also a _LARGE version of this key which uses ++ * off_t types, allowing for large file offsets on platforms which ++ * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. ++ */ ++ CINIT(RESUME_FROM, LONG, 21), ++ ++ /* Set cookie in request: */ ++ CINIT(COOKIE, OBJECTPOINT, 22), ++ ++ /* This points to a linked list of headers, struct curl_slist kind */ ++ CINIT(HTTPHEADER, OBJECTPOINT, 23), ++ ++ /* This points to a linked list of post entries, struct curl_httppost */ ++ CINIT(HTTPPOST, OBJECTPOINT, 24), ++ ++ /* name of the file keeping your private SSL-certificate */ ++ CINIT(SSLCERT, OBJECTPOINT, 25), ++ ++ /* password for the SSL or SSH private key */ ++ CINIT(KEYPASSWD, OBJECTPOINT, 26), ++ ++ /* send TYPE parameter? */ ++ CINIT(CRLF, LONG, 27), ++ ++ /* send linked-list of QUOTE commands */ ++ CINIT(QUOTE, OBJECTPOINT, 28), ++ ++ /* send FILE * or void * to store headers to, if you use a callback it ++ is simply passed to the callback unmodified */ ++ CINIT(WRITEHEADER, OBJECTPOINT, 29), ++ ++ /* point to a file to read the initial cookies from, also enables ++ "cookie awareness" */ ++ CINIT(COOKIEFILE, OBJECTPOINT, 31), ++ ++ /* What version to specifically try to use. ++ See CURL_SSLVERSION defines below. */ ++ CINIT(SSLVERSION, LONG, 32), ++ ++ /* What kind of HTTP time condition to use, see defines */ ++ CINIT(TIMECONDITION, LONG, 33), ++ ++ /* Time to use with the above condition. Specified in number of seconds ++ since 1 Jan 1970 */ ++ CINIT(TIMEVALUE, LONG, 34), ++ ++ /* 35 = OBSOLETE */ ++ ++ /* Custom request, for customizing the get command like ++ HTTP: DELETE, TRACE and others ++ FTP: to use a different list command ++ */ ++ CINIT(CUSTOMREQUEST, OBJECTPOINT, 36), ++ ++ /* HTTP request, for odd commands like DELETE, TRACE and others */ ++ CINIT(STDERR, OBJECTPOINT, 37), ++ ++ /* 38 is not used */ ++ ++ /* send linked-list of post-transfer QUOTE commands */ ++ CINIT(POSTQUOTE, OBJECTPOINT, 39), ++ ++ /* Pass a pointer to string of the output using full variable-replacement ++ as described elsewhere. */ ++ CINIT(WRITEINFO, OBJECTPOINT, 40), ++ ++ CINIT(VERBOSE, LONG, 41), /* talk a lot */ ++ CINIT(HEADER, LONG, 42), /* throw the header out too */ ++ CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ ++ CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ ++ CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ ++ CINIT(UPLOAD, LONG, 46), /* this is an upload */ ++ CINIT(POST, LONG, 47), /* HTTP POST method */ ++ CINIT(DIRLISTONLY, LONG, 48), /* return bare names when listing directories */ ++ ++ CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ ++ ++ /* Specify whether to read the user+password from the .netrc or the URL. ++ * This must be one of the CURL_NETRC_* enums below. */ ++ CINIT(NETRC, LONG, 51), ++ ++ CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ ++ ++ CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ ++ CINIT(PUT, LONG, 54), /* HTTP PUT */ ++ ++ /* 55 = OBSOLETE */ ++ ++ /* Function that will be called instead of the internal progress display ++ * function. This function should be defined as the curl_progress_callback ++ * prototype defines. */ ++ CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), ++ ++ /* Data passed to the progress callback */ ++ CINIT(PROGRESSDATA, OBJECTPOINT, 57), ++ ++ /* We want the referrer field set automatically when following locations */ ++ CINIT(AUTOREFERER, LONG, 58), ++ ++ /* Port of the proxy, can be set in the proxy string as well with: ++ "[host]:[port]" */ ++ CINIT(PROXYPORT, LONG, 59), ++ ++ /* size of the POST input data, if strlen() is not good to use */ ++ CINIT(POSTFIELDSIZE, LONG, 60), ++ ++ /* tunnel non-http operations through a HTTP proxy */ ++ CINIT(HTTPPROXYTUNNEL, LONG, 61), ++ ++ /* Set the interface string to use as outgoing network interface */ ++ CINIT(INTERFACE, OBJECTPOINT, 62), ++ ++ /* Set the krb4/5 security level, this also enables krb4/5 awareness. This ++ * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string ++ * is set but doesn't match one of these, 'private' will be used. */ ++ CINIT(KRBLEVEL, OBJECTPOINT, 63), ++ ++ /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ ++ CINIT(SSL_VERIFYPEER, LONG, 64), ++ ++ /* The CApath or CAfile used to validate the peer certificate ++ this option is used only if SSL_VERIFYPEER is true */ ++ CINIT(CAINFO, OBJECTPOINT, 65), ++ ++ /* 66 = OBSOLETE */ ++ /* 67 = OBSOLETE */ ++ ++ /* Maximum number of http redirects to follow */ ++ CINIT(MAXREDIRS, LONG, 68), ++ ++ /* Pass a long set to 1 to get the date of the requested document (if ++ possible)! Pass a zero to shut it off. */ ++ CINIT(FILETIME, LONG, 69), ++ ++ /* This points to a linked list of telnet options */ ++ CINIT(TELNETOPTIONS, OBJECTPOINT, 70), ++ ++ /* Max amount of cached alive connections */ ++ CINIT(MAXCONNECTS, LONG, 71), ++ ++ /* What policy to use when closing connections when the cache is filled ++ up */ ++ CINIT(CLOSEPOLICY, LONG, 72), ++ ++ /* 73 = OBSOLETE */ ++ ++ /* Set to explicitly use a new connection for the upcoming transfer. ++ Do not use this unless you're absolutely sure of this, as it makes the ++ operation slower and is less friendly for the network. */ ++ CINIT(FRESH_CONNECT, LONG, 74), ++ ++ /* Set to explicitly forbid the upcoming transfer's connection to be re-used ++ when done. Do not use this unless you're absolutely sure of this, as it ++ makes the operation slower and is less friendly for the network. */ ++ CINIT(FORBID_REUSE, LONG, 75), ++ ++ /* Set to a file name that contains random data for libcurl to use to ++ seed the random engine when doing SSL connects. */ ++ CINIT(RANDOM_FILE, OBJECTPOINT, 76), ++ ++ /* Set to the Entropy Gathering Daemon socket pathname */ ++ CINIT(EGDSOCKET, OBJECTPOINT, 77), ++ ++ /* Time-out connect operations after this amount of seconds, if connects ++ are OK within this time, then fine... This only aborts the connect ++ phase. [Only works on unix-style/SIGALRM operating systems] */ ++ CINIT(CONNECTTIMEOUT, LONG, 78), ++ ++ /* Function that will be called to store headers (instead of fwrite). The ++ * parameters will use fwrite() syntax, make sure to follow them. */ ++ CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79), ++ ++ /* Set this to force the HTTP request to get back to GET. Only really usable ++ if POST, PUT or a custom request have been used first. ++ */ ++ CINIT(HTTPGET, LONG, 80), ++ ++ /* Set if we should verify the Common name from the peer certificate in ssl ++ * handshake, set 1 to check existence, 2 to ensure that it matches the ++ * provided hostname. */ ++ CINIT(SSL_VERIFYHOST, LONG, 81), ++ ++ /* Specify which file name to write all known cookies in after completed ++ operation. Set file name to "-" (dash) to make it go to stdout. */ ++ CINIT(COOKIEJAR, OBJECTPOINT, 82), ++ ++ /* Specify which SSL ciphers to use */ ++ CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83), ++ ++ /* Specify which HTTP version to use! This must be set to one of the ++ CURL_HTTP_VERSION* enums set below. */ ++ CINIT(HTTP_VERSION, LONG, 84), ++ ++ /* Specifically switch on or off the FTP engine's use of the EPSV command. By ++ default, that one will always be attempted before the more traditional ++ PASV command. */ ++ CINIT(FTP_USE_EPSV, LONG, 85), ++ ++ /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ ++ CINIT(SSLCERTTYPE, OBJECTPOINT, 86), ++ ++ /* name of the file keeping your private SSL-key */ ++ CINIT(SSLKEY, OBJECTPOINT, 87), ++ ++ /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ ++ CINIT(SSLKEYTYPE, OBJECTPOINT, 88), ++ ++ /* crypto engine for the SSL-sub system */ ++ CINIT(SSLENGINE, OBJECTPOINT, 89), ++ ++ /* set the crypto engine for the SSL-sub system as default ++ the param has no meaning... ++ */ ++ CINIT(SSLENGINE_DEFAULT, LONG, 90), ++ ++ /* Non-zero value means to use the global dns cache */ ++ CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To become OBSOLETE soon */ ++ ++ /* DNS cache timeout */ ++ CINIT(DNS_CACHE_TIMEOUT, LONG, 92), ++ ++ /* send linked-list of pre-transfer QUOTE commands (Wesley Laxton)*/ ++ CINIT(PREQUOTE, OBJECTPOINT, 93), ++ ++ /* set the debug function */ ++ CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), ++ ++ /* set the data for the debug function */ ++ CINIT(DEBUGDATA, OBJECTPOINT, 95), ++ ++ /* mark this as start of a cookie session */ ++ CINIT(COOKIESESSION, LONG, 96), ++ ++ /* The CApath directory used to validate the peer certificate ++ this option is used only if SSL_VERIFYPEER is true */ ++ CINIT(CAPATH, OBJECTPOINT, 97), ++ ++ /* Instruct libcurl to use a smaller receive buffer */ ++ CINIT(BUFFERSIZE, LONG, 98), ++ ++ /* Instruct libcurl to not use any signal/alarm handlers, even when using ++ timeouts. This option is useful for multi-threaded applications. ++ See libcurl-the-guide for more background information. */ ++ CINIT(NOSIGNAL, LONG, 99), ++ ++ /* Provide a CURLShare for mutexing non-ts data */ ++ CINIT(SHARE, OBJECTPOINT, 100), ++ ++ /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), ++ CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */ ++ CINIT(PROXYTYPE, LONG, 101), ++ ++ /* Set the Accept-Encoding string. Use this to tell a server you would like ++ the response to be compressed. */ ++ CINIT(ENCODING, OBJECTPOINT, 102), ++ ++ /* Set pointer to private data */ ++ CINIT(PRIVATE, OBJECTPOINT, 103), ++ ++ /* Set aliases for HTTP 200 in the HTTP Response header */ ++ CINIT(HTTP200ALIASES, OBJECTPOINT, 104), ++ ++ /* Continue to send authentication (user+password) when following locations, ++ even when hostname changed. This can potentially send off the name ++ and password to whatever host the server decides. */ ++ CINIT(UNRESTRICTED_AUTH, LONG, 105), ++ ++ /* Specifically switch on or off the FTP engine's use of the EPRT command ( it ++ also disables the LPRT attempt). By default, those ones will always be ++ attempted before the good old traditional PORT command. */ ++ CINIT(FTP_USE_EPRT, LONG, 106), ++ ++ /* Set this to a bitmask value to enable the particular authentications ++ methods you like. Use this in combination with CURLOPT_USERPWD. ++ Note that setting multiple bits may cause extra network round-trips. */ ++ CINIT(HTTPAUTH, LONG, 107), ++ ++ /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx ++ in second argument. The function must be matching the ++ curl_ssl_ctx_callback proto. */ ++ CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), ++ ++ /* Set the userdata for the ssl context callback function's third ++ argument */ ++ CINIT(SSL_CTX_DATA, OBJECTPOINT, 109), ++ ++ /* FTP Option that causes missing dirs to be created on the remote server */ ++ CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110), ++ ++ /* Set this to a bitmask value to enable the particular authentications ++ methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. ++ Note that setting multiple bits may cause extra network round-trips. */ ++ CINIT(PROXYAUTH, LONG, 111), ++ ++ /* FTP option that changes the timeout, in seconds, associated with ++ getting a response. This is different from transfer timeout time and ++ essentially places a demand on the FTP server to acknowledge commands ++ in a timely manner. */ ++ CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), ++ ++ /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to ++ tell libcurl to resolve names to those IP versions only. This only has ++ affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ ++ CINIT(IPRESOLVE, LONG, 113), ++ ++ /* Set this option to limit the size of a file that will be downloaded from ++ an HTTP or FTP server. ++ ++ Note there is also _LARGE version which adds large file support for ++ platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ ++ CINIT(MAXFILESIZE, LONG, 114), ++ ++ /* See the comment for INFILESIZE above, but in short, specifies ++ * the size of the file being uploaded. -1 means unknown. ++ */ ++ CINIT(INFILESIZE_LARGE, OFF_T, 115), ++ ++ /* Sets the continuation offset. There is also a LONG version of this; ++ * look above for RESUME_FROM. ++ */ ++ CINIT(RESUME_FROM_LARGE, OFF_T, 116), ++ ++ /* Sets the maximum size of data that will be downloaded from ++ * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. ++ */ ++ CINIT(MAXFILESIZE_LARGE, OFF_T, 117), ++ ++ /* Set this option to the file name of your .netrc file you want libcurl ++ to parse (using the CURLOPT_NETRC option). If not set, libcurl will do ++ a poor attempt to find the user's home directory and check for a .netrc ++ file in there. */ ++ CINIT(NETRC_FILE, OBJECTPOINT, 118), ++ ++ /* Enable SSL/TLS for FTP, pick one of: ++ CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise ++ CURLFTPSSL_CONTROL - SSL for the control connection or fail ++ CURLFTPSSL_ALL - SSL for all communication or fail ++ */ ++ CINIT(USE_SSL, LONG, 119), ++ ++ /* The _LARGE version of the standard POSTFIELDSIZE option */ ++ CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), ++ ++ /* Enable/disable the TCP Nagle algorithm */ ++ CINIT(TCP_NODELAY, LONG, 121), ++ ++ /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ ++ /* 123 OBSOLETE. Gone in 7.16.0 */ ++ /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ ++ /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ ++ /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ ++ /* 127 OBSOLETE. Gone in 7.16.0 */ ++ /* 128 OBSOLETE. Gone in 7.16.0 */ ++ ++ /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option ++ can be used to change libcurl's default action which is to first try ++ "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK ++ response has been received. ++ ++ Available parameters are: ++ CURLFTPAUTH_DEFAULT - let libcurl decide ++ CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS ++ CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL ++ */ ++ CINIT(FTPSSLAUTH, LONG, 129), ++ ++ CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), ++ CINIT(IOCTLDATA, OBJECTPOINT, 131), ++ ++ /* 132 OBSOLETE. Gone in 7.16.0 */ ++ /* 133 OBSOLETE. Gone in 7.16.0 */ ++ ++ /* zero terminated string for pass on to the FTP server when asked for ++ "account" info */ ++ CINIT(FTP_ACCOUNT, OBJECTPOINT, 134), ++ ++ /* feed cookies into cookie engine */ ++ CINIT(COOKIELIST, OBJECTPOINT, 135), ++ ++ /* ignore Content-Length */ ++ CINIT(IGNORE_CONTENT_LENGTH, LONG, 136), ++ ++ /* Set to non-zero to skip the IP address received in a 227 PASV FTP server ++ response. Typically used for FTP-SSL purposes but is not restricted to ++ that. libcurl will then instead use the same IP address it used for the ++ control connection. */ ++ CINIT(FTP_SKIP_PASV_IP, LONG, 137), ++ ++ /* Select "file method" to use when doing FTP, see the curl_ftpmethod ++ above. */ ++ CINIT(FTP_FILEMETHOD, LONG, 138), ++ ++ /* Local port number to bind the socket to */ ++ CINIT(LOCALPORT, LONG, 139), ++ ++ /* Number of ports to try, including the first one set with LOCALPORT. ++ Thus, setting it to 1 will make no additional attempts but the first. ++ */ ++ CINIT(LOCALPORTRANGE, LONG, 140), ++ ++ /* no transfer, set up connection and let application use the socket by ++ extracting it with CURLINFO_LASTSOCKET */ ++ CINIT(CONNECT_ONLY, LONG, 141), ++ ++ /* Function that will be called to convert from the ++ network encoding (instead of using the iconv calls in libcurl) */ ++ CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142), ++ ++ /* Function that will be called to convert to the ++ network encoding (instead of using the iconv calls in libcurl) */ ++ CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143), ++ ++ /* Function that will be called to convert from UTF8 ++ (instead of using the iconv calls in libcurl) ++ Note that this is used only for SSL certificate processing */ ++ CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), ++ ++ /* if the connection proceeds too quickly then need to slow it down */ ++ /* limit-rate: maximum number of bytes per second to send or receive */ ++ CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), ++ CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), ++ ++ /* Pointer to command string to send if USER/PASS fails. */ ++ CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147), ++ ++ /* callback function for setting socket options */ ++ CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), ++ CINIT(SOCKOPTDATA, OBJECTPOINT, 149), ++ ++ /* set to 0 to disable session ID re-use for this transfer, default is ++ enabled (== 1) */ ++ CINIT(SSL_SESSIONID_CACHE, LONG, 150), ++ ++ /* allowed SSH authentication methods */ ++ CINIT(SSH_AUTH_TYPES, LONG, 151), ++ ++ /* Used by scp/sftp to do public/private key authentication */ ++ CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152), ++ CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153), ++ ++ /* Send CCC (Clear Command Channel) after authentication */ ++ CINIT(FTP_SSL_CCC, LONG, 154), ++ ++ /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ ++ CINIT(TIMEOUT_MS, LONG, 155), ++ CINIT(CONNECTTIMEOUT_MS, LONG, 156), ++ ++ /* set to zero to disable the libcurl's decoding and thus pass the raw body ++ data to the application even when it is encoded/compressed */ ++ CINIT(HTTP_TRANSFER_DECODING, LONG, 157), ++ CINIT(HTTP_CONTENT_DECODING, LONG, 158), ++ ++ /* Permission used when creating new files and directories on the remote ++ server for protocols that support it, SFTP/SCP/FILE */ ++ CINIT(NEW_FILE_PERMS, LONG, 159), ++ CINIT(NEW_DIRECTORY_PERMS, LONG, 160), ++ ++ /* Obey RFC 2616/10.3.2 and keep POSTs as POSTs after a 301 */ ++ CINIT(POST301, LONG, 161), ++ ++ /* used by scp/sftp to verify the host's public key */ ++ CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162), ++ ++ /* Callback function for opening socket (instead of socket(2)). Optionally, ++ callback is able change the address or refuse to connect returning ++ CURL_SOCKET_BAD. The callback should have type ++ curl_opensocket_callback */ ++ CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), ++ CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), ++ ++ /* POST volatile input fields. */ ++ CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165), ++ ++ /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */ ++ CINIT(PROXY_TRANSFER_MODE, LONG, 166), ++ ++ /* Callback function for seeking in the input stream */ ++ CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), ++ CINIT(SEEKDATA, OBJECTPOINT, 168), ++ ++ /* CRL file */ ++ CINIT(CRLFILE, OBJECTPOINT, 169), ++ ++ /* Issuer certificate */ ++ CINIT(ISSUERCERT, OBJECTPOINT, 170), ++ ++ /* (IPv6) Address scope */ ++ CINIT(ADDRESS_SCOPE, LONG, 171), ++ ++ CURLOPT_LASTENTRY /* the last unused */ ++} CURLoption; ++ ++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all ++ the obsolete stuff removed! */ ++ ++/* Backwards compatibility with older names */ ++/* These are scheduled to disappear by 2009 */ ++ ++/* The following were added in 7.17.0 */ ++#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD ++#define CURLOPT_FTPAPPEND CURLOPT_APPEND ++#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY ++#define CURLOPT_FTP_SSL CURLOPT_USE_SSL ++ ++/* The following were added earlier */ ++ ++#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD ++#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL ++ ++#else ++/* This is set if CURL_NO_OLDIES is defined at compile-time */ ++#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ ++#endif ++ ++ ++ /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host ++ name resolves addresses using more than one IP protocol version, this ++ option might be handy to force libcurl to use a specific IP version. */ ++#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP ++ versions that your system allows */ ++#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */ ++#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */ ++ ++ /* three convenient "aliases" that follow the name scheme better */ ++#define CURLOPT_WRITEDATA CURLOPT_FILE ++#define CURLOPT_READDATA CURLOPT_INFILE ++#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER ++ ++ /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ ++enum { ++ CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd ++ like the library to choose the best possible ++ for us! */ ++ CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ ++ CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ ++ ++ CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ ++}; ++ ++ /* These enums are for use with the CURLOPT_NETRC option. */ ++enum CURL_NETRC_OPTION { ++ CURL_NETRC_IGNORED, /* The .netrc will never be read. ++ * This is the default. */ ++ CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred ++ * to one in the .netrc. */ ++ CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. ++ * Unless one is set programmatically, the .netrc ++ * will be queried. */ ++ CURL_NETRC_LAST ++}; ++ ++enum { ++ CURL_SSLVERSION_DEFAULT, ++ CURL_SSLVERSION_TLSv1, ++ CURL_SSLVERSION_SSLv2, ++ CURL_SSLVERSION_SSLv3, ++ ++ CURL_SSLVERSION_LAST /* never use, keep last */ ++}; ++ ++ ++typedef enum { ++ CURL_TIMECOND_NONE, ++ ++ CURL_TIMECOND_IFMODSINCE, ++ CURL_TIMECOND_IFUNMODSINCE, ++ CURL_TIMECOND_LASTMOD, ++ ++ CURL_TIMECOND_LAST ++} curl_TimeCond; ++ ++ ++/* curl_strequal() and curl_strnequal() are subject for removal in a future ++ libcurl, see lib/README.curlx for details */ ++CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2); ++CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n); ++ ++/* name is uppercase CURLFORM_<name> */ ++#ifdef CFINIT ++#undef CFINIT ++#endif ++ ++#ifdef CURL_ISOCPP ++#define CFINIT(name) CURLFORM_ ## name ++#else ++/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ ++#define CFINIT(name) CURLFORM_/**/name ++#endif ++ ++typedef enum { ++ CFINIT(NOTHING), /********* the first one is unused ************/ ++ ++ /* */ ++ CFINIT(COPYNAME), ++ CFINIT(PTRNAME), ++ CFINIT(NAMELENGTH), ++ CFINIT(COPYCONTENTS), ++ CFINIT(PTRCONTENTS), ++ CFINIT(CONTENTSLENGTH), ++ CFINIT(FILECONTENT), ++ CFINIT(ARRAY), ++ CFINIT(OBSOLETE), ++ CFINIT(FILE), ++ ++ CFINIT(BUFFER), ++ CFINIT(BUFFERPTR), ++ CFINIT(BUFFERLENGTH), ++ ++ CFINIT(CONTENTTYPE), ++ CFINIT(CONTENTHEADER), ++ CFINIT(FILENAME), ++ CFINIT(END), ++ CFINIT(OBSOLETE2), ++ ++ CFINIT(STREAM), ++ ++ CURLFORM_LASTENTRY /* the last unused */ ++} CURLformoption; ++ ++#undef CFINIT /* done */ ++ ++/* structure to be used as parameter for CURLFORM_ARRAY */ ++struct curl_forms { ++ CURLformoption option; ++ const char *value; ++}; ++ ++/* use this for multipart formpost building */ ++/* Returns code for curl_formadd() ++ * ++ * Returns: ++ * CURL_FORMADD_OK on success ++ * CURL_FORMADD_MEMORY if the FormInfo allocation fails ++ * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form ++ * CURL_FORMADD_NULL if a null pointer was given for a char ++ * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed ++ * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used ++ * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) ++ * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated ++ * CURL_FORMADD_MEMORY if some allocation for string copying failed. ++ * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array ++ * ++ ***************************************************************************/ ++typedef enum { ++ CURL_FORMADD_OK, /* first, no error */ ++ ++ CURL_FORMADD_MEMORY, ++ CURL_FORMADD_OPTION_TWICE, ++ CURL_FORMADD_NULL, ++ CURL_FORMADD_UNKNOWN_OPTION, ++ CURL_FORMADD_INCOMPLETE, ++ CURL_FORMADD_ILLEGAL_ARRAY, ++ CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ ++ ++ CURL_FORMADD_LAST /* last */ ++} CURLFORMcode; ++ ++/* ++ * NAME curl_formadd() ++ * ++ * DESCRIPTION ++ * ++ * Pretty advanced function for building multi-part formposts. Each invoke ++ * adds one part that together construct a full post. Then use ++ * CURLOPT_HTTPPOST to send it off to libcurl. ++ */ ++CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, ++ struct curl_httppost **last_post, ++ ...); ++ ++/* ++ * callback function for curl_formget() ++ * The void *arg pointer will be the one passed as second argument to ++ * curl_formget(). ++ * The character buffer passed to it must not be freed. ++ * Should return the buffer length passed to it as the argument "len" on ++ * success. ++ */ ++typedef size_t (*curl_formget_callback)(void *arg, const char *buf, size_t len); ++ ++/* ++ * NAME curl_formget() ++ * ++ * DESCRIPTION ++ * ++ * Serialize a curl_httppost struct built with curl_formadd(). ++ * Accepts a void pointer as second argument which will be passed to ++ * the curl_formget_callback function. ++ * Returns 0 on success. ++ */ ++CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg, ++ curl_formget_callback append); ++/* ++ * NAME curl_formfree() ++ * ++ * DESCRIPTION ++ * ++ * Free a multipart formpost previously built with curl_formadd(). ++ */ ++CURL_EXTERN void curl_formfree(struct curl_httppost *form); ++ ++/* ++ * NAME curl_getenv() ++ * ++ * DESCRIPTION ++ * ++ * Returns a malloc()'ed string that MUST be curl_free()ed after usage is ++ * complete. DEPRECATED - see lib/README.curlx ++ */ ++CURL_EXTERN char *curl_getenv(const char *variable); ++ ++/* ++ * NAME curl_version() ++ * ++ * DESCRIPTION ++ * ++ * Returns a static ascii string of the libcurl version. ++ */ ++CURL_EXTERN char *curl_version(void); ++ ++/* ++ * NAME curl_easy_escape() ++ * ++ * DESCRIPTION ++ * ++ * Escapes URL strings (converts all letters consider illegal in URLs to their ++ * %XX versions). This function returns a new allocated string or NULL if an ++ * error occurred. ++ */ ++CURL_EXTERN char *curl_easy_escape(CURL *handle, ++ const char *string, ++ int length); ++ ++/* the previous version: */ ++CURL_EXTERN char *curl_escape(const char *string, ++ int length); ++ ++ ++/* ++ * NAME curl_easy_unescape() ++ * ++ * DESCRIPTION ++ * ++ * Unescapes URL encoding in strings (converts all %XX codes to their 8bit ++ * versions). This function returns a new allocated string or NULL if an error ++ * occurred. ++ * Conversion Note: On non-ASCII platforms the ASCII %XX codes are ++ * converted into the host encoding. ++ */ ++CURL_EXTERN char *curl_easy_unescape(CURL *handle, ++ const char *string, ++ int length, ++ int *outlength); ++ ++/* the previous version */ ++CURL_EXTERN char *curl_unescape(const char *string, ++ int length); ++ ++/* ++ * NAM... [truncated message content] |