7.19.5 coming up

RtlGenRandom, has been located or not. This function is only available on
WinXP and later. When unavailable c-ares uses portable rand() function.

.cvsignore

@@ -1,17 +1,22 @@
-compile
-config.log
 Makefile
-libtool
 Makefile.in
 aclocal.m4
 aclocal.m4.bak
-configure
-config.h
-config.status
-curl-config
 autom4te.cache
-depcomp
+compile
 config.guess
+config.h
+config.log
+config.lt
+config.status
 config.sub
-ltmain.sh
+configure
+curl-config
+depcomp
 libcurl.pc
+libtool
+ltmain.sh
+vc6curl.ncb
+vc6curl.opt
+vc6curl.sln
+vc6curl.suo

CMake/CMakeConfigurableFile.in

@@ -0,0 +1,2 @@
+@CMAKE_CONFIGURABLE_FILE_CONTENT@
+

CMake/CheckTypeSize.c.in

@@ -0,0 +1,34 @@
+#cmakedefine CHECK_TYPE_SIZE_TYPE @CHECK_TYPE_SIZE_TYPE@
+#ifdef CHECK_TYPE_SIZE_TYPE
+
+@CHECK_TYPE_SIZE_PREINCLUDE@
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif /* HAVE_SYS_TYPES_H */
+
+#ifdef HAVE_STDINT_H
+#  include <stdint.h>
+#endif /* HAVE_STDINT_H */
+
+#ifdef HAVE_STDDEF_H
+#  include <stddef.h>
+#endif /* HAVE_STDDEF_H */
+
+@CHECK_TYPE_SIZE_PREMAIN@
+
+#ifdef __CLASSIC_C__
+int main(){
+  int ac;
+  char*av[];
+#else
+int main(int ac, char*av[]){
+#endif
+  if(ac > 1000){return *av[0];}
+  return sizeof(CHECK_TYPE_SIZE_TYPE);
+}
+
+#else  /* CHECK_TYPE_SIZE_TYPE */
+
+#  error "CHECK_TYPE_SIZE_TYPE has to specify the type"
+
+#endif /* CHECK_TYPE_SIZE_TYPE */

CMake/CheckTypeSize.cmake

@@ -0,0 +1,56 @@
+# - Check sizeof a type
+#  CHECK_TYPE_SIZE(TYPE VARIABLE)
+# Check if the type exists and determine size of type.  if the type
+# exists, the size will be stored to the variable.
+#
+#  VARIABLE - variable to store size if the type exists.
+#  HAVE_${VARIABLE} - does the variable exists or not
+
+MACRO(CHECK_TYPE_SIZE TYPE VARIABLE)
+  SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS 1)
+  IF(NOT DEFINED ${VARIABLE})
+  IF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
+    SET(CHECK_TYPE_SIZE_TYPE "${TYPE}")
+    SET(MACRO_CHECK_TYPE_SIZE_FLAGS 
+      "${CMAKE_REQUIRED_FLAGS}")
+    FOREACH(def HAVE_SYS_TYPES_H HAVE_STDINT_H HAVE_STDDEF_H)
+      IF("${def}")
+        SET(MACRO_CHECK_TYPE_SIZE_FLAGS 
+          "${MACRO_CHECK_TYPE_SIZE_FLAGS} -D${def}")
+      ENDIF("${def}")
+    ENDFOREACH(def)
+    SET(CHECK_TYPE_SIZE_PREMAIN)
+    FOREACH(def ${CMAKE_EXTRA_INCLUDE_FILES})
+      SET(CHECK_TYPE_SIZE_PREMAIN "${CHECK_TYPE_SIZE_PREMAIN}#include \"${def}\"\n")
+    ENDFOREACH(def)
+    CONFIGURE_FILE(
+      "${CMAKE_CURRENT_SOURCE_DIR}/CMake/CheckTypeSize.c.in"
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c" 
+      IMMEDIATE @ONLY)
+    FILE(READ 
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c"
+      CHECK_TYPE_SIZE_FILE_CONTENT)
+    MESSAGE(STATUS "Check size of ${TYPE}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_TYPE_SIZE_ADD_LIBRARIES 
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    TRY_RUN(${VARIABLE} HAVE_${VARIABLE}
+      ${CMAKE_BINARY_DIR}
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c"
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_TYPE_SIZE_FLAGS}
+      "${CHECK_TYPE_SIZE_ADD_LIBRARIES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(HAVE_${VARIABLE})
+      MESSAGE(STATUS "Check size of ${TYPE} - done")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+        "Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n")
+    ELSE(HAVE_${VARIABLE})
+      MESSAGE(STATUS "Check size of ${TYPE} - failed")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
+        "Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSize.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n")
+    ENDIF(HAVE_${VARIABLE})
+  ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
+  ENDIF(NOT DEFINED ${VARIABLE})
+  SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS )
+ENDMACRO(CHECK_TYPE_SIZE)

CMake/CurlCheckCSourceCompiles.cmake

@@ -0,0 +1,75 @@
+# - Check if the source code provided in the SOURCE argument compiles.
+# CURL_CHECK_C_SOURCE_COMPILES(SOURCE VAR)
+# - macro which checks if the source code compiles
+#  SOURCE   - source code to try to compile
+#  VAR      - variable to store whether the source code compiled
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
+
+MACRO(CURL_CHECK_C_SOURCE_COMPILES SOURCE VAR)
+  IF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+    SET(message "${VAR}")
+    # If the number of arguments is greater than 2 (SOURCE VAR)
+    IF(${ARGC} GREATER 2)
+      # then add the third argument as a message
+      SET(message "${ARGV2} (${VAR})")
+    ENDIF(${ARGC} GREATER 2)
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS
+      "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ELSE(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    IF(CMAKE_REQUIRED_INCLUDES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES
+        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+    ELSE(CMAKE_REQUIRED_INCLUDES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)
+    ENDIF(CMAKE_REQUIRED_INCLUDES)
+    SET(src "")
+    FOREACH(def ${EXTRA_DEFINES})
+      SET(src "${src}#define ${def} 1\n")
+    ENDFOREACH(def)
+    FOREACH(inc ${HEADER_INCLUDES})
+      SET(src "${src}#include <${inc}>\n")
+    ENDFOREACH(inc)
+
+    SET(src "${src}\nint main() { ${SOURCE} ; return 0; }")
+    SET(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")
+    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"
+      IMMEDIATE)
+    MESSAGE(STATUS "Performing Test ${message}")
+    TRY_COMPILE(${VAR}
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}"
+      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(${VAR})
+      SET(${VAR} 1 CACHE INTERNAL "Test ${message}")
+      MESSAGE(STATUS "Performing Test ${message} - Success")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"
+        "${OUTPUT}\n"
+        "Source file was:\n${src}\n")
+    ELSE(${VAR})
+      MESSAGE(STATUS "Performing Test ${message} - Failed")
+      SET(${VAR} "" CACHE INTERNAL "Test ${message}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Performing C SOURCE FILE Test ${message} failed with the following output:\n"
+        "${OUTPUT}\n"
+        "Source file was:\n${src}\n")
+    ENDIF(${VAR})
+  ENDIF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+ENDMACRO(CURL_CHECK_C_SOURCE_COMPILES)

CMake/CurlCheckCSourceRuns.cmake

@@ -0,0 +1,83 @@
+# - Check if the source code provided in the SOURCE argument compiles and runs.
+# CURL_CHECK_C_SOURCE_RUNS(SOURCE VAR)
+# - macro which checks if the source code runs
+#  SOURCE   - source code to try to compile
+#  VAR - variable to store size if the type exists.
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
+
+MACRO(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR)
+  IF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+    SET(message "${VAR}")
+    # If the number of arguments is greater than 2 (SOURCE VAR)
+    IF(${ARGC} GREATER 2)
+      # then add the third argument as a message
+      SET(message "${ARGV2} (${VAR})")
+    ENDIF(${ARGC} GREATER 2)
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS
+      "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ELSE(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    IF(CMAKE_REQUIRED_INCLUDES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES
+        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+    ELSE(CMAKE_REQUIRED_INCLUDES)
+      SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)
+    ENDIF(CMAKE_REQUIRED_INCLUDES)
+    SET(src "")
+    FOREACH(def ${EXTRA_DEFINES})
+      SET(src "${src}#define ${def} 1\n")
+    ENDFOREACH(def)
+    FOREACH(inc ${HEADER_INCLUDES})
+      SET(src "${src}#include <${inc}>\n")
+    ENDFOREACH(inc)
+
+    SET(src "${src}\nint main() { ${SOURCE} ; return 0; }")
+    SET(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")
+    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"
+      IMMEDIATE)
+    MESSAGE(STATUS "Performing Test ${message}")
+    TRY_RUN(${VAR} ${VAR}_COMPILED
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}"
+      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"
+      OUTPUT_VARIABLE OUTPUT)
+    # if it did not compile make the return value fail code of 1
+    IF(NOT ${VAR}_COMPILED)
+      SET(${VAR} 1)
+    ENDIF(NOT ${VAR}_COMPILED)
+    # if the return value was 0 then it worked
+    SET(result_var ${${VAR}})
+    IF("${result_var}" EQUAL 0)
+      SET(${VAR} 1 CACHE INTERNAL "Test ${message}")
+      MESSAGE(STATUS "Performing Test ${message} - Success")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"
+        "${OUTPUT}\n"
+        "Return value: ${${VAR}}\n"
+        "Source file was:\n${src}\n")
+    ELSE("${result_var}" EQUAL 0)
+      MESSAGE(STATUS "Performing Test ${message} - Failed")
+      SET(${VAR} "" CACHE INTERNAL "Test ${message}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Performing C SOURCE FILE Test ${message} failed with the following output:\n"
+        "${OUTPUT}\n"
+        "Return value: ${result_var}\n"
+        "Source file was:\n${src}\n")
+    ENDIF("${result_var}" EQUAL 0)
+  ENDIF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+ENDMACRO(CURL_CHECK_C_SOURCE_RUNS)

CMake/CurlTests.c

@@ -0,0 +1,690 @@
+#ifdef TIME_WITH_SYS_TIME
+/* Time with sys/time test */
+ 
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+
+int
+main ()
+{
+if ((struct tm *) 0)
+return 0;
+  ;
+  return 0;
+}
+
+#endif
+
+#ifdef HAVE_FCNTL_O_NONBLOCK
+
+/* headers for FCNTL_O_NONBLOCK test */
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+/* */
+#if defined(sun) || defined(__sun__) || \
+    defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# if defined(__SVR4) || defined(__srv4__)
+#  define PLATFORM_SOLARIS
+# else
+#  define PLATFORM_SUNOS4
+# endif
+#endif
+#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
+# define PLATFORM_AIX_V3
+#endif
+/* */
+#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
+#error "O_NONBLOCK does not work on this platform"
+#endif
+
+int
+main ()
+{
+      /* O_NONBLOCK source test */
+      int flags = 0;
+      if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
+          return 1;
+      return 0;
+}
+#endif
+
+#ifdef HAVE_GETHOSTBYADDR_R_5
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;
+int type;
+struct hostent h;
+struct hostent_data hdata;
+int rc;
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+rc = gethostbyaddr_r(address, length, type, &h, &hdata);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYADDR_R_5_REENTRANT
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;q
+int type;
+struct hostent h;
+struct hostent_data hdata;
+int rc;
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+rc = gethostbyaddr_r(address, length, type, &h, &hdata);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYADDR_R_7
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+hp = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &h_errnop);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYADDR_R_7_REENTRANT
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+hp = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &h_errnop);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYADDR_R_8
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+int rc;
+
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+rc = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &hp, &h_errnop);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYADDR_R_8_REENTRANT
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+int
+main ()
+{
+
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+int rc;
+
+#ifndef gethostbyaddr_r
+  (void)gethostbyaddr_r;
+#endif
+rc = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &hp, &h_errnop);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_3
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+
+struct hostent_data data;
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_3_REENTRANT
+#define _REENTRANT
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+
+struct hostent_data data;
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_5
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL, 0, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_5_REENTRANT
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL, 0, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_6
+#include <sys/types.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL, 0, NULL, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GETHOSTBYNAME_R_6_REENTRANT
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+#undef NULL
+#define NULL (void *)0
+
+int
+main ()
+{
+
+#ifndef gethostbyname_r
+  (void)gethostbyname_r;
+#endif
+gethostbyname_r(NULL, NULL, NULL, 0, NULL, NULL);
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_SOCKLEN_T
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#endif
+int
+main ()
+{
+if ((socklen_t *) 0)
+  return 0;
+if (sizeof (socklen_t))
+  return 0;
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_IN_ADDR_T
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+int
+main ()
+{
+if ((in_addr_t *) 0)
+  return 0;
+if (sizeof (in_addr_t))
+  return 0;
+  ;
+  return 0;
+}
+#endif
+
+#ifdef HAVE_BOOL_T
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+int
+main ()
+{
+if (sizeof (bool *) )
+  return 0;
+  ;
+  return 0;
+}
+#endif
+
+#ifdef STDC_HEADERS
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+int main() { return 0; }
+#endif
+#ifdef RETSIGTYPE_TEST
+#include <sys/types.h>
+#include <signal.h>
+#ifdef signal
+# undef signal
+#endif
+#ifdef __cplusplus
+extern "C" void (*signal (int, void (*)(int)))(int);
+#else
+void (*signal ()) ();
+#endif
+
+int
+main ()
+{
+  return 0;
+}
+#endif
+#ifdef HAVE_INET_NTOA_R_DECL
+#include <arpa/inet.h>
+
+typedef void (*func_type)();
+
+int main()
+{
+#ifndef inet_ntoa_r
+  func_type func;
+  func = (func_type)inet_ntoa_r;
+#endif
+  return 0;
+}
+#endif
+#ifdef HAVE_INET_NTOA_R_DECL_REENTRANT
+#define _REENTRANT
+#include <arpa/inet.h>
+
+typedef void (*func_type)();
+
+int main()
+{
+#ifndef inet_ntoa_r
+  func_type func;
+  func = (func_type)&inet_ntoa_r;
+#endif
+  return 0;
+}
+#endif
+#ifdef HAVE_GETADDRINFO
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int main(void) {
+    struct addrinfo hints, *ai;
+    int error;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+#ifndef getaddrinfo
+    (void)getaddrinfo;
+#endif
+    error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
+    if (error) {
+        return 1;
+    }
+    return 0;
+}
+#endif
+#ifdef HAVE_FILE_OFFSET_BITS
+#ifdef _FILE_OFFSET_BITS
+#undef _FILE_OFFSET_BITS
+#endif
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+                       && LARGE_OFF_T % 2147483647 == 1)
+                      ? 1 : -1];
+int main () { ; return 0; }
+#endif
+#ifdef HAVE_IOCTLSOCKET
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+
+int
+main ()
+{
+
+/* ioctlsocket source code */
+ int socket;
+ unsigned long flags = ioctlsocket(socket, FIONBIO, &flags);
+
+  ;
+  return 0;
+}
+
+#endif
+#ifdef HAVE_IOCTLSOCKET_CAMEL
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+
+int
+main ()
+{
+
+/* IoctlSocket source code */
+    if(0 != IoctlSocket(0, 0, 0))
+	return 1;
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+
+int
+main ()
+{
+
+/* IoctlSocket source code */
+        long flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_IOCTLSOCKET_FIONBIO
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+
+int
+main ()
+{
+
+        int flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_IOCTL_FIONBIO
+/* headers for FIONBIO test */
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+#  include <stropts.h>
+#endif
+
+int
+main ()
+{
+
+        int flags = 0;
+        if(0 != ioctl(0, FIONBIO, &flags))
+          return 1;
+
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_IOCTL_SIOCGIFADDR
+/* headers for FIONBIO test */
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+#  include <stropts.h>
+#endif
+#include <net/if.h>
+
+int
+main ()
+{
+        struct ifreq ifr;
+        if(0 != ioctl(0, SIOCGIFADDR, &ifr))
+          return 1;
+
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_SETSOCKOPT_SO_NONBLOCK
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+/* includes end */
+
+int
+main ()
+{
+        if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
+          return 1;
+  ;
+  return 0;
+}
+#endif
+#ifdef HAVE_GLIBC_STRERROR_R
+#include <string.h>
+#include <errno.h>
+int
+main () {
+  char buffer[1024]; /* big enough to play with */
+  char *string =
+    strerror_r(EACCES, buffer, sizeof(buffer));
+    /* this should've returned a string */
+    if(!string || !string[0])
+      return 99;
+    return 0;
+}
+#endif
+#ifdef HAVE_POSIX_STRERROR_R
+#include <string.h>
+#include <errno.h>
+int
+main () {
+  char buffer[1024]; /* big enough to play with */
+  int error =
+    strerror_r(EACCES, buffer, sizeof(buffer));
+    /* This should've returned zero, and written an error string in the
+       buffer.*/
+    if(!buffer[0] || error)
+      return 99;
+    return 0;
+}
+#endif

CMake/FindOpenSSL.cmake

@@ -0,0 +1,19 @@
+# Extension of the standard FindOpenSSL.cmake
+# Adds OPENSSL_INCLUDE_DIRS and libeay32
+INCLUDE("${CMAKE_ROOT}/Modules/FindOpenSSL.cmake")
+
+# Bill Hoffman told that libeay32 is necessary for him:
+FIND_LIBRARY(SSL_LIBEAY NAMES libeay32)
+
+IF(OPENSSL_FOUND)
+	IF(SSL_LIBEAY)
+		LIST(APPEND OPENSSL_LIBRARIES ${SSL_LIBEAY})
+	ELSE()
+		SET(OPENSSL_FOUND FALSE)
+	ENDIF()
+ENDIF()
+
+
+IF(OPENSSL_FOUND)
+	SET(OPENSSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
+ENDIF()

CMake/FindZLIB.cmake

@@ -0,0 +1,8 @@
+# Locate zlib
+INCLUDE("${CMAKE_ROOT}/Modules/FindZLIB.cmake")
+
+FIND_LIBRARY(ZLIB_LIBRARY_DEBUG NAMES zd zlibd zdlld zlib1d )
+
+IF(ZLIB_FOUND AND ZLIB_LIBRARY_DEBUG)
+  SET( ZLIB_LIBRARIES optimized "${ZLIB_LIBRARY}" debug ${ZLIB_LIBRARY_DEBUG})
+ENDIF()

CMake/OtherTests.cmake

@@ -0,0 +1,250 @@
+INCLUDE(CurlCheckCSourceCompiles)
+SET(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")
+SET(HEADER_INCLUDES)
+SET(headers_hack)
+
+MACRO(add_header_include check header)
+  IF(${check})
+    SET(headers_hack
+      "${headers_hack}\n#include <${header}>")
+    #SET(HEADER_INCLUDES
+    #  ${HEADER_INCLUDES}
+    #  "${header}")
+  ENDIF(${check})
+ENDMACRO(add_header_include)
+
+SET(signature_call_conv)
+IF(HAVE_WINDOWS_H)
+  add_header_include(HAVE_WINDOWS_H "windows.h")
+  add_header_include(HAVE_WINSOCK2_H "winsock2.h")
+  add_header_include(HAVE_WINSOCK_H "winsock.h")
+  SET(EXTRA_DEFINES ${EXTRA_DEFINES}
+    "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")
+  SET(signature_call_conv "PASCAL")
+ELSE(HAVE_WINDOWS_H)
+  add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
+  add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h")
+ENDIF(HAVE_WINDOWS_H)
+
+SET(EXTRA_DEFINES_BACKUP "${EXTRA_DEFINES}")
+SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
+CURL_CHECK_C_SOURCE_COMPILES("recv(0, 0, 0, 0)" curl_cv_recv)
+IF(curl_cv_recv)
+  #    AC_CACHE_CHECK([types of arguments and return type for recv],
+  #[curl_cv_func_recv_args], [
+  #SET(curl_cv_func_recv_args "unknown")
+  #for recv_retv in 'int' 'ssize_t'; do
+  IF(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
+    FOREACH(recv_retv "int" "ssize_t" )
+      FOREACH(recv_arg1 "int" "ssize_t" "SOCKET")
+        FOREACH(recv_arg2 "void *" "char *")
+          FOREACH(recv_arg3 "size_t" "int" "socklen_t" "unsigned int")
+            FOREACH(recv_arg4 "int" "unsigned int")
+              IF(NOT curl_cv_func_recv_done)
+                SET(curl_cv_func_recv_test "UNKNOWN")
+                SET(extern_line "extern ${recv_retv} ${signature_call_conv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})\;")
+                SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
+                CURL_CHECK_C_SOURCE_COMPILES("
+                    ${recv_arg1} s=0;
+                    ${recv_arg2} buf=0;
+                    ${recv_arg3} len=0;
+                    ${recv_arg4} flags=0;
+                    ${recv_retv} res = recv(s, buf, len, flags)"
+                    curl_cv_func_recv_test
+                    "${recv_retv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})")
+                IF(curl_cv_func_recv_test)
+                  SET(curl_cv_func_recv_args
+                    "${recv_arg1},${recv_arg2},${recv_arg3},${recv_arg4},${recv_retv}")
+                  SET(RECV_TYPE_ARG1 "${recv_arg1}")
+                  SET(RECV_TYPE_ARG2 "${recv_arg2}")
+                  SET(RECV_TYPE_ARG3 "${recv_arg3}")
+                  SET(RECV_TYPE_ARG4 "${recv_arg4}")
+                  SET(RECV_TYPE_RETV "${recv_retv}")
+                  SET(HAVE_RECV 1)
+                  SET(curl_cv_func_recv_done 1)
+                ENDIF(curl_cv_func_recv_test)
+              ENDIF(NOT curl_cv_func_recv_done)
+            ENDFOREACH(recv_arg4)
+          ENDFOREACH(recv_arg3)
+        ENDFOREACH(recv_arg2)
+      ENDFOREACH(recv_arg1)
+    ENDFOREACH(recv_retv) 
+  ELSE(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
+    STRING(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG1 "${curl_cv_func_recv_args}")
+    STRING(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG2 "${curl_cv_func_recv_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG3 "${curl_cv_func_recv_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" RECV_TYPE_ARG4 "${curl_cv_func_recv_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" RECV_TYPE_RETV "${curl_cv_func_recv_args}")
+    #MESSAGE("RECV_TYPE_ARG1 ${RECV_TYPE_ARG1}")
+    #MESSAGE("RECV_TYPE_ARG2 ${RECV_TYPE_ARG2}")
+    #MESSAGE("RECV_TYPE_ARG3 ${RECV_TYPE_ARG3}")
+    #MESSAGE("RECV_TYPE_ARG4 ${RECV_TYPE_ARG4}")
+    #MESSAGE("RECV_TYPE_RETV ${RECV_TYPE_RETV}")
+  ENDIF(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
+  
+  IF("${curl_cv_func_recv_args}" STREQUAL "unknown")
+    MESSAGE(FATAL_ERROR "Cannot find proper types to use for recv args")
+  ENDIF("${curl_cv_func_recv_args}" STREQUAL "unknown")
+ELSE(curl_cv_recv)
+  MESSAGE(FATAL_ERROR "Unable to link function recv")
+ENDIF(curl_cv_recv)
+SET(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL "Arguments for recv")
+SET(HAVE_RECV 1)
+
+CURL_CHECK_C_SOURCE_COMPILES("send(0, 0, 0, 0)" curl_cv_send)
+IF(curl_cv_send)
+  #    AC_CACHE_CHECK([types of arguments and return type for send],
+  #[curl_cv_func_send_args], [
+  #SET(curl_cv_func_send_args "unknown")
+  #for send_retv in 'int' 'ssize_t'; do
+  IF(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
+    FOREACH(send_retv "int" "ssize_t" )
+      FOREACH(send_arg1 "int" "ssize_t" "SOCKET")
+        FOREACH(send_arg2 "const void *" "void *" "char *" "const char *")
+          FOREACH(send_arg3 "size_t" "int" "socklen_t" "unsigned int")
+            FOREACH(send_arg4 "int" "unsigned int")
+              IF(NOT curl_cv_func_send_done)
+                SET(curl_cv_func_send_test "UNKNOWN")
+                SET(extern_line "extern ${send_retv} ${signature_call_conv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})\;")
+                SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
+                CURL_CHECK_C_SOURCE_COMPILES("
+                    ${send_arg1} s=0;
+                    ${send_arg2} buf=0;
+                    ${send_arg3} len=0;
+                    ${send_arg4} flags=0;
+                    ${send_retv} res = send(s, buf, len, flags)"
+                    curl_cv_func_send_test
+                    "${send_retv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})")
+                IF(curl_cv_func_send_test)
+                  #MESSAGE("Found arguments: ${curl_cv_func_send_test}")
+                  STRING(REGEX REPLACE "(const) .*" "\\1" send_qual_arg2 "${send_arg2}")
+                  STRING(REGEX REPLACE "const (.*)" "\\1" send_arg2 "${send_arg2}")
+                  SET(curl_cv_func_send_args
+                    "${send_arg1},${send_arg2},${send_arg3},${send_arg4},${send_retv},${send_qual_arg2}")
+                  SET(SEND_TYPE_ARG1 "${send_arg1}")
+                  SET(SEND_TYPE_ARG2 "${send_arg2}")
+                  SET(SEND_TYPE_ARG3 "${send_arg3}")
+                  SET(SEND_TYPE_ARG4 "${send_arg4}")
+                  SET(SEND_TYPE_RETV "${send_retv}")
+                  SET(HAVE_SEND 1)
+                  SET(curl_cv_func_send_done 1)
+                ENDIF(curl_cv_func_send_test)
+              ENDIF(NOT curl_cv_func_send_done)
+            ENDFOREACH(send_arg4)
+          ENDFOREACH(send_arg3)
+        ENDFOREACH(send_arg2)
+      ENDFOREACH(send_arg1)
+    ENDFOREACH(send_retv) 
+  ELSE(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
+    STRING(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG1 "${curl_cv_func_send_args}")
+    STRING(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG2 "${curl_cv_func_send_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG3 "${curl_cv_func_send_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG4 "${curl_cv_func_send_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" SEND_TYPE_RETV "${curl_cv_func_send_args}")
+    STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" SEND_QUAL_ARG2 "${curl_cv_func_send_args}")
+    #MESSAGE("SEND_TYPE_ARG1 ${SEND_TYPE_ARG1}")
+    #MESSAGE("SEND_TYPE_ARG2 ${SEND_TYPE_ARG2}")
+    #MESSAGE("SEND_TYPE_ARG3 ${SEND_TYPE_ARG3}")
+    #MESSAGE("SEND_TYPE_ARG4 ${SEND_TYPE_ARG4}")
+    #MESSAGE("SEND_TYPE_RETV ${SEND_TYPE_RETV}")
+    #MESSAGE("SEND_QUAL_ARG2 ${SEND_QUAL_ARG2}")
+  ENDIF(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
+  
+  IF("${curl_cv_func_send_args}" STREQUAL "unknown")
+    MESSAGE(FATAL_ERROR "Cannot find proper types to use for send args")
+  ENDIF("${curl_cv_func_send_args}" STREQUAL "unknown")
+  SET(SEND_QUAL_ARG2 "const")
+ELSE(curl_cv_send)
+  MESSAGE(FATAL_ERROR "Unable to link function send")
+ENDIF(curl_cv_send)
+SET(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL "Arguments for send")
+SET(HAVE_SEND 1)
+
+SET(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")
+CURL_CHECK_C_SOURCE_COMPILES("int flag = MSG_NOSIGNAL" HAVE_MSG_NOSIGNAL)
+
+SET(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")
+SET(HEADER_INCLUDES)
+SET(headers_hack)
+
+MACRO(add_header_include check header)
+  IF(${check})
+    SET(headers_hack
+      "${headers_hack}\n#include <${header}>")
+    #SET(HEADER_INCLUDES
+    #  ${HEADER_INCLUDES}
+    #  "${header}")
+  ENDIF(${check})
+ENDMACRO(add_header_include header)
+
+IF(HAVE_WINDOWS_H)
+  SET(EXTRA_DEFINES ${EXTRA_DEFINES}
+    "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")
+  add_header_include(HAVE_WINDOWS_H "windows.h")
+  add_header_include(HAVE_WINSOCK2_H "winsock2.h")
+  add_header_include(HAVE_WINSOCK_H "winsock.h")
+ELSE(HAVE_WINDOWS_H)
+  add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
+  add_header_include(HAVE_SYS_TIME_H "sys/time.h")
+  add_header_include(TIME_WITH_SYS_TIME "time.h")
+  add_header_include(HAVE_TIME_H "time.h")
+ENDIF(HAVE_WINDOWS_H)
+SET(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")
+CURL_CHECK_C_SOURCE_COMPILES("struct timeval ts;\nts.tv_sec  = 0;\nts.tv_usec = 0" HAVE_STRUCT_TIMEVAL)
+
+
+INCLUDE(CurlCheckCSourceRuns)
+SET(EXTRA_DEFINES)
+SET(HEADER_INCLUDES)
+IF(HAVE_SYS_POLL_H)
+  SET(HEADER_INCLUDES "sys/poll.h")
+ENDIF(HAVE_SYS_POLL_H)
+CURL_CHECK_C_SOURCE_RUNS("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)
+
+SET(HAVE_SIG_ATOMIC_T 1)
+SET(EXTRA_DEFINES)
+SET(HEADER_INCLUDES)
+IF(HAVE_SIGNAL_H)
+  SET(HEADER_INCLUDES "signal.h")
+  SET(CMAKE_EXTRA_INCLUDE_FILES "signal.h")
+ENDIF(HAVE_SIGNAL_H)
+CHECK_TYPE_SIZE("sig_atomic_t" SIZEOF_SIG_ATOMIC_T)
+IF(HAVE_SIZEOF_SIG_ATOMIC_T)
+  CURL_CHECK_C_SOURCE_COMPILES("static volatile sig_atomic_t dummy = 0" HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+  IF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+    SET(HAVE_SIG_ATOMIC_T_VOLATILE 1)
+  ENDIF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+ENDIF(HAVE_SIZEOF_SIG_ATOMIC_T)
+
+SET(CHECK_TYPE_SIZE_PREINCLUDE
+  "#undef inline")
+
+IF(HAVE_WINDOWS_H)
+  SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}
+  #ifndef WIN32_LEAN_AND_MEAN
+  #define WIN32_LEAN_AND_MEAN
+  #endif
+  #include <windows.h>")
+  IF(HAVE_WINSOCK2_H)
+    SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}\n#include <winsock2.h>")
+  ENDIF(HAVE_WINSOCK2_H)
+ELSE(HAVE_WINDOWS_H)
+  IF(HAVE_SYS_SOCKET_H)
+    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+      "sys/socket.h")
+  ENDIF(HAVE_SYS_SOCKET_H)
+  IF(HAVE_NETINET_IN_H)
+    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+      "netinet/in.h")
+  ENDIF(HAVE_NETINET_IN_H)
+  IF(HAVE_ARPA_INET_H)
+    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+      "arpa/inet.h")
+  ENDIF(HAVE_ARPA_INET_H)
+ENDIF(HAVE_WINDOWS_H)
+
+CHECK_TYPE_SIZE("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
+IF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
+  SET(HAVE_STRUCT_SOCKADDR_STORAGE 1)
+ENDIF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
+

CMake/Platforms/WindowsCache.cmake

@@ -0,0 +1,121 @@
+IF(NOT UNIX)
+  IF(WIN32)
+    SET(HAVE_LIBDL 0)
+    SET(HAVE_LIBUCB 0)
+    SET(HAVE_LIBSOCKET 0)
+    SET(NOT_NEED_LIBNSL 0)
+    SET(HAVE_LIBNSL 0)
+    SET(HAVE_LIBZ 0)
+    SET(HAVE_LIBCRYPTO 0)
+
+    SET(HAVE_DLOPEN 0)
+
+    SET(HAVE_ALLOCA_H 0)
+    SET(HAVE_ARPA_INET_H 0)
+    SET(HAVE_DLFCN_H 0)
+    SET(HAVE_FCNTL_H 1)
+    SET(HAVE_FEATURES_H 0)
+    SET(HAVE_INTTYPES_H 0)
+    SET(HAVE_IO_H 1)
+    SET(HAVE_MALLOC_H 1)
+    SET(HAVE_MEMORY_H 1)
+    SET(HAVE_NETDB_H 0)
+    SET(HAVE_NETINET_IF_ETHER_H 0)
+    SET(HAVE_NETINET_IN_H 0)
+    SET(HAVE_NET_IF_H 0)
+    SET(HAVE_PROCESS_H 1)
+    SET(HAVE_PWD_H 0)
+    SET(HAVE_SETJMP_H 1)
+    SET(HAVE_SGTTY_H 0)
+    SET(HAVE_SIGNAL_H 1)
+    SET(HAVE_SOCKIO_H 0)
+    SET(HAVE_STDINT_H 0)
+    SET(HAVE_STDLIB_H 1)
+    SET(HAVE_STRINGS_H 0)
+    SET(HAVE_STRING_H 1)
+    SET(HAVE_SYS_PARAM_H 0)
+    SET(HAVE_SYS_POLL_H 0)
+    SET(HAVE_SYS_SELECT_H 0)
+    SET(HAVE_SYS_SOCKET_H 0)
+    SET(HAVE_SYS_SOCKIO_H 0)
+    SET(HAVE_SYS_STAT_H 1)
+    SET(HAVE_SYS_TIME_H 0)
+    SET(HAVE_SYS_TYPES_H 1)
+    SET(HAVE_SYS_UTIME_H 1)
+    SET(HAVE_TERMIOS_H 0)
+    SET(HAVE_TERMIO_H 0)
+    SET(HAVE_TIME_H 1)
+    SET(HAVE_UNISTD_H 0)
+    SET(HAVE_UTIME_H 0)
+    SET(HAVE_X509_H 0)
+    SET(HAVE_ZLIB_H 0)
+
+    SET(HAVE_SIZEOF_LONG_DOUBLE 1)
+    SET(SIZEOF_LONG_DOUBLE 8)
+
+    SET(HAVE_SOCKET 1)
+    SET(HAVE_POLL 0)
+    SET(HAVE_SELECT 1)
+    SET(HAVE_STRDUP 1)
+    SET(HAVE_STRSTR 1)
+    SET(HAVE_STRTOK_R 0)
+    SET(HAVE_STRFTIME 1)
+    SET(HAVE_UNAME 0)
+    SET(HAVE_STRCASECMP 0)
+    SET(HAVE_STRICMP 1)
+    SET(HAVE_STRCMPI 1)
+    SET(HAVE_GETHOSTBYADDR 1)
+    SET(HAVE_GETTIMEOFDAY 0)
+    SET(HAVE_INET_ADDR 1)
+    SET(HAVE_INET_NTOA 1)
+    SET(HAVE_INET_NTOA_R 0)
+    SET(HAVE_TCGETATTR 0)
+    SET(HAVE_TCSETATTR 0)
+    SET(HAVE_PERROR 1)
+    SET(HAVE_CLOSESOCKET 1)
+    SET(HAVE_SETVBUF 0)
+    SET(HAVE_SIGSETJMP 0)
+    SET(HAVE_GETPASS_R 0)
+    SET(HAVE_STRLCAT 0)
+    SET(HAVE_GETPWUID 0)
+    SET(HAVE_GETEUID 0)
+    SET(HAVE_UTIME 1)
+    SET(HAVE_RAND_EGD 0)
+    SET(HAVE_RAND_SCREEN 0)
+    SET(HAVE_RAND_STATUS 0)
+    SET(HAVE_GMTIME_R 0)
+    SET(HAVE_LOCALTIME_R 0)
+    SET(HAVE_GETHOSTBYADDR_R 0)
+    SET(HAVE_GETHOSTBYNAME_R 0)
+    SET(HAVE_SIGNAL_FUNC 1)
+    SET(HAVE_SIGNAL_MACRO 0)
+
+    SET(HAVE_GETHOSTBYADDR_R_5 0)
+    SET(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0)
+    SET(HAVE_GETHOSTBYADDR_R_7 0)
+    SET(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0)
+    SET(HAVE_GETHOSTBYADDR_R_8 0)
+    SET(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0)
+    SET(HAVE_GETHOSTBYNAME_R_3 0)
+    SET(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0)
+    SET(HAVE_GETHOSTBYNAME_R_5 0)
+    SET(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0)
+    SET(HAVE_GETHOSTBYNAME_R_6 0)
+    SET(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0)
+
+    SET(TIME_WITH_SYS_TIME 0)
+    SET(HAVE_O_NONBLOCK 0)
+    SET(HAVE_IN_ADDR_T 0)
+    SET(HAVE_INET_NTOA_R_DECL 0)
+    SET(HAVE_INET_NTOA_R_DECL_REENTRANT 0)
+    SET(HAVE_GETADDRINFO 0)
+    SET(STDC_HEADERS 1)
+    SET(RETSIGTYPE_TEST 1)
+
+    SET(HAVE_SIGACTION 0)
+    SET(HAVE_MACRO_SIGSETJMP 0)
+  ELSE(WIN32)
+    MESSAGE("This file should be included on Windows platform only")
+  ENDIF(WIN32)
+ENDIF(NOT UNIX)
+

CMake/Utilities.cmake

@@ -0,0 +1,31 @@
+# File containing various utilities
+
+# Converts a CMake list to a string containing elements separated by spaces
+FUNCTION(TO_LIST_SPACES _LIST_NAME OUTPUT_VAR)
+  SET(NEW_LIST_SPACE)
+  FOREACH(ITEM ${${_LIST_NAME}})
+    SET(NEW_LIST_SPACE "${NEW_LIST_SPACE} ${ITEM}")
+  ENDFOREACH()
+  STRING(STRIP ${NEW_LIST_SPACE} NEW_LIST_SPACE)
+  SET(${OUTPUT_VAR} "${NEW_LIST_SPACE}" PARENT_SCOPE)
+ENDFUNCTION()
+
+# Appends a lis of item to a string which is a space-separated list, if they don't already exist.
+FUNCTION(LIST_SPACES_APPEND_ONCE LIST_NAME)
+  STRING(REPLACE " " ";" _LIST ${${LIST_NAME}})
+  LIST(APPEND _LIST ${ARGN})
+  LIST(REMOVE_DUPLICATES _LIST)
+  TO_LIST_SPACES(_LIST NEW_LIST_SPACE)
+  SET(${LIST_NAME} "${NEW_LIST_SPACE}" PARENT_SCOPE)
+ENDFUNCTION()
+
+# Convinience function that does the same as LIST(FIND ...) but with a TRUE/FALSE return value.
+# Ex: IN_STR_LIST(MY_LIST "Searched item" WAS_FOUND)
+FUNCTION(IN_STR_LIST LIST_NAME ITEM_SEARCHED RETVAL)
+	LIST(FIND ${LIST_NAME} ${ITEM_SEARCHED} FIND_POS)
+	IF(${FIND_POS} EQUAL -1)
+		SET(${RETVAL} FALSE PARENT_SCOPE)
+	ELSE()
+		SET(${RETVAL} TRUE PARENT_SCOPE)
+	ENDIF()
+ENDFUNCTION()

CMakeLists.txt

@@ -0,0 +1,843 @@
+# cURL/libcurl CMake script
+# by Tetetest and Sukender (Benoit Neil)
+
+# TODO:
+# The output .so file lacks the soname number which we currently have within the lib/Makefile.am file
+# Add full (4 or 5 libs) SSL support
+# Add INSTALL target (EXTRA_DIST variables in Makefile.am may be moved to Makefile.inc so that CMake/CPack is aware of what's to include).
+# Add CTests(?)
+# Check on all possible platforms
+# Test with as many configurations possible (With or without any option)
+# Create scripts that help keeping the CMake build system up to date (to reduce maintenance). According to Tetetest:
+#  - lists of headers that 'configure' checks for;
+#  - curl-specific tests (the ones that are in m4/curl-*.m4 files);
+#  - (most obvious thing:) curl version numbers.
+# Add documentation subproject
+#
+# To check:
+# (From Daniel Stenberg) The cmake build selected to run gcc with -fPIC on my box while the plain configure script did not.
+# (From Daniel Stenberg) The gcc command line use neither -g nor any -O options. As a developer, I also treasure our configure scripts's --enable-debug option that sets a long range of "picky" compiler options.
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6.2 FATAL_ERROR)
+SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
+INCLUDE(Utilities)
+
+project( CURL C )
+SET(CURL_MAJOR_VERSION 7)
+SET(CURL_MINOR_VERSION 19)
+SET(CURL_PATCH_VERSION 4)
+
+INCLUDE_REGULAR_EXPRESSION("^.*$")    # Sukender: Is it necessary?
+
+# Setup package meta-data
+# SET(PACKAGE "curl")
+SET(CURL_VERSION ${CURL_MAJOR_VERSION}.${CURL_MINOR_VERSION}.${CURL_PATCH_VERSION})
+# SET(PACKAGE_TARNAME "curl")
+# SET(PACKAGE_NAME "curl")
+# SET(PACKAGE_VERSION "-")
+# SET(PACKAGE_STRING "curl-")
+# SET(PACKAGE_BUGREPORT "a suitable curl mailing list => http://curl.haxx.se/mail/")
+SET(OPERATING_SYSTEM "${CMAKE_SYSTEM_NAME}")
+SET(OS "\"${CMAKE_SYSTEM_NAME}\"")
+
+# Make the base headers visible to everything
+# IF(NOT ${PROJECT_BINARY_DIR} EQUAL ${PROJECT_SOURCE_DIR})
+   # INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}/include)
+# ENDIF()
+INCLUDE_DIRECTORIES( ${CURL_SOURCE_DIR}/include )
+
+IF(WIN32)
+  SET(NATIVE_WINDOWS ON)
+ENDIF()
+
+OPTION(BUILD_CURL_EXE "Set to ON to build cURL executable." ON)
+OPTION(BUILD_CURL_TESTS "Set to ON to build cURL tests." ON)
+OPTION(CURL_STATICLIB "Set to ON to build libcurl with static linking." OFF)
+
+OPTION(BUILD_DASHBOARD_REPORTS "Set to ON to activate reporting of cURL builds here http://www.cdash.org/CDashPublic/index.php?project=CURL" OFF)
+IF(BUILD_DASHBOARD_REPORTS)
+  #INCLUDE(Dart)
+  INCLUDE(CTest)
+ENDIF(BUILD_DASHBOARD_REPORTS)
+
+IF(MSVC)
+  OPTION(BUILD_RELEASE_DEBUG_DIRS "Set OFF to build each configuration to a separate directory" OFF)
+  MARK_AS_ADVANCED(BUILD_RELEASE_DEBUG_DIRS)
+ENDIF()
+
+OPTION(CURL_HIDDEN_SYMBOLS "Set to ON to hide libcurl internal symbols (=hide all symbols that aren't officially external)." ON)
+MARK_AS_ADVANCED(CURL_HIDDEN_SYMBOLS)
+
+# IF(WIN32)
+  # OPTION(CURL_WINDOWS_SSPI "Use windows libraries to allow NTLM authentication without openssl" ON)
+  # MARK_AS_ADVANCED(CURL_WINDOWS_SSPI)
+# ENDIF()
+
+OPTION(HTTP_ONLY "disables all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)
+MARK_AS_ADVANCED(HTTP_ONLY)
+OPTION(CURL_DISABLE_FTP "disables FTP" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_FTP)
+OPTION(CURL_DISABLE_LDAP "disables LDAP" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_LDAP)
+OPTION(CURL_DISABLE_TELNET "disables Telnet" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_TELNET)
+OPTION(CURL_DISABLE_DICT "disables DICT" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_DICT)
+OPTION(CURL_DISABLE_FILE "disables FILE" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_FILE)
+OPTION(CURL_DISABLE_TFTP "disables TFTP" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_TFTP)
+OPTION(CURL_DISABLE_HTTP "disables HTTP" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_HTTP)
+
+OPTION(CURL_DISABLE_LDAPS "to disable LDAPS" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_LDAPS)
+IF(WIN32)
+  OPTION(CURL_LDAP_WIN "Use W$ LDAP implementation" ON)
+  MARK_AS_ADVANCED(CURL_LDAP_WIN)
+  SET(CURL_LDAP_HYBRID OFF)
+ELSE()
+  OPTION(CURL_LDAP_HYBRID "W$ LDAP with non-W$ compiler" OFF)
+  MARK_AS_ADVANCED(CURL_LDAP_HYBRID)
+  SET(CURL_LDAP_WIN OFF)
+ENDIF()
+
+IF(HTTP_ONLY)
+  SET(CURL_DISABLE_FTP ON)
+  SET(CURL_DISABLE_LDAP ON)
+  SET(CURL_DISABLE_TELNET ON)
+  SET(CURL_DISABLE_DICT ON)
+  SET(CURL_DISABLE_FILE ON)
+  SET(CURL_DISABLE_TFTP ON)
+ENDIF()
+
+OPTION(CURL_DISABLE_COOKIES "to disable cookies support" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_COOKIES)
+
+OPTION(CURL_DISABLE_CRYPTO_AUTH "to disable cryptographic authentication" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_CRYPTO_AUTH)
+OPTION(CURL_DISABLE_VERBOSE_STRINGS "to disable verbose strings" OFF)
+MARK_AS_ADVANCED(CURL_DISABLE_VERBOSE_STRINGS)
+OPTION(DISABLED_THREADSAFE "Set to explicitly specify we don't want to use thread-safe functions" OFF)
+MARK_AS_ADVANCED(DISABLED_THREADSAFE)
+OPTION(ENABLE_IPV6 "Define if you want to enable IPv6 support" OFF)
+MARK_AS_ADVANCED(ENABLE_IPV6)
+
+IF(WIN32)
+  LIST_SPACES_APPEND_ONCE(CMAKE_C_STANDARD_LIBRARIES wsock32.lib ws2_32.lib)  # bufferoverflowu.lib
+  IF(CURL_DISABLE_LDAP)
+    # Remove wldap32.lib from space-separated list
+    STRING(REPLACE " " ";" _LIST ${CMAKE_C_STANDARD_LIBRARIES})
+    LIST(REMOVE_ITEM _LIST "wldap32.lib")
+    TO_LIST_SPACES(_LIST CMAKE_C_STANDARD_LIBRARIES)
+  ELSE()
+    # Append wldap32.lib
+    LIST_SPACES_APPEND_ONCE(CMAKE_C_STANDARD_LIBRARIES wldap32.lib)
+  ENDIF()
+  SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES}"   CACHE STRING "" FORCE)
+ENDIF()
+
+
+# We need ansi c-flags, especially on HP
+SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
+SET(CMAKE_REQUIRED_FLAGS ${CMAKE_ANSI_CFLAGS})
+
+# Disable warnings on Borland to avoid changing 3rd party code.
+IF(BORLAND)
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
+ENDIF(BORLAND)
+
+# If we are on AIX, do the _ALL_SOURCE magic
+IF(${CMAKE_SYSTEM_NAME} MATCHES AIX)
+  SET(_ALL_SOURCE 1)
+ENDIF(${CMAKE_SYSTEM_NAME} MATCHES AIX)
+
+# Include all the necessary files for macros
+INCLUDE (CheckFunctionExists)
+INCLUDE (CheckIncludeFile)
+INCLUDE (CheckIncludeFiles)
+INCLUDE (CheckLibraryExists)
+INCLUDE (CheckSymbolExists)
+# if crosscompiling is on, the CHECK_TYPE_SIZE macro coming with cmake uses
+# TRY_COMPILE instead of TRY_RUN which makes crosscompiling easier, Alex
+IF(CMAKE_CROSSCOMPILING)  
+  INCLUDE ("${CMAKE_MODULE_PATH}/CheckTypeSize.cmake")
+ELSE(CMAKE_CROSSCOMPILING)
+  INCLUDE (CheckTypeSize)
+ENDIF(CMAKE_CROSSCOMPILING)
+
+# On windows preload settings
+IF(WIN32)
+  INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake)
+ENDIF(WIN32)
+
+# This macro checks if the symbol exists in the library and if it
+# does, it appends library to the list.
+SET(CURL_LIBS "")
+MACRO(CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
+  CHECK_LIBRARY_EXISTS("${LIBRARY};${CURL_LIBS}" ${SYMBOL} "" 
+    ${VARIABLE})
+  IF(${VARIABLE})
+    SET(CURL_LIBS ${CURL_LIBS} ${LIBRARY})
+  ENDIF(${VARIABLE})
+ENDMACRO(CHECK_LIBRARY_EXISTS_CONCAT)
+
+# Check for all needed libraries
+CHECK_LIBRARY_EXISTS_CONCAT("dl"     dlopen       HAVE_LIBDL)
+#CHECK_LIBRARY_EXISTS_CONCAT("ucb"    gethostname  HAVE_LIBUCB)
+CHECK_LIBRARY_EXISTS_CONCAT("socket" connect      HAVE_LIBSOCKET)
+CHECK_LIBRARY_EXISTS("c" gethostbyname "" NOT_NEED_LIBNSL)
+
+# Yellowtab Zeta needs different libraries than BeOS 5.
+IF(BEOS)
+  SET(NOT_NEED_LIBNSL 1)
+  CHECK_LIBRARY_EXISTS_CONCAT("bind" gethostbyname HAVE_LIBBIND)
+  CHECK_LIBRARY_EXISTS_CONCAT("bnetapi" closesocket HAVE_LIBBNETAPI)
+ENDIF(BEOS)
+
+IF(NOT NOT_NEED_LIBNSL)
+  CHECK_LIBRARY_EXISTS_CONCAT("nsl"    gethostbyname  HAVE_LIBNSL)
+ENDIF(NOT NOT_NEED_LIBNSL)
+
+CHECK_LIBRARY_EXISTS_CONCAT("ws2_32" getch        HAVE_LIBWS2_32)
+CHECK_LIBRARY_EXISTS_CONCAT("winmm"  getch        HAVE_LIBWINMM)
+# IF(NOT CURL_SPECIAL_LIBZ)
+#  CHECK_LIBRARY_EXISTS_CONCAT("z"      inflateEnd   HAVE_LIBZ)
+# ENDIF(NOT CURL_SPECIAL_LIBZ)
+
+OPTION(CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ON)
+MARK_AS_ADVANCED(CMAKE_USE_OPENSSL)
+IF(CMAKE_USE_OPENSSL)
+  IF(WIN32)
+  FIND_PACKAGE(OpenSSL)
+  IF(OPENSSL_FOUND)
+    SET(USE_SSLEAY TRUE)
+    SET(USE_OPENSSL TRUE)
+    LIST(APPEND CURL_LIBS ${OPENSSL_LIBRARIES} )
+  ENDIF()
+    #FIND_LIBRARY(LIBEAY NAMES libeay32)
+    #LIST(APPEND CURL_LIBS ${LIBEAY} )
+  ELSE(WIN32)
+    CHECK_LIBRARY_EXISTS_CONCAT("crypto" CRYPTO_lock  HAVE_LIBCRYPTO)
+    CHECK_LIBRARY_EXISTS_CONCAT("ssl"    SSL_connect  HAVE_LIBSSL)
+  ENDIF(WIN32)
+ENDIF(CMAKE_USE_OPENSSL)
+
+# Check for idn
+CHECK_LIBRARY_EXISTS_CONCAT("idn" idna_to_ascii_lz HAVE_LIBIDN)
+
+# Check for LDAP
+CHECK_LIBRARY_EXISTS_CONCAT("ldap" ldap_init HAVE_LIBLDAP)
+# if(NOT HAVE_LIBLDAP)
+    # SET(CURL_DISABLE_LDAP ON)
+# endif(NOT HAVE_LIBLDAP)
+
+# Check for symbol dlopen (same as HAVE_LIBDL)
+CHECK_LIBRARY_EXISTS("${CURL_LIBS}" dlopen "" HAVE_DLOPEN)
+
+# For other tests to use the same libraries
+SET(CMAKE_REQUIRED_LIBRARIES ${CURL_LIBS})
+
+OPTION(CURL_ZLIB "Set to ON to enable building cURL with zlib support." ON)
+SET(HAVE_LIBZ OFF)
+SET(HAVE_ZLIB_H OFF)
+SET(HAVE_ZLIB OFF)
+IF(CURL_ZLIB)  # AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE
+  FIND_PACKAGE(ZLIB)
+  IF(ZLIB_FOUND)
+    SET(HAVE_ZLIB_H ON)
+    SET(HAVE_ZLIB ON)
+    SET(HAVE_LIBZ ON)
+  ENDIF()
+ENDIF()
+
+# If we have features.h, then do the _BSD_SOURCE magic
+CHECK_INCLUDE_FILE("features.h"       HAVE_FEATURES_H)
+
+# Check if header file exists and add it to the list.
+MACRO(CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
+  CHECK_INCLUDE_FILES("${CURL_INCLUDES};${FILE}" ${VARIABLE})
+  IF(${VARIABLE})
+    SET(CURL_INCLUDES ${CURL_INCLUDES} ${FILE})
+    SET(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${VARIABLE}")
+  ENDIF(${VARIABLE})
+ENDMACRO(CHECK_INCLUDE_FILE_CONCAT)
+
+
+# Check for header files
+IF(NOT UNIX)
+  CHECK_INCLUDE_FILE_CONCAT("ws2tcpip.h"     HAVE_WS2TCPIP_H)
+  CHECK_INCLUDE_FILE_CONCAT("winsock2.h"     HAVE_WINSOCK2_H)
+ENDIF(NOT UNIX)
+CHECK_INCLUDE_FILE_CONCAT("stdio.h"          HAVE_STDIO_H)
+IF(NOT UNIX)
+  CHECK_INCLUDE_FILE_CONCAT("windows.h"      HAVE_WINDOWS_H)
+  CHECK_INCLUDE_FILE_CONCAT("winsock.h"      HAVE_WINSOCK_H)
+ENDIF(NOT UNIX)
+
+CHECK_INCLUDE_FILE_CONCAT("inttypes.h"       HAVE_INTTYPES_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/filio.h"      HAVE_SYS_FILIO_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/ioctl.h"      HAVE_SYS_IOCTL_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/param.h"      HAVE_SYS_PARAM_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/poll.h"       HAVE_SYS_POLL_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/resource.h"   HAVE_SYS_RESOURCE_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/select.h"     HAVE_SYS_SELECT_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/socket.h"     HAVE_SYS_SOCKET_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/sockio.h"     HAVE_SYS_SOCKIO_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/stat.h"       HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/time.h"       HAVE_SYS_TIME_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/types.h"      HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/uio.h"        HAVE_SYS_UIO_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/un.h"         HAVE_SYS_UN_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/utime.h"      HAVE_SYS_UTIME_H)
+CHECK_INCLUDE_FILE_CONCAT("alloca.h"         HAVE_ALLOCA_H)
+CHECK_INCLUDE_FILE_CONCAT("arpa/inet.h"      HAVE_ARPA_INET_H)
+CHECK_INCLUDE_FILE_CONCAT("arpa/tftp.h"      HAVE_ARPA_TFTP_H)
+CHECK_INCLUDE_FILE_CONCAT("assert.h"         HAVE_ASSERT_H)
+CHECK_INCLUDE_FILE_CONCAT("crypto.h"         HAVE_CRYPTO_H)
+CHECK_INCLUDE_FILE_CONCAT("des.h"            HAVE_DES_H)
+CHECK_INCLUDE_FILE_CONCAT("err.h"            HAVE_ERR_H)
+CHECK_INCLUDE_FILE_CONCAT("errno.h"          HAVE_ERRNO_H)
+CHECK_INCLUDE_FILE_CONCAT("fcntl.h"          HAVE_FCNTL_H)
+CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi.h"  HAVE_GSSAPI_GSSAPI_H)
+CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi_generic.h" HAVE_GSSAPI_GSSAPI_GENERIC_H)
+CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi_krb5.h" HAVE_GSSAPI_GSSAPI_KRB5_H)
+CHECK_INCLUDE_FILE_CONCAT("idn-free.h"       HAVE_IDN_FREE_H)
+CHECK_INCLUDE_FILE_CONCAT("ifaddrs.h"        HAVE_IFADDRS_H)
+CHECK_INCLUDE_FILE_CONCAT("io.h"             HAVE_IO_H)
+CHECK_INCLUDE_FILE_CONCAT("krb.h"            HAVE_KRB_H)
+CHECK_INCLUDE_FILE_CONCAT("libgen.h"         HAVE_LIBGEN_H)
+CHECK_INCLUDE_FILE_CONCAT("libssh2.h"        HAVE_LIBSSH2_H)
+CHECK_INCLUDE_FILE_CONCAT("limits.h"         HAVE_LIMITS_H)
+CHECK_INCLUDE_FILE_CONCAT("locale.h"         HAVE_LOCALE_H)
+CHECK_INCLUDE_FILE_CONCAT("net/if.h"         HAVE_NET_IF_H)
+CHECK_INCLUDE_FILE_CONCAT("netdb.h"          HAVE_NETDB_H)
+CHECK_INCLUDE_FILE_CONCAT("netinet/in.h"     HAVE_NETINET_IN_H)
+CHECK_INCLUDE_FILE_CONCAT("netinet/tcp.h"    HAVE_NETINET_TCP_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/engine.h" HAVE_OPENSSL_ENGINE_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/err.h"    HAVE_OPENSSL_ERR_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/pem.h"    HAVE_OPENSSL_PEM_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/pkcs12.h" HAVE_OPENSSL_PKCS12_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/rsa.h"    HAVE_OPENSSL_RSA_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/ssl.h"    HAVE_OPENSSL_SSL_H)
+CHECK_INCLUDE_FILE_CONCAT("openssl/x509.h"   HAVE_OPENSSL_X509_H)
+CHECK_INCLUDE_FILE_CONCAT("pem.h"            HAVE_PEM_H)
+CHECK_INCLUDE_FILE_CONCAT("poll.h"           HAVE_POLL_H)
+CHECK_INCLUDE_FILE_CONCAT("pwd.h"            HAVE_PWD_H)
+CHECK_INCLUDE_FILE_CONCAT("rsa.h"            HAVE_RSA_H)
+CHECK_INCLUDE_FILE_CONCAT("setjmp.h"         HAVE_SETJMP_H)
+CHECK_INCLUDE_FILE_CONCAT("sgtty.h"          HAVE_SGTTY_H)
+CHECK_INCLUDE_FILE_CONCAT("signal.h"         HAVE_SIGNAL_H)
+CHECK_INCLUDE_FILE_CONCAT("ssl.h"            HAVE_SSL_H)
+CHECK_INCLUDE_FILE_CONCAT("stdbool.h"        HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILE_CONCAT("stdint.h"         HAVE_STDINT_H)
+CHECK_INCLUDE_FILE_CONCAT("stdio.h"          HAVE_STDIO_H)
+CHECK_INCLUDE_FILE_CONCAT("stdlib.h"         HAVE_STDLIB_H)
+CHECK_INCLUDE_FILE_CONCAT("string.h"         HAVE_STRING_H)
+CHECK_INCLUDE_FILE_CONCAT("strings.h"        HAVE_STRINGS_H)
+CHECK_INCLUDE_FILE_CONCAT("stropts.h"        HAVE_STROPTS_H)
+CHECK_INCLUDE_FILE_CONCAT("termio.h"         HAVE_TERMIO_H)
+CHECK_INCLUDE_FILE_CONCAT("termios.h"        HAVE_TERMIOS_H)
+CHECK_INCLUDE_FILE_CONCAT("time.h"           HAVE_TIME_H)
+CHECK_INCLUDE_FILE_CONCAT("tld.h"            HAVE_TLD_H)
+CHECK_INCLUDE_FILE_CONCAT("unistd.h"         HAVE_UNISTD_H)
+CHECK_INCLUDE_FILE_CONCAT("utime.h"          HAVE_UTIME_H)
+CHECK_INCLUDE_FILE_CONCAT("x509.h"           HAVE_X509_H)
+
+CHECK_INCLUDE_FILE_CONCAT("process.h"        HAVE_PROCESS_H)
+CHECK_INCLUDE_FILE_CONCAT("stddef.h"         HAVE_STDDEF_H)
+CHECK_INCLUDE_FILE_CONCAT("dlfcn.h"          HAVE_DLFCN_H)
+CHECK_INCLUDE_FILE_CONCAT("malloc.h"         HAVE_MALLOC_H)
+CHECK_INCLUDE_FILE_CONCAT("memory.h"         HAVE_MEMORY_H)
+CHECK_INCLUDE_FILE_CONCAT("ldap.h"           HAVE_LDAP_H)
+CHECK_INCLUDE_FILE_CONCAT("netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H)
+CHECK_INCLUDE_FILE_CONCAT("stdint.h"        HAVE_STDINT_H)
+CHECK_INCLUDE_FILE_CONCAT("sockio.h"        HAVE_SOCKIO_H)
+CHECK_INCLUDE_FILE_CONCAT("sys/utsname.h"   HAVE_SYS_UTSNAME_H)
+CHECK_INCLUDE_FILE_CONCAT("idna.h"          HAVE_IDNA_H)
+
+IF(CMAKE_USE_OPENSSL)
+  CHECK_INCLUDE_FILE_CONCAT("openssl/rand.h"   HAVE_OPENSSL_RAND_H)
+ENDIF(CMAKE_USE_OPENSSL)
+
+
+CHECK_TYPE_SIZE(size_t  SIZEOF_SIZE_T)
+CHECK_TYPE_SIZE(ssize_t  SIZEOF_SSIZE_T)
+CHECK_TYPE_SIZE("long long"  SIZEOF_LONG_LONG)
+CHECK_TYPE_SIZE("long"  SIZEOF_LONG)
+CHECK_TYPE_SIZE("int"  SIZEOF_INT)
+CHECK_TYPE_SIZE("__int64"  SIZEOF___INT64)
+CHECK_TYPE_SIZE("long double"  SIZEOF_LONG_DOUBLE)
+CHECK_TYPE_SIZE("time_t"  SIZEOF_TIME_T)
+IF(NOT HAVE_SIZEOF_SSIZE_T)
+  IF(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+    SET(ssize_t long)
+  ENDIF(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+  IF(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+    SET(ssize_t __int64)
+  ENDIF(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+ENDIF(NOT HAVE_SIZEOF_SSIZE_T)
+
+# Different sizeofs, etc.
+
+#    define CURL_SIZEOF_LONG        4
+#    define CURL_TYPEOF_CURL_OFF_T  long long
+#    define CURL_FORMAT_CURL_OFF_T  "lld"
+#    define CURL_FORMAT_CURL_OFF_TU "llu"
+#    define CURL_FORMAT_OFF_T       "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T  8
+#    define CURL_SUFFIX_CURL_OFF_T  LL
+#    define CURL_SUFFIX_CURL_OFF_TU ULL
+
+set(CURL_SIZEOF_LONG ${SIZEOF_LONG})
+
+if(SIZEOF_LONG EQUAL 8)
+  set(CURL_TYPEOF_CURL_OFF_T long)
+  set(CURL_SIZEOF_CURL_OFF_T 8)
+  set(CURL_FORMAT_CURL_OFF_T "ld")
+  set(CURL_FORMAT_CURL_OFF_TU "lu")
+  set(CURL_FORMAT_OFF_T "%ld")
+  set(CURL_SUFFIX_CURL_OFF_T L)
+  set(CURL_SUFFIX_CURL_OFF_TU LU)
+endif(SIZEOF_LONG EQUAL 8)
+
+if(SIZEOF_LONG_LONG EQUAL 8)
+  set(CURL_TYPEOF_CURL_OFF_T "long long")
+  set(CURL_SIZEOF_CURL_OFF_T 8)
+  set(CURL_FORMAT_CURL_OFF_T "lld")
+  set(CURL_FORMAT_CURL_OFF_TU "llu")
+  set(CURL_FORMAT_OFF_T "%lld")
+  set(CURL_SUFFIX_CURL_OFF_T LL)
+  set(CURL_SUFFIX_CURL_OFF_TU LLU)
+endif(SIZEOF_LONG_LONG EQUAL 8)
+
+if(NOT CURL_TYPEOF_CURL_OFF_T)
+  set(CURL_TYPEOF_CURL_OFF_T ${ssize_t})
+  set(CURL_SIZEOF_CURL_OFF_T ${SIZEOF_SSIZE_T})
+  # TODO: need adjustment here.
+  set(CURL_FORMAT_CURL_OFF_T "ld")
+  set(CURL_FORMAT_CURL_OFF_TU "lu")
+  set(CURL_FORMAT_OFF_T "%ld")
+  set(CURL_SUFFIX_CURL_OFF_T L)
+  set(CURL_SUFFIX_CURL_OFF_TU LU)
+endif(NOT CURL_TYPEOF_CURL_OFF_T)
+
+IF(HAVE_SIZEOF_LONG_LONG)
+  SET(HAVE_LONGLONG 1)
+  SET(HAVE_LL 1)
+ENDIF(HAVE_SIZEOF_LONG_LONG)
+
+FIND_FILE(RANDOM_FILE urandom /dev)
+MARK_AS_ADVANCED(RANDOM_FILE)
+
+# Check for some functions that are used
+CHECK_SYMBOL_EXISTS(basename      "${CURL_INCLUDES}" HAVE_BASENAME)
+CHECK_SYMBOL_EXISTS(socket        "${CURL_INCLUDES}" HAVE_SOCKET)
+CHECK_SYMBOL_EXISTS(poll          "${CURL_INCLUDES}" HAVE_POLL)
+CHECK_SYMBOL_EXISTS(select        "${CURL_INCLUDES}" HAVE_SELECT)
+CHECK_SYMBOL_EXISTS(strdup        "${CURL_INCLUDES}" HAVE_STRDUP)
+CHECK_SYMBOL_EXISTS(strstr        "${CURL_INCLUDES}" HAVE_STRSTR)
+CHECK_SYMBOL_EXISTS(strtok_r      "${CURL_INCLUDES}" HAVE_STRTOK_R)
+CHECK_SYMBOL_EXISTS(strftime      "${CURL_INCLUDES}" HAVE_STRFTIME)
+CHECK_SYMBOL_EXISTS(uname         "${CURL_INCLUDES}" HAVE_UNAME)
+CHECK_SYMBOL_EXISTS(strcasecmp    "${CURL_INCLUDES}" HAVE_STRCASECMP)
+CHECK_SYMBOL_EXISTS(stricmp       "${CURL_INCLUDES}" HAVE_STRICMP)
+CHECK_SYMBOL_EXISTS(strcmpi       "${CURL_INCLUDES}" HAVE_STRCMPI)
+CHECK_SYMBOL_EXISTS(strncmpi      "${CURL_INCLUDES}" HAVE_STRNCMPI)
+CHECK_SYMBOL_EXISTS(alarm         "${CURL_INCLUDES}" HAVE_ALARM)
+IF(NOT HAVE_STRNCMPI)
+  SET(HAVE_STRCMPI)
+ENDIF(NOT HAVE_STRNCMPI)
+CHECK_SYMBOL_EXISTS(gethostbyaddr "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR)
+CHECK_SYMBOL_EXISTS(gethostbyaddr_r "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR_R)
+CHECK_SYMBOL_EXISTS(gettimeofday  "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
+CHECK_SYMBOL_EXISTS(inet_addr     "${CURL_INCLUDES}" HAVE_INET_ADDR)
+CHECK_SYMBOL_EXISTS(inet_ntoa     "${CURL_INCLUDES}" HAVE_INET_NTOA)
+CHECK_SYMBOL_EXISTS(inet_ntoa_r   "${CURL_INCLUDES}" HAVE_INET_NTOA_R)
+CHECK_SYMBOL_EXISTS(tcsetattr     "${CURL_INCLUDES}" HAVE_TCSETATTR)
+CHECK_SYMBOL_EXISTS(tcgetattr     "${CURL_INCLUDES}" HAVE_TCGETATTR)
+CHECK_SYMBOL_EXISTS(perror        "${CURL_INCLUDES}" HAVE_PERROR)
+CHECK_SYMBOL_EXISTS(closesocket   "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
+CHECK_SYMBOL_EXISTS(setvbuf       "${CURL_INCLUDES}" HAVE_SETVBUF)
+CHECK_SYMBOL_EXISTS(sigsetjmp     "${CURL_INCLUDES}" HAVE_SIGSETJMP)
+CHECK_SYMBOL_EXISTS(getpass_r     "${CURL_INCLUDES}" HAVE_GETPASS_R)
+CHECK_SYMBOL_EXISTS(strlcat       "${CURL_INCLUDES}" HAVE_STRLCAT)
+CHECK_SYMBOL_EXISTS(getpwuid      "${CURL_INCLUDES}" HAVE_GETPWUID)
+CHECK_SYMBOL_EXISTS(geteuid       "${CURL_INCLUDES}" HAVE_GETEUID)
+CHECK_SYMBOL_EXISTS(utime         "${CURL_INCLUDES}" HAVE_UTIME)
+IF(CMAKE_USE_OPENSSL)
+  CHECK_SYMBOL_EXISTS(RAND_status   "${CURL_INCLUDES}" HAVE_RAND_STATUS)
+  CHECK_SYMBOL_EXISTS(RAND_screen   "${CURL_INCLUDES}" HAVE_RAND_SCREEN)
+  CHECK_SYMBOL_EXISTS(RAND_egd      "${CURL_INCLUDES}" HAVE_RAND_EGD)
+  CHECK_SYMBOL_EXISTS(CRYPTO_cleanup_all_ex_data "${CURL_INCLUDES}" 
+    HAVE_CRYPTO_CLEANUP_ALL_EX_DATA)
+  IF(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
+  SET(USE_OPENSSL 1)
+  SET(USE_SSLEAY 1)
+  ENDIF(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
+ENDIF(CMAKE_USE_OPENSSL)
+CHECK_SYMBOL_EXISTS(gmtime_r      "${CURL_INCLUDES}" HAVE_GMTIME_R)
+CHECK_SYMBOL_EXISTS(localtime_r   "${CURL_INCLUDES}" HAVE_LOCALTIME_R)
+
+CHECK_SYMBOL_EXISTS(gethostbyname   "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME)
+CHECK_SYMBOL_EXISTS(gethostbyname_r "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
+
+CHECK_SYMBOL_EXISTS(signal        "${CURL_INCLUDES}" HAVE_SIGNAL_FUNC)
+CHECK_SYMBOL_EXISTS(SIGALRM       "${CURL_INCLUDES}" HAVE_SIGNAL_MACRO)
+IF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
+  SET(HAVE_SIGNAL 1)
+ENDIF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
+CHECK_SYMBOL_EXISTS(uname          "${CURL_INCLUDES}" HAVE_UNAME)
+CHECK_SYMBOL_EXISTS(strtoll        "${CURL_INCLUDES}" HAVE_STRTOLL)
+CHECK_SYMBOL_EXISTS(_strtoi64      "${CURL_INCLUDES}" HAVE__STRTOI64)
+CHECK_SYMBOL_EXISTS(strerror_r     "${CURL_INCLUDES}" HAVE_STRERROR_R)
+CHECK_SYMBOL_EXISTS(siginterrupt   "${CURL_INCLUDES}" HAVE_SIGINTERRUPT)
+CHECK_SYMBOL_EXISTS(perror         "${CURL_INCLUDES}" HAVE_PERROR)
+CHECK_SYMBOL_EXISTS(fork           "${CURL_INCLUDES}" HAVE_FORK)
+CHECK_SYMBOL_EXISTS(freeaddrinfo   "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
+CHECK_SYMBOL_EXISTS(freeifaddrs    "${CURL_INCLUDES}" HAVE_FREEIFADDRS)
+CHECK_SYMBOL_EXISTS(pipe           "${CURL_INCLUDES}" HAVE_PIPE)
+CHECK_SYMBOL_EXISTS(ftruncate      "${CURL_INCLUDES}" HAVE_FTRUNCATE)
+CHECK_SYMBOL_EXISTS(getprotobyname "${CURL_INCLUDES}" HAVE_GETPROTOBYNAME)
+CHECK_SYMBOL_EXISTS(getrlimit      "${CURL_INCLUDES}" HAVE_GETRLIMIT)
+CHECK_SYMBOL_EXISTS(idn_free       "${CURL_INCLUDES}" HAVE_IDN_FREE)
+CHECK_SYMBOL_EXISTS(idna_strerror  "${CURL_INCLUDES}" HAVE_IDNA_STRERROR)
+CHECK_SYMBOL_EXISTS(tld_strerror   "${CURL_INCLUDES}" HAVE_TLD_STRERROR)
+CHECK_SYMBOL_EXISTS(setlocale      "${CURL_INCLUDES}" HAVE_SETLOCALE)
+CHECK_SYMBOL_EXISTS(setrlimit      "${CURL_INCLUDES}" HAVE_SETRLIMIT)
+CHECK_SYMBOL_EXISTS(fcntl          "${CURL_INCLUDES}" HAVE_FCNTL)
+CHECK_SYMBOL_EXISTS(ioctl          "${CURL_INCLUDES}" HAVE_IOCTL)
+CHECK_SYMBOL_EXISTS(setsockopt     "${CURL_INCLUDES}" HAVE_SETSOCKOPT)
+
+# symbol exists in win32, but function does not.
+CHECK_FUNCTION_EXISTS(inet_pton HAVE_INET_PTON)
+
+# sigaction and sigsetjmp are special. Use special mechanism for
+# detecting those, but only if previous attempt failed.
+IF(HAVE_SIGNAL_H)
+  CHECK_SYMBOL_EXISTS(sigaction "signal.h" HAVE_SIGACTION)
+ENDIF(HAVE_SIGNAL_H)
+
+IF(NOT HAVE_SIGSETJMP)
+  IF(HAVE_SETJMP_H)
+    CHECK_SYMBOL_EXISTS(sigsetjmp "setjmp.h" HAVE_MACRO_SIGSETJMP)
+    IF(HAVE_MACRO_SIGSETJMP)
+      SET(HAVE_SIGSETJMP 1)
+    ENDIF(HAVE_MACRO_SIGSETJMP)
+  ENDIF(HAVE_SETJMP_H)
+ENDIF(NOT HAVE_SIGSETJMP)
+
+# If there is no stricmp(), do not allow LDAP to parse URLs
+if(NOT HAVE_STRICMP)
+    SET(HAVE_LDAP_URL_PARSE 1)
+endif(NOT HAVE_STRICMP)
+
+# For other curl specific tests, use this macro.
+MACRO(CURL_INTERNAL_TEST CURL_TEST)
+  IF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
+      "-D${CURL_TEST} ${CURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_TEST_ADD_LIBRARIES
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+
+    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
+    TRY_COMPILE(${CURL_TEST}
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "${CURL_TEST_ADD_LIBRARIES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(${CURL_TEST})
+      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
+      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+        "Performing Curl Test ${CURL_TEST} passed with the following output:\n"
+        "${OUTPUT}\n")
+    ELSE(${CURL_TEST})
+      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
+      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
+        "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
+        "${OUTPUT}\n")
+    ENDIF(${CURL_TEST})
+  ENDIF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
+ENDMACRO(CURL_INTERNAL_TEST) 
+
+MACRO(CURL_INTERNAL_TEST_RUN CURL_TEST)
+  IF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
+    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
+      "-D${CURL_TEST} ${CMAKE_REQUIRED_FLAGS}")
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CURL_TEST_ADD_LIBRARIES
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+
+    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
+    TRY_RUN(${CURL_TEST} ${CURL_TEST}_COMPILE
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
+      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+      "${CURL_TEST_ADD_LIBRARIES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
+      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
+    ELSE(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
+      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
+      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
+        "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
+        "${OUTPUT}")
+      IF(${CURL_TEST}_COMPILE)
+        FILE(APPEND 
+          "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
+          "There was a problem running this test\n")
+      ENDIF(${CURL_TEST}_COMPILE)
+      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
+        "\n\n")
+    ENDIF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+  ENDIF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
+ENDMACRO(CURL_INTERNAL_TEST_RUN) 
+
+# Do curl specific tests
+FOREACH(CURL_TEST 
+    HAVE_FCNTL_O_NONBLOCK
+    HAVE_IOCTLSOCKET
+    HAVE_IOCTLSOCKET_CAMEL
+    HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+    HAVE_IOCTLSOCKET_FIONBIO
+    HAVE_IOCTL_FIONBIO
+    HAVE_IOCTL_SIOCGIFADDR
+    HAVE_SETSOCKOPT_SO_NONBLOCK
+    HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
+    TIME_WITH_SYS_TIME
+    HAVE_O_NONBLOCK
+    HAVE_GETHOSTBYADDR_R_5
+    HAVE_GETHOSTBYADDR_R_7
+    HAVE_GETHOSTBYADDR_R_8
+    HAVE_GETHOSTBYADDR_R_5_REENTRANT
+    HAVE_GETHOSTBYADDR_R_7_REENTRANT
+    HAVE_GETHOSTBYADDR_R_8_REENTRANT
+    HAVE_GETHOSTBYNAME_R_3
+    HAVE_GETHOSTBYNAME_R_5
+    HAVE_GETHOSTBYNAME_R_6
+    HAVE_GETHOSTBYNAME_R_3_REENTRANT
+    HAVE_GETHOSTBYNAME_R_5_REENTRANT
+    HAVE_GETHOSTBYNAME_R_6_REENTRANT
+    HAVE_SOCKLEN_T
+    HAVE_IN_ADDR_T
+    HAVE_BOOL_T
+    STDC_HEADERS
+    RETSIGTYPE_TEST
+    HAVE_INET_NTOA_R_DECL
+    HAVE_INET_NTOA_R_DECL_REENTRANT
+    HAVE_GETADDRINFO
+    HAVE_FILE_OFFSET_BITS
+    )
+  CURL_INTERNAL_TEST(${CURL_TEST})
+ENDFOREACH(CURL_TEST)
+IF(HAVE_FILE_OFFSET_BITS)
+  SET(_FILE_OFFSET_BITS 64)
+ENDIF(HAVE_FILE_OFFSET_BITS)
+
+FOREACH(CURL_TEST 
+    HAVE_GLIBC_STRERROR_R
+    HAVE_POSIX_STRERROR_R
+    )
+  CURL_INTERNAL_TEST_RUN(${CURL_TEST})
+ENDFOREACH(CURL_TEST)
+
+# Check for reentrant
+FOREACH(CURL_TEST
+    HAVE_GETHOSTBYADDR_R_5
+    HAVE_GETHOSTBYADDR_R_7
+    HAVE_GETHOSTBYADDR_R_8
+    HAVE_GETHOSTBYNAME_R_3
+    HAVE_GETHOSTBYNAME_R_5
+    HAVE_GETHOSTBYNAME_R_6
+    HAVE_INET_NTOA_R_DECL_REENTRANT)
+  IF(NOT ${CURL_TEST})
+    IF(${CURL_TEST}_REENTRANT)
+      SET(NEED_REENTRANT 1)
+    ENDIF(${CURL_TEST}_REENTRANT)
+  ENDIF(NOT ${CURL_TEST})
+ENDFOREACH(CURL_TEST)
+
+IF(NEED_REENTRANT)
+  FOREACH(CURL_TEST
+      HAVE_GETHOSTBYADDR_R_5
+      HAVE_GETHOSTBYADDR_R_7
+      HAVE_GETHOSTBYADDR_R_8
+      HAVE_GETHOSTBYNAME_R_3
+      HAVE_GETHOSTBYNAME_R_5
+      HAVE_GETHOSTBYNAME_R_6)
+    SET(${CURL_TEST} 0)
+    IF(${CURL_TEST}_REENTRANT)
+      SET(${CURL_TEST} 1)
+    ENDIF(${CURL_TEST}_REENTRANT)
+  ENDFOREACH(CURL_TEST)
+ENDIF(NEED_REENTRANT)
+
+IF(HAVE_INET_NTOA_R_DECL_REENTRANT)
+  SET(HAVE_INET_NTOA_R_DECL 1)
+  SET(NEED_REENTRANT 1)
+ENDIF(HAVE_INET_NTOA_R_DECL_REENTRANT)
+
+# Some other minor tests
+
+IF(NOT HAVE_IN_ADDR_T)
+  SET(in_addr_t "unsigned long")
+ENDIF(NOT HAVE_IN_ADDR_T)
+
+# Fix libz / zlib.h
+
+IF(NOT CURL_SPECIAL_LIBZ)
+  IF(NOT HAVE_LIBZ)
+    SET(HAVE_ZLIB_H 0)
+  ENDIF(NOT HAVE_LIBZ)
+
+  IF(NOT HAVE_ZLIB_H)
+    SET(HAVE_LIBZ 0)
+  ENDIF(NOT HAVE_ZLIB_H)
+ENDIF(NOT CURL_SPECIAL_LIBZ)
+
+IF(_FILE_OFFSET_BITS)
+  SET(_FILE_OFFSET_BITS 64)
+ENDIF(_FILE_OFFSET_BITS)
+SET(CMAKE_REQUIRED_FLAGS "-D_FILE_OFFSET_BITS=64")
+SET(CMAKE_EXTRA_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/curl/curl.h")
+CHECK_TYPE_SIZE("curl_off_t" SIZEOF_CURL_OFF_T)
+SET(CMAKE_EXTRA_INCLUDE_FILES)
+SET(CMAKE_REQUIRED_FLAGS)
+
+
+# Check for nonblocking
+SET(HAVE_DISABLED_NONBLOCKING 1)
+IF(HAVE_FIONBIO OR 
+    HAVE_IOCTLSOCKET OR
+    HAVE_IOCTLSOCKET_CASE OR
+    HAVE_O_NONBLOCK)
+  SET(HAVE_DISABLED_NONBLOCKING)
+ENDIF(HAVE_FIONBIO OR 
+  HAVE_IOCTLSOCKET OR
+  HAVE_IOCTLSOCKET_CASE OR
+  HAVE_O_NONBLOCK)
+
+IF(RETSIGTYPE_TEST)
+  SET(RETSIGTYPE void)
+ELSE(RETSIGTYPE_TEST)
+  SET(RETSIGTYPE int)
+ENDIF(RETSIGTYPE_TEST)
+
+IF(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+  INCLUDE(CheckCCompilerFlag)
+  CHECK_C_COMPILER_FLAG(-Wno-long-double HAVE_C_FLAG_Wno_long_double)
+  IF(HAVE_C_FLAG_Wno_long_double)
+    # The Mac version of GCC warns about use of long double.  Disable it.
+    GET_SOURCE_FILE_PROPERTY(MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS)
+    IF(MPRINTF_COMPILE_FLAGS)
+      SET(MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double")
+    ELSE(MPRINTF_COMPILE_FLAGS)
+      SET(MPRINTF_COMPILE_FLAGS "-Wno-long-double")
+    ENDIF(MPRINTF_COMPILE_FLAGS)
+    SET_SOURCE_FILES_PROPERTIES(mprintf.c PROPERTIES
+      COMPILE_FLAGS ${MPRINTF_COMPILE_FLAGS})
+  ENDIF(HAVE_C_FLAG_Wno_long_double)
+ENDIF(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+
+INCLUDE(CMake/OtherTests.cmake)
+
+ADD_DEFINITIONS(-DHAVE_CONFIG_H)
+
+# For windows, do not allow the compiler to use default target (Vista).
+IF(WIN32)
+  ADD_DEFINITIONS(-D_WIN32_WINNT=0x0501)
+ENDIF(WIN32)
+
+IF(MSVC)
+  ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+ENDIF(MSVC)
+
+# Sets up the dependencies (zlib, OpenSSL, etc.) of a cURL subproject according to options.
+# TODO This is far to be complete!
+FUNCTION(SETUP_CURL_DEPENDENCIES TARGET_NAME)
+  IF(CURL_ZLIB AND ZLIB_FOUND)
+    INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
+  ENDIF()
+  IF(CURL_ZLIB AND ZLIB_FOUND)
+    TARGET_LINK_LIBRARIES(${TARGET_NAME} ${ZLIB_LIBRARIES})
+    #ADD_DEFINITIONS( -DHAVE_ZLIB_H -DHAVE_ZLIB -DHAVE_LIBZ )
+  ENDIF()
+
+  IF(CMAKE_USE_OPENSSL AND OPENSSL_FOUND)
+    INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
+  ENDIF()
+  IF(CURL_SSL AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
+    TARGET_LINK_LIBRARIES(${TARGET_NAME} ${OPENSSL_LIBRARIES})
+    #ADD_DEFINITIONS( -DUSE_SSLEAY )
+  ENDIF()
+ENDFUNCTION()
+
+# Ugly (but functional) way to include "Makefile.inc" by transforming it (= regenerate it).
+FUNCTION(TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE)
+  FILE(READ ${INPUT_FILE} MAKEFILE_INC_TEXT)
+  STRING(REPLACE "$(top_srcdir)"   "\${CURL_SOURCE_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  STRING(REPLACE "$(top_builddir)" "\${CURL_BINARY_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+  STRING(REGEX REPLACE "\\\\\n" "<22>!<21>" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  STRING(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*\n)" "SET(\\1 \\2)\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  STRING(REPLACE "<22>!<21>" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+  STRING(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace $() with ${}
+  STRING(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace @@ with ${}, even if that may not be read by CMake scripts.
+  FILE(WRITE ${OUTPUT_FILE} ${MAKEFILE_INC_TEXT})
+
+  ### BUGGY METHOD 1
+  # FILE(STRINGS Makefile.inc MAKEFILE_INC_TEXT)
+  # STRING(REPLACE "# ./lib/Makefile.inc" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # STRING(REPLACE "  " " " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace tabs with spaces
+
+  # #STRING(REGEX MATCH "CSOURCES *=" AAA ${MAKEFILE_INC_TEXT})
+  # #MESSAGE(STATUS ${AAA})
+
+  # STRING(REPLACE "CSOURCES =" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # STRING(REPLACE "HHEADERS =" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+  # STRING(REGEX REPLACE "[^ ]+\\.c" "" ${HEADERS_VAR} ${MAKEFILE_INC_TEXT})    # Remove source files and store into headers var
+  # STRING(REGEX REPLACE "  +" " " ${HEADERS_VAR} ${${HEADERS_VAR}})
+  # STRING(REGEX REPLACE " " ";" ${HEADERS_VAR} ${${HEADERS_VAR}})
+
+  # STRING(REGEX REPLACE "[^ ]+\\.h" "" ${SOURCES_VAR} ${MAKEFILE_INC_TEXT})    # Remove headers and store into source files var
+  # STRING(REGEX REPLACE "  +" " " ${SOURCES_VAR} ${${SOURCES_VAR}})
+  # STRING(REGEX REPLACE " " ";" ${SOURCES_VAR} ${${SOURCES_VAR}})
+
+  # SET(${HEADERS_VAR} ${${HEADERS_VAR}} PARENT_SCOPE)
+  # SET(${SOURCES_VAR} ${${SOURCES_VAR}} PARENT_SCOPE)
+
+  ### BUGGY METHOD 2
+  # FILE(READ Makefile.inc MAKEFILE_INC_TEXT)
+  # #STRING(REPLACE "\t" " " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace tabs with spaces
+  # #STRING(REGEX REPLACE "\n+" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Remove empty lines (allow a simplification in the script)
+  # STRING(REGEX REPLACE "([A-Z]+)[\t ]*=[\t ]*" "SET(\\1 " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # #STRING(REGEX REPLACE "^(.*)[\t ]*[^\\]$" ")" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # STRING(REGEX REPLACE "([^\\])\n" "\\1)\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # # STRING(REGEX REPLACE "CSOURCES *=" "SET(libCurl_SRCS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # # STRING(REGEX REPLACE "HHEADERS *=" "SET(libCurl_HEADERS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  # FILE(WRITE Makefile.inc.cmake ${MAKEFILE_INC_TEXT})
+ENDFUNCTION()
+
+ADD_SUBDIRECTORY(lib)
+IF(BUILD_CURL_EXE)
+  ADD_SUBDIRECTORY(src)
+ENDIF()
+IF(BUILD_CURL_TESTS)
+  ADD_SUBDIRECTORY(tests)
+ENDIF()
+
+# This needs to be run very last so other parts of the scripts can take advantage of this.
+IF(NOT CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
+    SET(CURL_CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")
+ENDIF()

CTestConfig.cmake

@@ -0,0 +1,13 @@
+## This file should be placed in the root directory of your project.
+## Then modify the CMakeLists.txt file in the root directory of your
+## project to incorporate the testing dashboard.
+## # The following are required to uses Dart and the Cdash dashboard
+##   ENABLE_TESTING()
+##   INCLUDE(Dart)
+set(CTEST_PROJECT_NAME "CURL")
+set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
+
+set(CTEST_DROP_METHOD "http")
+set(CTEST_DROP_SITE "www.cdash.org")
+set(CTEST_DROP_LOCATION "/CDashPublic/submit.php?project=CURL")
+set(CTEST_DROP_SITE_CDASH TRUE)

MacOSX-Framework

@@ -0,0 +1,78 @@
+#!/bin/bash
+# This script performs all of the steps needed to build a 
+# universal binary libcurl.framework for Mac OS X 10.4 or greater.
+
+VERSION=`/usr/bin/sed -ne 's/^#define LIBCURL_VERSION "\(.*\)"/\1/p' include/curl/curlver.h`
+
+SDK32='/Developer/SDKs/MacOSX10.4u.sdk'
+
+MINVER32='-mmacosx-version-min=10.4'
+
+ARCHES32='-arch ppc -arch i386'
+
+SDK64='/Developer/SDKs/MacOSX10.5.sdk'
+
+MINVER64='-mmacosx-version-min=10.5'
+
+ARCHES64='-arch ppc64 -arch x86_64'
+
+if test -d $SDK32; then
+  echo "----Configuring libcurl for 32 bit universal framework..."
+  ./configure --disable-dependency-tracking --disable-static --with-gssapi \
+    CFLAGS="-Os -isysroot $SDK32 $ARCHES32 $MINVER32" \
+    LDFLAGS="-Wl,-syslibroot,$SDK32 $ARCHES32 $MINVER32 -Wl,-headerpad_max_install_names" \
+    CC=$CC
+  
+  echo "----Building 32 bit libcurl..."
+  make
+  
+  echo "----Creating 32 bit framework..."
+  rm -r libcurl.framework
+  mkdir -p libcurl.framework/Versions/A/Resources
+  cp lib/.libs/libcurl.dylib libcurl.framework/Versions/A/libcurl
+  install_name_tool -id @executable_path/../Frameworks/libcurl.framework/Versions/A/libcurl libcurl.framework/Versions/A/libcurl
+  /usr/bin/sed -e "s/7\.12\.3/$VERSION/" lib/libcurl.plist >libcurl.framework/Versions/A/Resources/Info.plist
+  mkdir -p libcurl.framework/Versions/A/Headers/curl
+  cp include/curl/*.h libcurl.framework/Versions/A/Headers/curl
+  pushd libcurl.framework
+  ln -fs Versions/A/libcurl libcurl
+  ln -fs Versions/A/Resources Resources
+  ln -fs Versions/A/Headers Headers
+  cd Versions
+  ln -fs A Current
+  
+  if test -d $SDK64; then
+    popd
+    make clean
+    echo "----Configuring libcurl for 64 bit universal framework..."
+    ./configure --disable-dependency-tracking --disable-static --with-gssapi \
+      CFLAGS="-Os -isysroot $SDK64 $ARCHES64 $MINVER64" \
+      LDFLAGS="-Wl,-syslibroot,$SDK64 $ARCHES64 $MINVER64 -Wl,-headerpad_max_install_names" \
+      CC=$CC
+  
+    echo "----Building 64 bit libcurl..."
+    make
+  
+    echo "----Appending 64 bit framework to 32 bit framework..."
+    cp lib/.libs/libcurl.dylib libcurl.framework/Versions/A/libcurl64
+    install_name_tool -id @executable_path/../Frameworks/libcurl.framework/Versions/A/libcurl libcurl.framework/Versions/A/libcurl64
+    cp libcurl.framework/Versions/A/libcurl libcurl.framework/Versions/A/libcurl32
+    lipo libcurl.framework/Versions/A/libcurl32 libcurl.framework/Versions/A/libcurl64 -create -output libcurl.framework/Versions/A/libcurl
+    rm libcurl.framework/Versions/A/libcurl32 libcurl.framework/Versions/A/libcurl64
+    cp libcurl.framework/Versions/A/Headers/curl/curlbuild.h libcurl.framework/Versions/A/Headers/curl/curlbuild32.h
+    cp include/curl/curlbuild.h libcurl.framework/Versions/A/Headers/curl/curlbuild64.h
+    cat >libcurl.framework/Versions/A/Headers/curl/curlbuild.h <<EOF
+#ifdef __LP64__
+#include "curl/curlbuild64.h"
+#else
+#include "curl/curlbuild32.h"
+#endif
+EOF
+  fi
+  
+  lipo -info libcurl.framework/Versions/A/libcurl
+  echo "libcurl.framework is built and can now be included in other projects."
+  echo "Copy libcurl.framework to your bundle's Contents/Frameworks folder, ~/Library/Frameworks or /Library/Frameworks."
+else
+  echo "Building libcurl.framework requires Mac OS X 10.4 or later with the MacOSX10.4u SDK installed."
+fi

Makefile.am

@@ -25,9 +25,15 @@ AUTOMAKE_OPTIONS = foreign
 
 ACLOCAL_AMFLAGS = -I m4
 
-EXTRA_DIST = CHANGES COPYING maketgz Makefile.dist curl-config.in \
- curl-style.el sample.emacs RELEASE-NOTES buildconf buildconf.bat 	 \
- libcurl.pc.in vc6curl.dsw
+CMAKE_DIST = CMakeLists.txt CMake/CheckTypeSize.c.in CMake/CheckTypeSize.cmake \
+CMake/CMakeConfigurableFile.in CMake/CurlCheckCSourceCompiles.cmake	       \
+CMake/CurlCheckCSourceRuns.cmake CMake/CurlTests.c CMake/FindOpenSSL.cmake     \
+CMake/FindZLIB.cmake CMake/OtherTests.cmake CMake/Platforms/WindowsCache.cmake \
+CMake/Utilities.cmake include/curl/curlbuild.h.cmake
+
+EXTRA_DIST = CHANGES COPYING maketgz Makefile.dist curl-config.in	\
+ curl-style.el sample.emacs RELEASE-NOTES buildconf buildconf.bat	\
+ libcurl.pc.in vc6curl.dsw MacOSX-Framework $(CMAKE_DIST)
 
 bin_SCRIPTS = curl-config
 

RELEASE-NOTES

@@ -1,54 +1,53 @@
-Curl and libcurl 7.19.3
+Curl and libcurl 7.19.5
 
- Public curl releases:         109
- Command line options:         128
- curl_easy_setopt() options:   158
+ Public curl releases:         111
+ Command line options:         132
+ curl_easy_setopt() options:   163
  Public functions in libcurl:  58
- Known libcurl bindings:       37
- Contributors:                 683
+ Known libcurl bindings:       38
+ Contributors:                 715
 
 This release includes the following changes:
 
- o CURLAUTH_DIGEST_IE bit added for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH
- o VC9 Makefiles were added to the release package
+ o libcurl now closes all dead connections whenever you attempt to open a new
+   connection
+ o libssh2's version number can now be figured out run-time instead of using
+   the build-time fixed number
+ o CURLOPT_SEEKFUNCTION may now return CURL_SEEKFUNC_CANTSEEK
+ o curl can now upload with resume even when reading from a pipe
+ o a build-time configured curl_socklen_t is now used instead of socklen_t
 
 This release includes the following bugfixes:
 
- o build failure when disabling FTP but enabling GSS
- o fixed several calls to memory functions that didn't check return codes
- o memory leak for SSL connects with libcurl/NSS when CURLOPT_ISSUERCERT was
-   used
- o re-use of connections with the multi interface when multiple handles used
-   the same server
- o memory leak with HTTP GSS/kerberos authentication
- o removed the default use of "Pragma: no-cache"
- o fix SCP/SFTP busyloop by using a new libssh2 1.0 function
- o bad fclose() after a fatal error in cookie code
- o curl_multi_remove_handle() when the handle was in use in a HTTP pipeline
- o GSS authentication infinite loop problem
- o 550 response from SIZE no longer treated as missing file
- o ftps:// control connections now use explicit protection level
- o dotted IPv6 addresses longer than 39 bytes failed
- o curl_easy_duphandle() doesn't try to duplicate the connection cache pointer
- o build failure on OS/400 when enabling IPv6
- o better detection of SFTP failures
- o improved connection re-use for subsequent SCP and SFTP transfers
- o multi interface does less busy-loops for SCP and SFTP transfers with libssh2
-   1.0 or later
- o curl_multi_timeout() no longer returns timeout 0 when there's still more
-   than 0 but less than 999 microseconds left
- o the multi_socket API and HTTP pipelining now work a lot better when combined
- o SFTP seek/resume beyond 32bit file sizes
- o fixed breakage with --with-ssl --disable-verbose
- o TTL "leak" in the DNS cache
- o improved NSS initing
- o curl_easy_reset now resets more options
- o rare Location: follow bug with the multi interface
- o the configure script can now detect gnutls with pkg-config
- o curlbuild.h was adjusted for SunPro compilers
- o CURLOPT_COOKIELIST set to "SESS" on an easy handle with no cookies data
- o fixed timeouts for TFTP
- o fixed PPC builds
+ o NTLM authentication memory leak on SSPI enabled Windows builds
+ o fixed the GnuTLS-using code to do correct return code checks
+ o an alloc-related call in the OpenSSL-using code didn't check the return value
+ o curl_easy_duphandle() failed to duplicate cookies at times
+ o missing TELNET timeout support in Windows builds
+ o missing Curl_read() and write callback result checking in TELNET transfers
+ o more ciphers enabled in libcurl built to use NSS
+ o properly return an error code in curl_easy_recv
+ o Sun compilers specific preprocessor block removed from curlbuild.h.dist
+ o allow creation of four way fat libcurl Mac OS X Framework
+ o several memory leaks in libcurl+NSS
+ o improved the CURLOPT_NOBODY set to 0 confusions
+ o persistent connections when doing FTP over a HTTP proxy
+ o --libcurl bogus strings where other data was pointed to
+ o crash related to FTP and "Re-used connection seems dead, get a new one"
+ o CURLINFO_APPCONNECT_TIME with the multi interface
+ o Enhanced upload speeds on Windows
+ o TFTP problems after a failed transfer to the same host
+ o improved out of the box TPF compatibility
+ o HTTP PUT protocol line endings portions mangled from CRLF to CRCRLF
+ o Rejected SSL session ids are killed properly (for OpenSSL and GnuTLS builds)
+ o Deal with the TFTP OACK packet
+ o fixed roff mistakes in man pages
+ o use SOCKS proxy with the multi interface
+ o fixed the Curl_getoff_all_pipelines SIGSEGV 
+ o POST, NTLM and following a redirect hang
+ o libcurl+NSS endless loop on incorrect password for private key
+ o gzip decompression memory leak
+ o no_proxy flaw with user name in URL
 
 This release includes the following known bugs:
 
@@ -57,11 +56,12 @@ This release includes the following known bugs:
 This release would not have looked like this without help, code, reports and
 advice from friends like these:
 
- Yang Tse, Daniel Fandrich, Jim Meyering, Christian Krause, Andreas Wurf,
- Markus Koetter, Josef Wolf, Vlad Grachov, Pawel Kierski, Igor Novoseltsev,
- Fred Machado, Ken Hirsch, Keshav Krity, Patrick Monnerat, Mark Karpeles,
- Anthony Bryan, Peter Korsgaard, Phil Lisiecki, Bas Mevissen, Rob Crittenden,
- Emil Romanus, Karl Moerder, Daniel Black, Stefan Teleman, Michael Wallner,
- Grant Erickson, Tim Ansell, Andrew de los Reyes
+ Daniel Fandrich, Yang Tse, David James, Chris Deidun, Bill Egert,
+ Andre Guibert de Bruet, Andreas Farber, Frank Hempel, Pierre Brico,
+ Kamil Dudka, Jim Freeman, Daniel Johnson, Toshio Kuratomi, Martin Storsjo,
+ Pramod Sharma, Gisle Vanem, Lenaic Lefever, Rainer Koenig, Sven Wegener,
+ Tim Chen, Constantine Sapuntzakis, David McCreedy, Michael Smith,
+ Colin Watson, Ebenezer Ikonne, Laurent Rabret, Michael Cronenworth,
+ Balint Szilakszi, James Bursa
 
         Thanks! (and sorry if I forgot to mention someone)

TODO-RELEASE

@@ -1,19 +1,9 @@
-To be addressed in 7.19.3 (planned release: January 2009)
+To be addressed in 7.19.6 (planned release: July 2009)
 =========================
 
+226 - Active Mode FTPS Data Port Range
 
-To be addressed in 7.19.4 (planned release: March 2009)
-=========================
-
-205 - A. Craig West's CURLOPT_NOPROXY option
-
-206 - A. Craig West's CURLOPT_HTTP_VERSION change for CONNECT
-
-208 - Patch to allow GSSAPI authentication to a socks5 server
-
-214 - progress bar prefix, second try (for the curl tool)
-
-215 - Patch for Metalink Support (for the curl tool)
-
-216 - 
+235 - KNOWN_BUG #65
+      Code adjustment for FTP over socks proxy remains
 
+240 - 

acinclude.m4

@@ -22,53 +22,6 @@
 #***************************************************************************
 
 
-dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
-dnl -------------------------------------------------
-dnl Verifies if the compiler actually halts after the
-dnl compilation phase without generating any object
-dnl code file, when the source compiles with errors.
-
-AC_DEFUN([CURL_CHECK_COMPILER_HALT_ON_ERROR], [
-  AC_MSG_CHECKING([if compiler halts on compilation errors])
-  AC_COMPILE_IFELSE([
-    AC_LANG_PROGRAM([[
-    ]],[[
-      force compilation error
-    ]])
-  ],[
-    AC_MSG_RESULT([no])
-    AC_MSG_ERROR([compiler does not halt on compilation errors.])
-  ],[
-    AC_MSG_RESULT([yes])
-  ])
-])
-
-
-dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
-dnl -------------------------------------------------
-dnl Verifies if the compiler actually halts after the
-dnl compilation phase without generating any object
-dnl code file, when the source code tries to define a
-dnl type for a constant array with negative dimension.
-
-AC_DEFUN([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
-  AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
-  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
-  AC_COMPILE_IFELSE([
-    AC_LANG_PROGRAM([[
-      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
-    ]],[[
-      bad_t dummy;
-    ]])
-  ],[
-    AC_MSG_RESULT([no])
-    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
-  ],[
-    AC_MSG_RESULT([yes])
-  ])
-])
-
-
 dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
 dnl -------------------------------------------------
 dnl Use the C preprocessor to find out if the given object-style symbol
@@ -118,6 +71,72 @@ CURL_DEF_TOKEN $1
 ])
 
 
+dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C compiler to find out only if the given symbol is defined
+dnl or not, this can not find out its expansion. This macro will not use
+dnl default includes even if no INCLUDES argument is given. This macro
+dnl will run silently when invoked with three arguments.
+
+AC_DEFUN([CURL_CHECK_DEF_CC], [
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+int main (void)
+{
+#ifdef $1
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_symbol_defined="yes"
+  ],[
+    tst_symbol_defined="no"
+  ])
+  if test "$tst_symbol_defined" = "yes"; then
+    AS_VAR_SET(ac_HaveDef, yes)
+    ifelse($3,,[AC_MSG_RESULT([yes])])
+  else
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  fi
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+])
+
+
+dnl CURL_CHECK_LIB_XNET
+dnl -------------------------------------------------
+dnl Verify if X/Open network library is required.
+
+AC_DEFUN([CURL_CHECK_LIB_XNET], [
+  AC_MSG_CHECKING([if X/Open network library is required])
+  tst_lib_xnet_required="no"
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE([[
+int main (void)
+{
+#if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
+  return 0;
+#elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_lib_xnet_required="yes"
+    LIBS="$LIBS -lxnet"
+  ])
+  AC_MSG_RESULT([$tst_lib_xnet_required])
+])
+
+
 dnl CURL_CHECK_AIX_ALL_SOURCE
 dnl -------------------------------------------------
 dnl Provides a replacement of traditional AC_AIX with
@@ -893,91 +912,55 @@ AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
 ])
 
 
-dnl CURL_CHECK_TYPE_SOCKLEN_T
+dnl CURL_CHECK_HEADER_MEMORY
 dnl -------------------------------------------------
-dnl Check for existing socklen_t type, and provide
-dnl an equivalent type if socklen_t not available
+dnl Check for compilable and valid memory.h header,
+dnl and check if it is needed even with stdlib.h for
+dnl memory related functions.
 
-AC_DEFUN([CURL_CHECK_TYPE_SOCKLEN_T], [
-  AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
-  AC_CHECK_TYPE([socklen_t], ,[
-    dnl socklen_t not available
-    AC_CACHE_CHECK([for socklen_t equivalent],
-      [curl_cv_socklen_t_equiv], [
-      curl_cv_socklen_t_equiv="unknown"
-      for arg1 in 'int' 'SOCKET'; do
-        for arg2 in "struct sockaddr" void; do
-          for t in int size_t unsigned long "unsigned long"; do
-            if test "$curl_cv_socklen_t_equiv" = "unknown"; then
-              AC_COMPILE_IFELSE([
-                AC_LANG_PROGRAM([[
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#define GETPEERNCALLCONV PASCAL
-#else
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#define GETPEERNCALLCONV
-#endif
-                  extern int GETPEERNCALLCONV getpeername($arg1, $arg2 *, $t *);
-                ]],[[
-                  $t len=0;
-                  getpeername(0,0,&len);
-                ]])
-              ],[
-                curl_cv_socklen_t_equiv="$t"
-              ])
-            fi
-          done
-        done
-      done
+AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [
+  AC_CACHE_CHECK([for memory.h], [ac_cv_header_memory_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <memory.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      ac_cv_header_memory_h="yes"
+    ],[
+      ac_cv_header_memory_h="no"
     ])
-    case "$curl_cv_socklen_t_equiv" in
-      unknown)
-        AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
-        ;;
-      *)
-        AC_DEFINE_UNQUOTED(socklen_t, $curl_cv_socklen_t_equiv,
-          [Type to use in place of socklen_t when system does not provide it.])
+  ])
+  if test "$ac_cv_header_memory_h" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_MEMORY_H, 1,
+      [Define to 1 if you have the memory.h header file.])
+    #
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <stdlib.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      curl_cv_need_header_memory_h="no"
+    ],[
+      curl_cv_need_header_memory_h="yes"
+    ])
+    #
+    case "$curl_cv_need_header_memory_h" in
+      yes)
+        AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,
+          [Define to 1 if you need the memory.h header file even with stdlib.h])
         ;;
     esac
-  ],[
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#ifdef HAVE_WS2TCPIP_H
-#include <ws2tcpip.h>
-#endif
-#endif
-#else
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#endif
-  ])
+  fi
 ])
 
 
@@ -994,7 +977,6 @@ dnl argument in GETNAMEINFO_QUAL_ARG1.
 
 AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [
   AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
-  AC_REQUIRE([CURL_CHECK_TYPE_SOCKLEN_T])dnl
   AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)
   #
   AC_MSG_CHECKING([for getnameinfo])
@@ -2217,6 +2199,168 @@ AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
 ])
 
 
+dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
+dnl -------------------------------------------------
+dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
+dnl symbol that can be further used in custom template configuration
+dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
+dnl argument for the description. Symbol definitions done with this
+dnl macro are intended to be exclusively used in handcrafted *.h.in
+dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
+dnl prevents autoheader generation and insertion of symbol template
+dnl stub and definition into the first configuration header file. Do
+dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
+dnl one serves different functional needs.
+
+AC_DEFUN([CURL_DEFINE_UNQUOTED], [
+cat >>confdefs.h <<_EOF
+[@%:@define] $1 ifelse($#, 2, [$2], 1)
+_EOF
+])
+
+
+dnl CURL_CONFIGURE_LONG
+dnl -------------------------------------------------
+dnl Find out the size of long as reported by sizeof() and define
+dnl CURL_SIZEOF_LONG as appropriate to be used in template file
+dnl include/curl/curlbuild.h.in to properly configure the library.
+dnl The size of long is a build time characteristic and as such
+dnl must be recorded in curlbuild.h
+
+AC_DEFUN([CURL_CONFIGURE_LONG], [
+  if test -z "$ac_cv_sizeof_long" ||
+    test "$ac_cv_sizeof_long" -eq "0"; then
+    AC_MSG_ERROR([cannot find out size of long.])
+  fi
+  CURL_DEFINE_UNQUOTED([CURL_SIZEOF_LONG], [$ac_cv_sizeof_long])
+])
+
+
+dnl CURL_CONFIGURE_CURL_SOCKLEN_T
+dnl -------------------------------------------------
+dnl Find out suitable curl_socklen_t data type definition and size, making
+dnl appropriate definitions for template file include/curl/curlbuild.h.in
+dnl to properly configure and use the library.
+dnl
+dnl The need for the curl_socklen_t definition arises mainly to properly
+dnl interface HP-UX systems which on one hand have a typedef'ed socklen_t
+dnl data type which is 32 or 64-Bit wide depending on the data model being
+dnl used, and that on the other hand is only actually used when interfacing
+dnl the X/Open sockets provided in the xnet library.
+
+AC_DEFUN([CURL_CONFIGURE_CURL_SOCKLEN_T], [
+  AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
+  #
+  AC_MSG_CHECKING([for curl_socklen_t data type])
+  curl_typeof_curl_socklen_t="unknown"
+  for arg1 in int SOCKET; do
+    for arg2 in 'struct sockaddr' void; do
+      for t in socklen_t int size_t 'unsigned int' long 'unsigned long' void; do
+        if test "$curl_typeof_curl_socklen_t" = "unknown"; then
+          AC_COMPILE_IFELSE([
+            AC_LANG_PROGRAM([[
+              $curl_includes_ws2tcpip
+              $curl_includes_sys_socket
+              $curl_preprocess_callconv
+              extern int FUNCALLCONV getpeername($arg1, $arg2 *, $t *);
+            ]],[[
+              $t *lenptr = 0;
+              if(0 != getpeername(0, 0, lenptr))
+                return 1;
+            ]])
+          ],[
+            curl_typeof_curl_socklen_t="$t"
+          ])
+        fi
+      done
+    done
+  done
+  for t in socklen_t int; do
+    if test "$curl_typeof_curl_socklen_t" = "void"; then
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $curl_includes_sys_socket
+          typedef $t curl_socklen_t;
+        ]],[[
+          curl_socklen_t dummy;
+        ]])
+      ],[
+        curl_typeof_curl_socklen_t="$t"
+      ])
+    fi
+  done
+  AC_MSG_RESULT([$curl_typeof_curl_socklen_t])
+  if test "$curl_typeof_curl_socklen_t" = "void" ||
+    test "$curl_typeof_curl_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find data type for curl_socklen_t.])
+  fi
+  #
+  AC_MSG_CHECKING([size of curl_socklen_t])
+  curl_sizeof_curl_socklen_t="unknown"
+  curl_pull_headers_socklen_t="unknown"
+  if test "$ac_cv_header_ws2tcpip_h" = "yes"; then
+    tst_pull_header_checks='none ws2tcpip'
+    tst_size_checks='4'
+  else
+    tst_pull_header_checks='none systypes syssocket'
+    tst_size_checks='4 8 2'
+  fi
+  for tst_size in $tst_size_checks; do
+    for tst_pull_headers in $tst_pull_header_checks; do
+      if test "$curl_sizeof_curl_socklen_t" = "unknown"; then
+        case $tst_pull_headers in
+          ws2tcpip)
+            tmp_includes="$curl_includes_ws2tcpip"
+            ;;
+          systypes)
+            tmp_includes="$curl_includes_sys_types"
+            ;;
+          syssocket)
+            tmp_includes="$curl_includes_sys_socket"
+            ;;
+          *)
+            tmp_includes=""
+            ;;
+        esac
+        AC_COMPILE_IFELSE([
+          AC_LANG_PROGRAM([[
+            $tmp_includes
+            typedef $curl_typeof_curl_socklen_t curl_socklen_t;
+            typedef char dummy_arr[sizeof(curl_socklen_t) == $tst_size ? 1 : -1];
+          ]],[[
+            curl_socklen_t dummy;
+          ]])
+        ],[
+          curl_sizeof_curl_socklen_t="$tst_size"
+          curl_pull_headers_socklen_t="$tst_pull_headers"
+        ])
+      fi
+    done
+  done
+  AC_MSG_RESULT([$curl_sizeof_curl_socklen_t])
+  if test "$curl_sizeof_curl_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find out size of curl_socklen_t.])
+  fi
+  #
+  case $curl_pull_headers_socklen_t in
+    ws2tcpip)
+      CURL_DEFINE_UNQUOTED([CURL_PULL_WS2TCPIP_H])
+      ;;
+    systypes)
+      CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
+      ;;
+    syssocket)
+      CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
+      CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_SOCKET_H])
+      ;;
+  esac
+  CURL_DEFINE_UNQUOTED([CURL_TYPEOF_CURL_SOCKLEN_T], [$curl_typeof_curl_socklen_t])
+  CURL_DEFINE_UNQUOTED([CURL_SIZEOF_CURL_SOCKLEN_T], [$curl_sizeof_curl_socklen_t])
+])
+
+
 dnl CURL_CHECK_FUNC_SELECT
 dnl -------------------------------------------------
 dnl Test if the socket select() function is available,
@@ -2640,67 +2784,6 @@ AC_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
 ])
 
 
-dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
-dnl -------------------------------------------------
-dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
-dnl symbol that can be further used in custom template configuration
-dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
-dnl argument for the description. Symbol definitions done with this
-dnl macro are intended to be exclusively used in handcrafted *.h.in
-dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
-dnl prevents autoheader generation and insertion of symbol template
-dnl stub and definition into the first configuration header file. Do
-dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
-dnl one serves different functional needs.
-
-AC_DEFUN([CURL_DEFINE_UNQUOTED], [
-cat >>confdefs.h <<_EOF
-[@%:@define] $1 ifelse($#, 2, [$2], 1)
-_EOF
-])
-
-
-dnl CURL_INCLUDES_INTTYPES
-dnl -------------------------------------------------
-dnl Set up variable with list of headers that must be
-dnl included when inttypes.h is to be included.
-
-AC_DEFUN([CURL_INCLUDES_INTTYPES], [
-curl_includes_inttypes="\
-/* includes start */
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-#ifdef HAVE_STDINT_H
-# include <stdint.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
-#endif
-/* includes end */"
-  AC_CHECK_HEADERS(
-    sys/types.h stdint.h inttypes.h,
-    [], [], [$curl_includes_inttypes])
-])
-
-
-dnl CURL_CONFIGURE_LONG
-dnl -------------------------------------------------
-dnl Find out the size of long as reported by sizeof() and define
-dnl CURL_SIZEOF_LONG as appropriate to be used in template file
-dnl include/curl/curlbuild.h.in to properly configure the library.
-dnl The size of long is a build time characteristic and as such
-dnl must be recorded in curlbuild.h
-
-AC_DEFUN([CURL_CONFIGURE_LONG], [
-  if test -z "$ac_cv_sizeof_long" ||
-    test "$ac_cv_sizeof_long" -eq "0"; then
-    AC_MSG_ERROR([cannot find out size of long.])
-  fi
-  CURL_DEFINE_UNQUOTED([CURL_SIZEOF_LONG], [$ac_cv_sizeof_long])
-])
-
-
 dnl DO_CURL_OFF_T_CHECK (TYPE, SIZE)
 dnl -------------------------------------------------
 dnl Internal macro for CURL_CONFIGURE_CURL_OFF_T

ares/.cvsignore

@@ -1,24 +1,26 @@
-configure
-autom4te.cache
+*.lo
+.deps
+.libs
 Makefile
+Makefile.in
+aclocal.m4
 adig
 ahost
-config.log
-config.status
-aclocal.m4
-.deps
-Makefile.in
+ares_build.h
+ares_version.h.dist
+autom4te.cache
 config.guess
 config.h
 config.h.in
+config.log
+config.lt
+config.status
 config.sub
-libtool
-ltmain.sh
-stamp-h1
-*.lo
-.libs
+configure
 depcomp
 libcares.la
-missing
-ares_version.h.dist
 libcares.pc
+libtool
+ltmain.sh
+missing
+stamp-h*

ares/CHANGES

@@ -1,5 +1,32 @@
   Changelog for the c-ares project
 
+* May 11 2009 (Daniel Stenberg)
+- Gregor Jasny made c-ares link with libtool 's -export-symbols-regex option to
+  only expose functions starting with ares_.
+
+* May 2 2009 (Yang Tse)
+- Use a build-time configured ares_socklen_t data type instead of socklen_t.
+
+* April 21 2009 (Yang Tse)
+- Moved potential inclusion of system's malloc.h and memory.h header files to
+  setup_once.h.  Inclusion of each header file is based on the definition of
+  NEED_MALLOC_H and NEED_MEMORY_H respectively.
+
+* March 11 2009 (Yang Tse)
+- Japheth Cleaver fixed acountry.c replacing u_long with unsigned long.
+
+* February 20 2009 (Yang Tse)
+- Do not halt compilation when using VS2008 to build a Windows 2000 target.
+
+* February 3 2009 (Phil Blundell)
+- If the server returns garbage or nothing at all in response to an AAAA query,
+  go on and ask for A records anyway.
+
+* January 31 2009 (Daniel Stenberg)
+- ares_gethostbyname() now accepts 'AF_UNSPEC' as a family for resolving
+  either AF_INET6 or AF_INET. It works by accepting any of the looksups in the
+  hosts file, and it resolves the AAAA field with a fallback to A.
+
 * January 14 2009 (Daniel Stenberg)
 - ares.h no longer uses the HAVE_STRUCT_IN6_ADDR define check, but instead it
   now declares the private struct ares_in6_addr for all systems instead of

ares/Makefile.am

@@ -46,7 +46,9 @@ noinst_PROGRAMS =$(PROGS)
 EXTRA_DIST = AUTHORS CHANGES README.cares Makefile.inc Makefile.dj	   \
  Makefile.m32 Makefile.netware Makefile.vc6 $(man_MANS) $(MSVCFILES)	   \
  config-win32.h RELEASE-NOTES libcares.pc.in buildconf get_ver.awk maketgz \
- TODO
+ TODO ares_build.h.in buildconf.bat
+
+DISTCLEANFILES = ares_build.h
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libcares.pc
@@ -85,8 +87,9 @@ if NO_UNDEFINED
 UNDEF = -no-undefined
 endif
 
+EXPORT_SYMBOLS = -export-symbols-regex '^ares_[[:alnum:]].*'
 
-libcares_la_LDFLAGS = $(UNDEF) $(VER)
+libcares_la_LDFLAGS = $(UNDEF) $(VER) $(EXPORT_SYMBOLS)
 
 # Makefile.inc provides the CSOURCES and HHEADERS defines
 include Makefile.inc
@@ -96,7 +99,8 @@ libcares_la_SOURCES = $(CSOURCES) $(HHEADERS)
 # where to install the c-ares headers
 libcares_ladir = $(includedir)
 # what headers to install on 'make install':
-libcares_la_HEADERS = ares.h ares_version.h ares_dns.h
+libcares_la_HEADERS = ares.h ares_version.h ares_dns.h \
+	ares_build.h ares_rules.h
 
 ahost_SOURCES = ahost.c ares_getopt.c ares_getopt.h
 ahost_LDADD = $(top_builddir)/$(lib_LTLIBRARIES)

ares/Makefile.dj

@@ -23,13 +23,14 @@ CFLAGS += -DWATT32 -DHAVE_AF_INET6 -DHAVE_PF_INET6 -DHAVE_IOCTLSOCKET \
           -DRECV_TYPE_ARG1='int'   -DRECV_TYPE_ARG2='void*' \
           -DRECV_TYPE_ARG3='int'   -DRECV_TYPE_ARG4='int' \
           -DRECV_TYPE_RETV='int'   -DHAVE_STRUCT_TIMEVAL \
-          -Dselect=select_s        -Dsocklen_t=int -UHAVE_CONFIG_H \
+          -Dselect=select_s        -UHAVE_CONFIG_H \
           -DRECVFROM_TYPE_ARG1='int' -DRECVFROM_TYPE_ARG2='void' \
           -DRECVFROM_TYPE_ARG3='int' -DRECVFROM_TYPE_ARG4='int' \
           -DRECVFROM_TYPE_ARG6='int' -DRECVFROM_TYPE_RETV='int' \
           -DRECVFROM_TYPE_ARG5='struct sockaddr' -DHAVE_RECVFROM \
           -DRECVFROM_TYPE_ARG2_IS_VOID -DHAVE_STRDUP -DHAVE_NETDB_H \
-          -DHAVE_STRCASECMP -DHAVE_STRNCASECMP -DHAVE_GETHOSTNAME
+          -DHAVE_STRCASECMP -DHAVE_STRNCASECMP -DHAVE_GETHOSTNAME \
+          -DHAVE_LIMITS_H
 
 LDFLAGS = -s
 

ares/Makefile.inc

@@ -6,11 +6,13 @@ ares_timeout.c ares_destroy.c ares_mkquery.c ares_version.c		\
 ares_expand_name.c ares_parse_a_reply.c windows_port.c ares_strdup.c	\
 ares_expand_string.c ares_parse_ptr_reply.c ares_parse_aaaa_reply.c	\
 ares_getnameinfo.c inet_net_pton.c bitncmp.c inet_ntop.c ares_writev.c	\
-ares_parse_ns_reply.c ares_llist.c ares__timeval.c ares_strcasecmp.c
+ares_parse_ns_reply.c ares_llist.c ares__timeval.c ares_strcasecmp.c	\
+ares_library_init.c
 
 HHEADERS = ares.h ares_private.h setup.h ares_dns.h ares_version.h          \
  nameser.h inet_net_pton.h inet_ntop.h ares_ipv6.h bitncmp.h setup_once.h   \
- ares_llist.h ares_strdup.h ares_strcasecmp.h ares_writev.h
+ ares_llist.h ares_strdup.h ares_strcasecmp.h ares_writev.h ares_build.h    \
+ ares_rules.h ares_library_init.h
 
 MANPAGES= ares_destroy.3 ares_expand_name.3 ares_expand_string.3 ares_fds.3 \
  ares_free_hostent.3 ares_free_string.3 ares_gethostbyaddr.3		    \

ares/Makefile.m32

@@ -40,7 +40,7 @@ tags:
 %.exe: %.o ares_getopt.o $(LIB)
 	$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
 
-$(OBJLIB): ares.h ares_dns.h ares_private.h
+$(OBJLIB): ares.h ares_dns.h ares_private.h ares_build.h ares_rules.h
 
 .c.o:
 	$(CC) $(CFLAGS) -c $<
@@ -55,7 +55,8 @@ install:
 	${RANLIB} ${DESTDIR}${libdir}/$(LIB)
 	chmod u-w ${DESTDIR}${libdir}/$(LIB)
 	${INSTALL} -m 444 ${srcdir}/ares.h ${DESTDIR}${includedir}
-	${INSTALL} -m 444 ${srcdir}/ares_version.h ${DESTDIR}${includedir}
+	${INSTALL} -m 444 ${srcdir}/ares_build.h ${DESTDIR}${includedir}
+	${INSTALL} -m 444 ${srcdir}/ares_rules.h ${DESTDIR}${includedir}
 	(for man in $(MANPAGES); do \
 	   ${INSTALL} -m 444 ${srcdir}/$${man} ${DESTDIR}${mandir}/man3; \
 	done)

ares/Makefile.netware

@@ -160,7 +160,7 @@ lib: prebuild $(LTARGET)
 
 nlm: prebuild $(TARGETS)
 
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc config.h
+prebuild: $(OBJDIR) ares_build.h $(OBJDIR)/version.inc config.h
 
 install: $(INSTDIR) all
 	@$(CP) *.nlm $(INSTDIR)
@@ -303,7 +303,6 @@ ifeq ($(LIBARCH),CLIB)
 	@echo $(DL)#define SEND_TYPE_ARG3 int$(DL) >> $@
 	@echo $(DL)#define SEND_TYPE_ARG4 int$(DL) >> $@
 	@echo $(DL)#define SEND_TYPE_RETV int$(DL) >> $@
-	@echo $(DL)#define socklen_t int$(DL) >> $@
 else
 	@echo $(DL)#define OS "i586-pc-libc-NetWare"$(DL) >> $@
 	@echo $(DL)#define HAVE_DLFCN_H 1$(DL) >> $@
@@ -311,7 +310,6 @@ else
 	@echo $(DL)#define HAVE_FTRUNCATE 1$(DL) >> $@
 	@echo $(DL)#define HAVE_GETTIMEOFDAY 1$(DL) >> $@
 	@echo $(DL)#define HAVE_INTTYPES_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@
 	@echo $(DL)#define HAVE_LONGLONG 1$(DL) >> $@
 	@echo $(DL)#define HAVE_STDINT_H 1$(DL) >> $@
 	@echo $(DL)#define HAVE_STRCASECMP 1$(DL) >> $@
@@ -361,6 +359,7 @@ endif
 	@echo $(DL)#define HAVE_INET_ADDR 1$(DL) >> $@
 	@echo $(DL)#define HAVE_IOCTL 1$(DL) >> $@
 	@echo $(DL)#define HAVE_IOCTL_FIONBIO 1$(DL) >> $@
+	@echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@
 	@echo $(DL)#define HAVE_LL 1$(DL) >> $@
 	@echo $(DL)#define HAVE_LOCALTIME_R 1$(DL) >> $@
 	@echo $(DL)#define HAVE_MALLOC_H 1$(DL) >> $@
@@ -407,7 +406,24 @@ endif
 	@echo $(DL)#else$(DL) >> $@
 	@echo $(DL)#define HAVE_VARIADIC_MACROS_C99 1$(DL) >> $@
 	@echo $(DL)#endif$(DL) >> $@
-ifdef OLD_NOVELLSDK
-	@echo $(DL)#define socklen_t int$(DL) >> $@
-endif
 
+FORCE: ;
+
+ares_build.h: Makefile.netware FORCE
+	@echo Creating $@
+	@echo $(DL)/* $@ intended for NetWare target.$(DL) > $@
+	@echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@
+	@echo $(DL)** All your changes will be lost!!$(DL) >> $@
+	@echo $(DL)*/$(DL) >> $@
+	@echo $(DL)#ifndef __CARES_BUILD_H$(DL) >> $@
+	@echo $(DL)#define __CARES_BUILD_H$(DL) >> $@
+ifeq ($(LIBARCH),CLIB)
+	@echo $(DL)#define CARES_TYPEOF_ARES_SOCKLEN_T int$(DL) >> $@
+	@echo $(DL)#define CARES_SIZEOF_ARES_SOCKLEN_T 4$(DL) >> $@
+else
+	@echo $(DL)#define CARES_TYPEOF_ARES_SOCKLEN_T unsigned int$(DL) >> $@
+	@echo $(DL)#define CARES_SIZEOF_ARES_SOCKLEN_T 4$(DL) >> $@
+endif
+	@echo $(DL)#define CARES_SIZEOF_LONG 4$(DL) >> $@
+	@echo $(DL)typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;$(DL) >> $@
+	@echo $(DL)#endif /* __CARES_BUILD_H */$(DL) >> $@

ares/Makefile.vc6

@@ -43,6 +43,8 @@ CFLAGS  = $(CFLAGS) -O2 -Og
 LDFLAGS = $(LDFLAGS) -release
 !endif
 
+CFLAGS  = $(CFLAGS) -I.\.
+
 OBJECTS = $(OBJ_DIR)\ares_fds.obj              \
           $(OBJ_DIR)\ares_process.obj          \
           $(OBJ_DIR)\ares_free_hostent.obj     \
@@ -61,6 +63,7 @@ OBJECTS = $(OBJ_DIR)\ares_fds.obj              \
           $(OBJ_DIR)\ares_strerror.obj         \
           $(OBJ_DIR)\ares_cancel.obj           \
           $(OBJ_DIR)\ares_init.obj             \
+          $(OBJ_DIR)\ares_library_init.obj     \
           $(OBJ_DIR)\ares_llist.obj            \
           $(OBJ_DIR)\ares_timeout.obj          \
           $(OBJ_DIR)\ares__timeval.obj         \
@@ -108,6 +111,8 @@ $(DEF_FILE): $(OBJECTS) Makefile.VC6
        @echo   ares_getsock           >> $@
        @echo   ares_init              >> $@
        @echo   ares_init_options      >> $@
+       @echo   ares_library_init      >> $@
+       @echo   ares_library_cleanup   >> $@
        @echo   ares_mkquery           >> $@
        @echo   ares_parse_a_reply     >> $@
        @echo   ares_parse_ptr_reply   >> $@
@@ -154,101 +159,116 @@ vclean realclean: clean
 # Copyright "gcc -MM .."
 #
 $(OBJ_DIR)\ares_fds.obj: ares_fds.c setup.h setup_once.h ares.h ares_private.h \
-  ares_ipv6.h
+  ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_process.obj: ares_process.c setup.h setup_once.h nameser.h     \
-  ares.h ares_dns.h ares_private.h ares_ipv6.h
+  ares.h ares_dns.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_free_hostent.obj: ares_free_hostent.c setup.h setup_once.h     \
-  ares.h ares_private.h ares_ipv6.h
+  ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_query.obj: ares_query.c setup.h setup_once.h nameser.h         \
-  ares.h ares_dns.h ares_private.h ares_ipv6.h
+  ares.h ares_dns.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares__close_sockets.obj: ares__close_sockets.c setup.h setup_once.h \
-  ares.h ares_private.h ares_ipv6.h
+  ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
-$(OBJ_DIR)\ares_free_string.obj: ares_free_string.c setup.h setup_once.h ares.h
+$(OBJ_DIR)\ares_free_string.obj: ares_free_string.c setup.h setup_once.h       \
+  ares.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_search.obj: ares_search.c setup.h setup_once.h nameser.h       \
-  ares.h ares_private.h ares_ipv6.h
+  ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares__get_hostent.obj: ares__get_hostent.c setup.h setup_once.h     \
-  ares.h ares_private.h ares_ipv6.h inet_net_pton.h
+  ares.h ares_private.h ares_ipv6.h inet_net_pton.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_gethostbyaddr.obj: ares_gethostbyaddr.c setup.h setup_once.h   \
-  nameser.h ares.h ares_private.h ares_ipv6.h inet_net_pton.h
+  nameser.h ares.h ares_private.h ares_ipv6.h inet_net_pton.h ares_build.h     \
+  ares_rules.h
 
 $(OBJ_DIR)\ares_send.obj: ares_send.c setup.h setup_once.h nameser.h ares.h    \
-  ares_dns.h ares_private.h ares_ipv6.h
+  ares_dns.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares__read_line.obj: ares__read_line.c setup.h setup_once.h ares.h  \
-  ares_private.h ares_ipv6.h
+  ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_gethostbyname.obj: ares_gethostbyname.c setup.h setup_once.h   \
-  nameser.h ares.h ares_private.h ares_ipv6.h inet_net_pton.h bitncmp.h
+  nameser.h ares.h ares_private.h ares_ipv6.h inet_net_pton.h bitncmp.h        \
+  ares_build.h ares_rules.h
 
-$(OBJ_DIR)\ares_strcasecmp.obj: ares_strcasecmp.c setup.h setup_once.h ares.h
+$(OBJ_DIR)\ares_strcasecmp.obj: ares_strcasecmp.c setup.h setup_once.h ares.h  \
+  ares_build.h ares_rules.h
 
-$(OBJ_DIR)\ares_strerror.obj: ares_strerror.c setup.h setup_once.h ares.h
+$(OBJ_DIR)\ares_strerror.obj: ares_strerror.c setup.h setup_once.h ares.h      \
+  ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_cancel.obj: ares_cancel.c setup.h setup_once.h ares.h          \
-  ares_private.h ares_ipv6.h
+  ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_init.obj: ares_init.c setup.h setup_once.h nameser.h ares.h    \
-  ares_private.h ares_ipv6.h inet_net_pton.h
+  ares_private.h ares_ipv6.h inet_net_pton.h ares_build.h ares_rules.h         \
+  ares_library_init.h
 
 $(OBJ_DIR)\ares_timeout.obj: ares_timeout.c setup.h setup_once.h ares.h        \
-  ares_private.h ares_ipv6.h
+  ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares__timeval.obj: ares__timeval.c setup.h setup_once.h ares.h      \
-  ares_private.h ares_ipv6.h
+  ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_destroy.obj: ares_destroy.c setup.h setup_once.h ares.h        \
-  ares_private.h ares_ipv6.h
+  ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_mkquery.obj: ares_mkquery.c setup.h setup_once.h nameser.h     \
-  ares.h ares_dns.h
+  ares.h ares_dns.h ares_build.h ares_rules.h
 
-$(OBJ_DIR)\ares_version.obj: ares_version.c setup.h setup_once.h ares_version.h
+$(OBJ_DIR)\ares_version.obj: ares_version.c setup.h setup_once.h ares.h        \
+  ares_version.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_expand_name.obj: ares_expand_name.c setup.h setup_once.h       \
-  nameser.h ares.h ares_private.h ares_ipv6.h
+  nameser.h ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_parse_a_reply.obj: ares_parse_a_reply.c setup.h setup_once.h   \
-  nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h
+  nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h ares_build.h          \
+  ares_rules.h
 
 $(OBJ_DIR)\windows_port.obj: windows_port.c setup.h setup_once.h nameser.h     \
-  ares.h ares_private.h ares_ipv6.h
+  ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_expand_string.obj: ares_expand_string.c setup.h setup_once.h   \
-  nameser.h ares.h ares_private.h ares_ipv6.h
+  nameser.h ares.h ares_private.h ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_parse_ptr_reply.obj: ares_parse_ptr_reply.c setup.h            \
-  setup_once.h nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h
+  setup_once.h nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h          \
+  ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_parse_aaaa_reply.obj: ares_parse_aaaa_reply.c setup.h          \
   setup_once.h nameser.h ares.h ares_dns.h inet_net_pton.h ares_private.h      \
-  ares_ipv6.h
+  ares_ipv6.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_parse_ns_reply.obj: ares_parse_ns_reply.c setup.h              \
-  setup_once.h nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h
+  setup_once.h nameser.h ares.h ares_dns.h ares_private.h ares_ipv6.h          \
+  ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_getnameinfo.obj: ares_getnameinfo.c setup.h setup_once.h       \
-  nameser.h ares.h ares_private.h ares_ipv6.h inet_ntop.h
+  nameser.h ares.h ares_private.h ares_ipv6.h inet_ntop.h ares_build.h         \
+  ares_rules.h
 
 $(OBJ_DIR)\inet_net_pton.obj: inet_net_pton.c setup.h setup_once.h nameser.h   \
-  ares_ipv6.h inet_net_pton.h
+  ares_ipv6.h inet_net_pton.h ares_build.h ares_rules.h
 
-$(OBJ_DIR)\bitncmp.obj: bitncmp.c bitncmp.h
+$(OBJ_DIR)\bitncmp.obj: bitncmp.c bitncmp.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\inet_ntop.obj: inet_ntop.c setup.h setup_once.h nameser.h           \
-  ares_ipv6.h inet_ntop.h
+  ares_ipv6.h inet_ntop.h ares_build.h ares_rules.h
 
-$(OBJ_DIR)\ares_getopt.obj: ares_getopt.c ares_getopt.h
+$(OBJ_DIR)\ares_getopt.obj: ares_getopt.c ares_getopt.h ares_build.h           \
+  ares_rules.h
+
+$(OBJ_DIR)\ares_library_init.obj: ares_library_init.c setup.h setup_once.h     \
+  ares.h ares_private.h ares_library_init.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_llist.obj: ares_llist.c setup.h setup_once.h ares.h            \
-  ares_private.h ares_llist.h
+  ares_private.h ares_llist.h ares_build.h ares_rules.h
 
 $(OBJ_DIR)\ares_writev.obj: ares_writev.c setup.h setup_once.h ares.h          \
-  ares_writev.h
+  ares_writev.h ares_build.h ares_rules.h

ares/README.cares

@@ -23,3 +23,41 @@ original ares.
 You'll find all c-ares details and news here:
 
         http://c-ares.haxx.se/
+
+
+NOTES FOR C-ARES HACKERS
+
+The following notes apply to c-ares version 1.6.1 and later.
+
+* The distributed ares_build.h file is only intended to be used on systems
+  which can not run the also distributed configure script.
+
+* The distributed ares_build.h file is generated as a copy of ares_build.h.dist
+  when the c-ares source code distribution archive file is originally created.
+
+* If you check out from CVS on a non-configure platform, you must run the
+  appropriate buildconf* script to set up ares_build.h and other local files
+  before being able of compiling the library.
+
+* On systems capable of running the configure script, the configure process
+  will overwrite the distributed ares_build.h file with one that is suitable
+  and specific to the library being configured and built, this new file is
+  generated from the ares_build.h.in template file.
+
+* If you intend to distribute an already compiled c-ares library you _MUST_
+  also distribute along with it the generated ares_build.h which has been
+  used to compile it. Otherwise the library will be of no use for the users of
+  the library that you have built. It is _your_ responsability to provide this
+  file. No one at the c-ares project can know how you have built the library.
+
+* File ares_build.h includes platform and configuration dependant info,
+  and must not be modified by anyone. Configure script generates it for you.
+
+* We cannot assume anything else but very basic compiler features being
+  present. While c-ares requires an ANSI C compiler to build, some of the
+  earlier ANSI compilers clearly can't deal with some preprocessor operators.
+
+* Newlines must remain unix-style for older compilers' sake.
+
+* Comments must be written in the old-style /* unnested C-fashion */
+

ares/RELEASE-NOTES

@@ -2,16 +2,20 @@ This is what's new and changed in the c-ares 1.6.1 release:
 
 Changed:
 
- o in6_addr is not used in ares.h anymore, but a private ares_in6_addr is instead
-   declared and used
+ o in6_addr is not used in ares.h anymore, but a private ares_in6_addr is
+   instead declared and used
+ o ares_gethostbyname() now supports 'AF_UNSPEC' as a family for resolving
+   either AF_INET6 or AF_INET
+ o a build-time configured ares_socklen_t is now used instead of socklen_t
 
 Fixed:
 
  o ares_parse_*_reply() functions now return ARES_EBADRESP instead of
    ARES_EBADNAME if the name in the response failed to decode
+ o only expose/export symbols starting with 'ares_'
 
 Thanks go to these friendly people for their efforts and contributions:
 
- Phil Blundell
+ Phil Blundell, Japheth Cleaver, Yang Tse, Gregor Jasny
 
 Have fun!

ares/acinclude.m4

@@ -1,52 +1,5 @@
 
 
-dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
-dnl -------------------------------------------------
-dnl Verifies if the compiler actually halts after the
-dnl compilation phase without generating any object
-dnl code file, when the source compiles with errors.
-
-AC_DEFUN([CURL_CHECK_COMPILER_HALT_ON_ERROR], [
-  AC_MSG_CHECKING([if compiler halts on compilation errors])
-  AC_COMPILE_IFELSE([
-    AC_LANG_PROGRAM([[
-    ]],[[
-      force compilation error
-    ]])
-  ],[
-    AC_MSG_RESULT([no])
-    AC_MSG_ERROR([compiler does not halt on compilation errors.])
-  ],[
-    AC_MSG_RESULT([yes])
-  ])
-])
-
-
-dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
-dnl -------------------------------------------------
-dnl Verifies if the compiler actually halts after the
-dnl compilation phase without generating any object
-dnl code file, when the source code tries to define a
-dnl type for a constant array with negative dimension.
-
-AC_DEFUN([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
-  AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
-  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
-  AC_COMPILE_IFELSE([
-    AC_LANG_PROGRAM([[
-      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
-    ]],[[
-      bad_t dummy;
-    ]])
-  ],[
-    AC_MSG_RESULT([no])
-    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
-  ],[
-    AC_MSG_RESULT([yes])
-  ])
-])
-
-
 dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
 dnl -------------------------------------------------
 dnl Use the C preprocessor to find out if the given object-style symbol
@@ -96,6 +49,72 @@ CURL_DEF_TOKEN $1
 ])
 
 
+dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C compiler to find out only if the given symbol is defined
+dnl or not, this can not find out its expansion. This macro will not use
+dnl default includes even if no INCLUDES argument is given. This macro
+dnl will run silently when invoked with three arguments.
+
+AC_DEFUN([CURL_CHECK_DEF_CC], [
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+int main (void)
+{
+#ifdef $1
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_symbol_defined="yes"
+  ],[
+    tst_symbol_defined="no"
+  ])
+  if test "$tst_symbol_defined" = "yes"; then
+    AS_VAR_SET(ac_HaveDef, yes)
+    ifelse($3,,[AC_MSG_RESULT([yes])])
+  else
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  fi
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+])
+
+
+dnl CARES_CHECK_LIB_XNET
+dnl -------------------------------------------------
+dnl Verify if X/Open network library is required.
+
+AC_DEFUN([CARES_CHECK_LIB_XNET], [
+  AC_MSG_CHECKING([if X/Open network library is required])
+  tst_lib_xnet_required="no"
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE([[
+int main (void)
+{
+#if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
+  return 0;
+#elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_lib_xnet_required="yes"
+    LIBS="$LIBS -lxnet"
+  ])
+  AC_MSG_RESULT([$tst_lib_xnet_required])
+])
+
+
 dnl CARES_CHECK_AIX_ALL_SOURCE
 dnl -------------------------------------------------
 dnl Provides a replacement of traditional AC_AIX with
@@ -360,91 +379,55 @@ AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
 ])
 
 
-dnl CURL_CHECK_TYPE_SOCKLEN_T
+dnl CURL_CHECK_HEADER_MEMORY
 dnl -------------------------------------------------
-dnl Check for existing socklen_t type, and provide
-dnl an equivalent type if socklen_t not available
+dnl Check for compilable and valid memory.h header,
+dnl and check if it is needed even with stdlib.h for
+dnl memory related functions.
 
-AC_DEFUN([CURL_CHECK_TYPE_SOCKLEN_T], [
-  AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
-  AC_CHECK_TYPE([socklen_t], ,[
-    dnl socklen_t not available
-    AC_CACHE_CHECK([for socklen_t equivalent],
-      [curl_cv_socklen_t_equiv], [
-      curl_cv_socklen_t_equiv="unknown"
-      for arg1 in 'int' 'SOCKET'; do
-        for arg2 in "struct sockaddr" void; do
-          for t in int size_t unsigned long "unsigned long"; do
-            if test "$curl_cv_socklen_t_equiv" = "unknown"; then
-              AC_COMPILE_IFELSE([
-                AC_LANG_PROGRAM([[
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#define GETPEERNCALLCONV PASCAL
-#else
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#define GETPEERNCALLCONV
-#endif
-                  extern int GETPEERNCALLCONV getpeername($arg1, $arg2 *, $t *);
-                ]],[[
-                  $t len=0;
-                  getpeername(0,0,&len);
-                ]])
-              ],[
-                curl_cv_socklen_t_equiv="$t"
-              ])
-            fi
-          done
-        done
-      done
+AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [
+  AC_CACHE_CHECK([for memory.h], [ac_cv_header_memory_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <memory.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      ac_cv_header_memory_h="yes"
+    ],[
+      ac_cv_header_memory_h="no"
     ])
-    case "$curl_cv_socklen_t_equiv" in
-      unknown)
-        AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
-        ;;
-      *)
-        AC_DEFINE_UNQUOTED(socklen_t, $curl_cv_socklen_t_equiv,
-          [Type to use in place of socklen_t when system does not provide it.])
+  ])
+  if test "$ac_cv_header_memory_h" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_MEMORY_H, 1,
+      [Define to 1 if you have the memory.h header file.])
+    #
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <stdlib.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      curl_cv_need_header_memory_h="no"
+    ],[
+      curl_cv_need_header_memory_h="yes"
+    ])
+    #
+    case "$curl_cv_need_header_memory_h" in
+      yes)
+        AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,
+          [Define to 1 if you need the memory.h header file even with stdlib.h])
         ;;
     esac
-  ],[
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#ifdef HAVE_WS2TCPIP_H
-#include <ws2tcpip.h>
-#endif
-#endif
-#else
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#endif
-  ])
+  fi
 ])
 
 
@@ -461,7 +444,6 @@ dnl argument in GETNAMEINFO_QUAL_ARG1.
 
 AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [
   AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
-  AC_REQUIRE([CURL_CHECK_TYPE_SOCKLEN_T])dnl
   AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)
   #
   AC_MSG_CHECKING([for getnameinfo])
@@ -1685,6 +1667,168 @@ AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
 ])
 
 
+dnl CARES_DEFINE_UNQUOTED (VARIABLE, [VALUE])
+dnl -------------------------------------------------
+dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
+dnl symbol that can be further used in custom template configuration
+dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
+dnl argument for the description. Symbol definitions done with this
+dnl macro are intended to be exclusively used in handcrafted *.h.in
+dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
+dnl prevents autoheader generation and insertion of symbol template
+dnl stub and definition into the first configuration header file. Do
+dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
+dnl one serves different functional needs.
+
+AC_DEFUN([CARES_DEFINE_UNQUOTED], [
+cat >>confdefs.h <<_EOF
+[@%:@define] $1 ifelse($#, 2, [$2], 1)
+_EOF
+])
+
+
+dnl CARES_CONFIGURE_LONG
+dnl -------------------------------------------------
+dnl Find out the size of long as reported by sizeof() and define
+dnl CARES_SIZEOF_LONG as appropriate to be used in template file
+dnl ares_build.h.in to properly configure the library.
+dnl The size of long is a build time characteristic and as such
+dnl must be recorded in ares_build.h
+
+AC_DEFUN([CARES_CONFIGURE_LONG], [
+  if test -z "$ac_cv_sizeof_long" ||
+    test "$ac_cv_sizeof_long" -eq "0"; then
+    AC_MSG_ERROR([cannot find out size of long.])
+  fi
+  CARES_DEFINE_UNQUOTED([CARES_SIZEOF_LONG], [$ac_cv_sizeof_long])
+])
+
+
+dnl CARES_CONFIGURE_ARES_SOCKLEN_T
+dnl -------------------------------------------------
+dnl Find out suitable ares_socklen_t data type definition and size, making
+dnl appropriate definitions for template file ares_build.h.in
+dnl to properly configure and use the library.
+dnl
+dnl The need for the ares_socklen_t definition arises mainly to properly
+dnl interface HP-UX systems which on one hand have a typedef'ed socklen_t
+dnl data type which is 32 or 64-Bit wide depending on the data model being
+dnl used, and that on the other hand is only actually used when interfacing
+dnl the X/Open sockets provided in the xnet library.
+
+AC_DEFUN([CARES_CONFIGURE_ARES_SOCKLEN_T], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_PREPROCESS_CALLCONV])dnl
+  #
+  AC_MSG_CHECKING([for ares_socklen_t data type])
+  cares_typeof_ares_socklen_t="unknown"
+  for arg1 in int SOCKET; do
+    for arg2 in 'struct sockaddr' void; do
+      for t in socklen_t int size_t 'unsigned int' long 'unsigned long' void; do
+        if test "$cares_typeof_ares_socklen_t" = "unknown"; then
+          AC_COMPILE_IFELSE([
+            AC_LANG_PROGRAM([[
+              $cares_includes_ws2tcpip
+              $cares_includes_sys_socket
+              $cares_preprocess_callconv
+              extern int FUNCALLCONV getpeername($arg1, $arg2 *, $t *);
+            ]],[[
+              $t *lenptr = 0;
+              if(0 != getpeername(0, 0, lenptr))
+                return 1;
+            ]])
+          ],[
+            cares_typeof_ares_socklen_t="$t"
+          ])
+        fi
+      done
+    done
+  done
+  for t in socklen_t int; do
+    if test "$cares_typeof_ares_socklen_t" = "void"; then
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_sys_socket
+          typedef $t ares_socklen_t;
+        ]],[[
+          ares_socklen_t dummy;
+        ]])
+      ],[
+        cares_typeof_ares_socklen_t="$t"
+      ])
+    fi
+  done
+  AC_MSG_RESULT([$cares_typeof_ares_socklen_t])
+  if test "$cares_typeof_ares_socklen_t" = "void" ||
+    test "$cares_typeof_ares_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find data type for ares_socklen_t.])
+  fi
+  #
+  AC_MSG_CHECKING([size of ares_socklen_t])
+  cares_sizeof_ares_socklen_t="unknown"
+  cares_pull_headers_socklen_t="unknown"
+  if test "$ac_cv_header_ws2tcpip_h" = "yes"; then
+    tst_pull_header_checks='none ws2tcpip'
+    tst_size_checks='4'
+  else
+    tst_pull_header_checks='none systypes syssocket'
+    tst_size_checks='4 8 2'
+  fi
+  for tst_size in $tst_size_checks; do
+    for tst_pull_headers in $tst_pull_header_checks; do
+      if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+        case $tst_pull_headers in
+          ws2tcpip)
+            tmp_includes="$cares_includes_ws2tcpip"
+            ;;
+          systypes)
+            tmp_includes="$cares_includes_sys_types"
+            ;;
+          syssocket)
+            tmp_includes="$cares_includes_sys_socket"
+            ;;
+          *)
+            tmp_includes=""
+            ;;
+        esac
+        AC_COMPILE_IFELSE([
+          AC_LANG_PROGRAM([[
+            $tmp_includes
+            typedef $cares_typeof_ares_socklen_t ares_socklen_t;
+            typedef char dummy_arr[sizeof(ares_socklen_t) == $tst_size ? 1 : -1];
+          ]],[[
+            ares_socklen_t dummy;
+          ]])
+        ],[
+          cares_sizeof_ares_socklen_t="$tst_size"
+          cares_pull_headers_socklen_t="$tst_pull_headers"
+        ])
+      fi
+    done
+  done
+  AC_MSG_RESULT([$cares_sizeof_ares_socklen_t])
+  if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find out size of ares_socklen_t.])
+  fi
+  #
+  case $cares_pull_headers_socklen_t in
+    ws2tcpip)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_WS2TCPIP_H])
+      ;;
+    systypes)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_TYPES_H])
+      ;;
+    syssocket)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_TYPES_H])
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_SOCKET_H])
+      ;;
+  esac
+  CARES_DEFINE_UNQUOTED([CARES_TYPEOF_ARES_SOCKLEN_T], [$cares_typeof_ares_socklen_t])
+  CARES_DEFINE_UNQUOTED([CARES_SIZEOF_ARES_SOCKLEN_T], [$cares_sizeof_ares_socklen_t])
+])
+
+
 dnl This macro determines if the specified struct exists in the specified file
 dnl Syntax:
 dnl CARES_CHECK_STRUCT(headers, struct name, if found, [if not found])

ares/acountry.c

@@ -116,6 +116,13 @@ int main(int argc, char **argv)
   WSAStartup(wVersionRequested, &wsaData);
 #endif
 
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
   while ((ch = ares_getopt(argc, argv, "dvh?")) != -1)
     switch (ch)
       {
@@ -178,6 +185,8 @@ int main(int argc, char **argv)
   wait_ares(channel);
   ares_destroy(channel);
 
+  ares_library_cleanup();
+
 #if defined(WIN32) && !defined(WATT32)
   WSACleanup();
 #endif
@@ -547,7 +556,7 @@ static void find_country_from_cname(const char *cname, struct in_addr addr)
   const struct search_list *country;
   char  ccode_A2[3], *ccopy, *dot_4;
   int   cnumber, z0, z1, ver_1, ver_2;
-  u_long ip;
+  unsigned long ip;
 
   ip = ntohl(addr.s_addr);
   z0 = tolower(cname[0]);

ares/adig.c

@@ -187,6 +187,13 @@ int main(int argc, char **argv)
   WSAStartup(wVersionRequested, &wsaData);
 #endif
 
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
   options.flags = ARES_FLAG_NOCHECKRESP;
   options.servers = NULL;
   options.nservers = 0;
@@ -325,6 +332,8 @@ int main(int argc, char **argv)
 
   ares_destroy(channel);
 
+  ares_library_cleanup();
+
 #ifdef USE_WINSOCK
   WSACleanup();
 #endif

ares/ahost.c

@@ -42,6 +42,7 @@
 #include "inet_ntop.h"
 #include "inet_net_pton.h"
 #include "ares_getopt.h"
+#include "ares_ipv6.h"
 
 #ifndef HAVE_STRDUP
 #  include "ares_strdup.h"
@@ -76,6 +77,13 @@ int main(int argc, char **argv)
   WSAStartup(wVersionRequested, &wsaData);
 #endif
 
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
   while ((c = ares_getopt(argc,argv,"dt:h")) != -1)
     {
       switch (c)
@@ -146,6 +154,8 @@ int main(int argc, char **argv)
 
   ares_destroy(channel);
 
+  ares_library_cleanup();
+
 #ifdef USE_WINSOCK
   WSACleanup();
 #endif

ares/ares.h

@@ -19,6 +19,10 @@
 #ifndef ARES__H
 #define ARES__H
 
+#include "ares_version.h"  /* c-ares version defines   */
+#include "ares_build.h"    /* c-ares build definitions */
+#include "ares_rules.h"    /* c-ares rules enforcement */
+
 /*
  * Define WIN32 when build target is Win32 API
  */
@@ -90,6 +94,11 @@ extern "C" {
 #define ARES_ENONAME            19
 #define ARES_EBADHINTS          20
 
+/* ares_library_init error codes */
+#define ARES_ELOADIPHLPAPI           21
+#define ARES_ELOADADVAPI32           22
+#define ARES_EADDRGetNetworkParams   23
+
 /* Flag values */
 #define ARES_FLAG_USEVC         (1 << 0)
 #define ARES_FLAG_PRIMARY       (1 << 1)
@@ -158,6 +167,11 @@ extern "C" {
 #define ARES_GETSOCK_WRITABLE(bits,num) (bits & (1 << ((num) + \
                                          ARES_GETSOCK_MAXNUM)))
 
+/* c-ares library initialization flag values */
+#define ARES_LIB_INIT_NONE   (0)
+#define ARES_LIB_INIT_WIN32  (1 << 0)
+#define ARES_LIB_INIT_ALL    (ARES_LIB_INIT_WIN32)
+
 
 /*
  * Typedef our socket type
@@ -232,6 +246,10 @@ typedef void (*ares_nameinfo_callback)(void *arg, int status, int timeouts,
 typedef int  (*ares_sock_create_callback)(ares_socket_t socket_fd,
                                           int type, void *data);
 
+int ares_library_init(int flags);
+void ares_library_cleanup(void);
+const char *ares_version(int *version);
+
 int ares_init(ares_channel *channelptr);
 int ares_init_options(ares_channel *channelptr, struct ares_options *options,
                       int optmask);
@@ -257,7 +275,7 @@ int ares_gethostbyname_file(ares_channel channel, const char *name,
 void ares_gethostbyaddr(ares_channel channel, const void *addr, int addrlen,
                         int family, ares_host_callback callback, void *arg);
 void ares_getnameinfo(ares_channel channel, const struct sockaddr *sa,
-                      socklen_t salen, int flags,
+                      ares_socklen_t salen, int flags,
                       ares_nameinfo_callback callback,
                       void *arg);
 int ares_fds(ares_channel channel, fd_set *read_fds, fd_set *write_fds);

ares/ares__get_hostent.c

@@ -47,7 +47,7 @@ int ares__get_hostent(FILE *fp, int family, struct hostent **host)
   int status, linesize, end_at_hostname, naliases;
   struct in_addr addr;
   struct in6_addr addr6;
-  int addrlen = sizeof(struct in_addr);
+  size_t addrlen = sizeof(struct in_addr);
   struct hostent *hostent = NULL;
 
   while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
@@ -68,17 +68,21 @@ int ares__get_hostent(FILE *fp, int family, struct hostent **host)
       *p = 0;
       addr.s_addr = inet_addr(line);
       if (addr.s_addr == INADDR_NONE)
-       {
-          if (ares_inet_pton(AF_INET6, line, &addr6) > 0)
-            {
-              if (family != AF_INET6)
-                continue;
-              addrlen = sizeof(struct in6_addr);
-            }
-          else
-            continue;
-       }
+      {
+        /* It wasn't an AF_INET dotted address, then AF_UNSPEC and AF_INET6
+           families are subject for this further check */
+        if ((family != AF_INET) &&
+            (ares_inet_pton(AF_INET6, line, &addr6) > 0)) {
+          addrlen = sizeof(struct in6_addr);
+          family = AF_INET6;
+        }
+        else
+          continue;
+      }
+      else if (family == AF_UNSPEC)
+        family = AF_INET; /* now confirmed! */
       else if (family != AF_INET)
+        /* unknown, keep moving */
         continue;
 
       /* Get the canonical hostname. */
@@ -158,7 +162,7 @@ int ares__get_hostent(FILE *fp, int family, struct hostent **host)
       hostent->h_aliases[naliases] = NULL;
 
       hostent->h_addrtype = family;
-      hostent->h_length = addrlen;
+      hostent->h_length = (int)addrlen;
       if (family == AF_INET)
         memcpy(hostent->h_addr_list[0], &addr, addrlen);
       else if (family == AF_INET6)

ares/ares_build.h.dist

@@ -0,0 +1,253 @@
+#ifndef __CARES_BUILD_H
+#define __CARES_BUILD_H
+
+/* $Id$ */
+
+/* Copyright (C) 2009 by Daniel Stenberg et al
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * See file ares_build.h.in, run configure, and forget that this file
+ * exists it is only used for non-configure systems.
+ * But you can keep reading if you want ;-)
+ *
+ */
+
+/* ================================================================ */
+/*                 NOTES FOR NON-CONFIGURE SYSTEMS                  */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * c-ares library user nor by the c-ares library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the c-ares development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/c-ares/
+ *
+ * Try to keep one section per platform, compiler and architecture,
+ * otherwise, if an existing section is reused for a different one and
+ * later on the original is adjusted, probably the piggybacking one can
+ * be adversely changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures
+ * use only compiler built in predefined preprocessor symbols.
+ *
+ * This header file shall only export symbols which are 'cares' or 'CARES'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file ares_build.h.dist or ares_build.h,
+ * this is due to the following reason: file ares_build.h.dist is renamed
+ * to ares_build.h when the c-ares source code distribution archive file is
+ * created.
+ *
+ * File ares_build.h.dist is not included in the distribution archive.
+ * File ares_build.h is not present in the CVS tree.
+ *
+ * The distributed ares_build.h file is only intended to be used on systems
+ * which can not run the also distributed configure script.
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed ares_build.h file with one that is suitable
+ * and specific to the library being configured and built, which is generated
+ * from the ares_build.h.in template file.
+ *
+ * If you check out from CVS on a non-configure platform, you must run the
+ * appropriate buildconf* script to set up ares_build.h and other local files.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CARES_SIZEOF_LONG
+#  error "CARES_SIZEOF_LONG shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CARES_TYPEOF_ARES_SOCKLEN_T
+#  error "CARES_TYPEOF_ARES_SOCKLEN_T shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CARES_SIZEOF_ARES_SOCKLEN_T
+#  error "CARES_SIZEOF_ARES_SOCKLEN_T shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_SIZEOF_ARES_SOCKLEN_T_already_defined
+#endif
+
+/* ================================================================ */
+/*    EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY    */
+/* ================================================================ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__SALFORDC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__BORLANDC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__TURBOC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__WATCOMC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__POCC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__LCC__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__SYMBIAN32__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T unsigned int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__MWERKS__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(_WIN32_WCE)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__MINGW32__)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__VMS)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T unsigned int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CARES_SIZEOF_LONG           4
+#    define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t
+#    define CARES_SIZEOF_ARES_SOCKLEN_T 4
+#    define CARES_PULL_SYS_TYPES_H      1
+#    define CARES_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CARES_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CARES_SIZEOF_LONG           8
+#    endif
+#    define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t
+#    define CARES_SIZEOF_ARES_SOCKLEN_T 4
+#    define CARES_PULL_SYS_TYPES_H      1
+#    define CARES_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CARES_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CARES_SIZEOF_LONG           8
+#    endif
+#    define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t
+#    define CARES_SIZEOF_ARES_SOCKLEN_T 4
+#    define CARES_PULL_SYS_TYPES_H      1
+#    define CARES_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CARES_SIZEOF_LONG           8
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  define CARES_SIZEOF_LONG           4
+#  define CARES_TYPEOF_ARES_SOCKLEN_T int
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__)
+#  if defined(__i386__) || defined(__ppc__)
+#    define CARES_SIZEOF_LONG           4
+#  elif defined(__x86_64__) || defined(__ppc64__)
+#    define CARES_SIZEOF_LONG           8
+#  endif
+#  define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t
+#  define CARES_SIZEOF_ARES_SOCKLEN_T 4
+#  define CARES_PULL_SYS_TYPES_H      1
+#  define CARES_PULL_SYS_SOCKET_H     1
+
+#else
+#  error "Unknown non-configure build target!"
+   Error Compilation_aborted_Unknown_non_configure_build_target
+#endif
+
+/* CARES_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below.  */
+#ifdef CARES_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CARES_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below.  */
+#ifdef CARES_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of ares_socklen_t. */
+
+#ifdef CARES_TYPEOF_ARES_SOCKLEN_T
+  typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
+#endif
+
+#endif /* __CARES_BUILD_H */

ares/ares_build.h.in

@@ -0,0 +1,111 @@
+#ifndef __CARES_BUILD_H
+#define __CARES_BUILD_H
+
+/* $Id$ */
+
+/* Copyright (C) 2009 by Daniel Stenberg et al
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * c-ares library user nor by the c-ares library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the c-ares development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/c-ares/
+ *
+ * This header file shall only export symbols which are 'cares' or 'CARES'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file ares_build.h.in or ares_build.h,
+ * this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed ares_build.h file with one that is suitable
+ * and specific to the library being configured and built, which is generated
+ * from the ares_build.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CARES_SIZEOF_LONG
+#  error "CARES_SIZEOF_LONG shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CARES_TYPEOF_ARES_SOCKLEN_T
+#  error "CARES_TYPEOF_ARES_SOCKLEN_T shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CARES_SIZEOF_ARES_SOCKLEN_T
+#  error "CARES_SIZEOF_ARES_SOCKLEN_T shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_SIZEOF_ARES_SOCKLEN_T_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file ws2tcpip.h must be included by the external interface. */
+#undef CARES_PULL_WS2TCPIP_H
+#ifdef CARES_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#undef CARES_PULL_SYS_TYPES_H
+#ifdef CARES_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system    */
+/* header file sys/socket.h must be included by the external interface. */
+#undef CARES_PULL_SYS_SOCKET_H
+#ifdef CARES_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#undef CARES_SIZEOF_LONG
+
+/* Integral data type used for ares_socklen_t. */
+#undef CARES_TYPEOF_ARES_SOCKLEN_T
+
+/* The size of `ares_socklen_t', as computed by sizeof. */
+#undef CARES_SIZEOF_ARES_SOCKLEN_T
+
+/* Data type definition of ares_socklen_t. */
+typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
+
+#endif /* __CARES_BUILD_H */

ares/ares_gethostbyaddr.c

@@ -145,16 +145,23 @@ static void addr_callback(void *arg, int status, int timeouts,
 {
   struct addr_query *aquery = (struct addr_query *) arg;
   struct hostent *host;
+  size_t addrlen;
 
   aquery->timeouts += timeouts;
   if (status == ARES_SUCCESS)
     {
       if (aquery->addr.family == AF_INET)
-        status = ares_parse_ptr_reply(abuf, alen, &aquery->addr.addrV4,
-                                      sizeof(struct in_addr), AF_INET, &host);
+        {
+          addrlen = sizeof(struct in_addr);
+          status = ares_parse_ptr_reply(abuf, alen, &aquery->addr.addrV4,
+                                        (int)addrlen, AF_INET, &host);
+        }
       else
-        status = ares_parse_ptr_reply(abuf, alen, &aquery->addr.addrV6,
-                                      sizeof(struct in6_addr), AF_INET6, &host);
+        {
+          addrlen = sizeof(struct in6_addr);
+          status = ares_parse_ptr_reply(abuf, alen, &aquery->addr.addrV6,
+                                        (int)addrlen, AF_INET6, &host);
+        }
       end_aquery(aquery, status, host);
     }
   else if (status == ARES_EDESTRUCTION)

ares/ares_gethostbyname.c

@@ -61,7 +61,8 @@ struct host_query {
   char *name;
   ares_host_callback callback;
   void *arg;
-  int family;
+  int sent_family; /* this family is what was is being used */
+  int want_family; /* this family is what is asked for in the API */
   const char *remaining_lookups;
   int timeouts;
 };
@@ -71,29 +72,34 @@ static void host_callback(void *arg, int status, int timeouts,
                           unsigned char *abuf, int alen);
 static void end_hquery(struct host_query *hquery, int status,
                        struct hostent *host);
-static int fake_hostent(const char *name, int family, ares_host_callback callback,
-                        void *arg);
+static int fake_hostent(const char *name, int family,
+                        ares_host_callback callback, void *arg);
 static int file_lookup(const char *name, int family, struct hostent **host);
-static void sort_addresses(struct hostent *host, const struct apattern *sortlist,
-                           int nsort);
-static void sort6_addresses(struct hostent *host, const struct apattern *sortlist,
-                           int nsort);
-static int get_address_index(const struct in_addr *addr, const struct apattern *sortlist,
-                             int nsort);
-static int get6_address_index(const struct in6_addr *addr, const struct apattern *sortlist,
-                             int nsort);
+static void sort_addresses(struct hostent *host,
+                           const struct apattern *sortlist, int nsort);
+static void sort6_addresses(struct hostent *host,
+                            const struct apattern *sortlist, int nsort);
+static int get_address_index(const struct in_addr *addr,
+                             const struct apattern *sortlist, int nsort);
+static int get6_address_index(const struct in6_addr *addr,
+                              const struct apattern *sortlist, int nsort);
 
 void ares_gethostbyname(ares_channel channel, const char *name, int family,
                         ares_host_callback callback, void *arg)
 {
   struct host_query *hquery;
 
-  /* Right now we only know how to look up Internet addresses. */
-  if (family != AF_INET && family != AF_INET6)
-    {
-      callback(arg, ARES_ENOTIMP, 0, NULL);
-      return;
-    }
+  /* Right now we only know how to look up Internet addresses - and unspec
+     means try both basically. */
+  switch (family) {
+  case AF_INET:
+  case AF_INET6:
+  case AF_UNSPEC:
+    break;
+  default:
+    callback(arg, ARES_ENOTIMP, 0, NULL);
+    return;
+  }
 
   if (fake_hostent(name, family, callback, arg))
     return;
@@ -107,13 +113,13 @@ void ares_gethostbyname(ares_channel channel, const char *name, int family,
     }
   hquery->channel = channel;
   hquery->name = strdup(name);
-  hquery->family = family;
-  if (!hquery->name)
-    {
-      free(hquery);
-      callback(arg, ARES_ENOMEM, 0, NULL);
-      return;
-    }
+  hquery->want_family = family;
+  hquery->sent_family = -1; /* nothing is sent yet */
+  if (!hquery->name) {
+    free(hquery);
+    callback(arg, ARES_ENOMEM, 0, NULL);
+    return;
+  }
   hquery->callback = callback;
   hquery->arg = arg;
   hquery->remaining_lookups = channel->lookups;
@@ -136,17 +142,23 @@ static void next_lookup(struct host_query *hquery, int status_code)
         case 'b':
           /* DNS lookup */
           hquery->remaining_lookups = p + 1;
-          if (hquery->family == AF_INET6)
+          if ((hquery->want_family == AF_INET6) ||
+              (hquery->want_family == AF_UNSPEC)) {
+            /* if inet6 or unspec, start out with AAAA */
+            hquery->sent_family = AF_INET6;
             ares_search(hquery->channel, hquery->name, C_IN, T_AAAA,
                         host_callback, hquery);
-          else
+          }
+          else {
+            hquery->sent_family = AF_INET;
             ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
                         hquery);
+          }
           return;
 
         case 'f':
           /* Host file lookup */
-          status = file_lookup(hquery->name, hquery->family, &host);
+          status = file_lookup(hquery->name, hquery->want_family, &host);
 
           /* this status check below previously checked for !ARES_ENOTFOUND,
              but we should not assume that this single error code is the one
@@ -173,33 +185,34 @@ static void host_callback(void *arg, int status, int timeouts,
   hquery->timeouts += timeouts;
   if (status == ARES_SUCCESS)
     {
-      if (hquery->family == AF_INET)
+      if (hquery->sent_family == AF_INET)
         {
           status = ares_parse_a_reply(abuf, alen, &host, NULL, NULL);
           if (host && channel->nsort)
             sort_addresses(host, channel->sortlist, channel->nsort);
         }
-      else if (hquery->family == AF_INET6)
+      else if (hquery->sent_family == AF_INET6)
         {
           status = ares_parse_aaaa_reply(abuf, alen, &host, NULL, NULL);
-          if (status == ARES_ENODATA)
-            {
-              /* The query returned something (e.g. CNAME) but there were no
-                 AAAA records.  Try looking up A instead.  */
-              hquery->family = AF_INET;
-              ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
-                          hquery);
-              return;
-            }
+          if (status == ARES_ENODATA || status == ARES_EBADRESP) {
+            /* The query returned something but either there were no AAAA records (e.g. just CNAME) 
+               or the response was malformed.  Try looking up A instead.  
+               We should possibly limit this attempt-next logic to AF_UNSPEC lookups only. */
+            hquery->sent_family = AF_INET;
+            ares_search(hquery->channel, hquery->name, C_IN, T_A,
+                        host_callback, hquery);
+            return;
+          }
           if (host && channel->nsort)
             sort6_addresses(host, channel->sortlist, channel->nsort);
         }
       end_hquery(hquery, status, host);
     }
-  else if (status == ARES_ENODATA && hquery->family == AF_INET6)
+  else if ((status == ARES_ENODATA || status == ARES_EBADRESP || status == ARES_ETIMEOUT) && hquery->sent_family == AF_INET6)
     {
-      /* There was no AAAA. Now lookup an A */
-      hquery->family = AF_INET;
+      /* The AAAA query yielded no useful result.  Now look up an A instead.  
+         We should possibly limit this attempt-next logic to AF_UNSPEC lookups only. */
+      hquery->sent_family = AF_INET;
       ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
                   hquery);
     }
@@ -262,12 +275,12 @@ static int fake_hostent(const char *name, int family, ares_host_callback callbac
 
   if (family == AF_INET)
     {
-      hostent.h_length = sizeof(struct in_addr);
+      hostent.h_length = (int)sizeof(struct in_addr);
       addrs[0] = (char *)∈
     }
   else if (family == AF_INET6)
     {
-      hostent.h_length = sizeof(struct in6_addr);
+      hostent.h_length = (int)sizeof(struct in6_addr);
       addrs[0] = (char *)&in6;
     }
   /* Duplicate the name, to avoid a constness violation. */

ares/ares_getnameinfo.3

@@ -14,7 +14,7 @@
 .\" this software for any purpose.  It is provided "as is"
 .\" without express or implied warranty.
 .\"
-.TH ARES_GETNAMEINFO 3 "16 May 2005"
+.TH ARES_GETNAMEINFO 3 "1 May 2009"
 .SH NAME
 ares_getnameinfo \- Address-to-nodename translation in protocol-independent manner
 .SH SYNOPSIS
@@ -25,7 +25,7 @@ ares_getnameinfo \- Address-to-nodename translation in protocol-independent mann
 .B	int \fItimeouts\fP, char *\fInode\fP, char *\fIservice\fP)
 .PP
 .B void ares_getnameinfo(ares_channel \fIchannel\fP, const struct sockaddr *\fIsa\fP,
-.B 	socklen_t \fIsalen\fP, int \fIflags\fP, ares_nameinfo_callback \fIcallback\fP,
+.B 	ares_socklen_t \fIsalen\fP, int \fIflags\fP, ares_nameinfo_callback \fIcallback\fP,
 .B 	void *\fIarg\fP)
 .fi
 .SH DESCRIPTION

ares/ares_getnameinfo.c

@@ -92,7 +92,8 @@ static void append_scopeid(struct sockaddr_in6 *addr6, unsigned int scopeid,
 #endif
 static char *ares_striendstr(const char *s1, const char *s2);
 
-void ares_getnameinfo(ares_channel channel, const struct sockaddr *sa, socklen_t salen,
+void ares_getnameinfo(ares_channel channel, const struct sockaddr *sa,
+                      ares_socklen_t salen,
                       int flags, ares_nameinfo_callback callback, void *arg)
 {
   struct sockaddr_in *addr = NULL;

ares/ares_init.c

@@ -1,7 +1,7 @@
 /* $Id$ */
 
 /* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2007-2008 by Daniel Stenberg
+ * Copyright (C) 2007-2009 by Daniel Stenberg
  *
  * Permission to use, copy, modify, and distribute this
  * software and its documentation for any purpose and without
@@ -20,7 +20,6 @@
 
 #if defined(WIN32) && !defined(WATT32)
 #include <iphlpapi.h>
-#include <malloc.h>
 #endif
 
 #ifdef HAVE_SYS_PARAM_H
@@ -68,6 +67,7 @@
 #include <errno.h>
 #include "ares.h"
 #include "inet_net_pton.h"
+#include "ares_library_init.h"
 #include "ares_private.h"
 
 #ifdef WATT32
@@ -559,11 +559,8 @@ static int get_res_interfaces_nt(HKEY hKey, const char *subkey, char **obuf)
 
 static int get_iphlpapi_dns_info (char *ret_buf, size_t ret_size)
 {
-  FIXED_INFO    *fi   = alloca (sizeof(*fi));
+  FIXED_INFO    *fi, *newfi;
   DWORD          size = sizeof (*fi);
-  typedef DWORD (WINAPI* get_net_param_func) (FIXED_INFO*, DWORD*);
-  get_net_param_func fpGetNetworkParams;  /* available only on Win-98/2000+ */
-  HMODULE        handle;
   IP_ADDR_STRING *ipAddr;
   int            i, count = 0;
   int            debug  = 0;
@@ -572,23 +569,21 @@ static int get_iphlpapi_dns_info (char *ret_buf, size_t ret_size)
   char          *ret = ret_buf;
   HRESULT        res;
 
+  fi = malloc(size);
   if (!fi)
-     return (0);
-
-  handle = LoadLibrary ("iphlpapi.dll");
-  if (!handle)
-     return (0);
-
-  fpGetNetworkParams = (get_net_param_func) GetProcAddress (handle, "GetNetworkParams");
-  if (!fpGetNetworkParams)
-     goto quit;
+     return 0;
 
   res = (*fpGetNetworkParams) (fi, &size);
   if ((res != ERROR_BUFFER_OVERFLOW) && (res != ERROR_SUCCESS))
      goto quit;
 
-  fi = alloca (size);
-  if (!fi || (*fpGetNetworkParams) (fi, &size) != ERROR_SUCCESS)
+  newfi = realloc(fi, size);
+  if (!newfi)
+     goto quit;
+
+  fi = newfi;
+  res = (*fpGetNetworkParams) (fi, &size);
+  if (res != ERROR_SUCCESS)
      goto quit;
 
   if (debug)
@@ -621,14 +616,14 @@ static int get_iphlpapi_dns_info (char *ret_buf, size_t ret_size)
   }
 
 quit:
-  if (handle)
-     FreeLibrary (handle);
+  if (fi)
+     free(fi);
 
   if (debug && left <= ip_size)
      printf ("Too many nameservers. Truncating to %d addressess", count);
   if (ret > ret_buf)
      ret[-1] = '\0';
-  return (count);
+  return count;
 }
 #endif
 
@@ -1490,15 +1485,13 @@ static void randomize_key(unsigned char* key,int key_data_len)
   int randomized = 0;
   int counter=0;
 #ifdef WIN32
-  HMODULE lib=LoadLibrary("ADVAPI32.DLL");
-  if (lib) {
-    BOOLEAN (APIENTRY *pfn)(void*, ULONG) =
-      (BOOLEAN (APIENTRY *)(void*,ULONG))GetProcAddress(lib,"SystemFunction036");
-    if (pfn && pfn(key,key_data_len) )
-      randomized = 1;
-
-    FreeLibrary(lib);
-  }
+  BOOLEAN res;
+  if (fpSystemFunction036)
+    {
+      res = (*fpSystemFunction036) (key, key_data_len);
+      if (res)
+        randomized = 1;
+    }
 #else /* !WIN32 */
 #ifdef RANDOM_FILE
   FILE *f = fopen(RANDOM_FILE, "rb");

ares/ares_ipv6.h

@@ -49,7 +49,7 @@ struct addrinfo
   int              ai_family;
   int              ai_socktype;
   int              ai_protocol;
-  socklen_t        ai_addrlen;   /* Follow rfc3493 struct addrinfo */
+  ares_socklen_t   ai_addrlen;   /* Follow rfc3493 struct addrinfo */
   char            *ai_canonname;
   struct sockaddr *ai_addr;
   struct addrinfo *ai_next;

ares/ares_library_init.c

@@ -0,0 +1,109 @@
+/* $Id$ */
+
+#include "setup.h"
+
+#include "ares.h"
+#include "ares_library_init.h"
+#include "ares_private.h"
+
+/* library-private global and unique instance vars */
+
+#ifdef WIN32
+fpGetNetworkParams_t fpGetNetworkParams = ZERO_NULL;
+fpSystemFunction036_t fpSystemFunction036 = ZERO_NULL;
+#endif
+
+/* library-private global vars with source visibility restricted to this file */
+
+static unsigned int ares_initialized;
+static int          ares_init_flags;
+
+#ifdef WIN32
+static HMODULE hnd_iphlpapi;
+static HMODULE hnd_advapi32;
+#endif
+
+
+static int ares_win32_init(void)
+{
+#ifdef WIN32
+
+  hnd_iphlpapi = 0;
+  hnd_iphlpapi = LoadLibrary("iphlpapi.dll");
+  if (!hnd_iphlpapi)
+    return ARES_ELOADIPHLPAPI;
+
+  fpGetNetworkParams = (fpGetNetworkParams_t)
+    GetProcAddress(hnd_iphlpapi, "GetNetworkParams");
+  if (!fpGetNetworkParams)
+    {
+      FreeLibrary(hnd_iphlpapi);
+      return ARES_EADDRGetNetworkParams;
+    }
+
+  hnd_advapi32 = 0;
+  hnd_advapi32 = LoadLibrary("advapi32.dll");
+  if (!hnd_advapi32)
+    {
+      FreeLibrary(hnd_iphlpapi);
+      return ARES_ELOADADVAPI32;
+    }
+
+  fpSystemFunction036 = (fpSystemFunction036_t)
+    GetProcAddress(hnd_advapi32, "SystemFunction036");
+
+  /*
+   * Intentionally avoid checking if the address of SystemFunction036, a.k.a.
+   * RtlGenRandom, has been located or not. This function is only available on
+   * WinXP and later. When unavailable c-ares uses portable rand() function.
+   */
+
+#endif
+  return ARES_SUCCESS;
+}
+
+
+static void ares_win32_cleanup(void)
+{
+#ifdef WIN32
+  if (hnd_advapi32)
+    FreeLibrary(hnd_advapi32);
+  if (hnd_iphlpapi)
+    FreeLibrary(hnd_iphlpapi);
+#endif
+}
+
+
+int ares_library_init(int flags)
+{
+  int res;
+
+  if (ares_initialized)
+    return ARES_SUCCESS;
+  ares_initialized++;
+
+  if (flags & ARES_LIB_INIT_WIN32)
+    {
+      res = ares_win32_init();
+      if (res != ARES_SUCCESS)
+        return res;
+    }
+
+  ares_init_flags = flags;
+
+  return ARES_SUCCESS;
+}
+
+
+void ares_library_cleanup(void)
+{
+  if (!ares_initialized)
+    return;
+  ares_initialized--;
+
+  if (ares_init_flags & ARES_LIB_INIT_WIN32)
+    ares_win32_cleanup();
+
+  ares_init_flags = ARES_LIB_INIT_NONE;
+}
+

ares/ares_library_init.h

@@ -0,0 +1,24 @@
+#ifndef HEADER_CARES_LIBRARY_INIT_H
+#define HEADER_CARES_LIBRARY_INIT_H
+
+/* $Id$ */
+
+#include "setup.h"
+
+#ifdef WIN32
+
+#include <iphlpapi.h>
+
+typedef DWORD (WINAPI *fpGetNetworkParams_t) (FIXED_INFO*, DWORD*);
+typedef BOOLEAN (APIENTRY *fpSystemFunction036_t) (void*, ULONG);
+
+/* Forward-declaration of variables defined in ares_library_init.c */
+/* that are global and unique instances for whole c-ares library.  */
+
+extern fpGetNetworkParams_t fpGetNetworkParams;
+extern fpSystemFunction036_t fpSystemFunction036;
+
+#endif /* WIN32 */
+
+#endif /* HEADER_CARES_LIBRARY_INIT_H */
+

ares/ares_parse_a_reply.c

@@ -44,7 +44,10 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <limits.h>
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
 #include "ares.h"
 #include "ares_dns.h"
 #include "ares_private.h"

ares/ares_parse_aaaa_reply.c

@@ -44,7 +44,10 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <limits.h>
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
 #include "ares.h"
 #include "ares_dns.h"
 #include "inet_net_pton.h"

ares/ares_process.c

@@ -1,7 +1,7 @@
 /* $Id$ */
 
 /* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2004-2008 by Daniel Stenberg
+ * Copyright (C) 2004-2009 by Daniel Stenberg
  *
  * Permission to use, copy, modify, and distribute this
  * software and its documentation for any purpose and without
@@ -104,7 +104,7 @@ static void end_query(ares_channel channel, struct query *query, int status,
 int ares__timedout(struct timeval *now,
                    struct timeval *check)
 {
-  int secs = (now->tv_sec - check->tv_sec);
+  long secs = (now->tv_sec - check->tv_sec);
 
   if(secs > 0)
     return 1; /* yes, timed out */
@@ -429,7 +429,7 @@ static void read_udp_packets(ares_channel channel, fd_set *read_fds,
   unsigned char buf[PACKETSZ + 1];
 #ifdef HAVE_RECVFROM
   struct sockaddr_in from;
-  socklen_t fromlen;
+  ares_socklen_t fromlen;
 #endif
 
   if(!read_fds && (read_fd == ARES_SOCKET_BAD))

ares/ares_rules.h

@@ -0,0 +1,145 @@
+#ifndef __CARES_RULES_H
+#define __CARES_RULES_H
+
+/* $Id$ */
+
+/* Copyright (C) 2009 by Daniel Stenberg et al
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/* ================================================================ */
+/*                    COMPILE TIME SANITY CHECKS                    */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by ares.h when an application is
+ * being built using an already built c-ares library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the ares_build.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * c-ares library user nor by the c-ares library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the c-ares development mailing list:
+ * http://cool.haxx.se/mailman/listinfo/c-ares/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependant but it will be quite similar to one of the following:
+ *
+ *   "negative subscript or subscript is too large"
+ *   "array must have at least one element"
+ *   "-1 is an illegal array size"
+ *   "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built c-ares library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CARES_SIZEOF_LONG
+#  error "CARES_SIZEOF_LONG definition is missing!"
+   Error Compilation_aborted_CARES_SIZEOF_LONG_is_missing
+#endif
+
+#ifndef CARES_TYPEOF_ARES_SOCKLEN_T
+#  error "CARES_TYPEOF_ARES_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CARES_SIZEOF_ARES_SOCKLEN_T
+#  error "CARES_SIZEOF_ARES_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CARES_SIZEOF_ARES_SOCKLEN_T_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CareschkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CareschkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for long
+ * is the same as the one reported by sizeof() at compile time.
+ */
+
+typedef char
+  __cares_rule_01__
+    [CareschkszEQ(long, CARES_SIZEOF_LONG)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * ares_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __cares_rule_02__
+    [CareschkszEQ(ares_socklen_t, CARES_SIZEOF_ARES_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of ares_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __cares_rule_03__
+    [CareschkszGE(ares_socklen_t, int)];
+
+/* ================================================================ */
+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
+/* ================================================================ */
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CareschkszEQ
+#undef CareschkszGE
+
+/*
+ * Get rid of macros not intended to exist beyond this point.
+ */
+
+#undef CARES_PULL_WS2TCPIP_H
+#undef CARES_PULL_SYS_TYPES_H
+#undef CARES_PULL_SYS_SOCKET_H
+
+#undef CARES_TYPEOF_ARES_SOCKLEN_T
+
+#endif /* __CARES_RULES_H */

ares/ares_strerror.c

@@ -43,7 +43,10 @@ const char *ares_strerror(int code)
     "Misformatted string",
     "Illegal flags specified",
     "Given hostname is not numeric",
-    "Illegal hints flags specified"
+    "Illegal hints flags specified",
+    "Error loading iphlpapi.dll",
+    "Error loading advapi32.dll",
+    "Could not find GetNetworkParams function"
   };
 
   if(code >= 0 && code < (int)(sizeof(errtext) / sizeof(*errtext)))

ares/ares_version.c

@@ -1,7 +1,7 @@
 /* $Id$ */
 
 #include "setup.h"
-#include "ares_version.h"
+#include "ares.h"
 
 const char *ares_version(int *version)
 {

ares/ares_version.h

@@ -11,15 +11,12 @@
                        (ARES_VERSION_PATCH))
 #define ARES_VERSION_STR "1.6.1-CVS"
 
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-const char *ares_version(int *version);
-
-#ifdef  __cplusplus
-}
+#if (ARES_VERSION >= 0x010601)
+#  define CARES_HAVE_ARES_LIBRARY_INIT 1
+#  define CARES_HAVE_ARES_LIBRARY_CLEANUP 1
+#else
+#  undef CARES_HAVE_ARES_LIBRARY_INIT
+#  undef CARES_HAVE_ARES_LIBRARY_CLEANUP
 #endif
 
 #endif
-

ares/ares_writev.c

@@ -18,7 +18,10 @@
 
 #include "setup.h"
 
-#include <limits.h>
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
 #include "ares.h"
 #include "ares_private.h"
 

ares/buildconf.bat

@@ -0,0 +1,8 @@
+@echo off
+REM set up a CVS tree to build when there's no autotools
+REM $Revision$
+REM $Date$
+
+REM create ares_build.h
+copy /Y ares_build.h.dist ares_build.h
+

ares/config-win32.h

@@ -29,6 +29,9 @@
 #define HAVE_GETOPT_H 1
 #endif
 
+/* Define if you have the <limits.h> header file.  */
+#define HAVE_LIMITS_H 1
+
 /* Define if you have the <signal.h> header file. */
 #define HAVE_SIGNAL_H 1
 
@@ -223,17 +226,33 @@
 #define _CRT_NONSTDC_NO_DEPRECATE 1
 #endif
 
-/* VS2008 does not support Windows build targets prior to WinXP, */
-/* so, if no build target has been defined we will target WinXP. */
+/* Officially, Microsoft's Windows SDK versions 6.X do not support Windows
+   2000 as a supported build target. VS2008 default installations provide an
+   embedded Windows SDK v6.0A along with the claim that Windows 2000 is a
+   valid build target for VS2008. Popular belief is that binaries built using
+   Windows SDK versions 6.X and Windows 2000 as a build target are functional */
+#if defined(_MSC_VER) && (_MSC_VER >= 1500)
+#  define VS2008_MINIMUM_TARGET 0x0500
+#endif
+
+/* When no build target is specified VS2008 default build target is Windows
+   Vista, which leaves out even Winsows XP. If no build target has been given
+   for VS2008 we will target the minimum Officially supported build target,
+   which happens to be Windows XP. */
+#if defined(_MSC_VER) && (_MSC_VER >= 1500)
+#  define VS2008_DEFAULT_TARGET  0x0501
+#endif
+
+/* VS2008 default target settings and minimum build target check */
 #if defined(_MSC_VER) && (_MSC_VER >= 1500)
 #  ifndef _WIN32_WINNT
-#    define _WIN32_WINNT 0x0501
+#    define _WIN32_WINNT VS2008_DEFAULT_TARGET
 #  endif
 #  ifndef WINVER
-#    define WINVER 0x0501
+#    define WINVER VS2008_DEFAULT_TARGET
 #  endif
-#  if (_WIN32_WINNT < 0x0501) || (WINVER < 0x0501)
-#    error VS2008 does not support Windows build targets prior to WinXP
+#  if (_WIN32_WINNT < VS2008_MINIMUM_TARGET) || (WINVER < VS2008_MINIMUM_TARGET)
+#    error VS2008 does not support Windows build targets prior to Windows 2000
 #  endif
 #endif
 

ares/configure.ac

@@ -7,7 +7,7 @@ AC_INIT([c-ares], [-],
 CARES_OVERRIDE_AUTOCONF
 
 AC_CONFIG_SRCDIR([ares_ipv6.h])
-AM_CONFIG_HEADER([config.h])
+AM_CONFIG_HEADER([config.h ares_build.h])
 AM_MAINTAINER_MODE
 
 CARES_CHECK_OPTION_DEBUG
@@ -158,8 +158,8 @@ case $host in
   #
 esac
 
-CURL_CHECK_COMPILER_HALT_ON_ERROR
-CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
+CARES_CHECK_COMPILER_HALT_ON_ERROR
+CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
 
 dnl **********************************************************************
 dnl Compilation based checks should not be done before this point.
@@ -191,6 +191,8 @@ dnl **********************************************************************
 dnl Checks for libraries.
 dnl **********************************************************************
 
+CARES_CHECK_LIB_XNET
+
 dnl gethostbyname without lib or in the nsl lib?
 AC_CHECK_FUNC(gethostbyname,
               [HAVE_GETHOSTBYNAME="1"
@@ -430,6 +432,7 @@ dnl Checks for header files.
 AC_HEADER_STDC
 
 CURL_CHECK_HEADER_MALLOC
+CURL_CHECK_HEADER_MEMORY
 
 dnl check for a few basic system headers we need
 AC_CHECK_HEADERS(
@@ -448,6 +451,7 @@ AC_CHECK_HEADERS(
        strings.h \
        stdbool.h \
        time.h \
+       limits.h \
        arpa/nameser.h \
        arpa/nameser_compat.h \
        arpa/inet.h,
@@ -487,7 +491,9 @@ AC_HEADER_TIME
 CURL_CHECK_STRUCT_TIMEVAL
 
 AC_CHECK_SIZEOF(size_t)
+AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
+CARES_CONFIGURE_LONG
 AC_CHECK_SIZEOF(time_t)
 
 AC_CHECK_TYPE(long long,
@@ -523,8 +529,7 @@ AC_CHECK_TYPE([bool],[
 #endif
 ])
 
-# Check for socklen_t or equivalent
-CURL_CHECK_TYPE_SOCKLEN_T
+CARES_CONFIGURE_ARES_SOCKLEN_T
 
 TYPE_IN_ADDR_T
 
@@ -743,7 +748,7 @@ AC_CHECK_FUNCS([bitncmp \
   ],[
     AC_MSG_RESULT([yes])
     eval "ac_cv_func_$func=yes"
-    AC_DEFINE_UNQUOTED([AS_TR_CPP([HAVE_$func])], [1],
+    AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$func]), [1],
       [Define to 1 if you have the $func function.])
   ],[
     AC_MSG_RESULT([but still no])

ares/m4/.cvsignore

@@ -0,0 +1,5 @@
+libtool.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+lt~obsolete.m4

ares/m4/cares-compilers.m4

@@ -1,7 +1,7 @@
 #***************************************************************************
 # $Id$
 #
-# Copyright (C) 2008 by Daniel Stenberg et al
+# Copyright (C) 2009 by Daniel Stenberg et al
 #
 # Permission to use, copy, modify, and distribute this software and its
 # documentation for any purpose and without fee is hereby granted, provided
@@ -16,7 +16,7 @@
 #***************************************************************************
 
 # File version for 'aclocal' use. Keep it a single number.
-# serial 46
+# serial 51
 
 
 dnl CARES_CHECK_COMPILER
@@ -186,7 +186,6 @@ AC_DEFUN([CARES_CHECK_COMPILER_INTEL_C], [
   if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
     AC_MSG_RESULT([yes])
     compiler_num="$curl_cv_def___INTEL_COMPILER"
-    CURL_CHECK_DEF([__i386__], [], [silent])
     CURL_CHECK_DEF([__unix__], [], [silent])
     if test "$curl_cv_have_def___unix__" = "yes"; then
       compiler_id="INTEL_UNIX_C"
@@ -196,13 +195,6 @@ AC_DEFUN([CARES_CHECK_COMPILER_INTEL_C], [
       flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
       flags_opt_yes="-O2"
       flags_opt_off="-O0"
-      dnl icc 9.1 optimization on IA32 triggers SIGSEGV
-      if test "$curl_cv_have_def___i386__" = "yes" &&
-        test "$compiler_num" -eq "910"; then
-        INTEL_UNIX_C_OPT_SIGSEGV="yes"
-      else
-        INTEL_UNIX_C_OPT_SIGSEGV="no"
-      fi
     else
       compiler_id="INTEL_WINDOWS_C"
       flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
@@ -382,8 +374,8 @@ dnl -------------------------------------------------
 dnl Changes standard include paths present in CFLAGS
 dnl and CPPFLAGS into isystem include paths. This is
 dnl done to prevent GNUC from generating warnings on
-dnl headers from these locations, even though this is
-dnl not reliable on ancient GNUC versions.
+dnl headers from these locations, although on ancient
+dnl GNUC versions these warnings are not silenced.
 
 AC_DEFUN([CARES_CONVERT_INCLUDE_TO_ISYSTEM], [
   AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
@@ -908,11 +900,7 @@ AC_DEFUN([CARES_SET_COMPILER_WARNING_OPTS], [
         #
         if test "$want_warnings" = "yes"; then
           dnl Issue all warnings
-          dnl tmp_CFLAGS="$tmp_CFLAGS +w1"
-          dnl Due to the HP-UX socklen_t issue it is insane to use the +w1
-          dnl warning level. Until the issue is somehow fixed we will just
-          dnl use the +w2 warning level.
-          tmp_CFLAGS="$tmp_CFLAGS +w2"
+          tmp_CFLAGS="$tmp_CFLAGS +w1"
         fi
         ;;
         #
@@ -961,39 +949,6 @@ AC_DEFUN([CARES_SET_COMPILER_WARNING_OPTS], [
           dnl Disable vectorizer diagnostic information
           tmp_CFLAGS="$tmp_CFLAGS -vec-report0"
         fi
-        dnl Disable some optimizations to debug icc 9.1 SIGSEGV
-        if test "$INTEL_UNIX_C_OPT_SIGSEGV" = "yes"; then
-          dnl Disable interprocedural optimizations
-          tmp_CFLAGS="$tmp_CFLAGS -no-ip -no-ipo"
-          dnl Separate functions for the linker
-          tmp_CFLAGS="$tmp_CFLAGS -ffunction-sections"
-          dnl Disable inlining of user-defined functions
-          tmp_CFLAGS="$tmp_CFLAGS -Ob0"
-          dnl Disable inline expansion of intrinsic functions
-          tmp_CFLAGS="$tmp_CFLAGS -fno-builtin"
-          dnl Disable inlining of functions
-          tmp_CFLAGS="$tmp_CFLAGS -fno-inline"
-          dnl Disable some IPO for single file optimizations
-          tmp_CFLAGS="$tmp_CFLAGS -fno-inline-functions"
-          dnl Disable inlining of standard library functions
-          tmp_CFLAGS="$tmp_CFLAGS -nolib-inline"
-          dnl Disable full and partial inlining when IPO
-          tmp_CFLAGS="$tmp_CFLAGS -ip-no-inlining"
-          dnl Enable floating-point stack integrity checks
-          tmp_CFLAGS="$tmp_CFLAGS -fpstkchk"
-          dnl Enable run-time detection of buffer overruns.
-          tmp_CFLAGS="$tmp_CFLAGS -fstack-security-check"
-          dnl Assume aliasing in the program.
-          tmp_CFLAGS="$tmp_CFLAGS -falias"
-          dnl Assume that arguments may be aliased.
-          tmp_CFLAGS="$tmp_CFLAGS -alias-args"
-          dnl Assume aliasing within functions
-          tmp_CFLAGS="$tmp_CFLAGS -ffnalias"
-          dnl Disable prefetch insertion optimization
-          tmp_CFLAGS="$tmp_CFLAGS -no-prefetch"
-          dnl Disable loop unrolling optimization
-          tmp_CFLAGS="$tmp_CFLAGS -unroll0"
-        fi
         ;;
         #
       INTEL_WINDOWS_C)
@@ -1162,6 +1117,115 @@ AC_DEFUN([CARES_CHECK_PROG_CC], [
 ])
 
 
+dnl CARES_CHECK_COMPILER_HALT_ON_ERROR
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source compiles with errors.
+
+AC_DEFUN([CARES_CHECK_COMPILER_HALT_ON_ERROR], [
+  AC_MSG_CHECKING([if compiler halts on compilation errors])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      force compilation error
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on compilation errors.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source code tries to define a
+dnl type for a constant array with negative dimension.
+
+AC_DEFUN([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
+  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
+    ]],[[
+      bad_t dummy;
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE
+dnl -------------------------------------------------
+dnl Verifies if the compiler is capable of handling the
+dnl size of a struct member, struct which is a function
+dnl result, as a compilation-time condition inside the
+dnl type definition of a constant array.
+
+AC_DEFUN([CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
+  AC_MSG_CHECKING([if compiler struct member size checking works])
+  tst_compiler_check_one_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char good_t1[sizeof(myfunc().mi) == sizeof(int)  ? 1 : -1 ];
+      typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
+    ]],[[
+      good_t1 dummy1;
+      good_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_one_works="yes"
+  ],[
+    tst_compiler_check_one_works="no"
+    sed 's/^/cc-src: /' conftest.$ac_ext >&6
+    sed 's/^/cc-err: /' conftest.err >&6
+  ])
+  tst_compiler_check_two_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int)  ? 1 : -1 ];
+      typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
+    ]],[[
+      bad_t1 dummy1;
+      bad_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_two_works="no"
+  ],[
+    tst_compiler_check_two_works="yes"
+  ])
+  if test "$tst_compiler_check_one_works" = "yes" &&
+    test "$tst_compiler_check_two_works" = "yes"; then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler fails struct member size checking.])
+  fi
+])
+
+
 dnl CARES_VAR_MATCH (VARNAME, VALUE)
 dnl -------------------------------------------------
 dnl Verifies if shell variable VARNAME contains VALUE.

ares/m4/cares-functions.m4

@@ -1,7 +1,7 @@
 #***************************************************************************
 # $Id$
 #
-# Copyright (C) 2008 by Daniel Stenberg et al
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
 #
 # Permission to use, copy, modify, and distribute this software and its
 # documentation for any purpose and without fee is hereby granted, provided
@@ -16,7 +16,7 @@
 #***************************************************************************
 
 # File version for 'aclocal' use. Keep it a single number.
-# serial 26
+# serial 29
 
 
 dnl CARES_INCLUDES_ARPA_INET
@@ -187,6 +187,24 @@ cares_includes_sys_socket="\
 ])
 
 
+dnl CARES_INCLUDES_SYS_TYPES
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/types.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_TYPES], [
+cares_includes_sys_types="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h,
+    [], [], [$cares_includes_sys_types])
+])
+
+
 dnl CARES_INCLUDES_SYS_UIO
 dnl -------------------------------------------------
 dnl Set up variable with list of headers that must be
@@ -284,6 +302,23 @@ cares_includes_ws2tcpip="\
 ])
 
 
+dnl CARES_PREPROCESS_CALLCONV
+dnl -------------------------------------------------
+dnl Set up variable with a preprocessor block which
+dnl defines function calling convention.
+
+AC_DEFUN([CARES_PREPROCESS_CALLCONV], [
+cares_preprocess_callconv="\
+/* preprocess start */
+#ifdef HAVE_WINDOWS_H
+#  define FUNCALLCONV __stdcall
+#else
+#  define FUNCALLCONV
+#endif
+/* preprocess end */"
+])
+
+
 dnl CARES_CHECK_FUNC_FCNTL
 dnl -------------------------------------------------
 dnl Verify if fcntl is available, prototyped, and

ares/setup.h

@@ -3,7 +3,7 @@
 
 /* $Id$ */
 
-/* Copyright (C) 2004 - 2008 by Daniel Stenberg et al
+/* Copyright (C) 2004 - 2009 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose and without fee is hereby granted, provided
@@ -39,6 +39,15 @@
 
 #endif /* HAVE_CONFIG_H */
 
+/* ================================================================ */
+/* Definition of preprocessor macros/symbols which modify compiler  */
+/* behaviour or generated code characteristics must be done here,   */
+/* as appropriate, before any system header file is included. It is */
+/* also possible to have them defined in the config file included   */
+/* before this point. As a result of all this we frown inclusion of */
+/* system header files in our config files, avoid this at any cost. */
+/* ================================================================ */
+
 /*
  * Tru64 needs _REENTRANT set for a few function prototypes and
  * things to appear in the system header files. Unixware needs it
@@ -51,6 +60,29 @@
 #  endif
 #endif
 
+/* ================================================================ */
+/*  If you need to include a system header file for your platform,  */
+/*  please, do it beyond the point further indicated in this file.  */
+/* ================================================================ */
+
+/*
+ * c-ares external interface definitions are also used internally,
+ * and might also include required system header files to define them.
+ */
+
+#include <ares_build.h>
+
+/*
+ * Compile time sanity checks must also be done when building the library.
+ */
+
+#include <ares_rules.h>
+
+/* ================================================================ */
+/* No system header file shall be included in this file before this */
+/* point. The only allowed ones are those included from curlbuild.h */
+/* ================================================================ */
+
 /*
  * Include header files for windows builds before redefining anything.
  * Use this preproessor block only to include or exclude windows.h,

ares/setup_once.h

@@ -3,7 +3,7 @@
 
 /* $Id$ */
 
-/* Copyright (C) 2004 - 2008 by Daniel Stenberg et al
+/* Copyright (C) 2004 - 2009 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose and without fee is hereby granted, provided
@@ -42,6 +42,14 @@
 #include <sys/types.h>
 #endif
 
+#ifdef NEED_MALLOC_H
+#include <malloc.h>
+#endif
+
+#ifdef NEED_MEMORY_H
+#include <memory.h>
+#endif
+
 #ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
@@ -91,23 +99,6 @@ struct timeval {
 #endif
 
 
-/*
- * Windows build targets have socklen_t definition in
- * ws2tcpip.h but some versions of ws2tcpip.h do not
- * have the definition. It seems that when the socklen_t
- * definition is missing from ws2tcpip.h the definition
- * for INET_ADDRSTRLEN is also missing, and that when one
- * definition is present the other one also is available.
- */
-
-#if defined(WIN32) && !defined(HAVE_CONFIG_H)
-#  if ( defined(_MSC_VER) && !defined(INET_ADDRSTRLEN) ) || \
-      (!defined(_MSC_VER) && !defined(HAVE_WS2TCPIP_H) )
-#    define socklen_t int
-#  endif
-#endif
-
-
 #if defined(__minix)
 /* Minix doesn't support recv on TCP sockets */
 #define sread(x,y,z) (ssize_t)read((RECV_TYPE_ARG1)(x), \
@@ -436,88 +427,5 @@ typedef int sig_atomic_t;
 #define ZERO_NULL 0
 
 
-#if defined (__LP64__) && defined(__hpux) && !defined(_XOPEN_SOURCE_EXTENDED)
-#include <sys/socket.h>
-/* HP-UX has this oddity where it features a few functions that don't work
-   with socklen_t so we need to convert to ints
-
-   This is due to socklen_t being a 64bit int under 64bit ABI, but the
-   pre-xopen (default) interfaces require an int, which is 32bits.
-
-   Therefore, Anytime socklen_t is passed by pointer, the libc function
-   truncates the 64bit socklen_t value by treating it as a 32bit value.
-
-
-   Note that some socket calls are allowed to have a NULL pointer for
-   the socklen arg.
-*/
-
-inline static int Curl_hp_getsockname(int s, struct sockaddr *name,
-                                      socklen_t *namelen)
-{
-  int rc;
-  if(namelen) {
-     int len = *namelen;
-     rc = getsockname(s, name, &len);
-     *namelen = len;
-   }
-  else
-     rc = getsockname(s, name, 0);
-  return rc;
-}
-
-inline static int Curl_hp_getsockopt(int  s, int level, int optname,
-                                     void *optval, socklen_t *optlen)
-{
-  int rc;
-  if(optlen) {
-    int len = *optlen;
-    rc = getsockopt(s, level, optname, optval, &len);
-    *optlen = len;
-  }
-  else
-    rc = getsockopt(s, level, optname, optval, 0);
-  return rc;
-}
-
-inline static int Curl_hp_accept(int sockfd, struct sockaddr *addr,
-                                 socklen_t *addrlen)
-{
-  int rc;
-  if(addrlen) {
-     int len = *addrlen;
-     rc = accept(sockfd, addr, &len);
-     *addrlen = len;
-  }
-  else
-     rc = accept(sockfd, addr, 0);
-  return rc;
-}
-
-
-inline static ssize_t Curl_hp_recvfrom(int s, void *buf, size_t len, int flags,
-                                       struct sockaddr *from,
-                                       socklen_t *fromlen)
-{
-  ssize_t rc;
-  if(fromlen) {
-    int fromlen32 = *fromlen;
-    rc = recvfrom(s, buf, len, flags, from, &fromlen32);
-    *fromlen = fromlen32;
-  }
-  else {
-    rc = recvfrom(s, buf, len, flags, from, 0);
-  }
-  return rc;
-}
-
-#define getsockname(a,b,c) Curl_hp_getsockname((a),(b),(c))
-#define getsockopt(a,b,c,d,e) Curl_hp_getsockopt((a),(b),(c),(d),(e))
-#define accept(a,b,c) Curl_hp_accept((a),(b),(c))
-#define recvfrom(a,b,c,d,e,f) Curl_hp_recvfrom((a),(b),(c),(d),(e),(f))
-
-#endif /* HPUX work-around */
-
-
 #endif /* __SETUP_ONCE_H */
 

ares/vc/acountry/acountry.dsp

@@ -41,8 +41,8 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -65,8 +65,8 @@ LINK32=link.exe
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe

ares/vc/adig/adig.dsp

@@ -41,8 +41,8 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -65,8 +65,8 @@ LINK32=link.exe
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe

ares/vc/ahost/ahost.dsp

@@ -41,8 +41,8 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -65,8 +65,8 @@ LINK32=link.exe
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe

ares/vc/areslib/areslib.dsp

@@ -145,6 +145,10 @@ SOURCE=..\..\ares_init.c
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\ares_library_init.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\ares_llist.c
 # End Source File
 # Begin Source File
@@ -225,6 +229,10 @@ SOURCE=..\..\ares.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\ares_build.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\ares_dns.h
 # End Source File
 # Begin Source File
@@ -233,6 +241,10 @@ SOURCE=..\..\ares_ipv6.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\ares_library_init.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\ares_llist.h
 # End Source File
 # Begin Source File
@@ -241,6 +253,10 @@ SOURCE=..\..\ares_private.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\ares_rules.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\ares_strcasecmp.h
 # End Source File
 # Begin Source File

buildconf

@@ -277,6 +277,10 @@ for fname in .deps \
     libtool \
     libtool.m4 \
     ltmain.sh \
+    ltoptions.m4 \
+    ltsugar.m4 \
+    ltversion.m4 \
+    lt~obsolete.m4 \
     stamp-h1 \
     stamp-h2 \
     stamp-h3 ; do
@@ -290,6 +294,11 @@ done
 echo "buildconf: running libtoolize"
 $libtoolize --copy --automake --force || die "The libtoolize command failed"
 
+if test ! -f m4/curl-functions.m4; then
+  echo "buildconf: cURL m4 macros not found"
+  exit 1
+fi
+
 echo "buildconf: running aclocal"
 ${ACLOCAL:-aclocal} -I m4 $ACLOCAL_FLAGS || die "The aclocal command line failed"
 

buildconf.bat

@@ -11,3 +11,11 @@ copy Makefile.dist Makefile
 
 REM create curlbuild.h
 copy include\curl\curlbuild.h.dist include\curl\curlbuild.h
+
+REM setup c-ares CVS tree
+if not exist ares\buildconf.bat goto end_c_ares
+cd ares
+call buildconf.bat
+cd ..
+:end_c_ares
+

configure.ac

@@ -30,7 +30,7 @@ AC_INIT([curl], [-], [a suitable curl mailing list => http://curl.haxx.se/mail/]
 CURL_OVERRIDE_AUTOCONF
 
 dnl configure script copyright
-AC_COPYRIGHT([Copyright (c) 1998 - 2008 Daniel Stenberg, <daniel@haxx.se>
+AC_COPYRIGHT([Copyright (c) 1998 - 2009 Daniel Stenberg, <daniel@haxx.se>
 This configure script may be copied, distributed and modified under the
 terms of the curl license; see COPYING for more details])
 
@@ -498,6 +498,8 @@ dnl **********************************************************************
 dnl Checks for libraries.
 dnl **********************************************************************
 
+CURL_CHECK_LIB_XNET
+
 dnl gethostbyname without lib or in the nsl lib?
 AC_CHECK_FUNC(gethostbyname,
               [HAVE_GETHOSTBYNAME="1"
@@ -1171,8 +1173,11 @@ if test X"$OPT_SSL" != Xno; then
     PKGTEST="no"
     PREFIX_OPENSSL=$OPT_SSL
     LIB_OPENSSL="$PREFIX_OPENSSL/lib$libsuff"
-    LDFLAGS="$LDFLAGS -L$LIB_OPENSSL"
-    CPPFLAGS="$CPPFLAGS -I$PREFIX_OPENSSL/include/openssl -I$PREFIX_OPENSSL/include"
+    if test "$PREFIX_OPENSSL" != "/usr" ; then
+      LDFLAGS="$LDFLAGS -L$LIB_OPENSSL"
+      CPPFLAGS="$CPPFLAGS -I$PREFIX_OPENSSL/include"
+    fi
+    CPPFLAGS="$CPPFLAGS -I$PREFIX_OPENSSL/include/openssl"
     ;;
   esac
 
@@ -1491,6 +1496,9 @@ if test X"$OPT_LIBSSH2" != Xno; then
        dnl linker doesn't search through, we need to add it to LD_LIBRARY_PATH
        dnl to prevent further configure tests to fail due to this
 
+       dnl libssh2_version is a post 1.0 addition
+       AC_CHECK_FUNCS( libssh2_version )
+
        LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$LIB_LIBSSH2"
        export LD_LIBRARY_PATH
        AC_MSG_NOTICE([Added $LIB_LIBSSH2 to LD_LIBRARY_PATH])
@@ -1863,6 +1871,7 @@ dnl Checks for header files.
 AC_HEADER_STDC
 
 CURL_CHECK_HEADER_MALLOC
+CURL_CHECK_HEADER_MEMORY
 
 dnl Now check for the very most basic headers. Then we can use these
 dnl ones as default-headers when checking for the rest!
@@ -1990,8 +1999,7 @@ AC_CHECK_TYPE([bool],[
 #endif
 ])
 
-# Check for socklen_t or equivalent
-CURL_CHECK_TYPE_SOCKLEN_T
+CURL_CONFIGURE_CURL_SOCKLEN_T
 
 TYPE_IN_ADDR_T
 
@@ -2030,6 +2038,7 @@ CURL_CHECK_FUNC_IOCTL
 CURL_CHECK_FUNC_IOCTLSOCKET
 CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL
 CURL_CHECK_FUNC_LOCALTIME_R
+CURL_CHECK_FUNC_POLL
 CURL_CHECK_FUNC_SETSOCKOPT
 CURL_CHECK_FUNC_SIGACTION
 CURL_CHECK_FUNC_SIGINTERRUPT
@@ -2075,7 +2084,6 @@ AC_CHECK_FUNCS([basename \
   inet_addr \
   perror \
   pipe \
-  poll \
   setlocale \
   setmode \
   setrlimit \
@@ -2096,7 +2104,7 @@ AC_CHECK_FUNCS([basename \
     ],[
       AC_MSG_RESULT([yes])
       eval "ac_cv_func_$func=yes"
-      AC_DEFINE_UNQUOTED([AS_TR_CPP([HAVE_$func])], [1],
+      AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$func]), [1],
         [Define to 1 if you have the $func function.])
     ],[
       AC_MSG_RESULT([but still no])
@@ -2132,45 +2140,6 @@ if test "$ipv6" = "yes"; then
   CURL_CHECK_NI_WITHSCOPEID
 fi
 
-AC_MSG_CHECKING([if we are Mac OS X (to disable poll)])
-disable_poll=no
-case $host in
-  *-*-darwin*)
-    disable_poll="yes";
-    ;;
-  *)
-    ;;
-esac
-AC_MSG_RESULT($disable_poll)
-
-if test "$disable_poll" = "no"; then
-
-  dnl poll() might be badly emulated, as in Mac OS X 10.3 (and other BSDs?) and
-  dnl to find out we make an extra check here!
-  if test "$ac_cv_func_poll" = "yes"; then
-    AC_MSG_CHECKING([if poll works with NULL inputs])
-    AC_RUN_IFELSE([
-#ifdef HAVE_SYS_POLL_H
-#include <sys/poll.h>
-#elif defined(HAVE_POLL_H)
-#include <poll.h>
-#endif
-
-  int main(void)
-  {
-    /* make this return 0 == timeout since there's nothing to read from */
-    return poll((void *)0, 0, 10 /*ms*/);
-  }
-],
-    AC_MSG_RESULT(yes)
-    AC_DEFINE(HAVE_POLL_FINE, 1, [If you have a fine poll]),
-    AC_MSG_RESULT(no),
-    AC_MSG_RESULT(cross-compiling assumes yes)
-    AC_DEFINE(HAVE_POLL_FINE, 1, [If you have a fine poll])
-    ) dnl end of AC_RUN_IFELSE
-  fi dnl poll() was found
-fi dnl poll()-check is not disabled
-
 dnl ************************************************************
 dnl enable non-blocking communications
 dnl
@@ -2505,7 +2474,7 @@ fi
 if test "x$USE_WINDOWS_SSPI" = "x1"; then
   SUPPORT_FEATURES="$SUPPORT_FEATURES SSPI"
 fi
-if test "x$USE_SSLEAY" = "x1" -o "x$USE_WINDOWS_SSPI" = "x1"; then
+if test "x$USE_SSLEAY" = "x1" -o "x$USE_WINDOWS_SSPI" = "x1" -o "x$GNUTLS_ENABLED" = "x1"; then
   SUPPORT_FEATURES="$SUPPORT_FEATURES NTLM"
 fi
 
@@ -2581,7 +2550,6 @@ AC_CONFIG_FILES([Makefile \
            packages/Linux/RPM/curl.spec \
            packages/Linux/RPM/curl-ssl.spec \
            packages/Solaris/Makefile \
-           packages/DOS/Makefile \
            packages/EPM/curl.list \
            packages/EPM/Makefile \
            packages/vms/Makefile \

curl-config.in

@@ -6,7 +6,7 @@
 #                            | (__| |_| |  _ <| |___
 #                             \___|\___/|_| \_\_____|
 #
-# Copyright (C) 2001 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+# Copyright (C) 2001 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 #
 # This software is licensed as described in the file COPYING, which
 # you should have received as part of this distribution. The terms
@@ -21,10 +21,7 @@
 #
 # $Id$
 ###########################################################################
-#
-# The idea to this kind of setup info script was stolen from numerous
-# other packages, such as neon, libxml and gnome.
-#
+
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 includedir=@includedir@

curl-style.el

@@ -35,7 +35,7 @@
   (setq tab-width 8
 	indent-tabs-mode nil		; Use spaces. Not tabs.
 	comment-column 40
-	c-font-lock-extra-types (append '("bool" "CURL" "CURLcode" "ssize_t" "size_t" "socklen_t" "fd_set" "time_t" "curl_off_t" "curl_socket_t" "in_addr_t" "CURLSHcode" "CURLMcode" "Curl_addrinfo"))
+	c-font-lock-extra-types (append '("bool" "CURL" "CURLcode" "ssize_t" "size_t" "curl_socklen_t" "fd_set" "time_t" "curl_off_t" "curl_socket_t" "in_addr_t" "CURLSHcode" "CURLMcode" "Curl_addrinfo"))
 	)
   ;; keybindings for C, C++, and Objective-C.  We can put these in
   ;; c-mode-base-map because of inheritance ...

diff-exclude

@@ -0,0 +1,39 @@
+diff-exclude
+*~
+*.orig
+*.org
+*.rej
+configure
+Makefile
+Makefile.in
+*.pid
+*.bak
+*.o
+*.lo
+*.Plo
+*.Po
+config.log
+config.status
+autom4te.cache
+*.patch
+CVS
+*.asc
+config.h
+*.la
+*.lai
+libtool
+ltmain.sh
+missing
+mkinstalldirs
+.#*
+aclocal.m4
+hugehelp.c
+.deps
+.libs
+libcurl.pc
+curl-config
+stamp-h*
+curllib.dsp
+curllib.vcproj
+*.spec
+curl.list

docs/BINDINGS

@@ -32,7 +32,7 @@ C
 C++
 
   Written by Jean-Philippe Barrette-LaPierre
-  http://rrette.com/textpattern/index.php?s=cURLpp
+  http://curlpp.org/
 
 Ch
 
@@ -54,6 +54,10 @@ Dylan
   Written by Chris Double
   http://dylanlibs.sourceforge.net/
 
+Eiffel
+  Written by Eiffel Software
+  http://curl.haxx.se/libcurl/eiffel/
+
 Euphoria
 
   Written by Ray Smith

docs/FAQ

@@ -1,4 +1,4 @@
-Updated: Jan 14, 2009 (http://curl.haxx.se/docs/faq.html)
+Updated: Feb 23, 2009 (http://curl.haxx.se/docs/faq.html)
                                   _   _ ____  _
                               ___| | | |  _ \| |
                              / __| | | | |_) | |
@@ -26,7 +26,7 @@ FAQ
    2.1.2 only the libssl lib is missing
   2.2 Does curl work/build with other SSL libraries?
   2.3 Where can I find a copy of LIBEAY32.DLL?
-  2.4 Does curl support Socks (RFC 1928) ?
+  2.4 Does curl support SOCKS (RFC 1928) ?
 
  3. Usage Problems
   3.1 curl: (1) SSL is disabled, https: not supported
@@ -42,7 +42,7 @@ FAQ
   3.11 How do I POST with a different Content-Type?
   3.12 Why do FTP specific features over HTTP proxy fail?
   3.13 Why does my single/double quotes fail?
-  3.14 Does curl support javascript or pac (automated proxy config)?
+  3.14 Does curl support Javascript or PAC (automated proxy config)?
   3.15 Can I do recursive fetches with curl?
   3.16 What certificates do I need when I use SSL?
   3.17 How do I list the root dir of an FTP server?
@@ -71,6 +71,7 @@ FAQ
   4.14 Redirects work in browser but not with curl!
   4.15 FTPS doesn't work
   4.16 My HTTP POST or PUT requests are slow!
+  4.17 Non-functional connect timeouts on Windows
 
  5. libcurl Issues
   5.1 Is libcurl thread-safe?
@@ -95,7 +96,7 @@ FAQ
   6.4 I have a program that uses LGPL libraries, can I use libcurl?
   6.5 Can I modify curl/libcurl for my program and keep the changes secret?
   6.6 Can you please change the curl/libcurl license to XXXX?
-  6.7 What are my obligations when using libcurl in my commerical apps?
+  6.7 What are my obligations when using libcurl in my commercial apps?
 
  7. PHP/CURL Issues
   7.1 What is PHP/CURL?
@@ -399,7 +400,7 @@ FAQ
   accurate and up-to-date pointers to recent OpenSSL DLLs and other binary
   packages.
 
-  2.4 Does curl support Socks (RFC 1928) ?
+  2.4 Does curl support SOCKS (RFC 1928) ?
 
   Yes, SOCKS 4 and 5 are supported.
 
@@ -557,27 +558,27 @@ FAQ
   Remember that curl works and runs on more operating systems than most single
   individuals have ever tried.
 
-  3.14 Does curl support javascript or pac (automated proxy config)?
+  3.14 Does curl support Javascript or PAC (automated proxy config)?
 
-  Many web pages do magic stuff using embedded javascript. Curl and libcurl
+  Many web pages do magic stuff using embedded Javascript. Curl and libcurl
   have no built-in support for that, so it will be treated just like any other
   contents.
 
   .pac files are a netscape invention and are sometimes used by organizations
   to allow them to differentiate which proxies to use. The .pac contents is
-  just a javascript program that gets invoked by the browser and that returns
-  the name of the proxy to connect to. Since curl doesn't support javascript,
+  just a Javascript program that gets invoked by the browser and that returns
+  the name of the proxy to connect to. Since curl doesn't support Javascript,
   it can't support .pac proxy configuration either.
 
-  Some work-arounds usually suggested to overcome this javascript dependency:
+  Some work-arounds usually suggested to overcome this Javascript dependency:
 
-  - Depending on the javascript complexity, write up a script that
+  - Depending on the Javascript complexity, write up a script that
     translates it to another language and execute that.
 
-  - Read the javascript code and rewrite the same logic in another language.
+  - Read the Javascript code and rewrite the same logic in another language.
 
-  - Implement a javascript interpreter, people have successfully used the
-    Mozilla javascript engine in the past.
+  - Implement a Javascript interpreter, people have successfully used the
+    Mozilla Javascript engine in the past.
 
   - Ask your admins to stop this, for a static proxy setup or similar.
 
@@ -658,21 +659,22 @@ FAQ
 
   4.2 Why do I get problems when I use & or % in the URL?
 
-  In general unix shells, the & letter is treated special and when used, it
+  In general unix shells, the & symbol is treated specially and when used, it
   runs the specified command in the background. To safely send the & as a part
   of a URL, you should quote the entire URL by using single (') or double (")
-  quotes around it.
+  quotes around it. Similar problems can also occur on some shells with other
+  characters, including ?*!$~(){}<>\|;`.  When in doubt, quote the URL.
 
-  An example that would invoke a remote CGI that uses &-letters could be:
+  An example that would invoke a remote CGI that uses &-symbols could be:
 
      curl 'http://www.altavista.com/cgi-bin/query?text=yes&q=curl'
 
-  In Windows, the standard DOS shell treats the %-letter specially and you
-  need to use TWO %-letters for each single one you want to use in the URL.
+  In Windows, the standard DOS shell treats the %-symbol specially and you
+  need to use TWO %-symbols for each single one you want to use in the URL.
 
-  Also note that if you want the literal %-letter to be part of the data you
+  Also note that if you want the literal %-symbol to be part of the data you
   pass in a POST using -d/--data you must encode it as '%25' (which then also
-  needs the %-letter doubled on Windows machines).
+  needs the %-symbol doubled on Windows machines).
 
   4.3 How can I use {, }, [ or ] to specify multiple URLs?
 
@@ -787,7 +789,7 @@ FAQ
 
   This is supported in curl 7.10.6 or later. No earlier curl version knows
   of this magic. Later versions require the OpenSSL or Microsoft Windows 
-  libraries to provide this functionality. Using GnuTLS or NSS libraries will 
+  libraries to provide this functionality. Using the NSS library will 
   not provide NTLM authentication functionality in curl.
 
   NTLM is a Microsoft proprietary protocol. Proprietary formats are evil. You
@@ -848,7 +850,7 @@ FAQ
   - Meta tags. You can write a HTML tag that will cause the browser to
     redirect to another given URL after a certain time.
 
-  - Javascript. You can write a javascript program embeded in a HTML page
+  - Javascript. You can write a Javascript program embedded in a HTML page
     that redirects the browser to another given URL.
 
   There is no way to make curl follow these redirects. You must either
@@ -884,6 +886,23 @@ FAQ
   You can disable libcurl's use of the Expect: header the same way you disable
   any header, using -H / CURLOPT_HTTPHEADER, or by forcing it to use HTTP 1.0.
 
+  4.17 Non-functional connect timeouts
+
+  In most Windows setups having a timeout longer than 21 seconds make no
+  difference, as it will only send 3 TCP SYN packets and no more. The second
+  packet sent three seconds after the first and the third six seconds after
+  the second.  No more than three packets are sent, no matter how long the
+  timeout is set.
+
+  See option TcpMaxConnectRetransmissions on this page:
+  http://support.microsoft.com/?scid=kb%3Ben-us%3B175523&x=6&y=7
+
+  Also, even on non-Windows systems there may run a firewall or anti-virus
+  software or similar that accepts the connection but does not actually do
+  anything else. This will make (lib)curl to consider the connection connected
+  and thus the connect timeout won't trigger.
+
+
 5. libcurl Issues
 
   5.1 Is libcurl thread-safe?
@@ -897,7 +916,7 @@ FAQ
   If you use a OpenSSL-powered libcurl in a multi-threaded environment, you
   need to provide one or two locking functions:
 
-    http://www.openssl.org/docs/crypto/threads.html#DESCRIPTION
+    http://www.openssl.org/docs/crypto/threads.html
 
   If you use a GnuTLS-powered libcurl in a multi-threaded environment, you
   need to provide locking function(s) for libgcrypt (which is used by GnuTLS
@@ -1158,7 +1177,7 @@ FAQ
   libraries that use it. It should be possible for everyone to use libcurl or
   curl in their projects, no matter what license they already have in use.
 
-  6.7 What are my obligations when using libcurl in my commerical apps?
+  6.7 What are my obligations when using libcurl in my commercial apps?
 
   Next to none. All you need to adhere to is the MIT-style license (stated in
   the COPYING file) which basically says you have to include the copyright
@@ -1174,7 +1193,7 @@ FAQ
   your app.
 
   As can be seen here: http://curl.haxx.se/docs/companies.html and
-  elsewhere, more and more companies are dicovering the power
+  elsewhere, more and more companies are discovering the power
   of libcurl and take advantage of it even in commercial environments.
 
 

docs/INSTALL

@@ -177,6 +177,9 @@ Win32
    KB140584 - How to link with the correct C Run-Time (CRT) library
               http://support.microsoft.com/kb/140584/en-us
 
+   KB190799 - Potential Errors Passing CRT Objects Across DLL Boundaries
+              http://msdn.microsoft.com/en-us/library/ms235460
+
    If your app is misbehaving in some strange way, or it is suffering
    from memory corruption, before asking for further help, please try
    first to rebuild every single library your app uses as well as your
@@ -383,7 +386,7 @@ Win32
    - Modify lib/setup.h
    - Modify lib/Makefile.vc6
    - Add defines to Project/Settings/C/C++/General/Preprocessor Definitions
-     in the curllib.dsw/curllib.dsp Visual C++ 6 IDE project.
+     in the vc6libcurl.dsw/vc6libcurl.dsp Visual C++ 6 IDE project.
 
 
    Important static libcurl usage note

docs/INTERNALS

@@ -472,3 +472,6 @@ Building Releases
  need to fill in the Makefile.am files properly for which files that should
  be included in the release archives.
 
+ NOTE: you need to have curl checked out from CVS to be able to do a proper
+ release build. The release tarballs do not have everything setup in order to
+ do releases properly.

docs/KNOWN_BUGS

@@ -3,6 +3,22 @@ join in and help us correct one or more of these! Also be sure to check the
 changelog of the current development status, as one or more of these problems
 may have been fixed since this was written!
 
+65. When doing FTP over a socks proxy or CONNECT through HTTP proxy and the
+  multi interface is used, libcurl will fail if the (passive) TCP connection
+  for the data transfer isn't more or less instant as the code does not
+  properly wait for the connect to be confirmed. See test case 564 for a first
+  shot at a test case.
+
+64. The threaded resolver used in libcurl on Windows has some kind of race
+  problem when multiple simultanoes resolves are done, like with the multi
+  interface transferring many files in parallell:
+  http://curl.haxx.se/mail/lib-2009-04/0028.html
+
+63. When CURLOPT_CONNECT_ONLY is used, the handle cannot reliably be re-used
+  for any further requests or transfers. The work-around is then to close that
+  handle with curl_easy_cleanup() and create a new. Some more details:
+  http://curl.haxx.se/mail/lib-2009-04/0300.html
+
 62. CURLOPT_TIMEOUT does not work properly with the regular multi and
   multi_socket interfaces. The work-around for apps is to simply remove the
   easy handle once the time is up. See also:
@@ -18,7 +34,8 @@ may have been fixed since this was written!
   http://curl.haxx.se/mail/lib-2008-08/0462.html
 
 59. If the CURLOPT_PORT option is used on an FTP URL like
-  "ftp://example.com/file;type=A" the ";type=A" is stripped off.
+  "ftp://example.com/file;type=A" using a proxy, the ";type=A" is stripped off.
+  See the comment in parse_remote_port()
 
 58. It seems sensible to be able to use CURLOPT_NOBODY and
   CURLOPT_FAILONERROR with FTP to detect if a file exists or not, but it is
@@ -42,11 +59,6 @@ may have been fixed since this was written!
   library header files exporting symbols/macros that should be kept private
   to the KfW library. See ticket #5601 at http://krbdev.mit.edu/rt/
 
-53. SFTP busy-loop problem. When doing SFTP uploads, we can see that libcurl
-  occasionally will busy-loop while waiting for certain network conditions.
-  Reported by Pavel Shalagin, explained somewhat by Daniel Stenberg here:
-  http://curl.haxx.se/mail/lib-2008-04/0439.html
-
 52. Gautam Kachroo's issue that identifies a problem with the multi interface
   where a connection can be re-used without actually being properly
   SSL-negoatiated:
@@ -64,13 +76,6 @@ may have been fixed since this was written!
   function will return prematurely and will confuse the rest of the HTTP
   protocol code. This should be very rare.
 
-45. libcurl built to support ipv6 uses getaddrinfo() to resolve host names.
-  getaddrinfo() sorts the response list which effectively kills how libcurl
-  deals with round-robin DNS entries. All details:
-    http://curl.haxx.se/mail/lib-2007-07/0168.html
-  initial suggested function to use for randomizing the response:
-    http://curl.haxx.se/mail/lib-2007-07/0178.html
-
 43. There seems to be a problem when connecting to the Microsoft telnet server.
   http://curl.haxx.se/bug/view.cgi?id=1720605
 

docs/MANUAL

@@ -136,6 +136,14 @@ PROXY
 
         curl -U user:passwd -x my-proxy:888 http://www.get.this/
 
+ A comma-separated list of hosts and domains which do not use the proxy can
+ be specified as:
+
+        curl --noproxy localhost,get.this -x my-proxy:888 http://www.get.this/
+
+ If the proxy is specified with --proxy1.0 instead of --proxy or -x, then
+ curl will use HTTP/1.0 instead of HTTP/1.1 for any CONNECT attempts.
+
  curl also supports SOCKS4 and SOCKS5 proxies with --socks4 and --socks5.
 
  See also the environment variables Curl support that offer further proxy
@@ -504,7 +512,7 @@ CONFIG FILE
   can also specify the long options without the dashes to make it more
   readable. You can separate the options and the parameter with spaces, or
   with = or :. Comments can be used within the file. If the first letter on a
-  line is a '#'-letter the rest of the line is treated as a comment.
+  line is a '#'-symbol the rest of the line is treated as a comment.
 
   If you want the parameter to contain spaces, you must enclose the entire
   parameter within double quotes ("). Within those quotes, you specify a
@@ -793,8 +801,9 @@ ENVIRONMENT VARIABLES
 
         NO_PROXY
 
-  If a tail substring of the domain-path for a host matches one of these
-  strings, transactions with that node will not be proxied.
+  If the host name matches one of these strings, or the host is within the
+  domain of one of these strings, transactions with that node will not be
+  proxied.
 
 
   The usage of the -x/--proxy flag overrides the environment variables.

docs/THANKS

@@ -21,6 +21,7 @@ Alexander Kourakos
 Alexander Krasnostavsky
 Alexander Lazic
 Alexander Zhuravlev
+Alexey Borzov
 Alexey Pesternikov
 Alexey Simak
 Alexis Carvalho
@@ -36,6 +37,7 @@ Andreas Ntaflos
 Andreas Olsson
 Andreas Rieke
 Andreas Schuldei
+Andreas Wurf
 Andres Garcia
 Andrew Benham
 Andrew Biggs
@@ -44,11 +46,13 @@ Andrew Francis
 Andrew Fuller
 Andrew Moise
 Andrew Wansink
+Andrew de los Reyes
 Andr<EFBFBD>s Garc<72>a
 Andy Cedilnik
 Andy Serpa
 Andy Tsouladze
 Angus Mackay
+Anthony Bryan
 Antoine Calando
 Anton Kalmykov
 Arkadiusz Miskiewicz
@@ -60,6 +64,7 @@ Augustus Saunders
 Avery Fay
 Axel Tillequin
 Bart Whiteley
+Bas Mevissen
 Ben Greear
 Ben Madsen
 Ben Van Hof
@@ -76,6 +81,7 @@ Brendan Jurd
 Brent Beardsley
 Brian Akins
 Brian Dessent
+Brian J. Murrell
 Brian R Duffy
 Brian Ulm
 Brock Noland
@@ -84,12 +90,14 @@ Bryan Henderson
 Bryan Kemp
 Caolan McNamara
 Casey O'Donnell
+Chad Monroe
 Chih-Chung Chang
 Chris "Bob Bob"
 Chris Combes
 Chris Flerackers
 Chris Gaukroger
 Chris Maltby
+Christian Krause
 Christian Kurz
 Christian Robottom Reis
 Christian Vogt
@@ -106,6 +114,7 @@ Colin Watson
 Colm Buckley
 Constantine Sapuntzakis
 Cory Nelson
+Craig A West
 Craig Davison
 Craig Markwardt
 Cris Bailiff
@@ -139,6 +148,7 @@ David Houlder
 David Hull
 David J Meyer
 David James
+David Kierznowski
 David Kimdon
 David Lang
 David LeBlanc
@@ -210,6 +220,7 @@ Forrest Cahoon
 Frank Hempel
 Frank Keeney
 Frank Ticheler
+Fred Machado
 Fred New
 Fred Noz
 Frederic Lepied
@@ -235,6 +246,7 @@ Giuseppe Attardi
 Giuseppe D'Ambrosio
 Glen Nakamura
 Glen Scott
+Grant Erickson
 Greg Hewgill
 Greg Morse
 Greg Onufer
@@ -255,6 +267,7 @@ Hardeep Singh
 Harshal Pradhan
 Heikki Korpela
 Henrik Storner
+Hidemoto Nakada
 Hzhijun
 Ian Ford
 Ian Gulliver
@@ -274,6 +287,7 @@ Ingo Wilken
 Jacky Lam
 Jacob Meuser
 James Bursa
+James Cheng
 James Clancy
 James Cone
 James Gallagher
@@ -308,6 +322,8 @@ Jes Badwal
 Jesper Jensen
 Jesse Noller
 Jim Drash
+Jim Meyering
+Jocelyn Jaubert
 Joe Halpin
 Joe Malicki
 Joel Chen
@@ -330,6 +346,7 @@ Jonatan Lander
 Jonathan Hseu
 Jongki Suwandi
 Jose Kahan
+Josef Wolf
 Josh Kapell
 Juan F. Codagnone
 Juan Ignacio Herv<72>s
@@ -344,6 +361,7 @@ J
 J<EFBFBD>rn Hartroth
 Kai Sommerfeld
 Kai-Uwe Rommel
+Kamil Dudka
 Kang-Jin Lee
 Karl Moerder
 Karol Pietrzak
@@ -356,6 +374,7 @@ Keith Mok
 Ken Hirsch
 Ken Rastatter
 Kent Boortz
+Keshav Krity
 Kevin Fisk
 Kevin Lussier
 Kevin Reed
@@ -386,6 +405,7 @@ Liam Healy
 Linas Vepstas
 Ling Thio
 Linus Nielsen Feltzing
+Lisa Xu
 Loic Dachary
 Loren Kirkby
 Luca Altea
@@ -406,6 +426,8 @@ Mario Schroeder
 Mark Butler
 Mark Davies
 Mark Eichin
+Mark Incley
+Mark Karpeles
 Mark Lentczner
 Markus Koetter
 Markus Moeller
@@ -487,7 +509,9 @@ P R Schaffner
 Pascal Terjan
 Patrick Bihan-Faou
 Patrick Monnerat
+Patrick Scott
 Patrick Smith
+Patrik Thunstrom
 Paul Harrington
 Paul Marquis
 Paul Moore
@@ -496,11 +520,13 @@ Paul Querna
 Pavel Cenek
 Pavel Orehov
 Pawel A. Gajda
+Pawel Kierski
 Pedro Neves
 Pete Su
 Peter Bray
 Peter Forret
 Peter Heuchert
+Peter Korsgaard
 Peter Lamberg
 Peter O'Gorman
 Peter Pentchev
@@ -513,6 +539,7 @@ Peter Wullinger
 Peteris Krumins
 Phil Blundell
 Phil Karn
+Phil Lisiecki
 Phil Pellouchoud
 Philip Gladstone
 Philip Langdale
@@ -588,9 +615,11 @@ Scott Cantor
 Scott Davis
 Scott McCreary
 Sebastien Willemijns
+Senthil Raja Velu
 Sergio Ballestrero
 Seshubabu Pasam
 Sh Diao
+Sharad Gupta
 Shard
 Shawn Poulson
 Shmulik Regev
@@ -605,6 +634,7 @@ Spiridonoff A.V
 Stadler Stephan
 Stefan Esser
 Stefan Krause
+Stefan Teleman
 Stefan Ulrich
 Stephan Bergmann
 Stephen Collyer
@@ -629,6 +659,7 @@ Thomas J. Moore
 Thomas Klausner
 Thomas Schwinge
 Thomas Tonino
+Tim Ansell
 Tim Baker
 Tim Bartley
 Tim Costello
@@ -666,6 +697,7 @@ Vincent Bronner
 Vincent Le Normand
 Vincent Penquerc'h
 Vincent Sanders
+Vlad Grachov
 Vladimir Lazarenko
 Vojtech Janota
 Vojtech Minarik

docs/TODO

@@ -328,10 +328,10 @@ to provide the data to send.
 
 8.1 Make NTLM work without OpenSSL functions
 
- Get NTLM working using the functions provided by libgcrypt, since GnuTLS
- already depends on that to function. Not strictly SSL/TLS related, but
- hey... Another option is to get available DES and MD4 source code from the
- cryptopp library. They are fine license-wise, but are C++.
+ Get NTLM working using the functions provided by NSS.  Not strictly
+ SSL/TLS related, but hey... Another option is to get available DES and
+ MD4 source code from the cryptopp library. They are fine license-wise,
+ but are C++.
 
 8.2 SSL engine stuff
 
@@ -551,7 +551,13 @@ to provide the data to send.
  curl_strnequal
 
  They will instead become curlx_ - alternatives. That makes the curl app
- still capable of building with them from source.
+ still capable of using them, by building with them from source.
+
+ These functions have no purpose anymore:
+
+ curl_multi_socket
+
+ curl_multi_socket_all
 
 15.5 remove CURLOPT_FAILONERROR
 

docs/curl.1

@@ -5,7 +5,7 @@
 .\" *                            | (__| |_| |  _ <| |___
 .\" *                             \___|\___/|_| \_\_____|
 .\" *
-.\" * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+.\" * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 .\" *
 .\" * This software is licensed as described in the file COPYING, which
 .\" * you should have received as part of this distribution. The terms
@@ -292,6 +292,10 @@ traditional PORT command.
 
 Since curl 7.19.0, \fB--eprt\fP can be used to explicitly enable EPRT again
 and \fB--no-eprt\fP is an alias for \fB--disable-eprt\fP.
+
+Disabling EPRT only changes the active behavior. If you want to switch to
+passive mode you need to not use \fI-P/--ftp-port\fP or force it with
+\fI--ftp-pasv\fP.
 .IP "--disable-epsv"
 (FTP) Tell curl to disable the use of the EPSV command when doing passive FTP
 transfers. Curl will normally always first attempt to use EPSV before PASV,
@@ -299,6 +303,9 @@ but with this option, it will not try using EPSV.
 
 Since curl 7.19.0, \fB--epsv\fP can be used to explicitly enable EPRT again
 and \fB--no-epsv\fP is an alias for \fB--disable-epsv\fP.
+
+Disabling EPSV only changes the passive behavior. If you want to switch to
+active mode you need to use \fI-P/--ftp-port\fP.
 .IP "-D/--dump-header <file>"
 Write the protocol headers to the specified file.
 
@@ -421,13 +428,16 @@ compliant than 'nocwd' but without the full penalty of 'multicwd'.
 .RE
 (Added in 7.15.1)
 .IP "--ftp-pasv"
-(FTP) Use PASV when transferring. PASV is the internal default behavior, but
-using this option can be used to override a previous --ftp-port option. (Added
-in 7.11.0)
+(FTP) Use passive mode for the data conection. Passive is the internal default
+behavior, but using this option can be used to override a previous
+\fI-P/-ftp-port\fP option. (Added in 7.11.0)
 
 If this option is used several times, the following occurrences make no
-difference. Undoing an enforced PASV really isn't doable but you must then
-instead enforce the correct EPRT again.
+difference. Undoing an enforced passive really isn't doable but you must then
+instead enforce the correct \fI-P/--ftp-port\fP again.
+
+Passive mode means that curl will try the EPSV command first and then PASV,
+unless \fI--disable-epsv\fP is used.
 .IP "--ftp-alternative-to-user <command>"
 (FTP) If authenticating with the USER and PASS commands fails, send this
 command.  When connecting to Tumbleweed's Secure Transport server over FTPS
@@ -815,6 +825,13 @@ you to succeed. (Added in 7.16.0)
 
 Note that this is the negated option name documented. You can thus use
 \fI--sessionid\fP to enforce session-ID caching.
+.IP "--noproxy <no-proxy-list>"
+Comma-separated list of hosts which do not use a proxy, if one is specified.
+The only wildcard is a single * character, which matches all hosts, and
+effectively disables the proxy. Each name in this list is matched as either
+a domain which contains the hostname, or the hostname itself. For example,
+local.com would match local.com, local.com:80, and www.local.com, but not
+www.notlocal.com.  (Added in 7.19.4).
 .IP "--ntlm"
 (HTTP) Enables NTLM authentication. The NTLM authentication method was
 designed by Microsoft and is used by IIS web servers. It is a proprietary
@@ -846,7 +863,8 @@ or use several variables like:
 You may use this option as many times as the number of URLs you have.
 
 See also the \fI--create-dirs\fP option to create the local directories
-dynamically.
+dynamically. Specifying the output as '-' (a single dash) will force the
+output to be done to stdout.
 .IP "-O/--remote-name"
 Write output to a local file named like the remote file we get. (Only the file
 part of the remote file is used, the path is cut off.)
@@ -875,7 +893,7 @@ a redirection. This option is meaningful only when using \fI-L/--location\fP
 Tells curl to respect RFC 2616/10.3.2 and not convert POST requests into GET
 requests when following a 302 redirection. The non-RFC behaviour is ubiquitous
 in web browsers, so curl does the conversion by default to maintain
-consistency. However, a server may requires a POST to remain a POST after such
+consistency. However, a server may require a POST to remain a POST after such
 a redirection. This option is meaningful only when using \fI-L/--location\fP
 (Added in 7.19.1)
 .IP "--proxy-anyauth"
@@ -896,6 +914,13 @@ with a remote host. (Added in 7.17.1)
 .IP "--proxy-ntlm"
 Tells curl to use HTTP NTLM authentication when communicating with the given
 proxy. Use \fI--ntlm\fP for enabling NTLM with a remote host.
+.IP "--proxy1.0 <proxyhost[:port]>"
+Use the specified HTTP 1.0 proxy. If the port number is not specified, it is
+assumed at port 1080.
+
+The only difference between this and the HTTP proxy option (\fI-x/--proxy\fP),
+is that attempts to use CONNECT through the proxy will specify an HTTP 1.0
+protocol instead of the default HTTP 1.1.
 .IP "-p/--proxytunnel"
 When an HTTP proxy is used (\fI-x/--proxy\fP), this option will cause non-HTTP
 protocols to attempt to tunnel through the proxy instead of merely using it to
@@ -908,11 +933,11 @@ separate file.
 
 If this option is used several times, the last one will be used.
 .IP "-P/--ftp-port <address>"
-(FTP) Reverses the initiator/listener roles when connecting with FTP. This
-switch makes Curl use the PORT command instead of PASV. In practice, PORT
-tells the server to connect to the client's specified address and port, while
-PASV asks the server for an IP address and port to connect to. <address>
-should be one of:
+(FTP) Reverses the default initiator/listener roles when connecting with
+FTP. This switch makes curl use active mode. In practice, curl then tells the
+server to connect back to the client's specified address and port, while
+passive mode asks the server to setup an IP address and port for it to connect
+to. <address> should be one of:
 .RS
 .IP interface
 i.e "eth0" to specify which interface's IP address you want to use (Unix only)
@@ -1107,6 +1132,21 @@ mutually exclusive.
 If this option is used several times, the last one will be used. (This option
 was previously wrongly documented and used as --socks without the number
 appended.)
+.IP "--socks5-gssapi-service <servicename>"
+The default service name for a socks server is rcmd/server-fqdn. This option
+allows you to change it.
+
+Examples:
+ --socks5 proxy-name \fI--socks5-gssapi-service\fP sockd   would use
+sockd/proxy-name
+ --socks5 proxy-name \fI--socks5-gssapi-service\fP sockd/real-name   would use
+sockd/real-name for cases where the proxy-name does not match the princpal name.
+ (Added in 7.19.4).
+.IP "--socks5-gssapi-nec"
+As part of the gssapi negotiation a protection mode is negotiated. The rfc1961
+says in section 4.3/4.4 it should be protected, but the NEC reference
+implementation does not.  The option \fI--socks5-gssapi-nec\fP allows the
+unprotected exchange of the protection mode negotiation. (Added in 7.19.4).
 .IP "--stderr <file>"
 Redirect all writes to stderr to the specified file instead. If the file name
 is a plain '-', it is instead written to stdout. This option has no point when
@@ -1442,8 +1482,10 @@ default statistics.
 .I ~/.curlrc
 .RS
 Default config file, see \fI-K/--config\fP for details.
-
 .SH ENVIRONMENT
+The environment variables can be specified in lower case or upper case. The
+lower case version has precedence. http_proxy is an exception as it is only
+available in lower case.
 .IP "http_proxy [protocol://]<host>[:port]"
 Sets the proxy server to use for HTTP.
 .IP "HTTPS_PROXY [protocol://]<host>[:port]"

docs/examples/htmltitle.cc

@@ -142,6 +142,7 @@ static void StartElement(void *voidContext,
     context->title = "";
     context->addTitle = true;
   }
+  (void) attributes;
 }
 
 //

docs/libcurl/ABI

@@ -13,7 +13,7 @@ ABI - Application Binary Interface
   conventions, function arguments, return values, struct sizes/defines and
   more.
 
-  For a longer descricption, see
+  For a longer description, see
   http://en.wikipedia.org/wiki/Application_binary_interface
 
 Upgrades
@@ -36,7 +36,7 @@ Soname Bumps
   breakage, that may require your application to get attention or possibly be
   changed to adhere to new things, we will bump the soname. Then the library
   will get a different output name and thus can in fact be installed in
-  parallell with an older installed lib (on most systems). Thus, old
+  parallel with an older installed lib (on most systems). Thus, old
   applications built against the previous ABI version will remain working and
   using the older lib, while newer applications build and use the newer one.
 
@@ -52,3 +52,18 @@ Downgrades
   that doesn't support the options your application needs. Or possibly you
   even downgrade so far so you cross an ABI break border and thus a different
   soname, and then your application may need to adapt to the modified ABI.
+
+History
+
+  The previous major library soname number bumps (breaking backwards
+  compatibility) have happened the following times:
+
+  0 - libcurl 7.1,   August 2000
+
+  1 - libcurl 7.5    December 2000
+
+  2 - libcurl 7.7    March 2001
+
+  3 - libcurl 7.12.0 June 2004
+
+  4 - libcurl 7.16.0 October 2006

docs/libcurl/Makefile.am

@@ -19,49 +19,52 @@ man_MANS = curl_easy_cleanup.3 curl_easy_getinfo.3 curl_easy_init.3	 \
  libcurl-tutorial.3 curl_easy_reset.3 curl_easy_escape.3		 \
  curl_easy_unescape.3 curl_multi_setopt.3 curl_multi_socket.3		 \
  curl_multi_timeout.3 curl_formget.3 curl_multi_assign.3		 \
- curl_easy_pause.3 curl_easy_recv.3 curl_easy_send.3
+ curl_easy_pause.3 curl_easy_recv.3 curl_easy_send.3			 \
+ curl_multi_socket_action.3
 
-HTMLPAGES = curl_easy_cleanup.html curl_easy_getinfo.html		  \
- curl_easy_init.html curl_easy_perform.html curl_easy_setopt.html	  \
- curl_easy_duphandle.html curl_formadd.html curl_formfree.html		  \
- curl_getdate.html curl_getenv.html curl_slist_append.html		  \
- curl_slist_free_all.html curl_version.html curl_version_info.html	  \
- curl_escape.html curl_unescape.html curl_free.html curl_strequal.html	  \
- curl_mprintf.html curl_global_init.html curl_global_cleanup.html	  \
- curl_multi_add_handle.html curl_multi_cleanup.html curl_multi_fdset.html \
- curl_multi_info_read.html curl_multi_init.html curl_multi_perform.html	  \
- curl_multi_remove_handle.html curl_share_cleanup.html			  \
- curl_share_init.html curl_share_setopt.html libcurl.html		  \
- libcurl-multi.html libcurl-easy.html libcurl-share.html		  \
- libcurl-errors.html curl_easy_strerror.html curl_multi_strerror.html	  \
- curl_share_strerror.html curl_global_init_mem.html libcurl-tutorial.html \
- curl_easy_reset.html curl_easy_escape.html curl_easy_unescape.html	  \
- curl_multi_setopt.html curl_multi_socket.html curl_multi_timeout.html	  \
- curl_formget.html curl_multi_assign.html curl_easy_pause.html \
- curl_easy_recv.html curl_easy_send.html
+HTMLPAGES = curl_easy_cleanup.html curl_easy_getinfo.html		\
+ curl_easy_init.html curl_easy_perform.html curl_easy_setopt.html	\
+ curl_easy_duphandle.html curl_formadd.html curl_formfree.html		\
+ curl_getdate.html curl_getenv.html curl_slist_append.html		\
+ curl_slist_free_all.html curl_version.html curl_version_info.html	\
+ curl_escape.html curl_unescape.html curl_free.html curl_strequal.html	\
+ curl_mprintf.html curl_global_init.html curl_global_cleanup.html	\
+ curl_multi_add_handle.html curl_multi_cleanup.html			\
+ curl_multi_fdset.html curl_multi_info_read.html curl_multi_init.html	\
+ curl_multi_perform.html curl_multi_remove_handle.html			\
+ curl_share_cleanup.html curl_share_init.html curl_share_setopt.html	\
+ libcurl.html libcurl-multi.html libcurl-easy.html libcurl-share.html	\
+ libcurl-errors.html curl_easy_strerror.html curl_multi_strerror.html	\
+ curl_share_strerror.html curl_global_init_mem.html			\
+ libcurl-tutorial.html curl_easy_reset.html curl_easy_escape.html	\
+ curl_easy_unescape.html curl_multi_setopt.html curl_multi_socket.html	\
+ curl_multi_timeout.html curl_formget.html curl_multi_assign.html	\
+ curl_easy_pause.html curl_easy_recv.html curl_easy_send.html		\
+ curl_multi_socket_action.html
 
-PDFPAGES = curl_easy_cleanup.pdf curl_easy_getinfo.pdf curl_easy_init.pdf \
- curl_easy_perform.pdf curl_easy_setopt.pdf curl_easy_duphandle.pdf	  \
- curl_formadd.pdf curl_formfree.pdf curl_getdate.pdf curl_getenv.pdf	  \
- curl_slist_append.pdf curl_slist_free_all.pdf curl_version.pdf		  \
- curl_version_info.pdf curl_escape.pdf curl_unescape.pdf curl_free.pdf	  \
- curl_strequal.pdf curl_mprintf.pdf curl_global_init.pdf		  \
- curl_global_cleanup.pdf curl_multi_add_handle.pdf curl_multi_cleanup.pdf \
- curl_multi_fdset.pdf curl_multi_info_read.pdf curl_multi_init.pdf	  \
- curl_multi_perform.pdf curl_multi_remove_handle.pdf			  \
- curl_share_cleanup.pdf curl_share_init.pdf curl_share_setopt.pdf	  \
- libcurl.pdf libcurl-multi.pdf libcurl-easy.pdf libcurl-share.pdf	  \
- libcurl-errors.pdf curl_easy_strerror.pdf curl_multi_strerror.pdf	  \
- curl_share_strerror.pdf curl_global_init_mem.pdf libcurl-tutorial.pdf	  \
- curl_easy_reset.pdf curl_easy_escape.pdf curl_easy_unescape.pdf	  \
- curl_multi_setopt.pdf curl_multi_socket.pdf curl_multi_timeout.pdf	  \
- curl_formget.pdf curl_multi_assign.pdf curl_easy_pause.pdf \
- curl_easy_recv.pdf curl_easy_send.pdf
+PDFPAGES = curl_easy_cleanup.pdf curl_easy_getinfo.pdf			 \
+ curl_easy_init.pdf curl_easy_perform.pdf curl_easy_setopt.pdf		 \
+ curl_easy_duphandle.pdf curl_formadd.pdf curl_formfree.pdf		 \
+ curl_getdate.pdf curl_getenv.pdf curl_slist_append.pdf			 \
+ curl_slist_free_all.pdf curl_version.pdf curl_version_info.pdf		 \
+ curl_escape.pdf curl_unescape.pdf curl_free.pdf curl_strequal.pdf	 \
+ curl_mprintf.pdf curl_global_init.pdf curl_global_cleanup.pdf		 \
+ curl_multi_add_handle.pdf curl_multi_cleanup.pdf curl_multi_fdset.pdf	 \
+ curl_multi_info_read.pdf curl_multi_init.pdf curl_multi_perform.pdf	 \
+ curl_multi_remove_handle.pdf curl_share_cleanup.pdf curl_share_init.pdf \
+ curl_share_setopt.pdf libcurl.pdf libcurl-multi.pdf libcurl-easy.pdf	 \
+ libcurl-share.pdf libcurl-errors.pdf curl_easy_strerror.pdf		 \
+ curl_multi_strerror.pdf curl_share_strerror.pdf			 \
+ curl_global_init_mem.pdf libcurl-tutorial.pdf curl_easy_reset.pdf	 \
+ curl_easy_escape.pdf curl_easy_unescape.pdf curl_multi_setopt.pdf	 \
+ curl_multi_socket.pdf curl_multi_timeout.pdf curl_formget.pdf		 \
+ curl_multi_assign.pdf curl_easy_pause.pdf curl_easy_recv.pdf		 \
+ curl_easy_send.pdf curl_multi_socket_action.pdf
 
 CLEANFILES = $(HTMLPAGES) $(PDFPAGES)
 
-EXTRA_DIST = $(man_MANS) $(HTMLPAGES) index.html $(PDFPAGES) libcurl.m4 ABI
-
+EXTRA_DIST = $(man_MANS) $(HTMLPAGES) index.html $(PDFPAGES) libcurl.m4 ABI \
+  symbols-in-versions
 MAN2HTML= roffit --mandir=. < $< >$@
 
 SUFFIXES = .3 .html

docs/libcurl/curl_easy_getinfo.3

@@ -5,7 +5,7 @@
 .\" *                            | (__| |_| |  _ <| |___
 .\" *                             \___|\___/|_| \_\_____|
 .\" *
-.\" * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+.\" * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 .\" *
 .\" * This software is licensed as described in the file COPYING, which
 .\" * you should have received as part of this distribution. The terms
@@ -21,7 +21,7 @@
 .\" * $Id$
 .\" **************************************************************************
 .\"
-.TH curl_easy_getinfo 3 "16 Oct 2008" "libcurl 7.19.1" "libcurl Manual"
+.TH curl_easy_getinfo 3 "11 Feb 2009" "libcurl 7.19.4" "libcurl Manual"
 .SH NAME
 curl_easy_getinfo - extract information from a curl handle
 .SH SYNOPSIS
@@ -43,7 +43,7 @@ explicitly mentioned below.
 .SH AVAILABLE INFORMATION
 The following information can be extracted:
 .IP CURLINFO_EFFECTIVE_URL
-Pass a pointer to a 'char *' to receive the last used effective URL.
+Pass a pointer to a char pointer to receive the last used effective URL.
 .IP CURLINFO_RESPONSE_CODE
 Pass a pointer to a long to receive the last received HTTP or FTP code. This
 option was known as CURLINFO_HTTP_CODE in libcurl 7.10.7 and earlier. This
@@ -134,19 +134,21 @@ on the list pointer once you're done with it, as libcurl will not free the
 data for you. (Added in 7.12.3)
 .IP CURLINFO_CONTENT_LENGTH_DOWNLOAD
 Pass a pointer to a double to receive the content-length of the download. This
-is the value read from the Content-Length: field.
+is the value read from the Content-Length: field. Since 7.19.4, this returns -1
+if the size isn't known.
 .IP CURLINFO_CONTENT_LENGTH_UPLOAD
-Pass a pointer to a double to receive the specified size of the upload.
+Pass a pointer to a double to receive the specified size of the upload.  Since
+7.19.4, this returns -1 if the size isn't known.
 .IP CURLINFO_CONTENT_TYPE
-Pass a pointer to a 'char *' to receive the content-type of the downloaded
+Pass a pointer to a char pointer to receive the content-type of the downloaded
 object. This is the value read from the Content-Type: field. If you get NULL,
 it means that the server didn't send a valid Content-Type header or that the
 protocol used doesn't support this.
 .IP CURLINFO_PRIVATE
-Pass a pointer to a 'char *' to receive the pointer to the private data
+Pass a pointer to a char pointer to receive the pointer to the private data
 associated with the curl handle (set with the CURLOPT_PRIVATE option to
 \fIcurl_easy_setopt(3)\fP). Please note that for internal reasons, the
-value is returned as a 'char *', although effectively being a 'void *'.
+value is returned as a char pointer, although effectively being a 'void *'.
 (Added in 7.10.3)
 .IP CURLINFO_HTTPAUTH_AVAIL
 Pass a pointer to a long to receive a bitmask indicating the authentication
@@ -186,10 +188,10 @@ libcurl close the socket and cleanup other resources associated with the
 handle. This is typically used in combination with \fICURLOPT_CONNECT_ONLY\fP.
 (Added in 7.15.2)
 .IP CURLINFO_FTP_ENTRY_PATH
-Pass a pointer to a 'char *' to receive a pointer to a string holding the path
-of the entry path. That is the initial path libcurl ended up in when logging
-on to the remote FTP server. This stores a NULL as pointer if something is
-wrong. (Added in 7.15.4)
+Pass a pointer to a char pointer to receive a pointer to a string holding the
+path of the entry path. That is the initial path libcurl ended up in when
+logging on to the remote FTP server. This stores a NULL as pointer if
+something is wrong. (Added in 7.15.4)
 .IP CURLINFO_CERTINFO
 Pass a pointer to a 'struct curl_certinfo *' and you'll get it set to point to
 struct that holds a number of linked lists with info about the certificate
@@ -200,8 +202,14 @@ provided in a series of data in the format "name:content" where the content is
 for the specific named data. See also the certinfo.c example. NOTE: this
 option is only available in libcurl built with OpenSSL support. (Added in
 7.19.1)
+.IP CURLINFO_CONDITION_UNMET
+Pass a pointer to a long to receive the number 1 if the condition provided in
+the previous request didn't match (see \fICURLOPT_TIMECONDITION\fP). Alas, if
+this returns a 1 you know that the reason you didn't get data in return is
+because it didn't fulfill the condition. The long ths argument points to will
+get a zero stored if the condition instead was met. (Added in 7.19.4)
 .SH TIMES
-.NF
+.nf
 An overview of the six time values available from curl_easy_getinfo()
 
 curl_easy_perform()
@@ -213,7 +221,7 @@ curl_easy_perform()
     |--|--|--|--|--STARTTRANSFER
     |--|--|--|--|--|--TOTAL
     |--|--|--|--|--|--REDIRECT
-.FI
+.fi
 .IP NAMELOOKUP
 \fICURLINFO_NAMELOOKUP_TIME\fP. The time it took from the start until the name
 resolving was completed.

docs/libcurl/curl_easy_setopt.3

@@ -5,7 +5,7 @@
 .\" *                            | (__| |_| |  _ <| |___
 .\" *                             \___|\___/|_| \_\_____|
 .\" *
-.\" * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+.\" * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 .\" *
 .\" * This software is licensed as described in the file COPYING, which
 .\" * you should have received as part of this distribution. The terms
@@ -189,8 +189,11 @@ uploaded bytes with the normal read function/callback). It is also called to
 rewind a stream when doing a HTTP PUT or POST with a multi-pass authentication
 method. The function shall work like "fseek" or "lseek" and accepted SEEK_SET,
 SEEK_CUR and SEEK_END as argument for origin, although (in 7.18.0) libcurl
-only passes SEEK_SET. The callback must return 0 on success as returning
-something else will cause the upload operation to fail.
+only passes SEEK_SET. The callback must return 0 (CURL_SEEKFUNC_OK) on
+success, 1 (CURL_SEEKFUNC_FAIL) to cause the upload operation to fail or 2
+(CURL_SEEKFUNC_CANTSEEK) to indicate that while the seek failed, libcurl is
+free to work around the problem if possible. The latter can sometimes be done
+by instead reading from the input or similar.
 
 If you forward the input arguments directly to "fseek" or "lseek", note that
 the data type for \fIoffset\fP is not the same as defined for curl_off_t on
@@ -208,9 +211,10 @@ currently only one value is supported: \fICURLSOCKTYPE_IPCXN\fP for the
 primary connection (meaning the control connection in the FTP case). Future
 versions of libcurl may support more purposes. It passes the newly created
 socket descriptor so additional setsockopt() calls can be done at the user's
-discretion.  A non-zero return code from the callback function will signal an
-unrecoverable error to the library and it will close the socket and return
-\fICURLE_COULDNT_CONNECT\fP.  (Option added in 7.15.6.)
+discretion.  Return 0 (zero) from the callback on success. Return 1 from the
+callback function to signal an unrecoverable error to the library and it will
+close the socket and return \fICURLE_COULDNT_CONNECT\fP.  (Option added in
+7.15.6.)
 .IP CURLOPT_SOCKOPTDATA
 Pass a pointer that will be untouched by libcurl and passed as the first
 argument in the sockopt callback set with \fICURLOPT_SOCKOPTFUNCTION\fP.
@@ -231,9 +235,9 @@ at the user's discretion.  \fICURL_SOCKET_BAD\fP return value from the
 callback function will signal an unrecoverable error to the library and it
 will return \fICURLE_COULDNT_CONNECT\fP.  This return code can be used for IP
 address blacklisting.  The default behavior is:
-.Bd -literal -offset indent
+.nf
    return socket(addr->family, addr->socktype, addr->protocol);
-.Ed
+.fi
 (Option added in 7.17.1.)
 .IP CURLOPT_OPENSOCKETDATA
 Pass a pointer that will be untouched by libcurl and passed as the first
@@ -440,12 +444,33 @@ The string given to CURLOPT_URL must be url-encoded and follow RFC 2396
 
 \fICURLOPT_URL\fP is the only option that \fBmust\fP be set before
 \fIcurl_easy_perform(3)\fP is called.
+
+\fICURLOPT_PROTOCOLS\fP can be used to limit what protocols libcurl will use
+for this transfer, independent of what libcurl has been compiled to
+support. That may be useful if you accept the URL from an external source and
+want to limit the accessibility.
+.IP CURLOPT_PROTOCOLS
+Pass a long that holds a bitmask of CURLPROTO_* defines. If used, this bitmask
+limits what protocols libcurl may use in the transfer. This allows you to have
+a libcurl built to support a wide range of protocols but still limit specific
+transfers to only be allowed to use a subset of them. By default libcurl will
+accept all protocols it supports. See also
+\fICURLOPT_REDIR_PROTOCOLS\fP. (Added in 7.19.4)
+.IP CURLOPT_REDIR_PROTOCOLS
+Pass a long that holds a bitmask of CURLPROTO_* defines. If used, this bitmask
+limits what protocols libcurl may use in a transfer that it follows to in a
+redirect when \fICURLOPT_FOLLOWLOCATION\fP is enabled. This allows you to
+limit specific transfers to only be allowed to use a subset of protocols in
+redirections. By default libcurl will allow all protocols except for FILE and
+SCP. This is a difference compared to pre-7.19.4 versions which
+unconditionally would follow to all protocols supported. (Added in 7.19.4)
 .IP CURLOPT_PROXY
 Set HTTP proxy to use. The parameter should be a char * to a zero terminated
 string holding the host name or dotted IP address. To specify port number in
 this string, append :[port] to the end of the host name. The proxy string may
 be prefixed with [protocol]:// since any such prefix will be ignored. The
-proxy's port number may optionally be specified with the separate option
+proxy's port number may optionally be specified with the separate option. If
+not specified, libcurl will default to using port 1080 for proxies.
 \fICURLOPT_PROXYPORT\fP.
 
 When you tell the library to use an HTTP proxy, libcurl will transparently
@@ -470,15 +495,33 @@ Pass a long with this option to set the proxy port to connect to unless it is
 specified in the proxy string \fICURLOPT_PROXY\fP.
 .IP CURLOPT_PROXYTYPE
 Pass a long with this option to set type of the proxy. Available options for
-this are \fICURLPROXY_HTTP\fP, \fICURLPROXY_SOCKS4\fP (added in 7.15.2),
-\fICURLPROXY_SOCKS5\fP, \fICURLPROXY_SOCKS4A\fP (added in 7.18.0) and
-\fICURLPROXY_SOCKS5_HOSTNAME\fP (added in 7.18.0). The HTTP type is
-default. (Added in 7.10)
+this are \fICURLPROXY_HTTP\fP, \fICURLPROXY_HTTP_1_0\fP (added in 7.19.4),
+\fICURLPROXY_SOCKS4\fP (added in 7.15.2), \fICURLPROXY_SOCKS5\fP,
+\fICURLPROXY_SOCKS4A\fP (added in 7.18.0) and \fICURLPROXY_SOCKS5_HOSTNAME\fP
+(added in 7.18.0). The HTTP type is default. (Added in 7.10)
+.IP CURLOPT_NOPROXY
+Pass a pointer to a zero terminated string. The should be a comma- separated
+list of hosts which do not use a proxy, if one is specified.  The only
+wildcard is a single * character, which matches all hosts, and effectively
+disables the proxy. Each name in this list is matched as either a domain which
+contains the hostname, or the hostname itself. For example, local.com would
+match local.com, local.com:80, and www.local.com, but not www.notlocal.com.
+(Added in 7.19.4)
 .IP CURLOPT_HTTPPROXYTUNNEL
 Set the parameter to 1 to make the library tunnel all operations through a
 given HTTP proxy. There is a big difference between using a proxy and to
 tunnel through it. If you don't know what this means, you probably don't want
 this tunneling option.
+.IP CURLOPT_SOCKS5_GSSAPI_SERVICE
+Pass a char * as parameter to a string holding the name of the service. The
+default service name for a SOCKS5 server is rcmd/server-fqdn. This option
+allows you to change it. (Added in 7.19.4)
+.IP CURLOPT_SOCKS5_GSSAPI_NEC
+Pass a long set to 1 to enable or 0 to disable. As part of the gssapi
+negotiation a protection mode is negotiated. The rfc1961 says in section
+4.3/4.4 it should be protected, but the NEC reference implementation does not.
+If enabled, this option allows the unprotected exchange of the protection mode
+negotiation. (Added in 7.19.4).
 .IP CURLOPT_INTERFACE
 Pass a char * as parameter. This sets the interface name to use as outgoing
 network interface. The name can be an interface name, an IP address, or a host
@@ -545,7 +588,7 @@ data at a time, and can contribute to congestion on the network if
 overdone.
 .IP CURLOPT_ADDRESS_SCOPE
 Pass a long specifying the scope_id value to use when connecting to IPv6
-link-local or site-local addresses.
+link-local or site-local addresses. (Added in 7.19.0)
 .SH NAMES and PASSWORDS OPTIONS (Authentication)
 .IP CURLOPT_NETRC
 This parameter controls the preference of libcurl between using user names and
@@ -724,6 +767,10 @@ This means that the library will re-send the same request on the new location
 and follow new Location: headers all the way until no more such headers are
 returned. \fICURLOPT_MAXREDIRS\fP can be used to limit the number of redirects
 libcurl will follow.
+
+NOTE: since 7.19.4, libcurl can limit to what protocols it will automatically
+follow. The accepted protocols are set with \fICURLOPT_REDIR_PROTOCOLS\fP and
+it excludes the FILE protocol by default.
 .IP CURLOPT_UNRESTRICTED_AUTH
 A parameter set to 1 tells the library it can continue to send authentication
 (user+password) when following locations, even when hostname changed. This
@@ -843,7 +890,6 @@ copy. In any case, the size must not be changed after
 \fICURLOPT_COPYPOSTFIELDS\fP, unless another \fICURLOPT_POSTFIELDS\fP or
 \fICURLOPT_COPYPOSTFIELDS\fP option is issued.
 (Added in 7.17.1)
-
 .IP CURLOPT_HTTPPOST
 Tells libcurl you want a multipart/formdata HTTP POST to be made and you
 instruct what data to pass on to the server.  Pass a pointer to a linked list
@@ -1000,6 +1046,14 @@ Pass a long to tell libcurl how to act on transfer decoding. If set to zero,
 transfer decoding will be disabled, if set to 1 it is enabled
 (default). libcurl does chunked transfer decoding by default unless this
 option is set to zero. (added in 7.16.2)
+.SH TFTP OPTIONS
+.IP CURLOPT_TFTPBLKSIZE
+Specify block size to use for TFTP data transmission. Valid range as per RFC
+2348 is 8-65464 bytes. The default of 512 bytes will be used if this option is
+not specified. The specified block size will only be used pending support by
+the remote server. If the server does not return an option acknowledgement or
+returns an option acknowledgement with no blksize, the default of 512 bytes
+will be used. (added in 7.19.4)
 .SH FTP OPTIONS
 .IP CURLOPT_FTPPORT
 Pass a pointer to a zero terminated string as parameter. It will be used to
@@ -1027,11 +1081,11 @@ rename, rm, rmdir, symlink (see
 .BR curl (1))
 (SFTP support added in 7.16.3)
 .IP CURLOPT_POSTQUOTE
-Pass a pointer to a linked list of FTP or SFTP commands to pass to the
-server after your FTP transfer request. The linked list should be a
-fully valid list of struct curl_slist structs properly filled in as
-described for \fICURLOPT_QUOTE\fP. Disable this operation again by
-setting a NULL to this option.
+Pass a pointer to a linked list of FTP or SFTP commands to pass to the server
+after your FTP transfer request. The commands will only be run if no error
+occurred. The linked list should be a fully valid list of struct curl_slist
+structs properly filled in as described for \fICURLOPT_QUOTE\fP. Disable this
+operation again by setting a NULL to this option.
 .IP CURLOPT_PREQUOTE
 Pass a pointer to a linked list of FTP commands to pass to the server after
 the transfer type is set. The linked list should be a fully valid list of
@@ -1078,6 +1132,17 @@ This setting also applies to SFTP-connections. curl will attempt to create
 the remote directory if it can't obtain a handle to the target-location. The
 creation will fail if a file of the same name as the directory to create
 already exists or lack of permissions prevents creation. (Added in 7.16.3)
+
+Starting with 7.19.4, you can also set this value to 2, which will make
+libcurl retry the CWD command again if the subsequent MKD command fails. This
+is especially useful if you're doing many simultanoes connections against the
+same server and they all have this option enabled, as then CWD may first fail
+but then another connection does MKD before this connection and thus MKD fails
+but trying CWD works! 7.19.4 also introduced the \fICURLFTP_CREATE_DIR\fP and
+\fICURLFTP_CREATE_DIR_RETRY\fP enum names for these arguments.
+
+Before version 7.19.4, libcurl will simply ignore arguments set to 2 and act
+as if 1 was selected.
 .IP CURLOPT_FTP_RESPONSE_TIMEOUT
 Pass a long.  Causes curl to set a timeout period (in seconds) on the amount
 of time that the server is allowed to take in order to generate a response
@@ -1164,6 +1229,7 @@ libcurl does one CWD with the full target directory and then operates on the
 file \&"normally" (like in the multicwd case). This is somewhat more standards
 compliant than 'nocwd' but without the full penalty of 'multicwd'.
 .RE
+(Added in 7.15.1)
 .SH PROTOCOL OPTIONS
 .IP CURLOPT_TRANSFERTEXT
 A parameter set to 1 tells the library to use ASCII mode for FTP transfers,
@@ -1300,8 +1366,10 @@ value is treated. You can set this parameter to \fICURL_TIMECOND_IFMODSINCE\fP
 or \fICURL_TIMECOND_IFUNMODSINCE\fP. This feature applies to HTTP and FTP.
 
 The last modification time of a file is not always known and in such instances
-this feature will have no effect even if the given time condition would not have
-been met.
+this feature will have no effect even if the given time condition would not
+have been met. \fIcurl_easy_getinfo(3)\fP with the
+\fICURLINFO_CONDITION_UNMET\fP option can be used after a transfer to learn if
+a zero-byte successful "transfer" was due to this condition not matching.
 .IP CURLOPT_TIMEVALUE
 Pass a long as parameter. This should be the time in seconds since 1 Jan 1970,
 and the time will be used in a condition as specified with
@@ -1662,8 +1730,9 @@ Pass a share handle as a parameter. The share handle must have been created by
 a previous call to \fIcurl_share_init(3)\fP. Setting this option, will make
 this curl handle use the data from the shared handle instead of keeping the
 data to itself. This enables several curl handles to share data. If the curl
-handles are used simultaneously, you \fBMUST\fP use the locking methods in the
-share handle. See \fIcurl_share_setopt(3)\fP for details.
+handles are used simultaneously in multiple threads, you \fBMUST\fP use the
+locking methods in the share handle. See \fIcurl_share_setopt(3)\fP for
+details.
 
 If you add a share that is set to share cookies, your easy handle will use
 that cookie cache and get the cookie engine enabled. If you unshare an object

docs/libcurl/curl_multi_info_read.3

@@ -34,7 +34,7 @@ If more involved information is wanted, the particular "easy handle" in
 present in that struct and can thus be used in subsequent regular
 \fIcurl_easy_getinfo(3)\fP calls (or similar):
 
-.NF
+.nf
  struct CURLMsg {
    CURLMSG msg;       /* what this message means */
    CURL *easy_handle; /* the handle it concerns */
@@ -43,7 +43,7 @@ present in that struct and can thus be used in subsequent regular
      CURLcode result;   /* return code for transfer */
    } data;
  };
-
+.fi
 When \fBmsg\fP is \fICURLMSG_DONE\fP, the message identifies a transfer that
 is done, and then \fBresult\fP contains the return code for the easy handle
 that just completed.

docs/libcurl/curl_multi_remove_handle.3

@@ -15,8 +15,9 @@ specified easy handle be removed from this multi handle's control.
 When the easy handle has been removed from a multi stack, it is again
 perfectly legal to invoke \fIcurl_easy_perform()\fP on this easy handle.
 
-Removing a handle while being used, will effectively halt all transfers in
-progress.
+Removing an easy handle while being used, will effectively halt the transfer
+in progress involving that easy handle. All other easy handles and transfers
+will remain unaffected.
 .SH RETURN VALUE
 CURLMcode type, general libcurl multi interface error code.
 .SH "SEE ALSO"

docs/libcurl/curl_multi_socket.3

@@ -6,14 +6,6 @@ curl_multi_socket \- reads/writes available data
 .SH SYNOPSIS
 .nf
 #include <curl/curl.h>
-
-CURLMcode curl_multi_socket_action(CURLM * multi_handle, 
-                                   curl_socket_t sockfd, int ev_bitmask,
-                                   int *running_handles);
-.fi
-
-.B "Now deprecated versions:"
-.nf
 CURLMcode curl_multi_socket(CURLM * multi_handle, curl_socket_t sockfd,
                             int *running_handles);
 
@@ -21,19 +13,8 @@ CURLMcode curl_multi_socket_all(CURLM *multi_handle,
                                 int *running_handles);
 .fi
 .SH DESCRIPTION
-Alternative versions of \fIcurl_multi_perform(3)\fP that allows the
-application to pass in the file descriptor/socket that has been detected to
-have \&"action" on it and let libcurl perform. This lets libcurl avoid having
-to scan through all possible file descriptors to check for action.
-
-When the application has detected action on a socket handled by libcurl, it
-should call \fIcurl_multi_socket_action(3)\fP with the \fBsockfd\fP argument
-set to the socket with the action. When the events on a socket are known, they
-can be passed as an events bitmask \fBev_bitmask\fP by first setting
-\fBev_bitmask\fP to 0, and then adding using bitwise OR (|) any combination of
-events to be chosen from CURL_CSELECT_IN, CURL_CSELECT_OUT or
-CURL_CSELECT_ERR. When the events on a socket are unknown, pass 0 instead, and
-libcurl will test the descriptor internally.
+These functions are deprecated. Do not use! See
+\fIcurl_multi_socket_action(3)\fP instead!
 
 At return, the integer \fBrunning_handles\fP points to will contain the number
 of still running easy handles within the multi handle. When this number

docs/libcurl/curl_multi_socket_action.3

@@ -0,0 +1,132 @@
+.\" $Id$
+.\"
+.TH curl_multi_socket_action 3 "9 Jul 2006" "libcurl 7.16.0" "libcurl Manual"
+.SH NAME
+curl_multi_socket_action \- reads/writes available data given an action
+.SH SYNOPSIS
+.nf
+#include <curl/curl.h>
+
+CURLMcode curl_multi_socket_action(CURLM * multi_handle, 
+                                   curl_socket_t sockfd, int ev_bitmask,
+                                   int *running_handles);
+.fi
+.SH DESCRIPTION
+When the application has detected action on a socket handled by libcurl, it
+should call \fIcurl_multi_socket_action(3)\fP with the \fBsockfd\fP argument
+set to the socket with the action. When the events on a socket are known, they
+can be passed as an events bitmask \fBev_bitmask\fP by first setting
+\fBev_bitmask\fP to 0, and then adding using bitwise OR (|) any combination of
+events to be chosen from CURL_CSELECT_IN, CURL_CSELECT_OUT or
+CURL_CSELECT_ERR. When the events on a socket are unknown, pass 0 instead, and
+libcurl will test the descriptor internally.
+
+At return, the integer \fBrunning_handles\fP points to will contain the number
+of still running easy handles within the multi handle. When this number
+reaches zero, all transfers are complete/done. Note that when you call
+\fIcurl_multi_socket_action(3)\fP on a specific socket and the counter
+decreases by one, it DOES NOT necessarily mean that this exact socket/transfer
+is the one that completed. Use \fIcurl_multi_info_read(3)\fP to figure out
+which easy handle that completed.
+
+The \fBcurl_multi_socket_action(3)\fP functions inform the application about
+updates in the socket (file descriptor) status by doing none, one, or multiple
+calls to the socket callback function set with the CURLMOPT_SOCKETFUNCTION
+option to \fIcurl_multi_setopt(3)\fP. They update the status with changes
+since the previous time the callback was called.
+
+Get the timeout time by setting the \fICURLMOPT_TIMERFUNCTION\fP option with
+\fIcurl_multi_setopt(3)\fP. Your application will then get called with
+information on how long to wait for socket actions at most before doing the
+timeout action: call the \fBcurl_multi_socket_action(3)\fP function with the
+\fBsockfd\fP argument set to CURL_SOCKET_TIMEOUT. You can also use the
+\fIcurl_multi_timeout(3)\fP function to poll the value at any given time, but
+for an event-based system using the callback is far better than relying on
+polling the timeout value.
+.SH "CALLBACK DETAILS"
+
+The socket \fBcallback\fP function uses a prototype like this
+.nf
+
+  int curl_socket_callback(CURL *easy,      /* easy handle */
+                           curl_socket_t s, /* socket */
+                           int action,      /* see values below */
+                           void *userp,    /* private callback pointer */
+                           void *socketp); /* private socket pointer */
+
+.fi
+The callback MUST return 0.
+
+The \fIeasy\fP argument is a pointer to the easy handle that deals with this
+particular socket. Note that a single handle may work with several sockets
+simultaneously.
+
+The \fIs\fP argument is the actual socket value as you use it within your
+system.
+
+The \fIaction\fP argument to the callback has one of five values:
+.RS
+.IP "CURL_POLL_NONE (0)"
+register, not interested in readiness (yet)
+.IP "CURL_POLL_IN (1)"
+register, interested in read readiness
+.IP "CURL_POLL_OUT (2)"
+register, interested in write readiness
+.IP "CURL_POLL_INOUT (3)"
+register, interested in both read and write readiness
+.IP "CURL_POLL_REMOVE (4)"
+unregister
+.RE
+
+The \fIsocketp\fP argument is a private pointer you have previously set with
+\fIcurl_multi_assign(3)\fP to be associated with the \fIs\fP socket. If no
+pointer has been set, socketp will be NULL. This argument is of course a
+service to applications that want to keep certain data or structs that are
+strictly associated to the given socket.
+
+The \fIuserp\fP argument is a private pointer you have previously set with
+\fIcurl_multi_setopt(3)\fP and the CURLMOPT_SOCKETDATA option.
+.SH "RETURN VALUE"
+CURLMcode type, general libcurl multi interface error code.
+
+Legacy: If you receive \fICURLM_CALL_MULTI_PERFORM\fP, this basically means
+that you should call \fIcurl_multi_socket_action(3)\fP again, before you wait
+for more actions on libcurl's sockets. You don't have to do it immediately,
+but the return code means that libcurl may have more data available to return
+or that there may be more data to send off before it is "satisfied".
+
+In modern libcurls, \fICURLM_CALL_MULTI_PERFORM\fP or
+\fICURLM_CALL_MULTI_SOKCET\fP should not be returned and no application needs
+to care about them.
+
+NOTE that the return code is for the whole multi stack. Problems still might have
+occurred on individual transfers even when one of these functions
+return OK.
+.SH "TYPICAL USAGE"
+1. Create a multi handle
+
+2. Set the socket callback with CURLMOPT_SOCKETFUNCTION
+
+3. Set the timeout callback with CURLMOPT_TIMERFUNCTION, to get to know what
+timeout value to use when waiting for socket activities.
+
+4. Add easy handles with curl_multi_add_handle()
+
+5. Provide some means to manage the sockets libcurl is using, so you can check
+them for activity. This can be done through your application code, or by way
+of an external library such as libevent or glib.
+
+6. Wait for activity on any of libcurl's sockets, use the timeout value your
+callback has been told
+
+7, When activity is detected, call curl_multi_socket_action() for the
+socket(s) that got action. If no activity is detected and the timeout expires,
+call \fIcurl_multi_socket_action(3)\fP with \fICURL_SOCKET_TIMEOUT\fP
+
+8. Go back to step 6.
+.SH AVAILABILITY
+This function was added in libcurl 7.15.4, and is deemed stable since 7.16.0.
+.SH "SEE ALSO"
+.BR curl_multi_cleanup "(3), " curl_multi_init "(3), "
+.BR curl_multi_fdset "(3), " curl_multi_info_read "(3), "
+.BR "the hiperfifo.c example"

docs/libcurl/libcurl-multi.3

@@ -5,7 +5,7 @@
 .\" *                            | (__| |_| |  _ <| |___
 .\" *                             \___|\___/|_| \_\_____|
 .\" *
-.\" * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
+.\" * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 .\" *
 .\" * This software is licensed as described in the file COPYING, which
 .\" * you should have received as part of this distribution. The terms
@@ -124,7 +124,7 @@ applications to not only avoid being forced to use select(), but it also
 offers a much more high-performance API that will make a significant difference
 for applications using large numbers of simultaneous connections.
 
-\fIcurl_multi_socket(3)\fP (and \fIcurl_multi_socket_all(3)\fP) is then used
+\fIcurl_multi_socket_action(3)\fP is then used
 instead of \fIcurl_multi_perform(3)\fP.
 .SH "BLOCKING"
 A few areas in the code are still using blocking code, even when used from the
@@ -136,6 +136,8 @@ the future, you should be aware of the following current restrictions:
  - GnuTLS SSL connections
  - Active FTP connections
  - HTTP proxy CONNECT operations
+ - SOCKS proxy handshakes
  - TFTP transfers
  - file:// transfers
+ - TELNET transfers
 .fi

docs/libcurl/libcurl-tutorial.3

@@ -5,7 +5,7 @@
 .\" *                            | (__| |_| |  _ <| |___
 .\" *                             \___|\___/|_| \_\_____|
 .\" *
-.\" * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+.\" * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
 .\" *
 .\" * This software is licensed as described in the file COPYING, which
 .\" * you should have received as part of this distribution. The terms
@@ -21,7 +21,7 @@
 .\" * $Id$
 .\" **************************************************************************
 .\"
-.TH libcurl-tutorial 3 "17 Nov 2008" "libcurl" "libcurl programming"
+.TH libcurl-tutorial 3 "4 Mar 2009" "libcurl" "libcurl programming"
 .SH NAME
 libcurl-tutorial \- libcurl programming tutorial
 .SH "Objective"
@@ -200,7 +200,7 @@ Using that property, you can easily pass local data between your application
 and the function that gets invoked by libcurl. libcurl itself won't touch the
 data you pass with \fICURLOPT_WRITEDATA\fP.
 
-libcurl offers its own default internal callback that'll take care of the data
+libcurl offers its own default internal callback that will take care of the data
 if you don't set the callback with \fICURLOPT_WRITEFUNCTION\fP. It will then
 simply output the received data to stdout. You can have the default callback
 write the data to a different file handle by passing a 'FILE *' to a file
@@ -381,7 +381,7 @@ them URL encoded, as %XX where XX is a two-digit hexadecimal number.
 libcurl also provides options to set various passwords. The user name and
 password as shown embedded in the URL can instead get set with the
 CURLOPT_USERPWD option. The argument passed to libcurl should be a char * to
-a string in the format "user:password:". In a manner like this:
+a string in the format "user:password". In a manner like this:
 
  curl_easy_setopt(easyhandle, CURLOPT_USERPWD, "myname:thesecret");
 
@@ -557,7 +557,7 @@ post handle:
  curl_easy_perform(easyhandle); /* post away! */
 
  curl_formfree(post); /* free post */
- curl_slist_free_all(post); /* free custom header list */
+ curl_slist_free_all(headers); /* free custom header list */
 .fi
 
 Since all options on an easyhandle are "sticky", they remain the same until
@@ -667,14 +667,14 @@ default to assume a HTTP proxy):
 
 .IP "Environment Variables"
 
-libcurl automatically checks and uses a set of environment variables to
-know what proxies to use for certain protocols. The names of the variables
-are following an ancient de facto standard and are built up as
-"[protocol]_proxy" (note the lower casing). Which makes the variable
-'http_proxy' checked for a name of a proxy to use when the input URL is
-HTTP. Following the same rule, the variable named 'ftp_proxy' is checked
-for FTP URLs. Again, the proxies are always HTTP proxies, the different
-names of the variables simply allows different HTTP proxies to be used.
+libcurl automatically checks and uses a set of environment variables to know
+what proxies to use for certain protocols. The names of the variables are
+following an ancient de facto standard and are built up as "[protocol]_proxy"
+(note the lower casing). Which makes the variable \&'http_proxy' checked for a
+name of a proxy to use when the input URL is HTTP. Following the same rule,
+the variable named 'ftp_proxy' is checked for FTP URLs. Again, the proxies are
+always HTTP proxies, the different names of the variables simply allows
+different HTTP proxies to be used.
 
 The proxy environment variable contents should be in the format
 \&"[protocol://][user:password@]machine[:port]". Where the protocol:// part is
@@ -738,24 +738,24 @@ stand in the way for such innovative actions either!
 .IP "Proxy Auto-Config"
 
 Netscape first came up with this. It is basically a web page (usually using a
-\&.pac extension) with a javascript that when executed by the browser with the
+\&.pac extension) with a Javascript that when executed by the browser with the
 requested URL as input, returns information to the browser on how to connect
 to the URL. The returned information might be "DIRECT" (which means no proxy
 should be used), "PROXY host:port" (to tell the browser where the proxy for
 this particular URL is) or "SOCKS host:port" (to direct the browser to a SOCKS
 proxy).
 
-libcurl has no means to interpret or evaluate javascript and thus it doesn't
+libcurl has no means to interpret or evaluate Javascript and thus it doesn't
 support this. If you get yourself in a position where you face this nasty
 invention, the following advice have been mentioned and used in the past:
 
-- Depending on the javascript complexity, write up a script that translates it
+- Depending on the Javascript complexity, write up a script that translates it
 to another language and execute that.
 
-- Read the javascript code and rewrite the same logic in another language.
+- Read the Javascript code and rewrite the same logic in another language.
 
-- Implement a javascript interpreted, people have successfully used the
-Mozilla javascript engine in the past.
+- Implement a Javascript interpreted, people have successfully used the
+Mozilla Javascript engine in the past.
 
 - Ask your admins to stop this, for a static proxy setup or similar.
 
@@ -836,7 +836,7 @@ If just changing the actual HTTP request keyword is what you want, like when
 GET, HEAD or POST is not good enough for you, CURLOPT_CUSTOMREQUEST is there
 for you. It is very simple to use:
 
- curl_easy_setopt(easyhandle, CURLOPT_CUSTOMREQUEST, "MYOWNRUQUEST");
+ curl_easy_setopt(easyhandle, CURLOPT_CUSTOMREQUEST, "MYOWNREQUEST");
 
 When using the custom request, you change the request keyword of the actual
 request you are performing. Thus, by default you make a GET request but you can
@@ -908,7 +908,7 @@ Sending custom commands to a FTP server means that you need to send the
 commands exactly as the FTP server expects them (RFC959 is a good guide
 here), and you can only use commands that work on the control-connection
 alone. All kinds of commands that require data interchange and thus need
-a data-connection must be left to libcurl's own judgment. Also be aware
+a data-connection must be left to libcurl's own judgement. Also be aware
 that libcurl will do its very best to change directory to the target
 directory before doing any transfer, so if you change directory (with CWD
 or similar) you might confuse libcurl and then it might not attempt to
@@ -1062,20 +1062,32 @@ actually true headers, but in this case we pretend they are! ;-)
 
 .SH "Security Considerations"
 
-libcurl is in itself not insecure. If used the right way, you can use libcurl
-to transfer data pretty safely.
+The libcurl project takes security seriously.  The library is written with
+caution and precautions are taken to mitigate many kinds of risks encountered
+while operating with potentially malicious servers on the Internet.  It is a
+powerful library, however, which allows application writers to make trade offs
+between ease of writing and exposure to potential risky operations.  If
+used the right way, you can use libcurl to transfer data pretty safely.
 
-There are of course many things to consider that may loosen up this
-situation:
+Many applications are used in closed networks where users and servers
+can be trusted, but many others are used on arbitrary servers and are fed
+input from potentially untrusted users.  Following is a discussion about
+some risks in the ways in which applications commonly use libcurl and
+potential mitigations of those risks. It is by no means comprehensive, but
+shows classes of attacks that robust applications should consider. The
+Common Weakness Enumeration project at http://cwe.mitre.org/ is a good
+reference for many of these and similar types of weaknesses of which
+application writers should be aware.
 
 .IP "Command Lines"
 If you use a command line tool (such as curl) that uses libcurl, and you give
-option to the tool on the command line those options can very likely get read
+options to the tool on the command line those options can very likely get read
 by other users of your system when they use 'ps' or other tools to list
 currently running processes.
 
 To avoid this problem, never feed sensitive things to programs using command
-line options.
+line options. Write them to a protected file and use the \-K option to
+avoid this.
 
 .IP ".netrc"
 \&.netrc is a pretty handy file/feature that allows you to login quickly and
@@ -1091,14 +1103,143 @@ plain text anywhere.
 .IP "Clear Text Passwords"
 Many of the protocols libcurl supports send name and password unencrypted as
 clear text (HTTP Basic authentication, FTP, TELNET etc). It is very easy for
-anyone on your network or a network nearby yours, to just fire up a network
+anyone on your network or a network nearby yours to just fire up a network
 analyzer tool and eavesdrop on your passwords. Don't let the fact that HTTP
 Basic uses base64 encoded passwords fool you. They may not look readable at a
 first glance, but they very easily "deciphered" by anyone within seconds.
 
-To avoid this problem, use HTTP athentication methods or other protocols that
+To avoid this problem, use HTTP authentication methods or other protocols that
 don't let snoopers see your password: HTTP with Digest, NTLM or GSS
-authentication, HTTPS, FTPS, SCP, SFTP and FTP-kerberos are a few examples.
+authentication, HTTPS, FTPS, SCP, SFTP and FTP-Kerberos are a few examples.
+
+.IP "Redirects"
+The CURLOPT_FOLLOWLOCATION option automatically follows HTTP redirects sent
+by a remote server.  These redirects can refer to any kind of URL, not just
+HTTP.  A redirect to a file: URL would cause the libcurl to read (or write)
+arbitrary files from the local filesystem.  If the application returns
+the data back to the user (as would happen in some kinds of CGI scripts),
+an attacker could leverage this to read otherwise forbidden data (e.g.
+file://localhost/etc/passwd).
+
+If authentication credentials are stored in the ~/.netrc file, or Kerberos
+is in use, any other URL type (not just file:) that requires
+authentication is also at risk.  A redirect such as
+ftp://some-internal-server/private-file would then return data even when
+the server is password protected.
+
+In the same way, if an unencrypted SSH private key has been configured for
+the user running the libcurl application, SCP: or SFTP: URLs could access
+password or private-key protected resources,
+e.g. sftp://user@some-internal-server/etc/passwd
+
+The CURLOPT_REDIR_PROTOCOLS and CURLOPT_NETRC options can be used to
+mitigate against this kind of attack.
+
+A redirect can also specify a location available only on the machine running
+libcurl, including servers hidden behind a firewall from the attacker.
+e.g. http://127.0.0.1/ or http://intranet/delete-stuff.cgi?delete=all or
+tftp://bootp-server/pc-config-data
+
+Apps can mitigate against this by disabling CURLOPT_FOLLOWLOCATION and
+handling redirects itself, sanitizing URLs as necessary. Alternately, an
+app could leave CURLOPT_FOLLOWLOCATION enabled but set CURLOPT_REDIR_PROTOCOLS
+and install a CURLOPT_OPENSOCKETFUNCTION callback function in which addresses
+are sanitized before use.
+
+.IP "Private Resources"
+A user who can control the DNS server of a domain being passed in within
+a URL can change the address of the host to a local, private address
+which the libcurl application will then use. e.g. The innocuous URL
+http://fuzzybunnies.example.com/ could actually resolve to the IP address
+of a server behind a firewall, such as 127.0.0.1 or 10.1.2.3
+Apps can mitigate against this by setting a CURLOPT_OPENSOCKETFUNCTION
+and checking the address before a connection.
+
+All the malicious scenarios regarding redirected URLs apply just as well
+to non-redirected URLs, if the user is allowed to specify an arbitrary URL
+that could point to a private resource. For example, a web app providing
+a translation service might happily translate file://localhost/etc/passwd
+and display the result.  Apps can mitigate against this with the
+CURLOPT_PROTOCOLS option as well as by similar mitigation techniques for
+redirections.
+
+A malicious FTP server could in response to the PASV command return an
+IP address and port number for a server local to the app running libcurl
+but behind a firewall.  Apps can mitigate against this by using the
+CURLOPT_FTP_SKIP_PASV_IP option or CURLOPT_FTPPORT.
+
+.IP Uploads
+When uploading, a redirect can cause a local (or remote) file to be
+overwritten.  Apps must not allow any unsanitized URL to be passed in
+for uploads.  Also, CURLOPT_FOLLOWLOCATION should not be used on uploads.
+Instead, the app should handle redirects itself, sanitizing each URL first.
+
+.IP Authentication
+Use of CURLOPT_UNRESTRICTED_AUTH could cause authentication information to
+be sent to an unknown second server.  Apps can mitigate against this
+by disabling CURLOPT_FOLLOWLOCATION and handling redirects itself,
+sanitizing where necessary.
+
+Use of the CURLAUTH_ANY option to CURLOPT_HTTPAUTH could result in user
+name and password being sent in clear text to an HTTP server.  Instead,
+use CURLAUTH_ANYSAFE which ensures that the password is encrypted over
+the network, or else fail the request.
+
+Use of the CURLUSESSL_TRY option to CURLOPT_USE_SSL could result in user
+name and password being sent in clear text to an FTP server.  Instead,
+use CURLUSESSL_CONTROL to ensure that an encrypted connection is used or
+else fail the request.
+
+.IP Cookies
+If cookies are enabled and cached, then a user could craft a URL which
+performs some malicious action to a site whose authentication is already
+stored in a cookie. e.g. http://mail.example.com/delete-stuff.cgi?delete=all
+Apps can mitigate against this by disabling cookies or clearing them
+between requests.
+
+.IP "Dangerous URLs"
+SCP URLs can contain raw commands within the scp: URL, which is a side effect
+of how the SCP protocol is designed. e.g. 
+scp://user:pass@host/a;date >/tmp/test;
+Apps must not allow unsanitized SCP: URLs to be passed in for downloads.
+
+.IP "Denial of Service"
+A malicious server could cause libcurl to effectively hang by sending
+a trickle of data through, or even no data at all but just keeping the TCP
+connection open.  This could result in a denial-of-service attack. The
+CURLOPT_TIMEOUT and/or CURLOPT_LOW_SPEED_LIMIT options can be used to
+mitigate against this.
+
+A malicious server could cause libcurl to effectively hang by starting to
+send data, then severing the connection without cleanly closing the
+TCP connection.  The app could install a CURLOPT_SOCKOPTFUNCTION callback
+function and set the TCP SO_KEEPALIVE option to mitigate against this.
+Setting one of the timeout options would also work against this attack.
+
+A malicious server could cause libcurl to download an infinite amount of
+data, potentially causing all of memory or disk to be filled. Setting
+the CURLOPT_MAXFILESIZE_LARGE option is not sufficient to guard against this.
+Instead, the app should monitor the amount of data received within the
+write or progress callback and abort once the limit is reached.
+
+A malicious HTTP server could cause an infinite redirection loop, causing a 
+denial-of-service. This can be mitigated by using the CURLOPT_MAXREDIRS
+option.
+
+.IP "Arbitrary Headers"
+User-supplied data must be sanitized when used in options like
+CURLOPT_USERAGENT, CURLOPT_HTTPHEADER, CURLOPT_POSTFIELDS and others that
+are used to generate structured data. Characters like embedded carriage
+returns or ampersands could allow the user to create additional headers or
+fields that could cause malicious transactions.
+
+.IP "Server Certificates"
+A secure application should never use the CURLOPT_SSL_VERIFYPEER option to
+disable certificate validation. There are numerous attacks that are enabled
+by apps that fail to properly validate server TLS/SSL certificates,
+thus enabling a malicious server to spoof a legitimate one. HTTPS without
+validated certificates is potentially as insecure as a plain HTTP connection.
+
 .IP "Showing What You Do"
 On a related issue, be aware that even in situations like when you have
 problems with libcurl and ask someone for help, everything you reveal in order

docs/libcurl/symbols-in-versions

@@ -0,0 +1,438 @@
+                                  _   _ ____  _
+                              ___| | | |  _ \| |
+                             / __| | | | |_) | |
+                            | (__| |_| |  _ <| |___
+                             \___|\___/|_| \_\_____|
+
+ This document lists defines and other symbols present in libcurl, together
+ with exact information about the first libcurl version that provides the
+ symbol, the first version in which the symbol was marked as deprecated and
+ for a few symbols the last version that featured it. The names appear in
+ alphabetical order.
+
+ Name                           Introduced  Deprecated  Removed
+
+CURLAUTH_ANY                    7.10.6
+CURLAUTH_ANYSAFE                7.10.6
+CURLAUTH_BASIC                  7.10.6
+CURLAUTH_DIGEST                 7.10.6
+CURLAUTH_DIGEST_IE              7.19.3
+CURLAUTH_GSSNEGOTIATE           7.10.6
+CURLAUTH_NTLM                   7.10.6
+CURLCLOSEPOLICY_CALLBACK        7.7
+CURLCLOSEPOLICY_LEAST_RECENTLY_USED 7.7
+CURLCLOSEPOLICY_LEAST_TRAFFIC   7.7
+CURLCLOSEPOLICY_OLDEST          7.7
+CURLCLOSEPOLICY_SLOWEST         7.7
+CURLE_ABORTED_BY_CALLBACK       7.1
+CURLE_AGAIN                     7.18.2
+CURLE_BAD_CALLING_ORDER         7.1           7.17.0
+CURLE_BAD_CONTENT_ENCODING      7.10
+CURLE_BAD_FUNCTION_ARGUMENT     7.1
+CURLE_BAD_PASSWORD_ENTERED      -             7.17.0
+CURLE_COULDNT_CONNECT           7.1
+CURLE_COULDNT_RESOLVE_HOST      7.1
+CURLE_COULDNT_RESOLVE_PROXY     7.1
+CURLE_FAILED_INIT               7.1
+CURLE_FILESIZE_EXCEEDED         7.10.8
+CURLE_FILE_COULDNT_READ_FILE    7.1
+CURLE_FTP_ACCESS_DENIED         7.1
+CURLE_FTP_BAD_DOWNLOAD_RESUME   7.1
+CURLE_FTP_CANT_GET_HOST         7.1
+CURLE_FTP_CANT_RECONNECT        7.1           7.17.0
+CURLE_FTP_COULDNT_GET_SIZE      7.1           7.17.0
+CURLE_FTP_COULDNT_RETR_FILE     7.1
+CURLE_FTP_COULDNT_SET_ASCII     7.1           7.17.0
+CURLE_FTP_COULDNT_SET_BINARY    7.1           7.17.0
+CURLE_FTP_COULDNT_SET_TYPE      7.17.0
+CURLE_FTP_COULDNT_STOR_FILE     7.1
+CURLE_FTP_COULDNT_USE_REST      7.1
+CURLE_FTP_PORT_FAILED           7.1
+CURLE_FTP_QUOTE_ERROR           7.1           7.17.0
+CURLE_FTP_SSL_FAILED            -             7.17.0
+CURLE_FTP_USER_PASSWORD_INCORRECT 7.1         7.17.0
+CURLE_FTP_WEIRD_227_FORMAT      7.1
+CURLE_FTP_WEIRD_PASS_REPLY      7.1
+CURLE_FTP_WEIRD_PASV_REPLY      7.1
+CURLE_FTP_WEIRD_SERVER_REPLY    7.1
+CURLE_FTP_WEIRD_USER_REPLY      7.1           7.17.0
+CURLE_FTP_WRITE_ERROR           7.1           7.17.0
+CURLE_FUNCTION_NOT_FOUND        7.1
+CURLE_GOT_NOTHING               7.9.1
+CURLE_HTTP_NOT_FOUND            7.1
+CURLE_HTTP_PORT_FAILED          -             7.12.0
+CURLE_HTTP_POST_ERROR           7.1
+CURLE_HTTP_RANGE_ERROR          7.1           7.17.0
+CURLE_INTERFACE_FAILED          7.12.0
+CURLE_LDAP_CANNOT_BIND          7.1
+CURLE_LDAP_INVALID_URL          7.10.8
+CURLE_LDAP_SEARCH_FAILED        7.1
+CURLE_LIBRARY_NOT_FOUND         7.1           7.17.0
+CURLE_MALFORMAT_USER            7.1           7.17.0
+CURLE_OK                        7.1
+CURLE_OPERATION_TIMEDOUT        7.17.0
+CURLE_OPERATION_TIMEOUTED       7.1           7.17.0
+CURLE_OUT_OF_MEMORY             7.1
+CURLE_PARTIAL_FILE              7.1
+CURLE_PEER_FAILED_VERIFICATION  -             7.17.1
+CURLE_QUOTE_ERROR               7.17.0
+CURLE_RANGE_ERROR               7.17.0
+CURLE_READ_ERROR                7.1
+CURLE_RECV_ERROR                7.13.0
+CURLE_REMOTE_ACCESS_DENIED      7.17.0
+CURLE_REMOTE_DISK_FULL          7.17.0
+CURLE_SEND_ERROR                7.13.0
+CURLE_SHARE_IN_USE              -             7.17.0
+CURLE_SSH                       7.16.1
+CURLE_SSL_CACERT                7.10
+CURLE_SSL_CERTPROBLEM           7.10
+CURLE_SSL_CIPHER                7.10
+CURLE_SSL_CONNECT_ERROR         7.1
+CURLE_SSL_CRL_BADFILE           7.19.0
+CURLE_SSL_ENGINE_INITFAILED     7.13.0
+CURLE_SSL_ENGINE_NOTFOUND       7.9.3
+CURLE_SSL_ENGINE_SETFAILED      7.9.3
+CURLE_SSL_ISSUER_ERROR          7.19.0
+CURLE_SSL_PEER_CERTIFICATE      7.17.1
+CURLE_SSL_SHUTDOWN_FAILED       7.16.1
+CURLE_TELNET_OPTION_SYNTAX      7.7
+CURLE_TFTP_DISKFULL             7.15.0        7.17.0
+CURLE_TFTP_EXISTS               7.15.0        7.17.0
+CURLE_TFTP_ILLEGAL              7.15.0
+CURLE_TFTP_NOSUCHUSER           7.15.0
+CURLE_TFTP_UNKNOWNID            7.15.0
+CURLE_TOO_MANY_REDIRECTS        7.5
+CURLE_UNKNOWN_TELNET_OPTION     7.7
+CURLE_UNSUPPORTED_PROTOCOL      7.1
+CURLE_URL_MALFORMAT             7.1
+CURLE_URL_MALFORMAT_USER        7.1           7.17.0
+CURLE_USE_SSL_FAILED            7.17.0
+CURLE_WRITE_ERROR               7.1
+CURLFTPAUTH_DEFAULT             7.12.2
+CURLFTPAUTH_DEFAULT             7.12.2
+CURLFTPAUTH_SSL                 7.12.2
+CURLFTPAUTH_SSL                 7.12.2
+CURLFTPAUTH_TLS                 7.12.2
+CURLFTPAUTH_TLS                 7.12.2
+CURLFTPMETHOD_MULTICWD          7.15.1
+CURLFTPMETHOD_NOCWD             7.15.1
+CURLFTPMETHOD_SINGLECWD         7.15.1
+CURLFTPSSL_ALL                  -             7.17.0
+CURLFTPSSL_CCC_ACTIVE           7.16.1
+CURLFTPSSL_CCC_NONE             7.16.1
+CURLFTPSSL_CCC_PASSIVE          7.16.1
+CURLFTPSSL_CONTROL              7.11.0        7.17.0
+CURLFTPSSL_NONE                 7.11.0        7.17.0
+CURLFTPSSL_TRY                  7.11.0        7.17.0
+CURLFTP_CREATE_DIR              7.19.4
+CURLFTP_CREATE_DIR_NONE         7.19.4
+CURLFTP_CREATE_DIR_RETRY        7.19.4
+CURLINFO_APPCONNECT_TIME        7.19.0
+CURLINFO_CERTINFO               7.19.1
+CURLINFO_CONDITION_UNMET        7.19.4
+CURLINFO_CONNECT_TIME           7.4.1
+CURLINFO_CONTENT_LENGTH_DOWNLOAD 7.6.1
+CURLINFO_CONTENT_LENGTH_UPLOAD  7.6.1
+CURLINFO_CONTENT_TYPE           7.9.4
+CURLINFO_COOKIELIST             7.14.1
+CURLINFO_DATA_IN                7.9.6
+CURLINFO_DATA_OUT               7.9.6
+CURLINFO_EFFECTIVE_URL          7.3
+CURLINFO_FILETIME               7.5
+CURLINFO_FTP_ENTRY_PATH         7.15.4
+CURLINFO_HEADER_IN              7.9.6
+CURLINFO_HEADER_OUT             7.9.6
+CURLINFO_HEADER_SIZE            7.4.1
+CURLINFO_HTTPAUTH_AVAIL         7.10.8
+CURLINFO_HTTP_CODE              7.4.1         7.10.8
+CURLINFO_HTTP_CONNECTCODE       7.10.7
+CURLINFO_LASTSOCKET             7.15.2
+CURLINFO_NAMELOOKUP_TIME        7.4.1
+CURLINFO_NUM_CONNECTS           7.12.3
+CURLINFO_OS_ERRNO               7.12.2
+CURLINFO_PRETRANSFER_TIME       7.4.1
+CURLINFO_PRIMARY_IP             7.19.0
+CURLINFO_PRIVATE                7.10.3
+CURLINFO_PRIVATE                7.10.3
+CURLINFO_PROXYAUTH_AVAIL        7.10.8
+CURLINFO_REDIRECT_COUNT         7.9.7
+CURLINFO_REDIRECT_TIME          7.9.7
+CURLINFO_REDIRECT_URL           7.18.2
+CURLINFO_REQUEST_SIZE           7.4.1
+CURLINFO_RESPONSE_CODE          7.10.8
+CURLINFO_SIZE_DOWNLOAD          7.4.1
+CURLINFO_SIZE_UPLOAD            7.4.1
+CURLINFO_SPEED_DOWNLOAD         7.4.1
+CURLINFO_SPEED_UPLOAD           7.4.1
+CURLINFO_SSL_ENGINES            7.12.3
+CURLINFO_SSL_VERIFYRESULT       7.5
+CURLINFO_STARTTRANSFER_TIME     7.9.2
+CURLINFO_TEXT                   7.9.6
+CURLINFO_TOTAL_TIME             7.4.1
+CURLMSG_DONE                    7.9.6
+CURLM_BAD_EASY_HANDLE           7.9.6
+CURLM_BAD_HANDLE                7.9.6
+CURLM_CALL_MULTI_PERFORM        7.9.6
+CURLM_CALL_MULTI_SOCKET         7.15.5
+CURLM_INTERNAL_ERROR            7.9.6
+CURLM_OK                        7.9.6
+CURLM_OUT_OF_MEMORY             7.9.6
+CURLOPT_ADDRESS_SCOPE           7.19.0
+CURLOPT_APPEND                  7.16.4
+CURLOPT_AUTOREFERER             7.1
+CURLOPT_BUFFERSIZE              7.10
+CURLOPT_CAINFO                  7.4.2
+CURLOPT_CAPATH                  7.9.8
+CURLOPT_CERTINFO                7.19.1
+CURLOPT_CLOSEFUNCTION           7.7           7.11.1      7.15.4
+CURLOPT_CLOSEPOLICY             7.7           7.16.1
+CURLOPT_CONNECTTIMEOUT          7.7
+CURLOPT_CONNECTTIMEOUT_MS       7.16.2
+CURLOPT_CONNECT_ONLY            7.15.2
+CURLOPT_CONV_FROM_NETWORK_FUNCTION 7.15.4
+CURLOPT_CONV_FROM_UTF8_FUNCTION 7.15.4
+CURLOPT_CONV_TO_NETWORK_FUNCTION 7.15.4
+CURLOPT_COOKIE                  7.1
+CURLOPT_COOKIEFILE              7.1
+CURLOPT_COOKIEJAR               7.9
+CURLOPT_COOKIELIST              7.17.1
+CURLOPT_COOKIESESSION           7.9.7
+CURLOPT_COPYPOSTFIELDS          7.17.1
+CURLOPT_CRLF                    7.1
+CURLOPT_CRLFILE                 7.19.0
+CURLOPT_CUSTOMREQUEST           7.1
+CURLOPT_DEBUGDATA               7.9.6
+CURLOPT_DEBUGFUNCTION           7.9.6
+CURLOPT_DIRLISTONLY             7.16.4
+CURLOPT_DNS_CACHE_TIMEOUT       7.9.3
+CURLOPT_DNS_USE_GLOBAL_CACHE    7.9.3         7.11.1
+CURLOPT_EGDSOCKET               7.7
+CURLOPT_ENCODING                7.12.2
+CURLOPT_ERRORBUFFER             7.1
+CURLOPT_FAILONERROR             7.1
+CURLOPT_FILE                    7.1           7.9.7
+CURLOPT_FILETIME                7.5
+CURLOPT_FLAGS                   7.1           -           7.9.2
+CURLOPT_FOLLOWLOCATION          7.1
+CURLOPT_FORBID_REUSE            7.7
+CURLOPT_FRESH_CONNECT           7.7
+CURLOPT_FTPAPPEND               7.1           7.16.4
+CURLOPT_FTPASCII                7.1           7.11.1      7.15.4
+CURLOPT_FTPLISTONLY             7.1           7.16.4
+CURLOPT_FTPPORT                 7.1
+CURLOPT_FTPSSLAUTH              7.12.2     
+CURLOPT_FTP_ACCOUNT             7.13.1
+CURLOPT_FTP_ALTERNATIVE_TO_USER 7.15.5
+CURLOPT_FTP_CREATE_MISSING_DIRS 7.10.7
+CURLOPT_FTP_FILEMETHOD          7.15.1
+CURLOPT_FTP_RESPONSE_TIMEOUT    7.10.8
+CURLOPT_FTP_SKIP_PASV_IP        7.15.0
+CURLOPT_FTP_SSL                 7.11.0        7.16.4
+CURLOPT_FTP_SSL_CCC             7.16.1
+CURLOPT_FTP_USE_EPRT            7.10.5
+CURLOPT_FTP_USE_EPSV            7.9.2
+CURLOPT_HEADER                  7.1
+CURLOPT_HEADERFUNCTION          7.7.2
+CURLOPT_HTTP200ALIASES          7.10.3
+CURLOPT_HTTPAUTH                7.10.6
+CURLOPT_HTTPGET                 7.8.1
+CURLOPT_HTTPHEADER              7.1
+CURLOPT_HTTPPOST                7.1
+CURLOPT_HTTPPROXYTUNNEL         7.3
+CURLOPT_HTTPREQUEST             7.1           -           7.15.4
+CURLOPT_HTTP_CONTENT_DECODING   7.16.2
+CURLOPT_HTTP_TRANSFER_DECODING  7.16.2
+CURLOPT_HTTP_VERSION            7.9.1
+CURLOPT_IGNORE_CONTENT_LENGTH   7.14.1
+CURLOPT_INFILE                  7.1           7.9.7
+CURLOPT_INFILESIZE              7.1
+CURLOPT_INFILESIZE_LARGE        7.11.0
+CURLOPT_INTERFACE               7.3
+CURLOPT_IOCTLDATA               7.12.3
+CURLOPT_IOCTLFUNCTION           7.12.3
+CURLOPT_IPRESOLVE               7.10.8
+CURLOPT_ISSUERCERT              7.19.0
+CURLOPT_KEYPASSWD               -             7.17.0
+CURLOPT_KRB4LEVEL               7.3           7.17.0
+CURLOPT_KRBLEVEL                7.17.0
+CURLOPT_LOCALPORT               7.15.2
+CURLOPT_LOCALPORTRANGE          7.15.2
+CURLOPT_LOW_SPEED_LIMIT         7.1
+CURLOPT_LOW_SPEED_TIME          7.1
+CURLOPT_MAXCONNECTS             7.7
+CURLOPT_MAXFILESIZE             7.10.8
+CURLOPT_MAXFILESIZE_LARGE       7.11.0
+CURLOPT_MAXREDIRS               7.5
+CURLOPT_MAX_RECV_SPEED_LARGE    7.15.5
+CURLOPT_MAX_SEND_SPEED_LARGE    7.15.5
+CURLOPT_MUTE                    7.1           7.8         7.15.4
+CURLOPT_NETRC                   7.1
+CURLOPT_NETRC_FILE              7.11.0
+CURLOPT_NEW_DIRECTORY_PERMS     7.16.4
+CURLOPT_NEW_FILE_PERMS          7.16.4
+CURLOPT_NOBODY                  7.1
+CURLOPT_NOPROGRESS              7.1
+CURLOPT_NOPROXY                 7.19.4
+CURLOPT_NOSIGNAL                7.10
+CURLOPT_OPENSOCKETDATA          7.17.1
+CURLOPT_OPENSOCKETFUNCTION      7.17.1
+CURLOPT_PASSWDDATA              7.1           7.11.1      7.15.4
+CURLOPT_PASSWDFUNCTION          7.1           7.11.1      7.15.4
+CURLOPT_PASSWORD                7.19.1
+CURLOPT_PASV_POST               7.12.1        -           7.13.0
+CURLOPT_PORT                    7.1
+CURLOPT_POST                    7.1
+CURLOPT_POST301                 7.17.1        7.19.1
+CURLOPT_POSTFIELDS              7.1
+CURLOPT_POSTFIELDSIZE           7.2
+CURLOPT_POSTFIELDSIZE_LARGE     7.11.1
+CURLOPT_POSTQUOTE               7.1
+CURLOPT_POSTREDIR               7.19.1
+CURLOPT_PREQUOTE                7.9.5
+CURLOPT_PRIVATE                 7.10.3
+CURLOPT_PROGRESSDATA            7.1
+CURLOPT_PROGRESSFUNCTION        7.1
+CURLOPT_PROGRESSMODE            7.1           -           7.9.2
+CURLOPT_PROTOCOLS               7.19.4
+CURLOPT_PROXY                   7.1
+CURLOPT_PROXYAUTH               7.10.7
+CURLOPT_PROXYPASSWORD           7.19.1
+CURLOPT_PROXYPORT               7.1
+CURLOPT_PROXYTYPE               7.10
+CURLOPT_PROXYUSERNAME           7.19.1
+CURLOPT_PROXYUSERPWD            7.1
+CURLOPT_PROXY_TRANSFER_MODE     7.18.0
+CURLOPT_PUT                     7.1
+CURLOPT_QUOTE                   7.1
+CURLOPT_RANDOM_FILE             7.7
+CURLOPT_RANGE                   7.1
+CURLOPT_READDATA                7.9.7
+CURLOPT_READFUNCTION            7.1
+CURLOPT_REDIR_PROTOCOLS         7.19.4
+CURLOPT_REFERER                 7.1
+CURLOPT_RESUME_FROM             7.1
+CURLOPT_RESUME_FROM_LARGE       7.11.0
+CURLOPT_SEEKDATA                7.18.1
+CURLOPT_SEEKFUNCTION            7.18.1
+CURLOPT_SHARE                   7.10
+CURLOPT_SOCKOPTDATA             7.16.0
+CURLOPT_SOCKOPTFUNCTION         7.16.0
+CURLOPT_SOCKS5_GSSAPI_NEC       7.19.4
+CURLOPT_SOCKS5_GSSAPI_SERVICE   7.19.4
+CURLOPT_SOURCE_HOST             7.12.1        -           7.13.0
+CURLOPT_SOURCE_PATH             7.12.1        -           7.13.0
+CURLOPT_SOURCE_PORT             7.12.1        -           7.13.0
+CURLOPT_SOURCE_POSTQUOTE        7.12.1        -           7.15.4
+CURLOPT_SOURCE_PREQUOTE         7.12.1        -           7.15.4
+CURLOPT_SOURCE_QUOTE            7.13.0        -           7.15.4
+CURLOPT_SOURCE_URL              7.13.0        -           7.15.4
+CURLOPT_SOURCE_USERPWD          7.12.1        -           7.15.4
+CURLOPT_SSH_AUTH_TYPES          7.16.1
+CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 7.17.1
+CURLOPT_SSH_PRIVATE_KEYFILE     7.16.1
+CURLOPT_SSH_PUBLIC_KEYFILE      7.16.1
+CURLOPT_SSLCERT                 7.1
+CURLOPT_SSLCERTPASSWD           7.17.0
+CURLOPT_SSLCERTTYPE             7.9.3
+CURLOPT_SSLENGINE               7.9.3
+CURLOPT_SSLENGINE_DEFAULT       7.9.3
+CURLOPT_SSLKEY                  7.9.3
+CURLOPT_SSLKEYPASSWD            7.17.0
+CURLOPT_SSLKEYPASSWD            7.17.0
+CURLOPT_SSLKEYTYPE              7.9.3
+CURLOPT_SSLVERSION              7.1
+CURLOPT_SSL_CIPHER_LIST         7.9
+CURLOPT_SSL_CTX_DATA            7.10.6
+CURLOPT_SSL_CTX_FUNCTION        7.10.6
+CURLOPT_SSL_SESSIONID_CACHE     7.16.0
+CURLOPT_SSL_VERIFYHOST          7.8.1
+CURLOPT_SSL_VERIFYPEER          7.4.2
+CURLOPT_STDERR                  7.1
+CURLOPT_TCP_NODELAY             7.11.2
+CURLOPT_TELNETOPTIONS           7.7
+CURLOPT_TFTPBLKSIZE             7.19.4
+CURLOPT_TIMECONDITION           7.1
+CURLOPT_TIMEOUT                 7.1
+CURLOPT_TIMEOUT_MS              7.16.2
+CURLOPT_TIMEVALUE               7.1
+CURLOPT_TRANSFERTEXT            7.11.1
+CURLOPT_UNRESTRICTED_AUTH       7.10.4
+CURLOPT_UPLOAD                  7.1
+CURLOPT_URL                     7.1
+CURLOPT_USERAGENT               7.1
+CURLOPT_USERNAME                7.19.1
+CURLOPT_USERPWD                 7.1
+CURLOPT_USE_SSL                 7.17.0
+CURLOPT_VERBOSE                 7.1
+CURLOPT_WRITEDATA               7.9.7
+CURLOPT_WRITEFUNCTION           7.1
+CURLOPT_WRITEHEADER             7.1
+CURLPROTO_ALL                   7.19.4
+CURLPROTO_DICT                  7.19.4
+CURLPROTO_FILE                  7.19.4
+CURLPROTO_FTP                   7.19.4
+CURLPROTO_FTPS                  7.19.4
+CURLPROTO_HTTP                  7.19.4
+CURLPROTO_HTTPS                 7.19.4
+CURLPROTO_LDAP                  7.19.4
+CURLPROTO_LDAPS                 7.19.4
+CURLPROTO_SCP                   7.19.4
+CURLPROTO_SFTP                  7.19.4
+CURLPROTO_TELNET                7.19.4
+CURLPROTO_TFTP                  7.19.4
+CURLPROXY_HTTP                  7.10
+CURLPROXY_HTTP_1_0              7.19.4
+CURLPROXY_SOCKS4                7.10
+CURLPROXY_SOCKS4A               7.18.0
+CURLPROXY_SOCKS5                7.10
+CURLPROXY_SOCKS5_HOSTNAME       7.18.0
+CURLSSH_AUTH_DEFAULT            7.16.1
+CURLSSH_AUTH_HOST               7.16.1
+CURLSSH_AUTH_KEYBOARD           7.16.1
+CURLSSH_AUTH_NONE               7.16.1
+CURLSSH_AUTH_PASSWORD           7.16.1
+CURLSSH_AUTH_PUBLICKEY          7.16.1
+CURLUSESSL_ALL                  7.17.0
+CURLUSESSL_ALL                  7.17.0
+CURLUSESSL_CONTROL              7.17.0
+CURLUSESSL_CONTROL              7.17.0
+CURLUSESSL_NONE                 7.17.0
+CURLUSESSL_NONE                 7.17.0
+CURLUSESSL_TRY                  7.17.0
+CURLUSESSL_TRY                  7.17.0
+CURLVERSION_FIRST               7.10
+CURLVERSION_NOW                 7.10
+CURLVERSION_SECOND              7.11.1
+CURLVERSION_THIRD               7.12.0
+CURL_HTTP_VERSION_1_0           7.9.1
+CURL_HTTP_VERSION_1_1           7.9.1
+CURL_HTTP_VERSION_NONE          7.9.1
+CURL_IPRESOLVE_V4               7.10.8
+CURL_IPRESOLVE_V6               7.10.8
+CURL_IPRESOLVE_WHATEVER         7.10.8
+CURL_NETRC_IGNORED              7.9.8
+CURL_NETRC_OPTIONAL             7.9.8
+CURL_NETRC_REQUIRED             7.9.8
+CURL_SEEKFUNC_CANTSEEK          7.19.5
+CURL_SEEKFUNC_FAIL              7.19.5
+CURL_SEEKFUNC_OK                7.19.5
+CURL_SSLVERSION_DEFAULT         7.9.2
+CURL_SSLVERSION_SSLv2           7.9.2
+CURL_SSLVERSION_SSLv3           7.9.2
+CURL_SSLVERSION_TLSv1           7.9.2
+CURL_TIMECOND_IFMODSINCE        7.9.7
+CURL_TIMECOND_IFUNMODSINCE      7.9.7
+CURL_TIMECOND_LASTMOD           7.9.7
+CURL_VERSION_ASYNCHDNS          7.10.7
+CURL_VERSION_CONV               7.15.4
+CURL_VERSION_DEBUG              7.10.6
+CURL_VERSION_GSSNEGOTIATE       7.10.6
+CURL_VERSION_IDN                7.12.0
+CURL_VERSION_IPV6               7.10
+CURL_VERSION_KERBEROS4          7.10
+CURL_VERSION_LARGEFILE          7.11.1
+CURL_VERSION_LIBZ               7.10
+CURL_VERSION_NTLM               7.10.6
+CURL_VERSION_SPNEGO             7.10.8
+CURL_VERSION_SSL                7.10
+CURL_VERSION_SSPI               7.13.2

include/curl/curl.h

@@ -7,7 +7,7 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
@@ -186,15 +186,21 @@ typedef size_t (*curl_write_callback)(char *buffer,
                                       size_t nitems,
                                       void *outstream);
 
+/* this is the return codes for the seek callbacks */
+#define CURL_SEEKFUNC_OK       0
+#define CURL_SEEKFUNC_FAIL     1 /* fail the entire transfer */
+#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
+                                    libcurl might try other means instead */
+typedef int (*curl_seek_callback)(void *instream,
+                                  curl_off_t offset,
+                                  int origin); /* 'whence' */
+
 /* This is a return code for the read callback that, when returned, will
    signal libcurl to immediately abort the current transfer. */
 #define CURL_READFUNC_ABORT 0x10000000
 /* This is a return code for the read callback that, when returned, will
    signal libcurl to pause sending data on the current transfer. */
 #define CURL_READFUNC_PAUSE 0x10000001
-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,
@@ -459,7 +465,10 @@ typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl,    /* easy handle */
                                           void *userptr);
 
 typedef enum {
-  CURLPROXY_HTTP = 0,   /* added in 7.10 */
+  CURLPROXY_HTTP = 0,   /* added in 7.10, new in 7.19.4 default is to use
+                           CONNECT HTTP/1.1 */
+  CURLPROXY_HTTP_1_0 = 1,   /* added in 7.19.4, force to use CONNECT
+                               HTTP/1.0  */
   CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
                            in 7.10 */
   CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
@@ -527,6 +536,17 @@ typedef enum {
   CURLFTPAUTH_LAST /* not an option, never use */
 } curl_ftpauth;
 
+/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
+typedef enum {
+  CURLFTP_CREATE_DIR_NONE,  /* do NOT create missing dirs! */
+  CURLFTP_CREATE_DIR,       /* (FTP/SFTP) if CWD fails, try MKD and then CWD
+                               again if MKD succeeded, for SFTP this does
+                               similar magic */
+  CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
+                               again even if MKD failed! */
+  CURLFTP_CREATE_DIR_LAST   /* not an option, never use */
+} curl_ftpcreatedir;
+
 /* parameter for the CURLOPT_FTP_FILEMETHOD option */
 typedef enum {
   CURLFTPMETHOD_DEFAULT,   /* let libcurl pick */
@@ -536,6 +556,21 @@ typedef enum {
   CURLFTPMETHOD_LAST       /* not an option, never use */
 } curl_ftpmethod;
 
+/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
+#define CURLPROTO_HTTP   (1<<0)
+#define CURLPROTO_HTTPS  (1<<1)
+#define CURLPROTO_FTP    (1<<2)
+#define CURLPROTO_FTPS   (1<<3)
+#define CURLPROTO_SCP    (1<<4)
+#define CURLPROTO_SFTP   (1<<5)
+#define CURLPROTO_TELNET (1<<6)
+#define CURLPROTO_LDAP   (1<<7)
+#define CURLPROTO_LDAPS  (1<<8)
+#define CURLPROTO_DICT   (1<<9)
+#define CURLPROTO_FILE   (1<<10)
+#define CURLPROTO_TFTP   (1<<11)
+#define CURLPROTO_ALL    (~0) /* enable everything */
+
 /* long may be 32 or 64 bits, but we should never depend on anything else
    but 32 */
 #define CURLOPTTYPE_LONG          0
@@ -868,7 +903,7 @@ typedef enum {
   /* DNS cache timeout */
   CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
 
-  /* send linked-list of pre-transfer QUOTE commands (Wesley Laxton)*/
+  /* send linked-list of pre-transfer QUOTE commands */
   CINIT(PREQUOTE, OBJECTPOINT, 93),
 
   /* set the debug function */
@@ -933,7 +968,10 @@ typedef enum {
      argument */
   CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
 
-  /* FTP Option that causes missing dirs to be created on the remote server */
+  /* FTP Option that causes missing dirs to be created on the remote server.
+     In 7.19.4 we introduced the convenience enums for this option using the
+     CURLFTP_CREATE_DIR prefix.
+  */
   CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
 
   /* Set this to a bitmask value to enable the particular authentications
@@ -1150,6 +1188,36 @@ typedef enum {
   CINIT(PROXYUSERNAME, OBJECTPOINT, 175),
   CINIT(PROXYPASSWORD, OBJECTPOINT, 176),
 
+  /* Comma separated list of hostnames defining no-proxy zones. These should
+     match both hostnames directly, and hostnames within a domain. For
+     example, local.com will match local.com and www.local.com, but NOT
+     notlocal.com or www.notlocal.com. For compatibility with other
+     implementations of this, .local.com will be considered to be the same as
+     local.com. A single * is the only valid wildcard, and effectively
+     disables the use of proxy. */
+  CINIT(NOPROXY, OBJECTPOINT, 177),
+
+  /* block size for TFTP transfers */
+  CINIT(TFTP_BLKSIZE, LONG, 178),
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_SERVICE, LONG, 179),
+
+  /* Socks Service */
+  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
+
+  /* set the bitmask for the protocols that are allowed to be used for the
+     transfer, which thus helps the app which takes URLs from users or other
+     external inputs and want to restrict what protocol(s) to deal
+     with. Defaults to CURLPROTO_ALL. */
+  CINIT(PROTOCOLS, LONG, 181),
+
+  /* set the bitmask for the protocols that libcurl is allowed to follow to,
+     as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
+     to be set in both bitmasks to be allowed to get redirected to. Defaults
+     to all protocols except FILE and SCP. */
+  CINIT(REDIR_PROTOCOLS, LONG, 182),
+
   CURLOPT_LASTENTRY /* the last unused */
 } CURLoption;
 
@@ -1448,7 +1516,9 @@ CURL_EXTERN void curl_free(void *p);
  * DESCRIPTION
  *
  * curl_global_init() should be invoked exactly once for each application that
- * uses libcurl
+ * uses libcurl and before any call of other libcurl function.
+ *
+ * This function is not thread-safe!
  */
 CURL_EXTERN CURLcode curl_global_init(long flags);
 
@@ -1571,9 +1641,10 @@ typedef enum {
   CURLINFO_PRIMARY_IP       = CURLINFO_STRING + 32,
   CURLINFO_APPCONNECT_TIME  = CURLINFO_DOUBLE + 33,
   CURLINFO_CERTINFO         = CURLINFO_SLIST  + 34,
+  CURLINFO_CONDITION_UNMET  = CURLINFO_LONG   + 35,
   /* Fill in new entries below here! */
 
-  CURLINFO_LASTONE          = 34
+  CURLINFO_LASTONE          = 35
 } CURLINFO;
 
 /* CURLINFO_RESPONSE_CODE is the new name for the option previously known as

include/curl/curlbuild.h.cmake

@@ -0,0 +1,153 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, 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$
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#cmakedefine CURL_PULL_SYS_TYPES_H ${CURL_PULL_SYS_TYPES_H}
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface.  */
+#cmakedefine CURL_PULL_STDINT_H ${CURL_PULL_STDINT_H}
+#ifdef CURL_PULL_STDINT_H
+#  include <stdint.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file inttypes.h must be included by the external interface. */
+#cmakedefine CURL_PULL_INTTYPES_H ${CURL_PULL_INTTYPES_H}
+#ifdef CURL_PULL_INTTYPES_H
+#  include <inttypes.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_LONG ${CURL_SIZEOF_LONG}
+
+/* Signed integral data type used for curl_off_t. */
+#cmakedefine CURL_TYPEOF_CURL_OFF_T ${CURL_TYPEOF_CURL_OFF_T}
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_T ${CURL_FORMAT_CURL_OFF_T}
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_TU ${CURL_FORMAT_CURL_OFF_TU}
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_OFF_T ${CURL_FORMAT_OFF_T}
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_CURL_OFF_T ${CURL_SIZEOF_CURL_OFF_T}
+
+/* curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_T ${CURL_SUFFIX_CURL_OFF_T}
+
+/* unsigned curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_TU ${CURL_SUFFIX_CURL_OFF_TU}
+
+#endif /* __CURL_CURLBUILD_H */

include/curl/curlbuild.h.dist

@@ -114,6 +114,16 @@
    Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
 #endif
 
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
 #ifdef CURL_TYPEOF_CURL_OFF_T
 #  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
    Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
@@ -155,314 +165,336 @@
 
 #if defined(__DJGPP__) || defined(__GO32__)
 #  if defined(__DJGPP__) && (__DJGPP__ > 1)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__SALFORDC__)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  long
-#  define CURL_FORMAT_CURL_OFF_T  "ld"
-#  define CURL_FORMAT_CURL_OFF_TU "lu"
-#  define CURL_FORMAT_OFF_T       "%ld"
-#  define CURL_SIZEOF_CURL_OFF_T  4
-#  define CURL_SUFFIX_CURL_OFF_T  L
-#  define CURL_SUFFIX_CURL_OFF_TU UL
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__BORLANDC__)
 #  if (__BORLANDC__ < 0x520)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  __int64
-#    define CURL_FORMAT_CURL_OFF_T  "I64d"
-#    define CURL_FORMAT_CURL_OFF_TU "I64u"
-#    define CURL_FORMAT_OFF_T       "%I64d"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  i64
-#    define CURL_SUFFIX_CURL_OFF_TU ui64
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__TURBOC__)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  long
-#  define CURL_FORMAT_CURL_OFF_T  "ld"
-#  define CURL_FORMAT_CURL_OFF_TU "lu"
-#  define CURL_FORMAT_OFF_T       "%ld"
-#  define CURL_SIZEOF_CURL_OFF_T  4
-#  define CURL_SUFFIX_CURL_OFF_T  L
-#  define CURL_SUFFIX_CURL_OFF_TU UL
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__WATCOMC__)
 #  if defined(__386__)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  __int64
-#    define CURL_FORMAT_CURL_OFF_T  "I64d"
-#    define CURL_FORMAT_CURL_OFF_TU "I64u"
-#    define CURL_FORMAT_OFF_T       "%I64d"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  i64
-#    define CURL_SUFFIX_CURL_OFF_TU ui64
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__POCC__)
 #  if (__POCC__ < 280)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  elif defined(_MSC_VER)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  __int64
-#    define CURL_FORMAT_CURL_OFF_T  "I64d"
-#    define CURL_FORMAT_CURL_OFF_TU "I64u"
-#    define CURL_FORMAT_OFF_T       "%I64d"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  i64
-#    define CURL_SUFFIX_CURL_OFF_TU ui64
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__LCC__)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  long
-#  define CURL_FORMAT_CURL_OFF_T  "ld"
-#  define CURL_FORMAT_CURL_OFF_TU "lu"
-#  define CURL_FORMAT_OFF_T       "%ld"
-#  define CURL_SIZEOF_CURL_OFF_T  4
-#  define CURL_SUFFIX_CURL_OFF_T  L
-#  define CURL_SUFFIX_CURL_OFF_TU UL
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__SYMBIAN32__)
 #  if defined(__EABI__)  /* Treat all ARM compilers equally */
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  elif defined(__CW32__)
 #    pragma longlong on
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  elif defined(__VC32__)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  __int64
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__MWERKS__)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  long long
-#  define CURL_FORMAT_CURL_OFF_T  "lld"
-#  define CURL_FORMAT_CURL_OFF_TU "llu"
-#  define CURL_FORMAT_OFF_T       "%lld"
-#  define CURL_SIZEOF_CURL_OFF_T  8
-#  define CURL_SUFFIX_CURL_OFF_T  LL
-#  define CURL_SUFFIX_CURL_OFF_TU ULL
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_FORMAT_OFF_T          "%lld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(_WIN32_WCE)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  __int64
-#  define CURL_FORMAT_CURL_OFF_T  "I64d"
-#  define CURL_FORMAT_CURL_OFF_TU "I64u"
-#  define CURL_FORMAT_OFF_T       "%I64d"
-#  define CURL_SIZEOF_CURL_OFF_T  8
-#  define CURL_SUFFIX_CURL_OFF_T  i64
-#  define CURL_SUFFIX_CURL_OFF_TU ui64
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__MINGW32__)
-#  define CURL_SIZEOF_LONG        4
-#  define CURL_TYPEOF_CURL_OFF_T  long long
-#  define CURL_FORMAT_CURL_OFF_T  "I64d"
-#  define CURL_FORMAT_CURL_OFF_TU "I64u"
-#  define CURL_FORMAT_OFF_T       "%I64d"
-#  define CURL_SIZEOF_CURL_OFF_T  8
-#  define CURL_SUFFIX_CURL_OFF_T  LL
-#  define CURL_SUFFIX_CURL_OFF_TU ULL
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__VMS)
 #  if defined(__alpha) || defined(__ia64)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 #elif defined(__OS400__)
 #  if defined(__ILEC400__)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
 #  endif
 
 #elif defined(__MVS__)
 #  if defined(__IBMC__) || defined(__IBMCPP__)
 #    if defined(_ILP32)
-#      define CURL_SIZEOF_LONG        4
+#      define CURL_SIZEOF_LONG           4
 #    elif defined(_LP64)
-#      define CURL_SIZEOF_LONG        8
+#      define CURL_SIZEOF_LONG           8
 #    endif
 #    if defined(_LONG_LONG)
-#      define CURL_TYPEOF_CURL_OFF_T  long long
-#      define CURL_FORMAT_CURL_OFF_T  "lld"
-#      define CURL_FORMAT_CURL_OFF_TU "llu"
-#      define CURL_FORMAT_OFF_T       "%lld"
-#      define CURL_SIZEOF_CURL_OFF_T  8
-#      define CURL_SUFFIX_CURL_OFF_T  LL
-#      define CURL_SUFFIX_CURL_OFF_TU ULL
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
 #    elif defined(_LP64)
-#      define CURL_TYPEOF_CURL_OFF_T  long
-#      define CURL_FORMAT_CURL_OFF_T  "ld"
-#      define CURL_FORMAT_CURL_OFF_TU "lu"
-#      define CURL_FORMAT_OFF_T       "%ld"
-#      define CURL_SIZEOF_CURL_OFF_T  8
-#      define CURL_SUFFIX_CURL_OFF_T  L
-#      define CURL_SUFFIX_CURL_OFF_TU UL
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
 #    else
-#      define CURL_TYPEOF_CURL_OFF_T  long
-#      define CURL_FORMAT_CURL_OFF_T  "ld"
-#      define CURL_FORMAT_CURL_OFF_TU "lu"
-#      define CURL_FORMAT_OFF_T       "%ld"
-#      define CURL_SIZEOF_CURL_OFF_T  4
-#      define CURL_SUFFIX_CURL_OFF_T  L
-#      define CURL_SUFFIX_CURL_OFF_TU UL
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
 #    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
 #  endif
 
 #elif defined(__370__)
 #  if defined(__IBMC__) || defined(__IBMCPP__)
 #    if defined(_ILP32)
-#      define CURL_SIZEOF_LONG        4
+#      define CURL_SIZEOF_LONG           4
 #    elif defined(_LP64)
-#      define CURL_SIZEOF_LONG        8
+#      define CURL_SIZEOF_LONG           8
 #    endif
 #    if defined(_LONG_LONG)
-#      define CURL_TYPEOF_CURL_OFF_T  long long
-#      define CURL_FORMAT_CURL_OFF_T  "lld"
-#      define CURL_FORMAT_CURL_OFF_TU "llu"
-#      define CURL_FORMAT_OFF_T       "%lld"
-#      define CURL_SIZEOF_CURL_OFF_T  8
-#      define CURL_SUFFIX_CURL_OFF_T  LL
-#      define CURL_SUFFIX_CURL_OFF_TU ULL
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
 #    elif defined(_LP64)
-#      define CURL_TYPEOF_CURL_OFF_T  long
-#      define CURL_FORMAT_CURL_OFF_T  "ld"
-#      define CURL_FORMAT_CURL_OFF_TU "lu"
-#      define CURL_FORMAT_OFF_T       "%ld"
-#      define CURL_SIZEOF_CURL_OFF_T  8
-#      define CURL_SUFFIX_CURL_OFF_T  L
-#      define CURL_SUFFIX_CURL_OFF_TU UL
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
 #    else
-#      define CURL_TYPEOF_CURL_OFF_T  long
-#      define CURL_FORMAT_CURL_OFF_T  "ld"
-#      define CURL_FORMAT_CURL_OFF_TU "lu"
-#      define CURL_FORMAT_OFF_T       "%ld"
-#      define CURL_SIZEOF_CURL_OFF_T  4
-#      define CURL_SUFFIX_CURL_OFF_T  L
-#      define CURL_SUFFIX_CURL_OFF_TU UL
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
 #    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
 #  endif
 
-/* ===================================== */
-/*    SunPro Compilers                   */
-/* ===================================== */
-
-#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-#include <sys/types.h>
-#include <stdint.h>
-
-#  define CURL_TYPEOF_CURL_OFF_T off_t
-#  define CURL_SIZEOF_CURL_OFF_T 8
-#  if defined(__amd64) || defined(__sparcv9)
-#     define CURL_SIZEOF_LONG 8
-#     define CURL_FORMAT_CURL_OFF_T  "ld"
-#     define CURL_FORMAT_CURL_OFF_TU "lu"
-#     define CURL_FORMAT_OFF_T       "%ld"
-#     define CURL_SUFFIX_CURL_OFF_T L
-#     define CURL_SUFFIX_CURL_OFF_TU UL
-#  else
-#     define CURL_SIZEOF_LONG 4
-#     define CURL_FORMAT_CURL_OFF_T  "lld"
-#     define CURL_FORMAT_CURL_OFF_TU "llu"
-#     define CURL_FORMAT_OFF_T       "%lld"
-#     define CURL_SUFFIX_CURL_OFF_T LL
-#     define CURL_SUFFIX_CURL_OFF_TU ULL
-#  endif
+#elif defined(TPF)
+#  define CURL_SIZEOF_LONG           8
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 /* ===================================== */
 /*    KEEP MSVC THE PENULTIMATE ENTRY    */
@@ -470,24 +502,26 @@
 
 #elif defined(_MSC_VER)
 #  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  __int64
-#    define CURL_FORMAT_CURL_OFF_T  "I64d"
-#    define CURL_FORMAT_CURL_OFF_TU "I64u"
-#    define CURL_FORMAT_OFF_T       "%I64d"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  i64
-#    define CURL_SUFFIX_CURL_OFF_TU ui64
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
 #  else
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  4
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
 
 /* ===================================== */
 /*    KEEP GENERIC GCC THE LAST ENTRY    */
@@ -495,30 +529,52 @@
 
 #elif defined(__GNUC__)
 #  if defined(__i386__) || defined(__ppc__)
-#    define CURL_SIZEOF_LONG        4
-#    define CURL_TYPEOF_CURL_OFF_T  long long
-#    define CURL_FORMAT_CURL_OFF_T  "lld"
-#    define CURL_FORMAT_CURL_OFF_TU "llu"
-#    define CURL_FORMAT_OFF_T       "%lld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  LL
-#    define CURL_SUFFIX_CURL_OFF_TU ULL
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
 #  elif defined(__x86_64__) || defined(__ppc64__)
-#    define CURL_SIZEOF_LONG        8
-#    define CURL_TYPEOF_CURL_OFF_T  long
-#    define CURL_FORMAT_CURL_OFF_T  "ld"
-#    define CURL_FORMAT_CURL_OFF_TU "lu"
-#    define CURL_FORMAT_OFF_T       "%ld"
-#    define CURL_SIZEOF_CURL_OFF_T  8
-#    define CURL_SUFFIX_CURL_OFF_T  L
-#    define CURL_SUFFIX_CURL_OFF_TU UL
+#    define CURL_SIZEOF_LONG           8
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
 #  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
 
 #else
 #  error "Unknown non-configure build target!"
    Error Compilation_aborted_Unknown_non_configure_build_target
 #endif
 
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
 /* Data type definition of curl_off_t. */
 
 #ifdef CURL_TYPEOF_CURL_OFF_T

include/curl/curlbuild.h.in

@@ -7,7 +7,7 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
@@ -63,6 +63,16 @@
    Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
 #endif
 
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
 #ifdef CURL_TYPEOF_CURL_OFF_T
 #  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
    Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
@@ -102,6 +112,18 @@
 /*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
 /* ================================================================ */
 
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file ws2tcpip.h must be included by the external interface. */
+#undef CURL_PULL_WS2TCPIP_H
+#ifdef CURL_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
 /* Configure process defines this to 1 when it finds out that system   */
 /* header file sys/types.h must be included by the external interface. */
 #undef CURL_PULL_SYS_TYPES_H
@@ -123,9 +145,25 @@
 #  include <inttypes.h>
 #endif
 
+/* Configure process defines this to 1 when it finds out that system    */
+/* header file sys/socket.h must be included by the external interface. */
+#undef CURL_PULL_SYS_SOCKET_H
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
 /* The size of `long', as computed by sizeof. */
 #undef CURL_SIZEOF_LONG
 
+/* Integral data type used for curl_socklen_t. */
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#undef CURL_SIZEOF_CURL_SOCKLEN_T
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
 /* Signed integral data type used for curl_off_t. */
 #undef CURL_TYPEOF_CURL_OFF_T
 

include/curl/curlrules.h

@@ -7,7 +7,7 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2009, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
@@ -81,6 +81,16 @@
    Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
 #endif
 
+#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
 #ifndef CURL_TYPEOF_CURL_OFF_T
 #  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
    Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
@@ -153,6 +163,26 @@ typedef char
   __curl_rule_03__
     [CurlchkszGE(curl_off_t, long)];
 
+/*
+ * Verify that the size previously defined and expected for
+ * curl_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_04__
+    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of curl_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __curl_rule_05__
+    [CurlchkszGE(curl_socklen_t, int)];
+
 /* ================================================================ */
 /*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
 /* ================================================================ */
@@ -207,10 +237,13 @@ typedef char
  * Get rid of macros not intended to exist beyond this point.
  */
 
+#undef CURL_PULL_WS2TCPIP_H
 #undef CURL_PULL_SYS_TYPES_H
+#undef CURL_PULL_SYS_SOCKET_H
 #undef CURL_PULL_STDINT_H
 #undef CURL_PULL_INTTYPES_H
 
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
 #undef CURL_TYPEOF_CURL_OFF_T
 
 #endif /* __CURL_CURLRULES_H */

include/curl/curlver.h

@@ -31,13 +31,13 @@
 
 /* This is the version number of the libcurl package from which this header
    file origins: */
-#define LIBCURL_VERSION "7.19.3-CVS"
+#define LIBCURL_VERSION "7.19.5-CVS"
 
 /* The numeric version number is also available "in parts" by using these
    defines: */
 #define LIBCURL_VERSION_MAJOR 7
 #define LIBCURL_VERSION_MINOR 19
-#define LIBCURL_VERSION_PATCH 3
+#define LIBCURL_VERSION_PATCH 5
 
 /* This is the numeric version of the libcurl version number, meant for easier
    parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
@@ -54,7 +54,7 @@
    and it is always a greater number in a more recent release. It makes
    comparisons with greater than and less than work.
 */
-#define LIBCURL_VERSION_NUM 0x071303
+#define LIBCURL_VERSION_NUM 0x071305
 
 /*
  * This is the date and time when the full source package was created. The