take port numbers into account when finding a previous session from the

cache

MITX.txt

@@ -1,6 +1,6 @@
 COPYRIGHT AND PERMISSION NOTICE
 
-Copyright (c) 2000, Daniel Stenberg, <daniel@haxx.se>.
+Copyright (c) 1996 - 2001, Daniel Stenberg, <daniel@haxx.se>.
 
 All rights reserved.
 

Makefile.am

@@ -6,8 +6,9 @@ AUTOMAKE_OPTIONS = foreign no-dependencies
 
 EXTRA_DIST =						\
 	CHANGES LEGAL maketgz MITX.txt MPL-1.1.txt	\
-	config-win32.h reconf packages/README Makefile.dist \
+	config-win32.h reconf Makefile.dist		\
-	curl-config.in libtool
+	curl-config.in build_vms.com config-riscos.h	\
+	config-vms.h
 
 bin_SCRIPTS = curl-config
 
@@ -17,6 +18,9 @@ SUBDIRS = docs lib src include tests packages perl php
 dist-hook:
 	cp $(srcdir)/Makefile.dist $(distdir)/Makefile
 
+html:
+	cd docs; make html
+
 check: test
 
 test:

README

@@ -12,7 +12,7 @@ README
   document.
 
   libcurl is a library that Curl is using to do its job. It is readily
-  available to be used by your software. Read the libcurl.5 man page to
+  available to be used by your software. Read the libcurl.3 man page to
   find out how!
 
   You find answers to the most frequent questions we get in the FAQ document.

acinclude.m4

@@ -0,0 +1,325 @@
+dnl Check for socklen_t: historically on BSD it is an int, and in
+dnl POSIX 1g it is a type of its own, but some platforms use different
+dnl types for the argument to getsockopt, getpeername, etc.  So we
+dnl have to test to find something that will work.
+AC_DEFUN([TYPE_SOCKLEN_T],
+[
+   AC_CHECK_TYPE([socklen_t], ,[
+      AC_MSG_CHECKING([for socklen_t equivalent])
+      AC_CACHE_VAL([curl_cv_socklen_t_equiv],
+      [
+         # Systems have either "struct sockaddr *" or
+         # "void *" as the second argument to getpeername
+         curl_cv_socklen_t_equiv=
+         for arg2 in "struct sockaddr" void; do
+            for t in int size_t unsigned long "unsigned long"; do
+               AC_TRY_COMPILE([
+                  #include <sys/types.h>
+                  #include <sys/socket.h>
+
+                  int getpeername (int, $arg2 *, $t *);
+               ],[
+                  $t len;
+                  getpeername(0,0,&len);
+               ],[
+                  curl_cv_socklen_t_equiv="$t"
+                  break
+               ])
+            done
+         done
+
+         if test "x$curl_cv_socklen_t_equiv" = x; then
+            AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
+         fi
+      ])
+      AC_MSG_RESULT($curl_cv_socklen_t_equiv)
+      AC_DEFINE_UNQUOTED(socklen_t, $curl_cv_socklen_t_equiv,
+			[type to use in place of socklen_t if not defined])],
+      [#include <sys/types.h>
+#include <sys/socket.h>])
+])
+
+dnl ************************************************************
+dnl check for "localhost", if it doesn't exist, we can't do the
+dnl gethostbyname_r tests!
+dnl 
+
+AC_DEFUN(CURL_CHECK_WORKING_RESOLVER,[
+AC_MSG_CHECKING([if "localhost" resolves])
+AC_TRY_RUN([
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+
+int
+main () {
+struct hostent *h;
+h = gethostbyname("localhost");
+exit (h == NULL ? 1 : 0); }],[
+      AC_MSG_RESULT(yes)],[
+      AC_MSG_RESULT(no)
+      AC_MSG_ERROR([can't figure out gethostbyname_r() since localhost doesn't resolve])
+
+      ]
+)
+])
+
+dnl ************************************************************
+dnl check for working getaddrinfo()
+dnl
+AC_DEFUN(CURL_CHECK_WORKING_GETADDRINFO,[
+  AC_CACHE_CHECK(for working getaddrinfo, ac_cv_working_getaddrinfo,[
+  AC_TRY_RUN( [
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+void main(void) {
+    struct addrinfo hints, *ai;
+    int error;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
+    if (error) {
+        exit(1);
+    }
+    else {
+        exit(0);
+    }
+}
+],[
+  ac_cv_working_getaddrinfo="yes"
+],[
+  ac_cv_working_getaddrinfo="no"
+],[
+  ac_cv_working_getaddrinfo="yes"
+])])
+if test "$ac_cv_working_getaddrinfo" = "yes"; then
+  AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if getaddrinfo exists and works])
+  AC_DEFINE(ENABLE_IPV6, 1, [Define if you want to enable IPv6 support])
+
+  IPV6_ENABLED=1
+  AC_SUBST(IPV6_ENABLED)
+fi
+])
+
+
+AC_DEFUN(CURL_CHECK_LOCALTIME_R,
+[
+  dnl check for a few thread-safe functions
+  AC_CHECK_FUNCS(localtime_r,[
+    AC_MSG_CHECKING(whether localtime_r is declared)
+    AC_EGREP_CPP(localtime_r,[
+#include <time.h>],[
+      AC_MSG_RESULT(yes)],[
+      AC_MSG_RESULT(no)
+      AC_MSG_CHECKING(whether localtime_r with -D_REENTRANT is declared)
+      AC_EGREP_CPP(localtime_r,[
+#define _REENTRANT
+#include <time.h>],[
+	AC_DEFINE(NEED_REENTRANT)
+	AC_MSG_RESULT(yes)],
+	AC_MSG_RESULT(no))])])
+])
+
+AC_DEFUN(CURL_CHECK_INET_NTOA_R,
+[
+  dnl determine if function definition for inet_ntoa_r exists.
+  AC_CHECK_FUNCS(inet_ntoa_r,[
+    AC_MSG_CHECKING(whether inet_ntoa_r is declared)
+    AC_EGREP_CPP(inet_ntoa_r,[
+#include <arpa/inet.h>],[
+      AC_DEFINE(HAVE_INET_NTOA_R_DECL)
+      AC_MSG_RESULT(yes)],[
+      AC_MSG_RESULT(no)
+      AC_MSG_CHECKING(whether inet_ntoa_r with -D_REENTRANT is declared)
+      AC_EGREP_CPP(inet_ntoa_r,[
+#define _REENTRANT
+#include <arpa/inet.h>],[
+	AC_DEFINE(HAVE_INET_NTOA_R_DECL)
+	AC_DEFINE(NEED_REENTRANT)
+	AC_MSG_RESULT(yes)],
+	AC_MSG_RESULT(no))])])
+
+])
+
+AC_DEFUN(CURL_CHECK_GETHOSTBYADDR_R,
+[
+  dnl check for number of arguments to gethostbyaddr_r. it might take
+  dnl either 5, 7, or 8 arguments.
+  AC_CHECK_FUNCS(gethostbyaddr_r,[
+    AC_MSG_CHECKING(if gethostbyaddr_r takes 5 arguments)
+    AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <netdb.h>],[
+char * address;
+int length;
+int type;
+struct hostent h;
+struct hostent_data hdata;
+int rc;
+rc = gethostbyaddr_r(address, length, type, &h, &hdata);],[
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(HAVE_GETHOSTBYADDR_R_5)
+      ac_cv_gethostbyaddr_args=5],[
+      AC_MSG_RESULT(no)
+      AC_MSG_CHECKING(if gethostbyaddr_r with -D_REENTRANT takes 5 arguments)
+      AC_TRY_COMPILE([
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>],[
+char * address;
+int length;
+int type;
+struct hostent h;
+struct hostent_data hdata;
+int rc;
+rc = gethostbyaddr_r(address, length, type, &h, &hdata);],[
+	AC_MSG_RESULT(yes)
+	AC_DEFINE(HAVE_GETHOSTBYADDR_R_5)
+	AC_DEFINE(NEED_REENTRANT)
+	ac_cv_gethostbyaddr_args=5],[
+	AC_MSG_RESULT(no)
+	AC_MSG_CHECKING(if gethostbyaddr_r takes 7 arguments)
+	AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <netdb.h>],[
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+
+hp = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &h_errnop);],[
+	  AC_MSG_RESULT(yes)
+	  AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
+	  ac_cv_gethostbyaddr_args=7],[
+	  AC_MSG_RESULT(no)
+	  AC_MSG_CHECKING(if gethostbyaddr_r takes 8 arguments)
+	  AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <netdb.h>],[
+char * address;
+int length;
+int type;
+struct hostent h;
+char buffer[8192];
+int h_errnop;
+struct hostent * hp;
+int rc;
+
+rc = gethostbyaddr_r(address, length, type, &h,
+                     buffer, 8192, &hp, &h_errnop);],[
+	    AC_MSG_RESULT(yes)
+	    AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
+	    ac_cv_gethostbyaddr_args=8],[
+	    AC_MSG_RESULT(no)
+	    have_missing_r_funcs="$have_missing_r_funcs gethostbyaddr_r"])])])])])
+
+
+])
+
+AC_DEFUN(CURL_CHECK_GETHOSTBYNAME_R,
+[
+  dnl check for number of arguments to gethostbyname_r. it might take
+  dnl either 3, 5, or 6 arguments.
+  AC_CHECK_FUNCS(gethostbyname_r,[
+    AC_MSG_CHECKING(if gethostbyname_r takes 3 arguments)
+    AC_TRY_RUN([
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+
+int
+main () {
+struct hostent h;
+struct hostent_data hdata;
+char *name = "localhost";
+int rc;
+memset(&h, 0, sizeof(struct hostent));
+memset(&hdata, 0, sizeof(struct hostent_data));
+rc = gethostbyname_r(name, &h, &hdata);
+exit (rc != 0 ? 1 : 0); }],[
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
+      ac_cv_gethostbyname_args=3],[
+      AC_MSG_RESULT(no)
+      AC_MSG_CHECKING(if gethostbyname_r with -D_REENTRANT takes 3 arguments)
+      AC_TRY_RUN([
+#define _REENTRANT
+
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+
+int
+main () {
+struct hostent h;
+struct hostent_data hdata;
+char *name = "localhost";
+int rc;
+memset(&h, 0, sizeof(struct hostent));
+memset(&hdata, 0, sizeof(struct hostent_data));
+rc = gethostbyname_r(name, &h, &hdata);
+exit (rc != 0 ? 1 : 0); }],[
+	AC_MSG_RESULT(yes)
+	AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
+	AC_DEFINE(NEED_REENTRANT)
+	ac_cv_gethostbyname_args=3],[
+	AC_MSG_RESULT(no)
+	AC_MSG_CHECKING(if gethostbyname_r takes 5 arguments)
+	AC_TRY_RUN([
+#include <sys/types.h>
+#include <netdb.h>
+
+int
+main () {
+struct hostent *hp;
+struct hostent h;
+char *name = "localhost";
+char buffer[8192];
+int h_errno;
+hp = gethostbyname_r(name, &h, buffer, 8192, &h_errno);
+exit (hp == NULL ? 1 : 0); }],[
+	  AC_MSG_RESULT(yes)
+	  AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
+          ac_cv_gethostbyname_args=5],[
+	  AC_MSG_RESULT(no)
+	  AC_MSG_CHECKING(if gethostbyname_r takes 6 arguments)
+	  AC_TRY_RUN([
+#include <sys/types.h>
+#include <netdb.h>
+
+int
+main () {
+struct hostent h;
+struct hostent *hp;
+char *name = "localhost";
+char buf[8192];
+int rc;
+int h_errno;
+rc = gethostbyname_r(name, &h, buf, 8192, &hp, &h_errno);
+exit (rc != 0 ? 1 : 0); }],[
+	    AC_MSG_RESULT(yes)
+	    AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
+            ac_cv_gethostbyname_args=6],[
+	    AC_MSG_RESULT(no)
+	    have_missing_r_funcs="$have_missing_r_funcs gethostbyname_r"],
+	    [ac_cv_gethostbyname_args=0])],
+	  [ac_cv_gethostbyname_args=0])],
+	[ac_cv_gethostbyname_args=0])],
+      [ac_cv_gethostbyname_args=0])])
+
+if test "$ac_cv_func_gethostbyname_r" = "yes"; then
+  if test "$ac_cv_gethostbyname_args" = "0"; then
+    dnl there's a gethostbyname_r() function, but we don't know how
+    dnl many arguments it wants!
+    AC_MSG_ERROR([couldn't figure out how to use gethostbyname_r()])
+  fi
+fi
+])

config-riscos.h

@@ -0,0 +1,25 @@
+
+#define socklen_t int
+
+#define HAVE_SYS_SOCKET_H
+#define HAVE_ARPA_INET_H
+#define HAVE_SYS_SELECT_H
+#define HAVE_FCNTL_H
+#define HAVE_GETTIMEOFDAY
+
+#define HAVE_SELECT
+#define HAVE_SOCKET
+#define ifr_dstaddr ifr_addr
+
+
+#include <sys/socket.h>
+#include <sys/if.h>
+#include <sys/fcntl.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+#define ioctl(a,b,c,d) (ioctl(a,b,c) * (d==d))
+
+
+#define OS "RISC OS"

config-vms.h

@@ -0,0 +1,367 @@
+/* config.h.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Define if on AIX 3.
+   System headers sometimes define this.
+   We just want to avoid a redefinition error message.  */
+#ifndef _ALL_SOURCE
+#undef _ALL_SOURCE
+#endif
+
+/* Define to empty if the keyword does not work.  */
+#undef const
+
+/* Define as the return type of signal handlers (int or void).  */
+#undef RETSIGTYPE
+
+/* Define to `unsigned' if <sys/types.h> doesn't define.  */
+#undef size_t
+
+/* Define if you have the ANSI C header files.  */
+#define STDC_HEADERS 1
+
+/* Define if you can safely include both <sys/time.h> and <time.h>.  */
+#define TIME_WITH_SYS_TIME 1
+
+/* Define cpu-machine-OS */
+#define OS "ALPHA-COMPAQ-VMS"
+
+/* Define if you have the gethostbyaddr_r() function with 5 arguments */
+#undef HAVE_GETHOSTBYADDR_R_5
+
+/* Define if you have the gethostbyaddr_r() function with 7 arguments */
+#undef HAVE_GETHOSTBYADDR_R_7
+
+/* Define if you have the gethostbyaddr_r() function with 8 arguments */
+#undef HAVE_GETHOSTBYADDR_R_8
+
+/* Define if you have the gethostbyname_r() function with 3 arguments */
+#undef HAVE_GETHOSTBYNAME_R_3
+
+/* Define if you have the gethostbyname_r() function with 5 arguments */
+#undef HAVE_GETHOSTBYNAME_R_5
+
+/* Define if you have the gethostbyname_r() function with 6 arguments */
+#undef HAVE_GETHOSTBYNAME_R_6
+
+/* Define if you have the inet_ntoa_r function declared. */
+#undef HAVE_INET_NTOA_R_DECL
+
+/* Define if you need the _REENTRANT define for some functions */
+#undef NEED_REENTRANT
+
+/* Define if you have the Kerberos4 libraries (including -ldes) */
+#undef KRB4
+
+/* Define this to 'int' if ssize_t is not an available typedefed type */
+#undef ssize_t
+
+/* Define this to 'int' if socklen_t is not an available typedefed type */
+#define socklen_t size_t
+
+/* Define this as a suitable file to read random data from */
+#undef RANDOM_FILE
+
+/* Define this to your Entropy Gathering Daemon socket pathname */
+#undef EGD_SOCKET
+
+/* The number of bytes in a long double.  */
+#define SIZEOF_LONG_DOUBLE 8
+
+/* The number of bytes in a long long.  */
+#define SIZEOF_LONG_LONG 8
+
+/* Define if you have the RAND_egd function.  */
+#undef HAVE_RAND_EGD
+
+/* Define if you have the RAND_screen function.  */
+#undef HAVE_RAND_SCREEN
+
+/* Define if you have the RAND_status function.  */
+#undef HAVE_RAND_STATUS
+
+/* Define if you have the closesocket function.  */
+#undef HAVE_CLOSESOCKET
+
+/* Define if you have the geteuid function.  */
+#define HAVE_GETEUID 1
+
+/* Define if you have the gethostbyaddr function.  */
+#define HAVE_GETHOSTBYADDR 1
+
+/* Define if you have the gethostbyaddr_r function.  */
+#undef HAVE_GETHOSTBYADDR_R
+
+/* Define if you have the gethostbyname_r function.  */
+#undef HAVE_GETHOSTBYNAME_R
+
+/* Define if you have the gethostname function.  */
+#define HAVE_GETHOSTNAME 1
+
+/* Define if you have the getpass_r function.  */
+#undef HAVE_GETPASS_R
+
+/* Define if you have the getpwuid function.  */
+#define HAVE_GETPWUID 1
+
+/* Define if you have the getservbyname function.  */
+#define HAVE_GETSERVBYNAME 1
+
+/* Define if you have the gettimeofday function.  */
+#define HAVE_GETTIMEOFDAY 1
+
+/* Define if you have the inet_addr function.  */
+#define HAVE_INET_ADDR 1
+
+/* Define if you have the inet_ntoa function.  */
+#define HAVE_INET_NTOA 1
+
+/* Define if you have the inet_ntoa_r function.  */
+#undef HAVE_INET_NTOA_R
+
+/* Define if you have the krb_get_our_ip_for_realm function.  */
+#undef HAVE_KRB_GET_OUR_IP_FOR_REALM
+
+/* Define if you have the localtime_r function.  */
+#undef HAVE_LOCALTIME_R
+
+/* Define if you have the perror function.  */
+#define HAVE_PERROR 1
+
+/* Define if you have the select function.  */
+#define HAVE_SELECT 1
+
+/* Define if you have the setvbuf function.  */
+#undef HAVE_SETVBUF
+
+/* Define if you have the sigaction function.  */
+#define HAVE_SIGACTION 1
+
+/* Define if you have the signal function.  */
+#define HAVE_SIGNAL 1
+
+/* Define if you have the socket function.  */
+#define HAVE_SOCKET 1
+
+/* Define if you have the strcasecmp function.  */
+#define HAVE_STRCASECMP 1
+
+/* Define if you have the strcmpi function.  */
+#define HAVE_STRCMPI 1
+
+/* Define if you have the strdup function.  */
+#define HAVE_STRDUP 1
+
+/* Define if you have the strftime function.  */
+#define HAVE_STRFTIME 1
+
+/* Define if you have the stricmp function.  */
+#define HAVE_STRICMP 1
+
+/* Define if you have the strlcat function.  */
+#undef HAVE_STRLCAT
+
+/* Define if you have the strlcpy function.  */
+#undef HAVE_STRLCPY
+
+/* Define if you have the strstr function.  */
+#define  HAVE_STRSTR 1
+
+/* Define if you have the tcgetattr function.  */
+#undef HAVE_TCGETATTR
+
+/* Define if you have the tcsetattr function.  */
+#undef HAVE_TCSETATTR
+
+/* Define if you have the uname function.  */
+#define HAVE_UNAME 1
+
+/* Define if you have the <alloca.h> header file.  */
+#undef HAVE_ALLOCA_H
+
+/* Define if you have the <arpa/inet.h> header file.  */
+#undef HAVE_ARPA_INET_H
+
+/* Define if you have the <crypto.h> header file.  */
+#undef HAVE_CRYPTO_H
+
+/* Define if you have the <des.h> header file.  */
+#undef HAVE_DES_H
+
+/* Define if you have the <dlfcn.h> header file.  */
+#undef HAVE_DLFCN_H
+
+/* Define if you have the <err.h> header file.  */
+#define HAVE_ERR_H 1
+
+/* Define if you have the <fcntl.h> header file.  */
+#define HAVE_FCNTL_H 1
+
+/* Define if you have the <getopt.h> header file.  */
+#define HAVE_GETOPT_H 1
+
+/* Define if you have the <io.h> header file.  */
+#undef HAVE_IO_H
+
+/* Define if you have the <krb.h> header file.  */
+#undef HAVE_KRB_H
+
+/* Define if you have the <malloc.h> header file.  */
+#define HAVE_MALLOC_H 1
+
+/* Define if you have the <net/if.h> header file.  */
+#define HAVE_NET_IF_H 1
+
+/* Define if you have the <netdb.h> header file.  */
+#define HAVE_NETDB_H 1
+
+/* Define if you have the <netinet/if_ether.h> header file.  */
+#define HAVE_NETINET_IF_ETHER_H 1
+
+/* Define if you have the <netinet/in.h> header file.  */
+#define HAVE_NETINET_IN_H 1
+
+/* Define if you have the <openssl/crypto.h> header file.  */
+#undef HAVE_OPENSSL_CRYPTO_H
+
+/* Define if you have the <openssl/err.h> header file.  */
+#undef HAVE_OPENSSL_ERR_H
+
+/* Define if you have the <openssl/pem.h> header file.  */
+#undef HAVE_OPENSSL_PEM_H
+
+/* Define if you have the <openssl/rsa.h> header file.  */
+#undef HAVE_OPENSSL_RSA_H
+
+/* Define if you have the <openssl/ssl.h> header file.  */
+#undef HAVE_OPENSSL_SSL_H
+
+/* Define if you have the <openssl/x509.h> header file.  */
+#undef HAVE_OPENSSL_X509_H
+
+/* Define if you have the <pem.h> header file.  */
+#undef HAVE_PEM_H
+
+/* Define if you have the <pwd.h> header file.  */
+#define HAVE_PWD_H 1
+
+/* Define if you have the <rsa.h> header file.  */
+#undef HAVE_RSA_H
+
+/* Define if you have the <sgtty.h> header file.  */
+#define HAVE_SGTTY_H 1
+
+/* Define if you have the <ssl.h> header file.  */
+#undef HAVE_SSL_H
+
+/* Define if you have the <stdlib.h> header file.  */
+#define HAVE_STDLIB_H 1
+
+/* Define if you have the <sys/param.h> header file.  */
+#undef HAVE_SYS_PARAM_H
+
+/* Define if you have the <sys/select.h> header file.  */
+#undef HAVE_SYS_SELECT_H
+
+/* Define if you have the <sys/socket.h> header file.  */
+#define HAVE_SYS_SOCKET_H 1
+
+/* Define if you have the <sys/sockio.h> header file.  */
+#undef HAVE_SYS_SOCKIO_H
+
+/* Define if you have the <sys/stat.h> header file.  */
+#define HAVE_SYS_STAT_H 1
+
+/* Define if you have the <sys/time.h> header file.  */
+#define HAVE_SYS_TIME_H 1
+
+/* Define if you have the <sys/types.h> header file.  */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define if you have the <termio.h> header file.  */
+#undef HAVE_TERMIO_H
+
+/* Define if you have the <termios.h> header file.  */
+#define HAVE_TERMIOS_H 1
+
+/* Define if you have the <time.h> header file.  */
+#define HAVE_TIME_H 1
+
+/* Define if you have the <unistd.h> header file.  */
+#define HAVE_UNISTD_H 1
+
+/* Define if you have the <winsock.h> header file.  */
+#undef HAVE_WINSOCK_H
+
+/* Define if you have the <x509.h> header file.  */
+#undef HAVE_X509_H
+
+/* Define if you have the crypto library (-lcrypto).  */
+#undef HAVE_LIBCRYPTO
+
+/* Define if you have the dl library (-ldl).  */
+#undef HAVE_LIBDL
+
+/* Define if you have the nsl library (-lnsl).  */
+#undef HAVE_LIBNSL
+
+/* Define if you have the resolv library (-lresolv).  */
+#define HAVE_LIBRESOLV 1
+
+/* Define if you have the resolve library (-lresolve).  */
+#undef HAVE_LIBRESOLVE
+
+/* Define if you have the socket library (-lsocket).  */
+#define HAVE_LIBSOCKET 1
+
+/* Define if you have the ssl library (-lssl).  */
+#undef HAVE_LIBSSL
+
+/* Define if you have the ucb library (-lucb).  */
+#undef HAVE_LIBUCB
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#undef _FILE_OFFSET_BITS
+
+/* Define for large files, on AIX-style hosts. */
+#undef _LARGE_FILES
+
+/* Define if getaddrinfo exists and works */
+#define HAVE_GETADDRINFO 1
+
+/* Define if you want to enable IPv6 support */
+#undef ENABLE_IPV6
+
+/* Set to explicitly specify we don't want to use thread-safe functions */
+#undef DISABLED_THREADSAFE
+
+#define	HAVE_TIMEVAL_H	1
+
+/* Name of this package! */
+#define PACKAGE "not-used"
+
+/* Version number of this archive. */
+#define VERSION "not-used"
+
+/* Define if you have the getpass function.  */
+#undef HAVE_GETPASS
+
+/* Define if you have a working OpenSSL installation */
+#undef OPENSSL_ENABLED
+
+/* Define if you have the `dlopen' function. */
+#undef HAVE_DLOPEN
+
+/* Define if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define if you have the `strtok_r' function. */
+#undef HAVE_STRTOK_R
+
+#define HAVE_MEMORY_H   1
+

config-win32.h

@@ -101,6 +101,9 @@
 /* Define if you have the <alloca.h> header file.  */
 /*#define HAVE_ALLOCA_H 1*/
 
+/* Define if you have the malloc.h file.  */
+#define HAVE_MALLOC_H 1
+
 /* Define if you have the <arpa/inet.h> header file.  */
 #define HAVE_ARPA_INET_H 1
 
@@ -185,3 +188,28 @@
 #define HAVE_UNISTD_H 1
 
 #endif
+
+/**************************************************
+ *This is to eliminate the warnings when compiled *
+ * using MS VC++ compiler	  			  *
+ **************************************************/
+#ifdef _MSC_VER
+
+#pragma warning (disable: 4244)	/* truncation from 'const int' to 'char' */
+#pragma warning (disable: 4127)	/* conditional expression is constant */
+#pragma warning (disable: 4706)	/* assignment within conditional expression */
+#pragma warning (disable: 4761)	/* integral size mismatch in argument */
+#pragma warning (disable: 4101)	/* unreferenced local variable */
+#pragma warning (disable: 4131)	/* uses old-style declarator */
+#pragma warning (disable: 4057)	/* const char *' differs in indirection to
+                                   slightly different base types from
+                                   'unsigned char [x] */
+#pragma warning (disable: 4100)	/* unreferenced formal parameter */
+#pragma warning (disable: 4055)	/* type cast' : from data pointer 'void *' to
+                                   function pointer
+                                   'void *(__cdecl *)(char *,int ) */
+#pragma warning (disable: 4701)	/* local variable may be used without having
+                                   been initialized */
+#pragma warning (disable: 4715)	/* ToHour' : not all control paths return a
+                                   value */
+#endif

configure.in

@@ -58,274 +58,12 @@ AC_ARG_ENABLE(debug,
   *)   AC_MSG_RESULT(yes)
 
     CPPFLAGS="$CPPFLAGS -DMALLOCDEBUG"
-    CFLAGS="-Wall -pedantic -g" 
+    CFLAGS="-W -Wall -Wwrite-strings -pedantic -g" 
        ;;
   esac ],
        AC_MSG_RESULT(no)
 )
 
-
-dnl
-dnl check for working getaddrinfo()
-dnl
-AC_DEFUN(CURL_CHECK_WORKING_GETADDRINFO,[
-  AC_CACHE_CHECK(for working getaddrinfo, ac_cv_working_getaddrinfo,[
-  AC_TRY_RUN( [
-#include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-void main(void) {
-    struct addrinfo hints, *ai;
-    int error;
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
-    error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
-    if (error) {
-        exit(1);
-    }
-    else {
-        exit(0);
-    }
-}
-],[
-  ac_cv_working_getaddrinfo="yes"
-],[
-  ac_cv_working_getaddrinfo="no"
-],[
-  ac_cv_working_getaddrinfo="yes"
-])])
-if test "$ac_cv_working_getaddrinfo" = "yes"; then
-  AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if getaddrinfo exists and works])
-  AC_DEFINE(ENABLE_IPV6, 1, [Define if you want to enable IPv6 support])
-
-  IPV6_ENABLED=1
-  AC_SUBST(IPV6_ENABLED)
-fi
-])
-
-
-AC_DEFUN(CURL_CHECK_LOCALTIME_R,
-[
-  dnl check for a few thread-safe functions
-  AC_CHECK_FUNCS(localtime_r,[
-    AC_MSG_CHECKING(whether localtime_r is declared)
-    AC_EGREP_CPP(localtime_r,[
-#include <time.h>],[
-      AC_MSG_RESULT(yes)],[
-      AC_MSG_RESULT(no)
-      AC_MSG_CHECKING(whether localtime_r with -D_REENTRANT is declared)
-      AC_EGREP_CPP(localtime_r,[
-#define _REENTRANT
-#include <time.h>],[
-	AC_DEFINE(NEED_REENTRANT)
-	AC_MSG_RESULT(yes)],
-	AC_MSG_RESULT(no))])])
-])
-
-AC_DEFUN(CURL_CHECK_INET_NTOA_R,
-[
-  dnl determine if function definition for inet_ntoa_r exists.
-  AC_CHECK_FUNCS(inet_ntoa_r,[
-    AC_MSG_CHECKING(whether inet_ntoa_r is declared)
-    AC_EGREP_CPP(inet_ntoa_r,[
-#include <arpa/inet.h>],[
-      AC_DEFINE(HAVE_INET_NTOA_R_DECL)
-      AC_MSG_RESULT(yes)],[
-      AC_MSG_RESULT(no)
-      AC_MSG_CHECKING(whether inet_ntoa_r with -D_REENTRANT is declared)
-      AC_EGREP_CPP(inet_ntoa_r,[
-#define _REENTRANT
-#include <arpa/inet.h>],[
-	AC_DEFINE(HAVE_INET_NTOA_R_DECL)
-	AC_DEFINE(NEED_REENTRANT)
-	AC_MSG_RESULT(yes)],
-	AC_MSG_RESULT(no))])])
-
-])
-
-AC_DEFUN(CURL_CHECK_GETHOSTBYADDR_R,
-[
-  dnl check for number of arguments to gethostbyaddr_r. it might take
-  dnl either 5, 7, or 8 arguments.
-  AC_CHECK_FUNCS(gethostbyaddr_r,[
-    AC_MSG_CHECKING(if gethostbyaddr_r takes 5 arguments)
-    AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <netdb.h>],[
-char * address;
-int length;
-int type;
-struct hostent h;
-struct hostent_data hdata;
-int rc;
-rc = gethostbyaddr_r(address, length, type, &h, &hdata);],[
-      AC_MSG_RESULT(yes)
-      AC_DEFINE(HAVE_GETHOSTBYADDR_R_5)
-      ac_cv_gethostbyaddr_args=5],[
-      AC_MSG_RESULT(no)
-      AC_MSG_CHECKING(if gethostbyaddr_r with -D_REENTRANT takes 5 arguments)
-      AC_TRY_COMPILE([
-#define _REENTRANT
-#include <sys/types.h>
-#include <netdb.h>],[
-char * address;
-int length;
-int type;
-struct hostent h;
-struct hostent_data hdata;
-int rc;
-rc = gethostbyaddr_r(address, length, type, &h, &hdata);],[
-	AC_MSG_RESULT(yes)
-	AC_DEFINE(HAVE_GETHOSTBYADDR_R_5)
-	AC_DEFINE(NEED_REENTRANT)
-	ac_cv_gethostbyaddr_args=5],[
-	AC_MSG_RESULT(no)
-	AC_MSG_CHECKING(if gethostbyaddr_r takes 7 arguments)
-	AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <netdb.h>],[
-char * address;
-int length;
-int type;
-struct hostent h;
-char buffer[8192];
-int h_errnop;
-struct hostent * hp;
-
-hp = gethostbyaddr_r(address, length, type, &h,
-                     buffer, 8192, &h_errnop);],[
-	  AC_MSG_RESULT(yes)
-	  AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
-	  ac_cv_gethostbyaddr_args=7],[
-	  AC_MSG_RESULT(no)
-	  AC_MSG_CHECKING(if gethostbyaddr_r takes 8 arguments)
-	  AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <netdb.h>],[
-char * address;
-int length;
-int type;
-struct hostent h;
-char buffer[8192];
-int h_errnop;
-struct hostent * hp;
-int rc;
-
-rc = gethostbyaddr_r(address, length, type, &h,
-                     buffer, 8192, &hp, &h_errnop);],[
-	    AC_MSG_RESULT(yes)
-	    AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
-	    ac_cv_gethostbyaddr_args=8],[
-	    AC_MSG_RESULT(no)
-	    have_missing_r_funcs="$have_missing_r_funcs gethostbyaddr_r"])])])])])
-
-
-])
-
-AC_DEFUN(CURL_CHECK_GETHOSTBYNAME_R,
-[
-  dnl check for number of arguments to gethostbyname_r. it might take
-  dnl either 3, 5, or 6 arguments.
-  AC_CHECK_FUNCS(gethostbyname_r,[
-    AC_MSG_CHECKING(if gethostbyname_r takes 3 arguments)
-    AC_TRY_RUN([
-#include <string.h>
-#include <sys/types.h>
-#include <netdb.h>
-
-int
-main () {
-struct hostent h;
-struct hostent_data hdata;
-char *name = "localhost";
-int rc;
-memset(&h, 0, sizeof(struct hostent));
-memset(&hdata, 0, sizeof(struct hostent_data));
-rc = gethostbyname_r(name, &h, &hdata);
-exit (rc != 0 ? 1 : 0); }],[
-      AC_MSG_RESULT(yes)
-      AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
-      ac_cv_gethostbyname_args=3],[
-      AC_MSG_RESULT(no)
-      AC_MSG_CHECKING(if gethostbyname_r with -D_REENTRANT takes 3 arguments)
-      AC_TRY_RUN([
-#define _REENTRANT
-
-#include <string.h>
-#include <sys/types.h>
-#include <netdb.h>
-
-int
-main () {
-struct hostent h;
-struct hostent_data hdata;
-char *name = "localhost";
-int rc;
-memset(&h, 0, sizeof(struct hostent));
-memset(&hdata, 0, sizeof(struct hostent_data));
-rc = gethostbyname_r(name, &h, &hdata);
-exit (rc != 0 ? 1 : 0); }],[
-	AC_MSG_RESULT(yes)
-	AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
-	AC_DEFINE(NEED_REENTRANT)
-	ac_cv_gethostbyname_args=3],[
-	AC_MSG_RESULT(no)
-	AC_MSG_CHECKING(if gethostbyname_r takes 5 arguments)
-	AC_TRY_RUN([
-#include <sys/types.h>
-#include <netdb.h>
-
-int
-main () {
-struct hostent *hp;
-struct hostent h;
-char *name = "localhost";
-char buffer[8192];
-int h_errno;
-hp = gethostbyname_r(name, &h, buffer, 8192, &h_errno);
-exit (hp == NULL ? 1 : 0); }],[
-	  AC_MSG_RESULT(yes)
-	  AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
-          ac_cv_gethostbyname_args=5],[
-	  AC_MSG_RESULT(no)
-	  AC_MSG_CHECKING(if gethostbyname_r takes 6 arguments)
-	  AC_TRY_RUN([
-#include <sys/types.h>
-#include <netdb.h>
-
-int
-main () {
-struct hostent h;
-struct hostent *hp;
-char *name = "localhost";
-char buf[8192];
-int rc;
-int h_errno;
-rc = gethostbyname_r(name, &h, buf, 8192, &hp, &h_errno);
-exit (rc != 0 ? 1 : 0); }],[
-	    AC_MSG_RESULT(yes)
-	    AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
-            ac_cv_gethostbyname_args=6],[
-	    AC_MSG_RESULT(no)
-	    have_missing_r_funcs="$have_missing_r_funcs gethostbyname_r"],
-	    [ac_cv_gethostbyname_args=0])],
-	  [ac_cv_gethostbyname_args=0])],
-	[ac_cv_gethostbyname_args=0])],
-      [ac_cv_gethostbyname_args=0])])
-
-if test "$ac_cv_func_gethostbyname_r" = "yes"; then
-  if test "$ac_cv_gethostbyname_args" = "0"; then
-    dnl there's a gethostbyname_r() function, but we don't know how
-    dnl many arguments it wants!
-    AC_MSG_ERROR([couldn't figure out how to use gethostbyname_r()])
-  fi
-fi
-
-])
-
 dnl **********************************************************************
 dnl Checks for IPv6
 dnl **********************************************************************
@@ -559,13 +297,22 @@ then
 else
 
   dnl Check for and handle argument to --with-ssl.
-  EXTRA_SSL=
+
+  dnl save the pre-ssl check flags for a while
+  CLEANLDFLAGS="$LDFLAGS"
+  CLEANCPPFLAGS="$CPPFLAGS"
 
   case "$OPT_SSL" in
   yes)
     EXTRA_SSL=/usr/local/ssl ;;
+  off)
+    EXTRA_SSL= ;;
   *)
-    EXTRA_SSL=$OPT_SSL ;;
+    dnl check the given spot right away!
+    EXTRA_SSL=$OPT_SSL
+    LDFLAGS="$LDFLAGS -L$EXTRA_SSL/lib"
+    CPPFLAGS="$CPPFLAGS -I$EXTRA_SSL/include/openssl -I$EXTRA_SSL/include"
+    ;;
   esac
 
   AC_CHECK_LIB(crypto, CRYPTO_lock,[
@@ -573,8 +320,8 @@ else
      ],[
      OLDLDFLAGS="$LDFLAGS"
      OLDCPPFLAGS="$CPPFLAGS"
-     LDFLAGS="$LDFLAGS -L$EXTRA_SSL/lib"
+     LDFLAGS="$CLEANLDFLAGS -L$EXTRA_SSL/lib"
-     CPPFLAGS="$CPPFLAGS -I$EXTRA_SSL/include/openssl -I$EXTRA_SSL/include"
+     CPPFLAGS="$CLEANCPPFLAGS -I$EXTRA_SSL/include/openssl -I$EXTRA_SSL/include"
      AC_CHECK_LIB(crypto, CRYPTO_add_lock,[
        HAVECRYPTO="yes" ], [
        LDFLAGS="$OLDLDFLAGS"
@@ -681,6 +428,9 @@ then
 Set to explicitly specify we don't want to use thread-safe functions)
 else
 
+  dnl check that 'localhost' resolves first
+  CURL_CHECK_WORKING_RESOLVER
+
   dnl dig around for gethostbyname_r()
   CURL_CHECK_GETHOSTBYNAME_R()
 
@@ -748,26 +498,7 @@ AC_CHECK_SIZEOF(long long, 4)
 # check for ssize_t
 AC_CHECK_TYPE(ssize_t, int)
 
-dnl
+TYPE_SOCKLEN_T
-dnl We can't just AC_CHECK_TYPE() for socklen_t since it doesn't appear
-dnl in the standard headers. We egrep for it in the socket headers and
-dnl if it is used there we assume we have the type defined, otherwise
-dnl we search for it with AC_CHECK_TYPE() the "normal" way
-dnl
-
-if test "$ac_cv_header_sys_socket_h" = "yes"; then
-   AC_MSG_CHECKING(for socklen_t in sys/socket.h)
-   AC_EGREP_HEADER(socklen_t,
-    sys/socket.h,
-    socklen_t=yes
-    AC_MSG_RESULT(yes),
-    AC_MSG_RESULT(no))
-fi
-
-if test "$socklen_t" != "yes"; then
-  # check for socklen_t the standard way if it wasn't found before
-  AC_CHECK_TYPE(socklen_t, int)
-fi
 
 dnl Checks for library functions.
 dnl AC_PROG_GCC_TRADITIONAL

curl-config.in

@@ -73,14 +73,15 @@ while test $# -gt 0; do
 	;;
 
     --cflags)
-       	echo @CPPFLAGS@
+       	echo -I@includedir@
        	;;
 
     --libs)
-       	echo @LDFLAGS@ @LIBS@
+       	echo -L@libdir@ -lcurl @LDFLAGS@ @LIBS@
        	;;
 
     *)
+        echo "unknown option: $1"
 	usage
 	exit 1
 	;;

docs/FAQ

@@ -1,4 +1,4 @@
-Updated: May 29, 2001 (http://curl.haxx.se/docs/faq.shtml)
+Updated: August 23, 2001 (http://curl.haxx.se/docs/faq.shtml)
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -14,6 +14,7 @@ FAQ
   1.4 When will you make curl do XXXX ?
   1.5 Who makes cURL?
   1.6 What do you get for making cURL?
+  1.7 What about CURL from curl.com?
 
  2. Install Related Problems
   2.1 configure doesn't find OpenSSL even when it is installed
@@ -80,7 +81,7 @@ FAQ
   fact it can also be pronounced 'see URL' also helped.
 
   Curl supports a range of common Internet protocols, currently including
-  HTTP, HTTPS, FTP, GOPHER, LDAP, DICT, TELNET and FILE.
+  HTTP, HTTPS, FTP, FTPS, GOPHER, LDAP, DICT, TELNET and FILE.
 
   We spell it cURL or just curl. We pronounce it with an initial k sound:
   [kurl].
@@ -170,6 +171,25 @@ FAQ
   sourceforge.net hosts several project tools we take advantage from like the
   bug tracker, mailing lists and more.
 
+  If you feel you want to show support our project with a donation, a very
+  nice way of doing that would be to buy "gift certificates" at useful online
+  shopping sites, such as amazon.com or thinkgeek.com.
+
+  1.7 What about CURL from curl.com?
+
+  During the summer 2001, curl.com has been busy advertising their client-side
+  programming language for the web, named CURL.
+
+  We are in no way associated with curl.com or their CURL programming
+  language. 
+
+  Our project name curl has been in effective use since 1998. We were not the
+  first computer related project to use the name "curl" and do not claim any
+  first-hand rights to the name.
+
+  We recognize that we will be living in parallel with curl.com and wish them
+  every success.
+
 2. Install Related Problems
 
   2.1. configure doesn't find OpenSSL even when it is installed
@@ -447,9 +467,9 @@ FAQ
   4.6. Can you tell me what error code 142 means?
 
   All error codes that are larger than the highest documented error code means
-  that curl has existed due to a timeout. There was no nice way for curl to
+  that curl has exited due to a crash. This is a serious error, and we
-  abort from such a condition and that's why it got this undocumented
+  appriciate a detailed bug report from you that describes how we could go
-  error. This should not occur in releases after 7.4.1.
+  ahead and repeat this!
 
   4.7. How do I keep user names and passwords secret in Curl command lines?
 

docs/INSTALL

@@ -6,12 +6,10 @@
 
                                 How To Compile
 
-Curl has been compiled and built on numerous different operating systems. The
+Curl has been compiled and built on numerous different operating systems.
-way to proceed is mainly divided in two different ways: the unix way or the 
-windows way.
 
-If you're using Windows (95/98/NT/ME/2000 or whatever) or OS/2, you should
+If you're using Windows (95/98/NT/ME/2000 or whatever), VMS, RISC OS or OS/2,
-continue reading from the Win32 or OS/2 headers further down. All other
+you should continue reading from one the paragraphs further down. All other
 systems should be capable of being installed as described below.
 
 UNIX
@@ -255,10 +253,82 @@ IBM OS/2
    If you're getting huge binaries, probably your makefiles have the -g in
    CFLAGS.
 
+VMS
+===
+   (The VMS section is in whole contributed by the friendly Nico Baggus)
+
+   This is the first attempt at porting cURL to VMS.
+
+   Curl seems to work with FTP & HTTP other protocols are not tested.  (the
+   perl http/ftp testing server supplied as testing too cannot work on VMS
+   because vms has no concept of fork(). [ I tried to give it a whack, but
+   thats of no use.
+
+   SSL stuff has not been ported.
+
+   Telnet has about the same issues as for Win32. When the changes for Win32
+   are clear maybe they'l work for VMS too. The basic problem is that select
+   ONLY works for sockets.
+
+   Marked instances of fopen/[f]stat that might become a problem, especially
+   for non stream files. In this regard, the files opened for writing will be
+   created stream/lf and will thus be safe. Just keep in mind that non-binary
+   read/wring from/to files will have a records size limit of 32767 bytes
+   imposed.
+
+   Stat to get the size of the files is again only safe for stream files &
+   fixed record files without implied CC.
+
+   -- My guess is that only allowing access to stream files is the quickest
+   way to get around the most issues. Therefore all files need to to be
+   checked to be sure they will be stream/lf before processing them.  This is
+   the easiest way out, I know. The reason for this is that code that needs to
+   report the filesize will become a pain in the ass otherwise.
+
+   Exit status.... Well we needed something done here,
+
+   VMS has a structured exist status:
+   | 3  |       2    |     1       |  0|
+   |1098|765432109876|5432109876543|210|
+   +----+------------+-------------+---+
+   |Ctrl|  Facility  | Error code  |sev|
+   +----+------------+-------------+---+
+
+   With the Ctrl-bits an application can tell if part or the whole message has
+   allready been printed from the program, DCL doesn't need to print it again.
+
+   Facility - basicaly the program ID. A code assigned to the program
+   the name can be fetched from external or internal message libraries
+   Errorcode - the errodes assigned by the application
+   Sev. - severity: Even = error, off = non error
+		0 = Warning
+		1 = Success
+		2 = Error
+		3 = Information
+		4 = Fatal 
+		<5-7> reserved.
+
+   This all presents itself with:
+   %<FACILITY>-<SeV>-<Errorname>, <Error message>
+
+   See also the src/curlmsg.msg file, it has the source for the messages In
+   src/main.c a section is devoted to message status values, the globalvalues
+   create symbols with certain values, referenced from a compiled message
+   file. Have all exit function use a exit status derived from a translation
+   table with the compiled message codes.
+
+   This was all compiled with:
+
+	Compaq C V6.2-003 on OpenVMS Alpha V7.1-1H2
+
+   So far for porting notes as of:
+   13-jul-2001
+   N. Baggus
+
 PORTS
 =====
-   This is a probably incomplete list of known hardware and
+   This is a probably incomplete list of known hardware and operating systems
-   operating systems that curl has been compiled for:
+   that curl has been compiled for:
 
         - Ultrix 4.3a
         - SINIX-Z v5
@@ -266,6 +336,7 @@ PORTS
         - Alpha Digital UNIX v3.2
         - Alpha FreeBSD 4.1
         - Alpha Linux 2.2.16
+        - Alpha OpenVMS V7.1-1H2
         - Alpha Tru64 v5.0 5.1
         - HP-PA HP-UX 9.X 10.X 11.X
         - MIPS IRIX 6.2, 6.5
@@ -289,6 +360,7 @@ PORTS
         - m68k AmigaOS 3
         - m68k OpenBSD
         - StrongARM NetBSD 1.4.1
+        - StrongARM (and other ARM) RISC OS 3.1, 4.02
 
 OpenSSL
 =======

docs/LIBCURL

@@ -1,117 +0,0 @@
-                         _ _ _                     _ 
-                        | (_) |__   ___ _   _ _ __| |
-                        | | | '_ \ / __| | | | '__| |
-                        | | | |_) | (__| |_| | |  | |
-                        |_|_|_.__/ \___|\__,_|_|  |_|
-
-                   How To Use Libcurl In Your C/C++ Program
-
- [ libcurl can be used directly from within your Java, PHP, Perl, Ruby or Tcl
-   programs as well, look elsewhere for documentation on this ]
-
- The interface is meant to be very simple for applictions/programmers, hence
- the name "easy". We have therefore minimized the number of entries.
-
-The Easy Interface
-
- When using the easy interface, you init your session and get a handle, which
- you use as input to the following interface functions you use. Use
- curl_easy_init() to get the handle.
-
- You continue by setting all the options you want in the upcoming transfer,
- most important among them is the URL itself (you can't transfer anything
- without a specified URL as you may have figured out yourself). You might want
- to set some callbacks as well that will be called from the library when data
- is available etc. curl_easy_setopt() is there for this.
-
- When all is setup, you tell libcurl to perform the transfer using
- curl_easy_perform(). It will then do the entire operation and won't return
- until it is done or failed.
-
- After the transfer has been made, you cleanup the session with
- curl_easy_cleanup() and libcurl is entirely off the hook! If you want
- persistant connections, you don't cleanup immediately, but instead run ahead
- and perform other transfers. See the chapter below for Persistant
- Connections.
-
- While the above mentioned four functions are the main functions to use in the
- easy interface, there is a series of other helpful functions to use. They
- are:
-
-   curl_version()        - displays the libcurl version
-   curl_getdate()        - converts a date string to time_t
-   curl_getenv()         - portable environment variable reader
-   curl_easy_getinfo()   - get information about a performed transfer
-   curl_formparse()      - helps building a HTTP form POST
-   curl_formfree()       - free a list built with curl_formparse()
-   curl_slist_append()   - builds a linked list
-   curl_slist_free_all() - frees a whole curl_slist
-
- For details on these, read the separate man pages.
-
-Linking with libcurl
-
- Staring with 7.7.2 (on unix-like machines), there's a tool named curl-config
- that gets installed with the rest of the curl stuff when 'make install' is
- performed.
-
- curl-config is added to make it easier for applications to link with
- libcurl and developers to learn about libcurl and how to use it.
-
- Run 'curl-config --libs' to get the (additional) linker options you need to
- link with the particular version of libcurl you've installed.
-
- For details, see the curl-config.1 man page.
-
-libcurl symbol names
-
- All public functions in the libcurl interface are prefixed with 'curl_' (with
- a lowercase c). You can find other functions in the library source code, but
- other prefixes indicate the functions are private and may change without
- further notice in the next release.
-
- Only use documented functions and functionality!
-
-Portability
-
- libcurl works *exactly* the same, on any of the platforms it compiles and
- builds on.
-
- There's only one caution, and that is the win32 platform that may(*) require
- you to init the winsock stuff before you use the libcurl functions. Details
- on this are noted on the curl_easy_init() man page.
-
- (*) = it appears as if users of the cygwin environment get this done
-       automatically.
-
-Threads
-
- Never *ever* call curl-functions simultaneously using the same handle from
- several threads. libcurl is thread-safe and can be used in any number of
- threads, but you must use separate curl handles if you want to use libcurl in
- more than one thread simultaneously.
-
-Persistant Connections
-
- With libcurl 7.7, persistant connections were added. Persistant connections
- means that libcurl can re-use the same connection for several transfers, if
- the conditions are right.
-
- libcurl will *always* attempt to use persistant connections. Whenever you use
- curl_easy_perform(), libcurl will attempt to use an existing connection to do
- the transfer, and if none exists it'll open a new one that will be subject
- for re-use on a possible following call to curl_easy_perform().
-
- To allow libcurl to take full advantage of persistant connections, you should
- do as many of your file transfers as possible using the same curl
- handle. When you call curl_easy_cleanup(), all the possibly open connections
- held by libcurl will be closed and forgotten.
-
- Note that the options set with curl_easy_setopt() will be used in on every
- repeat curl_easy_perform() call
-
-Compatibility with older libcurls
-
- Repeated curl_easy_perform() calls on the same handle were not supported in
- pre-7.7 versions, and caused confusion and defined behaviour.
-

docs/MANUAL

@@ -591,7 +591,7 @@ HTTPS
     Run the 'openssl' application to convert the certificate. If you cd to the
     openssl installation, you can do it like:
 
-     # ./apps/openssl pkcs12 -certfile [file you saved] -out [PEMfile]
+     # ./apps/openssl pkcs12 -in [file you saved] -clcerts -out [PEMfile]
 
 
 RESUMING FILE TRANSFERS

docs/Makefile.am

@@ -13,6 +13,7 @@ man_MANS = \
 	curl_easy_perform.3 \
 	curl_easy_setopt.3 \
 	curl_formparse.3 \
+	curl_formadd.3 \
 	curl_formfree.3 \
 	curl_getdate.3 \
 	curl_getenv.3 \
@@ -26,10 +27,48 @@ man_MANS = \
 	curl_mprintf.3 \
 	curl_global_init.3 \
 	curl_global_cleanup.3 \
-	libcurl.5
+	libcurl.3
+
+SUBDIRS = examples
+
+HTMLPAGES = \
+	curl.html \
+	curl-config.html \
+	curl_easy_cleanup.html \
+	curl_easy_getinfo.html \
+	curl_easy_init.html \
+	curl_easy_perform.html \
+	curl_easy_setopt.html \
+	curl_formadd.html \
+	curl_formparse.html \
+	curl_formfree.html \
+	curl_getdate.html \
+	curl_getenv.html \
+	curl_slist_append.html \
+	curl_slist_free_all.html \
+	curl_version.html \
+	curl_escape.html \
+	curl_unescape.html \
+	curl_strequal.html \
+	curl_strnequal.html \
+	curl_mprintf.html \
+	curl_global_init.html \
+	curl_global_cleanup.html \
+	libcurl.html
 
 EXTRA_DIST = $(man_MANS) \
 	MANUAL BUGS CONTRIBUTE FAQ FEATURES INTERNALS \
-	LIBCURL README.win32 RESOURCES TODO TheArtOfHttpScripting THANKS
+	README.win32 RESOURCES TODO TheArtOfHttpScripting THANKS \
+	$(HTMLPAGES)
 
-SUBDIRS = examples
+MAN2HTML= gnroff -man $< | man2html >$@
+
+SUFFIXES = .1 .3 .html
+
+html: $(HTMLPAGES)
+
+.3.html:
+	$(MAN2HTML)
+
+.1.html:
+	$(MAN2HTML)

docs/THANKS

@@ -69,3 +69,9 @@ that have contributed with non-trivial parts:
  - S. Moonesamy
  - Ingo Wilken <iw@WWW.Ecce-Terram.DE>
  - Pawel A. Gajda <mis@k2.net.pl>
+ - Patrick Bihan-Faou
+ - Nico Baggus <Nico.Baggus@mail.ing.nl>
+ - Sergio Ballestrero
+ - Andrew Francis <locust@familyhealth.com.au>
+ - Tomasz Lacki <Tomasz.Lacki@primark.pl>
+ - Georg Huettenegger <georg@ist.org>

docs/TODO

@@ -7,22 +7,47 @@
 TODO
 
  Things to do in project cURL. Please tell me what you think, contribute and
- send me patches that improve things!
+ send me patches that improve things! Also check the http://curl.haxx.se/dev
+ web section for various development notes.
 
 To do in a future release (random order):
 
+ * FTP ASCII upload does not follow RFC959 section 3.1.1.1: 
+    "The sender converts the data from an internal character representation to
+    the standard 8-bit NVT-ASCII representation (see the Telnet
+    specification).  The receiver will convert the data from the standard form
+    to his own internal form."
+
+ * Make the connect non-blocking so that timeouts work for connect in 
+   multi-threaded programs 
+
+ * Add an interface that enables a user to select prefered SSL ciphers to use.
+
+ * Make curl deal with cookies better. libcurl should be able to maintain a
+   "cookie jar". Updating it with cookies that is received, and using it to
+   pass cookies to the servers that have matching cookies in the jar.
+   http://curl.haxx.se/dev/cookie-jar.txt
+
+ * Consider an interface to libcurl that allows applications to easier get to
+   know what cookies that are sent back in the response headers.
+
  * Make SSL session ids get used if multiple HTTPS documents from the same
-   host is requested. Note: is this really prioritized now with the persistent
+   host is requested. http://curl.haxx.se/dev/SSL_session_id.txt
-   connections?
+
+ * HTTP PUT for files passed on stdin. Requires libcurl to send the file
+   with chunked content encoding. http://curl.haxx.se/dev/HTTP-PUT-stdin.txt
+
+ * Introduce another callback interface for upload/download that makes one
+   less copy of data and thus a faster operation.
+   http://curl.haxx.se/dev/no_copy_callbacks.txt
+
+ * An option to only download remote FTP files if they're newer than the local
+   one is a good idea, and it would fit right into the same syntax as the
+   already working http dito works. It of course requires that 'MDTM' works,
+   and it isn't a standard FTP command.
 
  * Suggested on the mailing list: CURLOPT_FTP_MKDIR...!
 
- * Rewrite parts of the test suite. Make a (XML?) format to store all
-   test-data in a single for a single test case. The current system makes far
-   too many separate files. We also need to have the test suite support
-   different behaviors, like when libcurl is compiled for IPv6 support and
-   thus performs a different set of FTP commands.
-
  * Add configure options that disables certain protocols in libcurl to
    decrease footprint.  '--disable-[protocol]' where protocol is http, ftp,
    telnet, ldap, dict or file.
@@ -30,6 +55,8 @@ To do in a future release (random order):
  * Extend the test suite to include telnet. The telnet could just do ftp or
    http operations (for which we have test servers).
 
+ * Make TELNET work on windows!
+
  * Add a command line option that allows the output file to get the same time
    stamp as the remote file. libcurl already is capable of fetching the remote
    file's date.
@@ -40,7 +67,7 @@ To do in a future release (random order):
    (http://gnutls.hellug.gr/)
 
  * Add asynchronous name resolving, as this enables full timeout support for
-   fork() systems.
+   fork() systems. http://curl.haxx.se/dev/async-resolver.txt
 
  * Move non-URL related functions that are used by both the lib and the curl
    application to a separate "portability lib".

docs/TheArtOfHttpScripting

@@ -1,6 +1,7 @@
+Online:  http://curl.haxx.se/docs/httpscripting.shtml
 Author:  Daniel Stenberg <daniel@haxx.se>
-Date:    September 15, 2000
+Date:    August 20, 2001
-Version: 0.3
+Version: 0.4
 
                 The Art Of Scripting HTTP Requests Using Curl
                 =============================================
@@ -174,6 +175,19 @@ Version: 0.3
 
         curl -d "birthyear=1905&press=OK&person=daniel" [URL]
 
+ 4.5 FIGURE OUT WHAT A POST LOOKS LIKE
+
+  When you're about fill in a form and send to a server by using curl instead
+  of a browser, you're of course very interested in sending a POST exactly the
+  way your browser does.
+
+  An easy way to get to see this, is to save the HTML page with the form on
+  your local disk, mofidy the 'method' to a GET, and press the submit button
+  (you could also change the action URL if you want to).
+
+  You will then clearly see the data get appended to the URL, separated with a
+  '?'-letter as GET forms are supposed to.
+
 5. PUT
 
  The perhaps best way to upload data to a HTTP server is to use PUT. Then
@@ -182,7 +196,7 @@ Version: 0.3
 
  Put a file to a HTTP server with curl:
 
-        curl -t uploadfile www.uploadhttp.com/receive.cgi
+        curl -T uploadfile www.uploadhttp.com/receive.cgi
 
 6. AUTHENTICATION
 
@@ -289,7 +303,6 @@ Version: 0.3
 
         curl -b "name=Daniel" www.cookiesite.com
 
-
  Cookies are sent as common HTTP headers. This is practical as it allows curl
  to record cookies simply by recording headers. Record cookies with curl by
  using the -D option like:
@@ -304,6 +317,14 @@ Version: 0.3
 
         curl -b stored_cookies_in_file www.cookiesite.com
 
+ Curl's "cookie engine" gets enabled when you use the -b option. If you only
+ want curl to understand received cookies, use -b with a file that doesn't
+ exist. Example, if you want to let curl understand cookies from a page and
+ follow a location (and thus possibly send back cookies it received), you can
+ invoke it like:
+
+        curl -b nada -L www.cookiesite.com
+
 11. HTTPS
 
  There are a few ways to do secure HTTP transfers. The by far most common

docs/curl-config.1

@@ -2,7 +2,7 @@
 .\" nroff -man curl-config.1
 .\" Written by Daniel Stenberg
 .\"
-.TH curl-config 1 "28 May 2001" "Curl 7.8" "curl-config manual"
+.TH curl-config 1 "16 August 2001" "Curl 7.8.1" "curl-config manual"
 .SH NAME
 curl-config \- Get information about a libcurl installation
 .SH SYNOPSIS
@@ -12,8 +12,8 @@ curl-config \- Get information about a libcurl installation
 displays information about a previous curl and libcurl installation.
 .SH OPTIONS
 .IP "--cflags"
-What set of CFLAGS that was used when libcurl was built. This is mostly a
+Set of compiler options (CFLAGS) to use when compiling files that use
-debug option that serves no particular use to most people.
+libcurl. Currently that is only thw include path to the curl include files.
 .IP "--feature"
 Lists what particular main features the installed libcurl was built with. At
 the time of writing, this list may include SSL, KRB4 or IPv6. Do not assume
@@ -36,18 +36,14 @@ This outputs the version number, in hexadecimal, with 8 bits for each part;
 major, minor, patch. So that libcurl 7.7.4 would appear as 070704 and libcurl
 12.13.14 would appear as 0c0d0e...
 .SH "EXAMPLES"
-What is the path to the curl header files?
+What linker options do I need when I link with libcurl?
-
-  echo `curl-config --prefix`/include
-
-What is the path to libcurl?
-
-  echo `curl-config --prefix`/lib
-
-What other linker options do I need when I link with libcurl?
 
   curl-config --libs
 
+What compiler options do I need when I compile using libcurl functions?
+
+  curl-config --cflags
+
 How do I know if libcurl was built with SSL support?
 
   curl-config --feature | grep SSL

docs/curl.1

@@ -2,7 +2,7 @@
 .\" nroff -man curl.1
 .\" Written by Daniel Stenberg
 .\"
-.TH curl 1 "8 May 2001" "Curl 7.7.3" "Curl Manual"
+.TH curl 1 "16 Aug 2001" "Curl 7.8.1" "Curl Manual"
 .SH NAME
 curl \- get a URL with FTP, TELNET, LDAP, GOPHER, DICT, FILE, HTTP or
 HTTPS syntax.
@@ -134,7 +134,8 @@ name=daniel -d skill=lousy' would generate a post chunk that looks like
 If you start the data with the letter @, the rest should be a file name to
 read the data from, or - if you want curl to read the data from stdin.  The
 contents of the file must already be url-encoded. Multiple files can also be
-specified.
+specified. Posting data from a file named 'foobar' would thus be done with
+"--data @foobar".
 
 To post data purely binary, you should instead use the --data-binary option.
 
@@ -232,6 +233,11 @@ you can specify URLs that contain the letters {}[] without having them being
 interpreted by curl itself. Note that these letters are not normal legal URL
 contents but they should be encoded according to the URI standard. (Option
 added in curl 7.6)
+.IP "-G/--get"
+When used, this option will make all data specified with -d/--data or
+--data-binary to be used in a HTTP GET request instead of the POST request
+that otherwise would be used. The data will be appended to the URL with a '?'
+separator.
 .IP "-h/--help"
 Usage help.
 .IP "-H/--header <header>"

docs/curl_easy_cleanup.3

@@ -8,7 +8,7 @@ curl_easy_cleanup - End a libcurl session
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
-.BI "curl_easy_cleanup(CURL *" handle ");"
+.BI "void curl_easy_cleanup(CURL *" handle ");"
 .ad
 .SH DESCRIPTION
 This function must be the last function to call for a curl session. It is the

docs/curl_easy_init.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_easy_init 3 "5 March 2001" "libcurl 7.7" "libcurl Manual"
+.TH curl_easy_init 3 "14 August 2001" "libcurl 7.8.1" "libcurl Manual"
 .SH NAME
 curl_easy_init - Start a libcurl session
 .SH SYNOPSIS
@@ -17,8 +17,10 @@ intializes curl and this call MUST have a corresponding call to
 .I curl_easy_cleanup
 when the operation is complete.
 
-On win32 systems, you need to init the winsock stuff manually, libcurl will
+On win32 systems, if you want to init the winsock stuff manually, libcurl will
-not do that for you. WSAStartup() and WSACleanup() should be used accordingly.
+not do that for you. WSAStartup() and WSACleanup() should then be called
+accordingly.  If you want libcurl to handle this, use the CURL_GLOBAL_WIN32
+flag in the initial curl_global_init() call.
 
 Using libcurl 7.7 and later, you should perform all your sequential file
 transfers using the same curl handle. This enables libcurl to use persistant
@@ -27,6 +29,6 @@ connections where possible.
 If this function returns NULL, something went wrong and you cannot use the
 other curl functions.
 .SH "SEE ALSO"
-.BR curl_easy_cleanup "(3), "
+.BR curl_easy_cleanup "(3), " curl_global_init "(3)
 .SH BUGS
 Surely there are some, you tell me!

docs/curl_easy_setopt.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_easy_setopt 3 "1 June 2001" "libcurl 7.8" "libcurl Manual"
+.TH curl_easy_setopt 3 "22 August 2001" "libcurl 7.8.1" "libcurl Manual"
 .SH NAME
 curl_easy_setopt - Set curl easy-session options
 .SH SYNOPSIS
@@ -140,7 +140,9 @@ CURLOPT_INFILE and CURLOPT_INFILESIZE are also interesting for uploads.
 A non-zero parameter tells the library to do a regular HTTP post. This is a
 normal application/x-www-form-urlencoded kind, which is the most commonly used
 one by HTML forms. See the CURLOPT_POSTFIELDS option for how to specify the
-data to post and CURLOPT_POSTFIELDSIZE in how to set the data size.
+data to post and CURLOPT_POSTFIELDSIZE in how to set the data size. Starting
+with libcurl 7.8, this option is obsolete. Using the CURLOPT_POSTFIELDS option
+will imply this option.
 .TP
 .B CURLOPT_FTPLISTONLY
 A non-zero parameter tells the library to just list the names of an ftp
@@ -202,14 +204,17 @@ library. The buffer must be at least CURL_ERROR_SIZE big.
 .TP
 .B CURLOPT_TIMEOUT
 Pass a long as parameter containing the maximum time in seconds that you allow
-the libcurl transfer operation to take. Do note that normally, name lookups
+the libcurl transfer operation to take. Normally, name lookups can take a
-maky take a considerable time and that limiting the operation to less than a
+considerable time and limiting operations to less than a few minutes risk
-few minutes risk aborting perfectly normal operations. This option will cause
+aborting perfectly normal operations. This option will cause curl to use the
-curl to use the SIGALRM to enable timeouting system calls.
+SIGALRM to enable timeouting system calls.
+.B NOTE
+that this does not work in multi-threaded programs!
 .TP
 .B CURLOPT_POSTFIELDS
 Pass a char * as parameter, which should be the full data to post in a HTTP
-post operation. See also the CURLOPT_POST.
+post operation. See also the CURLOPT_POST. Since 7.8, using CURLOPT_POSTFIELDS
+implies CURLOPT_POST.
 .TP
 .B CURLOPT_POSTFIELDSIZE
 If you want to post data to the server without letting libcurl do a strlen()
@@ -273,7 +278,7 @@ instruct what data to pass on to the server.  Pass a pointer to a linked list
 of HTTP post structs as parameter.  The linked list should be a fully valid
 list of 'struct HttpPost' structs properly filled in. The best and most
 elegant way to do this, is to use
-.I curl_formparse(3)
+.I curl_formadd(3)
 as documented. The data in this list must remained intact until you close this
 curl handle again with curl_easy_cleanup().
 .TP
@@ -498,6 +503,18 @@ connection timeout (it will then only timeout on the system's internal
 timeouts). See also the
 .I CURLOPT_TIMEOUT
 option.
+.B NOTE
+that this does not work in multi-threaded programs!
+.TP
+.B CURLOPT_HTTPGET
+Pass a long. If the long is non-zero, this forces the HTTP request to get back
+to GET. Only really usable if POST, PUT or a custom request have been used
+previously using the same curl handle. (Added in 7.8.1)
+.TP
+.B CURLOPT_SSL_VERIFYHOST
+Pass a long. Set if we should verify the Common name from the peer certificate
+in the SSL handshake, set 1 to check existence, 2 to ensure that it matches
+the provided hostname. (Added in 7.8.1)
 .PP
 .SH RETURN VALUE
 0 means the option was set properly, non-zero means an error as

docs/curl_formadd.3

@@ -0,0 +1,121 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" $Id$
+.\"
+.TH curl_formadd 3 "27 August 2001" "libcurl 7.9" "libcurl Manual"
+.SH NAME
+curl_formadd - add a section to a multipart/formdata HTTP POST
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "CURLcode curl_formadd(struct HttpPost ** " firstitem,
+.BI "struct HttpPost ** " lastitem, " ...);"
+.ad
+.SH DESCRIPTION
+curl_formadd() is used to append sections when building a multipart/formdata
+HTTP POST (sometimes refered to as rfc1867-style posts). Append one section at
+a time until you've added all the sections you want included and then you pass
+the \fIfirstitem\fP pointer as parameter to \fBCURLOPT_HTTPPOST\fP.
+\fIlastitem\fP is set after each call and on repeated invokes it should be
+left as set to allow repeated invokes to find the end of the list in a faster
+way.
+
+After \fIlastitem\fP follow the real arguments that constitute the
+new section (if the following description confuses you jump directly
+to the examples):
+
+CURLFORM_COPYNAME or CURLFORM_PTRNAME followed by a string is used for
+the name of the section. Optionally one may use CURLFORM_NAMELENGTH to
+specify the length of the name (allowing null characters within the name).
+
+The three options for providing values are: CURLFORM_COPYCONTENTS,
+CURLFORM_PTRCONTENTS, or CURLFORM_FILE, followed by a char or void
+pointer (allowed for PTRCONTENTS).
+
+Other arguments may be CURLFORM_CONTENTTYPE if the
+user wishes to specify one (for FILE if no type is given the library
+tries to provide the correct one; for CONTENTS no Content-Type is sent
+in this case)
+
+For CURLFORM_PTRCONTENTS or CURLFORM_COPYNAME the user may also add
+CURLFORM_CONTENTSLENGTH followed by the length as a long (if not given
+the library will use strlen to determine the length).
+
+For CURLFORM_FILE the user may send multiple files in one section by
+providing multiple CURLFORM_FILE arguments each followed by the filename
+(and each FILE is allowed to have a CONTENTTYPE).
+
+The last argument always is CURLFORM_END.
+
+The pointers \fI*firstitem\fP and \fI*lastitem\fP should both be pointing to
+NULL in the first call to this function. All list-data will be allocated by
+the function itself. You must call \fIcurl_formfree\fP after the form post has
+been done to free the resources again.
+
+This function will copy all input data except the data pointed to by
+the arguments after CURLFORM_PTRNAME and CURLFORM_PTRCONTENTS and keep
+its own version of it allocated until you call \fIcurl_formfree\fP. When
+you've passed the pointer to \fIcurl_easy_setopt\fP, you must not free
+the list until after you've called \fIcurl_easy_cleanup\fP for the
+curl handle. If you provide a pointer as an arguments after
+CURLFORM_PTRNAME or CURLFORM_PTRCONTENTS you must ensure that the pointer
+stays valid until you call \fIcurl_form_free\fP and \fIcurl_easy_cleanup\fP.
+
+See example below.
+.SH RETURN VALUE
+Returns non-zero if an error occurs.
+.SH EXAMPLE
+.nf
+
+ HttpPost* post = NULL;
+ HttpPost* last = NULL;
+ char namebuffer[] = "name buffer";
+ long namelength = strlen(namebuffer);
+ char buffer[] = "test buffer";
+ char htmlbuffer[] = "<HTML>test buffer</HTML>";
+ long htmlbufferlength = strlen(htmlbuffer);
+ /* add null character into htmlbuffer, to demonstrate that
+    transfers of buffers containing null characters actually work
+ */
+ htmlbuffer[8] = '\\0';
+
+ /* Add simple name/content section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "name",
+              CURLFORM_COPYCONTENTS, "content", CURLFORM_END); 
+ /* Add simple name/content/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "htmlcode",
+              CURLFORM_COPYCONTENTS, "<HTML></HTML>",
+              CURLFORM_CONTENTTYPE, "text/html", CURLFORM_END);
+ /* Add name/ptrcontent section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "name_for_ptrcontent",
+              CURLFORM_PTRCONTENTS, buffer, CURLFORM_END);
+ /* Add ptrname/ptrcontent section */
+ curl_formadd(&post, &last, CURLFORM_PTRNAME, namebuffer,
+	      CURLFORM_PTRCONTENTS, buffer, CURLFORM_NAMELENGTH,
+	      namelength, CURLFORM_END);
+ /* Add name/ptrcontent/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "html_code_with_hole",
+              CURLFORM_PTRCONTENTS, htmlbuffer,
+              CURLFORM_CONTENTSLENGTH, htmlbufferlength,
+              CURLFORM_CONTENTTYPE, "text/html", CURLFORM_END);
+ /* Add simple file section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "picture",
+              CURLFORM_FILE, "my-face.jpg", CURLFORM_END);
+ /* Add file/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "picture",
+              CURLFORM_FILE, "my-face.jpg",
+              CURLFORM_CONTENTTYPE, "image/jpeg", CURLFORM_END);
+ /* Add two file section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "pictures",
+              CURLFORM_FILE, "my-face.jpg",
+              CURLFORM_FILE, "your-face.jpg", CURLFORM_END);
+ /* Set the form info */
+ curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
+
+.SH "SEE ALSO"
+.BR curl_easy_setopt "(3), "
+.BR curl_formparse "(3) [deprecated], "
+.BR curl_formfree "(3)
+.SH BUGS
+Surely there are some, you tell me!
+

docs/curl_formfree.3

@@ -12,12 +12,14 @@ curl_formfree - free a previously build multipart/formdata HTTP POST chain
 .ad
 .SH DESCRIPTION
 curl_formfree() is used to clean up data previously built/appended with
-curl_formparse(). This must be called when the data has been used, which
+curl_formadd()/curl_formparse(). This must be called when the data has
-typically means after the curl_easy_perform() has been called.
+been used, which typically means after the curl_easy_perform() has
+been called.
 .SH RETURN VALUE
 None
 .SH "SEE ALSO"
-.BR curl_formparse "(3) "
+.BR curl_formparse "(3) [deprecated], "
+.BR curl_formadd "(3) "
 .SH BUGS
 libcurl 7.7.1 and earlier versions does not allow a NULL pointer to be used as
 argument.

docs/curl_formparse.3

@@ -4,7 +4,8 @@
 .\"
 .TH curl_formparse 3 "21 May 2001" "libcurl 7.7.4" "libcurl Manual"
 .SH NAME
-curl_formparse - add a section to a multipart/formdata HTTP POST
+curl_formparse - add a section to a multipart/formdata HTTP POST:
+deprecated (use curl_formadd instead)
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
@@ -79,6 +80,7 @@ Returns non-zero if an error occurs.
 
 .SH "SEE ALSO"
 .BR curl_easy_setopt "(3), "
+.BR curl_formadd "(3), "
 .BR curl_formfree "(3)
 .SH BUGS
 Surely there are some, you tell me!

docs/curl_getenv.3

@@ -2,13 +2,13 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_getenv 3 "5 March 2001" "libcurl 7.0" "libcurl Manual"
+.TH curl_getenv 3 "15 August 2001" "libcurl 7.8.1" "libcurl Manual"
 .SH NAME
 curl_getenv - return value for environment name
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
-.BI "char *curl_getenv(char *" name ");
+.BI "char *curl_getenv(const char *" name ");
 .ad
 .SH DESCRIPTION
 curl_getenv() is a portable wrapper for the getenv() function, meant to

docs/curl_global_init.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_global_init 3 "31 May 2001" "libcurl 7.8" "libcurl Manual"
+.TH curl_global_init 3 "14 August 2001" "libcurl 7.8.1" "libcurl Manual"
 .SH NAME
 curl_global_init - Global libcurl initialisation
 .SH SYNOPSIS
@@ -27,10 +27,13 @@ This function was added in libcurl 7.8.
 .SH FLAGS
 .TP 5
 .B CURL_GLOBAL_ALL
-Initialise everyting possible. This sets all known bits.
+Initialize everything possible. This sets all known bits.
 .TP
 .B CURL_GLOBAL_SSL
-Initialise SSL
+Initialize SSL
+.TP
+.B CURL_GLOBAL_WIN32
+Initialize the Win32 socket libraries. (added in libcurl 7.8.1)
 .TP
 .B CURL_GLOBAL_NOTHING
 Initialise nothing extra. This sets no bit.

docs/curl_slist_append.3

@@ -8,7 +8,7 @@ curl_slist_append - add a string to an slist
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
-.BI "struct curl_slist *curl_slist_append(struct curl_slit *" list,
+.BI "struct curl_slist *curl_slist_append(struct curl_slist *" list,
 .BI "const char * "string ");"
 .ad
 .SH DESCRIPTION

docs/curl_strequal.3

@@ -25,6 +25,6 @@ These functions are provided by libcurl to enable applications to compare
 strings in a truly portable manner. There are no standard portable case
 insensitive string comparison functions. These two works on all platforms.
 .SH RETURN VALUE
-A pointer to a zero terminated string.
+Non-zero if the strings are identical. Zero if they're not.
 .SH "SEE ALSO"
 .BR strcmp "(3), " strcasecmp "(3)"

docs/examples/Makefile.am

@@ -4,9 +4,9 @@
 
 AUTOMAKE_OPTIONS = foreign no-dependencies
 
-EXTRA_DIST = README curlgtk.c sepheaders.c simple.c postit.c \
+EXTRA_DIST = README curlgtk.c sepheaders.c simple.c postit.c postit2.c \
 	     win32sockets.c persistant.c ftpget.c Makefile.example \
-	     multithread.c getinmemory.c
+	     multithread.c getinmemory.c ftpupload.c
 
 all:
 	@echo "done"

docs/examples/ftpupload.c

@@ -0,0 +1,88 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ */
+
+#include <stdio.h>
+
+#include <curl/curl.h>
+
+/*
+ * This example shows an FTP upload, with a rename of the file just after
+ * a successful upload.
+ *
+ * Example based on source code provided by Erick Nuwendam. Thanks!
+ */
+
+#define LOCAL_FILE      "/tmp/uploadthis.txt"
+#define UPLOAD_FILE_AS  "while-uploading.txt"
+#define REMOTE_URL      "ftp://localhost/"  UPLOAD_FILE_AS
+#define RENAME_FILE_TO  "renamed-and-fine.txt"
+
+int main(int argc, char **argv)
+{
+  CURL *curl;
+  CURLcode res;
+  FILE *ftpfile;
+  FILE * hd_src ;
+  int hd ;
+  struct stat file_info;
+
+  struct curl_slist *headerlist=NULL;
+  char buf_1 [] = "RNFR " UPLOAD_FILE_AS;
+  char buf_2 [] = "RNTO " RENAME_FILE_TO;
+
+  /* get the file size of the local file */
+  hd = open(LOCAL_FILE, O_RDONLY) ;
+  fstat(hd, &file_info);
+  close(hd) ;
+
+  /* get a FILE * of the same file, could also be made with
+     fdopen() from the previous descriptor, but hey this is just 
+     an example! */
+  hd_src = fopen(LOCAL_FILE, "rb");
+
+  /* In windows, this will init the winsock stuff */
+  curl_global_init(CURL_GLOBAL_ALL);
+
+  /* get a curl handle */
+  curl = curl_easy_init();
+  if(curl) {
+    /* build a list of commands to pass to libcurl */
+    headerlist = curl_slist_append(headerlist, buf_1);
+    headerlist = curl_slist_append(headerlist, buf_2);
+
+    /* enable uploading */
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ;
+
+    /* specify target */
+    curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL);
+
+    /* pass in that last of FTP commands to run after the transfer */
+    curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
+
+    /* now specify which file to upload */
+    curl_easy_setopt(curl, CURLOPT_INFILE, hd_src);
+
+    /* and give the size of the upload (optional) */
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, file_info.st_size);
+
+    /* Now run off and do what you've been told! */
+    res = curl_easy_perform(curl);
+
+    /* clean up the FTP commands list */
+    curl_slist_free_all (headerlist);
+
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+  fclose(hd_src); /* close the local file */
+
+  curl_global_cleanup();
+  return 0;
+}

docs/examples/postit2.c

@@ -0,0 +1,92 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ *
+ * Example code that uploads a file name 'foo' to a remote script that accepts
+ * "HTML form based" (as described in RFC1738) uploads using HTTP POST.
+ *
+ * The imaginary form we'll fill in looks like:
+ *
+ * <form method="post" enctype="multipart/form-data" action="examplepost.cgi">
+ * Enter file: <input type="file" name="sendfile" size="40">
+ * Enter file name: <input type="text" name="filename" size="30">
+ * <input type="submit" value="send" name="submit">
+ * </form>
+ *
+ * This exact source code has not been verified to work.
+ */
+
+/* to make this work under windows, use the win32-functions from the
+   win32socket.c file as well */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+#if LIBCURL_VERSION_NUM < 0x070900
+#error "curl_formadd() is not introduced until libcurl 7.9 and later"
+#endif
+
+int main(int argc, char *argv[])
+{
+  CURL *curl;
+  CURLcode res;
+
+  struct HttpPost *formpost=NULL;
+  struct HttpPost *lastptr=NULL;
+  struct curl_slist *headerlist=NULL;
+  char buf[] = "Expect:";
+
+  /* Fill in the file upload field */
+  curl_formadd(&formpost,
+               &lastptr,
+               CURLFORM_COPYNAME, "sendfile",
+               CURLFORM_FILE, "postit2.c",
+               CURLFORM_END);
+
+  /* Fill in the filename field */
+  curl_formadd(&formpost,
+               &lastptr,
+               CURLFORM_COPYNAME, "filename",
+               CURLFORM_COPYCONTENTS, "postit2.c",
+               CURLFORM_END);
+  
+
+  /* Fill in the submit field too, even if this is rarely needed */
+  curl_formadd(&formpost,
+               &lastptr,
+               CURLFORM_COPYNAME, "submit",
+               CURLFORM_COPYCONTENTS, "send",
+               CURLFORM_END);
+
+  curl = curl_easy_init();
+  /* initalize custom header list (stating that Expect: 100-continue is not
+     wanted */
+  headerlist = curl_slist_append(headerlist, buf);
+  if(curl) {
+    /* what URL that receives this POST */
+    curl_easy_setopt(curl, CURLOPT_URL, "http://curl.haxx.se/examplepost.cgi");
+    if ( (argc == 2) && (!strcmp(argv[1], "noexpectheader")) )
+      /* only disable 100-continue header if explicitly requested */
+      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
+    res = curl_easy_perform(curl);
+
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+
+    /* then cleanup the formpost chain */
+    curl_formfree(formpost);
+    /* free slist */
+    curl_slist_free_all (headerlist);
+  }
+  return 0;
+}

docs/examples/win32sockets.c

@@ -1,14 +1,23 @@
+
+/*
+ * Note: This is only required if you use curl 7.8 or lower, later 
+ * versions provide an option to curl_global_init() that does the
+ * win32 initialization for you.
+ */
+
 /*
  * These are example functions doing socket init that Windows
  * require. If you don't use windows, you can safely ignore this crap.
  */
 
-static void win32_cleanup(void)
+#include <windows.h>
+
+void win32_cleanup(void)
 {
   WSACleanup();
 }
 
-static CURLcode win32_init(void)
+int win32_init(void)
 {
   WORD wVersionRequested;  
   WSADATA wsaData; 

docs/libcurl.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH libcurl 5 "28 May 2001" "libcurl 7.8" "libcurl overview"
+.TH libcurl 5 "14 August 2001" "libcurl 7.8.1" "libcurl overview"
 .SH NAME
 libcurl \- client-side URL transfers
 .SH DESCRIPTION
@@ -53,11 +53,14 @@ portable environment variable reader
 .B curl_easy_getinfo()
 get information about a performed transfer
 .TP
-.B curl_formparse()
+.B curl_formadd()
 helps building a HTTP form POST
 .TP
+.B curl_formparse()
+helps building a HTTP form POST (deprecated since 7.9 use curl_formadd()!)
+.TP
 .B curl_formfree()
-free a list built with curl_formparse()
+free a list built with curl_formparse()/curl_formadd()
 .TP
 .B curl_slist_append()
 builds a linked list
@@ -101,7 +104,7 @@ you to init the winsock stuff before you use the libcurl functions. Details on
 this are noted on the curl_easy_init() man page.
 
 (*) = it appears as if users of the cygwin environment get this done
-automatically.
+automatically, also libcurl 7.8.1 and later can handle this for you.
 .SH "THREADS"
 Never ever call curl-functions simultaneously using the same handle from
 several threads. libcurl is thread-safe and can be used in any number of

include/curl/curl.h

@@ -58,13 +58,19 @@ extern "C" {
 struct HttpPost {
   struct HttpPost *next; /* next entry in the list */
   char *name;     /* pointer to allocated name */
+  long namelength; /* length of name length */
   char *contents; /* pointer to allocated data contents */
+  long contentslength; /* length of contents field */
   char *contenttype; /* Content-Type */
   struct HttpPost *more; /* if one field name has more than one file, this
 			    link should link to following files */
   long flags;     /* as defined below */
 #define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */
 #define HTTPPOST_READFILE (1<<1) /* specified content is a file name */
+#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer
+                                   do not free in formfree */
+#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer
+                                       do not free in formfree */
 };
 
 typedef int (*curl_progress_callback)(void *clientp,
@@ -84,7 +90,7 @@ typedef size_t (*curl_read_callback)(char *buffer,
                                      void *instream);
 
 typedef int (*curl_passwd_callback)(void *clientp,
-                                    char *prompt,
+                                    const char *prompt,
                                     char *buffer,
                                     int buflen);
 
@@ -286,11 +292,6 @@ typedef enum {
      is simply passed to the callback unmodified */
   CINIT(WRITEHEADER, OBJECTPOINT, 29),
 
-#ifdef MULTIDOC
-  /* send linked list of MoreDoc structs */
-  CINIT(MOREDOCS, OBJECTPOINT, 30),
-#endif
-
   /* point to a file to read the initial cookies from, also enables
      "cookie awareness" */
   CINIT(COOKIEFILE, OBJECTPOINT, 31),
@@ -443,6 +444,20 @@ typedef enum {
    * parameters will use fwrite() syntax, make sure to follow them. */
   CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
 
+  /* Set this to force the HTTP request to get back to GET. Only really usable
+     if POST, PUT or a custom request have been used first.
+   */
+  CINIT(HTTPGET, LONG, 80),
+
+  /* Set if we should verify the Common name from the peer certificate in ssl
+   * handshake, set 1 to check existence, 2 to ensure that it matches the
+   * provided hostname. */
+  CINIT(SSL_VERIFYHOST, LONG, 81),
+
+  /* Specify which file name to write all known cookies in after completed
+     operation. Set file name to "-" (dash) to make it go to stdout. */
+  CINIT(COOKIEJAR, OBJECTPOINT, 82),
+  
   CURLOPT_LASTENTRY /* the last unusued */
 } CURLoption;
 
@@ -478,20 +493,48 @@ int curl_formparse(char *string,
                    struct HttpPost **httppost,
                    struct HttpPost **last_post);
 
+/* name is uppercase CURLFORM_<name> */
+#ifdef CFINIT
+#undef CFINIT
+#endif
+#define CFINIT(name) CURLFORM_ ## name
+
+typedef enum {
+  CFINIT(NOTHING),        /********* the first one is unused ************/
+  
+  /*  */
+  CFINIT(COPYNAME),
+  CFINIT(PTRNAME),
+  CFINIT(NAMELENGTH),
+  CFINIT(COPYCONTENTS),
+  CFINIT(PTRCONTENTS),
+  CFINIT(CONTENTSLENGTH),
+  CFINIT(FILE),
+  CFINIT(CONTENTTYPE),
+  CFINIT(END),
+
+  CURLFORM_LASTENTRY /* the last unusued */
+} CURLformoption;
+
+/* new external form function */
+int curl_formadd(struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...);
+
 /* cleanup a form: */
 void curl_formfree(struct HttpPost *form);
 
 /* Unix and Win32 getenv function call, this returns a malloc()'ed string that
    MUST be free()ed after usage is complete. */
-char *curl_getenv(char *variable);
+char *curl_getenv(const char *variable);
 
 /* Returns a static ascii string of the libcurl version. */
 char *curl_version(void);
 
 /* Escape and unescape URL encoding in strings. The functions return a new
  * allocated string or NULL if an error occurred.  */
-char *curl_escape(char *string, int length);
+char *curl_escape(const char *string, int length);
-char *curl_unescape(char *string, int length);
+char *curl_unescape(const char *string, int length);
 
 /* curl_global_init() should be invoked exactly once for each application that
    uses libcurl */
@@ -501,11 +544,9 @@ CURLcode curl_global_init(long flags);
    that uses libcurl */
 void curl_global_cleanup(void);
 
-
-
 /* This is the version number */
-#define LIBCURL_VERSION "7.8"
+#define LIBCURL_VERSION "7.8.2-pre1"
-#define LIBCURL_VERSION_NUM 0x070800
+#define LIBCURL_VERSION_NUM 0x070802
 
 /* linked-list structure for the CURLOPT_QUOTE option (and other) */
 struct curl_slist {
@@ -575,7 +616,8 @@ typedef enum {
 } curl_closepolicy;
 
 #define CURL_GLOBAL_SSL (1<<0)
-#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL)
+#define CURL_GLOBAL_WIN32 (1<<1)
+#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
 #define CURL_GLOBAL_NOTHING 0
 #define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
 

include/curl/mprintf.h

@@ -54,6 +54,7 @@
 #define H_MPRINTF
 
 #include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
 
 int curl_mprintf(const char *format, ...);
 int curl_mfprintf(FILE *fd, const char *format, ...);

lib/.cvsignore

@@ -0,0 +1,6 @@
+*.la
+*.lo
+Makefile
+Makefile.in
+.deps
+.libs

lib/Makefile.am

@@ -2,7 +2,7 @@
 # $Id$
 #
 
-AUTOMAKE_OPTIONS = foreign
+AUTOMAKE_OPTIONS = foreign no-dependencies
 
 EXTRA_DIST = getdate.y \
        Makefile.b32 Makefile.b32.resp Makefile.m32 Makefile.vc6 \
@@ -16,7 +16,7 @@ lib_LTLIBRARIES = libcurl.la
 INCLUDES = -I$(top_srcdir)/include
 
 
-libcurl_la_LDFLAGS = -version-info 2:0:1
+libcurl_la_LDFLAGS = -version-info 2:2:0
 # This flag accepts an argument of the form current[:revision[:age]]. So,
 # passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
 # 1.
@@ -57,7 +57,7 @@ getdate.h      ldap.c         ssluse.c       version.c \
 getenv.c       ldap.h         ssluse.h       \
 escape.c       mprintf.c      telnet.c       \
 escape.h       getpass.c      netrc.c        telnet.h       \
-getinfo.c transfer.c strequal.c strequal.h easy.c \
+getinfo.c getinfo.h transfer.c strequal.c strequal.h easy.c \
 security.h security.c krb4.c krb4.h memdebug.c memdebug.h inet_ntoa_r.h \
 http_chunks.c http_chunks.h strtok.c strtok.h
 

lib/Makefile.b32

@@ -1,4 +1,6 @@
 ############################################################
+# $Id$
+#
 #  Makefile.b32 - Borland's C++ Compiler 5.X
 #
 #  'lib' directory
@@ -55,7 +57,8 @@ SOURCES	   = \
 	getinfo.c \
 	version.c \
 	easy.c \
-	strequal.c
+	strequal.c \
+	strtok.c
 
 OBJECTS = $(SOURCES:.c=.obj)
 

lib/Makefile.b32.resp

@@ -26,4 +26,6 @@
 +getinfo.obj &
 +version.obj &
 +easy.obj &
-+strequal.obj
++strequal.obj &
++strtok.obj
+

lib/Makefile.m32

@@ -1,4 +1,6 @@
 #############################################################
+# $Id$
+#
 ## Makefile for building libcurl.a with MingW32 (GCC-2.95) and
 ## optionally OpenSSL (0.9.6)
 ## Use: make -f Makefile.m32

lib/Makefile.vc6

@@ -1,15 +1,16 @@
 #############################################################
+#
 ## Makefile for building libcurl.lib with MSVC6
 ## Use: nmake -f makefile.vc6 [release | release-ssl | debug]
 ##      (default is release)
 ##
-## Comments to: Troy Engel <tengel@sonic.net>
+## Originally written by: Troy Engel <tengel@sonic.net>
 ## Updated by: Craig Davison <cd@securityfocus.com>
 ## Updated by: SM <sm@technologist.com>
 
 PROGRAM_NAME = libcurl.lib
 PROGRAM_NAME_DEBUG = libcurld.lib
-#OPENSSL_PATH = ../../openssl-0.9.6a
+#OPENSSL_PATH = ../../openssl-0.9.6b
 
 ########################################################
 ## Nothing more to do below this line!
@@ -125,7 +126,7 @@ RELEASE_SSL_OBJS= \
 	versionrs.obj \
 	easyrs.obj \
 	strequalrs.obj \
-	strtokd.obj
+	strtokrs.obj
 
 LINK_OBJS= \
 	base64.obj \
@@ -292,7 +293,7 @@ easyd.obj: easy.c
 strequald.obj: strequal.c
 	$(CCD) $(CFLAGS) strequal.c
 strtokd.obj:strtok.c
-	$(CCR) $(CFLAGS) strtok.c
+	$(CCD) $(CFLAGS) strtok.c
 
 ## Release SSL
 base64rs.obj: base64.c
@@ -308,7 +309,7 @@ formdatars.obj: formdata.c
 ftprs.obj: ftp.c
 	$(CCRS) $(CFLAGS) ftp.c
 httprs.obj: http.c
-	$(CCR) $(CFLAGS) http.c
+	$(CCRS) $(CFLAGS) http.c
 http_chunksrs.obj: http_chunks.c
 	$(CCRS) $(CFLAGS) http_chunks.c
 ldaprs.obj: ldap.c
@@ -354,7 +355,7 @@ easyrs.obj: easy.c
 strequalrs.obj: strequal.c
 	$(CCRS) $(CFLAGS) strequal.c
 strtokrs.obj:strtok.c
-	$(CCR) $(CFLAGS) strtok.c
+	$(CCRS) $(CFLAGS) strtok.c
 
 
 clean:

lib/arpa_telnet.h

@@ -1,321 +1,101 @@
-/*
+#ifndef __ARPA_TELNET_H
- * Copyright (c) 1983, 1993
+#define __ARPA_TELNET_H
- *	The Regents of the University of California.  All rights reserved.
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
  *
- * Redistribution and use in source and binary forms, with or without
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * In order to be useful for every potential user, curl and libcurl are
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
  *
- *	@(#)telnet.h	8.2 (Berkeley) 12/15/93
+ * 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 MPL or the MIT/X-derivate
-#ifndef _ARPA_TELNET_H
+ * licenses. You may pick one of these licenses.
-#define _ARPA_TELNET_H
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
 
 /*
- * Definitions for the TELNET protocol.
+ * Telnet option defines. Add more here if in need.
  */
-#define	IAC	255		/* interpret as command: */
+#define TELOPT_BINARY   0  /* binary 8bit data */
-#define	DONT	254		/* you are not to use option */
+#define TELOPT_SGA      3  /* Supress Go Ahead */
-#define	DO	253		/* please, you use option */
+#define TELOPT_EXOPL  255  /* EXtended OPtions List */
-#define	WONT	252		/* I won't use option */
+#define TELOPT_TTYPE   24  /* Terminal TYPE */
-#define	WILL	251		/* I will use option */
+#define TELOPT_XDISPLOC 35 /* X DISPlay LOCation */
-#define	SB	250		/* interpret as subnegotiation */
-#define	GA	249		/* you may reverse the line */
-#define	EL	248		/* erase the current line */
-#define	EC	247		/* erase the current character */
-#define	AYT	246		/* are you there */
-#define	AO	245		/* abort output--but let prog finish */
-#define	IP	244		/* interrupt process--permanently */
-#define	BREAK	243		/* break */
-#define	DM	242		/* data mark--for connect. cleaning */
-#define	NOP	241		/* nop */
-#define	SE	240		/* end sub negotiation */
-#define EOR     239             /* end of record (transparent mode) */
-#define	ABORT	238		/* Abort process */
-#define	SUSP	237		/* Suspend process */
-#define	xEOF	236		/* End of file: EOF is already used... */
 
-#define SYNCH	242		/* for telfunc calls */
+#define TELOPT_NEW_ENVIRON 39  /* NEW ENVIRONment variables */
-
-#ifdef TELCMDS
-static
-char *telcmds[] = {
-	"EOF", "SUSP", "ABORT", "EOR",
-	"SE", "NOP", "DMARK", "BRK", "IP", "AO", "AYT", "EC",
-	"EL", "GA", "SB", "WILL", "WONT", "DO", "DONT", "IAC", 0,
-};
-#else
-extern char *telcmds[];
-#endif
-
-#define	TELCMD_FIRST	xEOF
-#define	TELCMD_LAST	IAC
-#define	TELCMD_OK(x)	((unsigned int)(x) <= TELCMD_LAST && \
-			 (unsigned int)(x) >= TELCMD_FIRST)
-#define	TELCMD(x)	telcmds[(x)-TELCMD_FIRST]
-
-/* telnet options */
-#define TELOPT_BINARY	0	/* 8-bit data path */
-#define TELOPT_ECHO	1	/* echo */
-#define	TELOPT_RCP	2	/* prepare to reconnect */
-#define	TELOPT_SGA	3	/* suppress go ahead */
-#define	TELOPT_NAMS	4	/* approximate message size */
-#define	TELOPT_STATUS	5	/* give status */
-#define	TELOPT_TM	6	/* timing mark */
-#define	TELOPT_RCTE	7	/* remote controlled transmission and echo */
-#define TELOPT_NAOL 	8	/* negotiate about output line width */
-#define TELOPT_NAOP 	9	/* negotiate about output page size */
-#define TELOPT_NAOCRD	10	/* negotiate about CR disposition */
-#define TELOPT_NAOHTS	11	/* negotiate about horizontal tabstops */
-#define TELOPT_NAOHTD	12	/* negotiate about horizontal tab disposition */
-#define TELOPT_NAOFFD	13	/* negotiate about formfeed disposition */
-#define TELOPT_NAOVTS	14	/* negotiate about vertical tab stops */
-#define TELOPT_NAOVTD	15	/* negotiate about vertical tab disposition */
-#define TELOPT_NAOLFD	16	/* negotiate about output LF disposition */
-#define TELOPT_XASCII	17	/* extended ascic character set */
-#define	TELOPT_LOGOUT	18	/* force logout */
-#define	TELOPT_BM	19	/* byte macro */
-#define	TELOPT_DET	20	/* data entry terminal */
-#define	TELOPT_SUPDUP	21	/* supdup protocol */
-#define	TELOPT_SUPDUPOUTPUT 22	/* supdup output */
-#define	TELOPT_SNDLOC	23	/* send location */
-#define	TELOPT_TTYPE	24	/* terminal type */
-#define	TELOPT_EOR	25	/* end or record */
-#define	TELOPT_TUID	26	/* TACACS user identification */
-#define	TELOPT_OUTMRK	27	/* output marking */
-#define	TELOPT_TTYLOC	28	/* terminal location number */
-#define	TELOPT_3270REGIME 29	/* 3270 regime */
-#define	TELOPT_X3PAD	30	/* X.3 PAD */
-#define	TELOPT_NAWS	31	/* window size */
-#define	TELOPT_TSPEED	32	/* terminal speed */
-#define	TELOPT_LFLOW	33	/* remote flow control */
-#define TELOPT_LINEMODE	34	/* Linemode option */
-#define TELOPT_XDISPLOC	35	/* X Display Location */
-#define TELOPT_OLD_ENVIRON 36	/* Old - Environment variables */
-#define	TELOPT_AUTHENTICATION 37/* Authenticate */
-#define	TELOPT_ENCRYPT	38	/* Encryption option */
-#define TELOPT_NEW_ENVIRON 39	/* New - Environment variables */
-#define	TELOPT_EXOPL	255	/* extended-options-list */
-
-
-#define	NTELOPTS	(1+TELOPT_NEW_ENVIRON)
-#ifdef TELOPTS
-static
-char *telopts[NTELOPTS+1] = {
-	"BINARY", "ECHO", "RCP", "SUPPRESS GO AHEAD", "NAME",
-	"STATUS", "TIMING MARK", "RCTE", "NAOL", "NAOP",
-	"NAOCRD", "NAOHTS", "NAOHTD", "NAOFFD", "NAOVTS",
-	"NAOVTD", "NAOLFD", "EXTEND ASCII", "LOGOUT", "BYTE MACRO",
-	"DATA ENTRY TERMINAL", "SUPDUP", "SUPDUP OUTPUT",
-	"SEND LOCATION", "TERMINAL TYPE", "END OF RECORD",
-	"TACACS UID", "OUTPUT MARKING", "TTYLOC",
-	"3270 REGIME", "X.3 PAD", "NAWS", "TSPEED", "LFLOW",
-	"LINEMODE", "XDISPLOC", "OLD-ENVIRON", "AUTHENTICATION",
-	"ENCRYPT", "NEW-ENVIRON",
-	0,
-};
-#define	TELOPT_FIRST	TELOPT_BINARY
-#define	TELOPT_LAST	TELOPT_NEW_ENVIRON
-#define	TELOPT_OK(x)	((unsigned int)(x) <= TELOPT_LAST)
-#define	TELOPT(x)	telopts[(x)-TELOPT_FIRST]
-#endif
-
-/* sub-option qualifiers */
-#define	TELQUAL_IS	0	/* option is... */
-#define	TELQUAL_SEND	1	/* send option */
-#define	TELQUAL_INFO	2	/* ENVIRON: informational version of IS */
-#define	TELQUAL_REPLY	2	/* AUTHENTICATION: client version of IS */
-#define	TELQUAL_NAME	3	/* AUTHENTICATION: client version of IS */
-
-#define	LFLOW_OFF		0	/* Disable remote flow control */
-#define	LFLOW_ON		1	/* Enable remote flow control */
-#define	LFLOW_RESTART_ANY	2	/* Restart output on any char */
-#define	LFLOW_RESTART_XON	3	/* Restart output only on XON */
-
-/*
- * LINEMODE suboptions
- */
-
-#define	LM_MODE		1
-#define	LM_FORWARDMASK	2
-#define	LM_SLC		3
-
-#define	MODE_EDIT	0x01
-#define	MODE_TRAPSIG	0x02
-#define	MODE_ACK	0x04
-#define MODE_SOFT_TAB	0x08
-#define MODE_LIT_ECHO	0x10
-
-#define	MODE_MASK	0x1f
-
-/* Not part of protocol, but needed to simplify things... */
-#define MODE_FLOW		0x0100
-#define MODE_ECHO		0x0200
-#define MODE_INBIN		0x0400
-#define MODE_OUTBIN		0x0800
-#define MODE_FORCE		0x1000
-
-#define	SLC_SYNCH	1
-#define	SLC_BRK		2
-#define	SLC_IP		3
-#define	SLC_AO		4
-#define	SLC_AYT		5
-#define	SLC_EOR		6
-#define	SLC_ABORT	7
-#define	SLC_EOF		8
-#define	SLC_SUSP	9
-#define	SLC_EC		10
-#define	SLC_EL		11
-#define	SLC_EW		12
-#define	SLC_RP		13
-#define	SLC_LNEXT	14
-#define	SLC_XON		15
-#define	SLC_XOFF	16
-#define	SLC_FORW1	17
-#define	SLC_FORW2	18
-
-#define	NSLC		18
-
-/*
- * For backwards compatability, we define SLC_NAMES to be the
- * list of names if SLC_NAMES is not defined.
- */
-#define	SLC_NAMELIST	"0", "SYNCH", "BRK", "IP", "AO", "AYT", "EOR", \
-			"ABORT", "EOF", "SUSP", "EC", "EL", "EW", "RP", \
-			"LNEXT", "XON", "XOFF", "FORW1", "FORW2", 0,
-#ifdef	SLC_NAMES
-char *slc_names[] = {
-	SLC_NAMELIST
-};
-#else
-extern char *slc_names[];
-#define	SLC_NAMES SLC_NAMELIST
-#endif
-
-#define	SLC_NAME_OK(x)	((unsigned int)(x) <= NSLC)
-#define SLC_NAME(x)	slc_names[x]
-
-#define	SLC_NOSUPPORT	0
-#define	SLC_CANTCHANGE	1
-#define	SLC_VARIABLE	2
-#define	SLC_DEFAULT	3
-#define	SLC_LEVELBITS	0x03
-
-#define	SLC_FUNC	0
-#define	SLC_FLAGS	1
-#define	SLC_VALUE	2
-
-#define	SLC_ACK		0x80
-#define	SLC_FLUSHIN	0x40
-#define	SLC_FLUSHOUT	0x20
-
-#define	OLD_ENV_VAR	1
-#define	OLD_ENV_VALUE	0
 #define NEW_ENV_VAR   0
 #define NEW_ENV_VALUE 1
-#define	ENV_ESC		2
-#define	ENV_USERVAR	3
 
 /*
- * AUTHENTICATION suboptions
+ * The telnet options represented as strings
  */
-
+static const char *telnetoptions[]=
-/*
+{
- * Who is authenticating who ...
+  "BINARY",      "ECHO",           "RCP",           "SUPPRESS GO AHEAD",
- */
+  "NAME",        "STATUS"          "TIMING MARK",   "RCTE",
-#define	AUTH_WHO_CLIENT		0	/* Client authenticating server */
+  "NAOL",        "NAOP",           "NAOCRD",        "NAOHTS",
-#define	AUTH_WHO_SERVER		1	/* Server authenticating client */
+  "NAOHTD",      "NAOFFD",         "NAOVTS",        "NAOVTD",
-#define	AUTH_WHO_MASK		1
+  "NAOLFD",      "EXTEND ASCII",   "LOGOUT",        "BYTE MACRO",
-
+  "DE TERMINAL", "SUPDUP",         "SUPDUP OUTPUT", "SEND LOCATION",
-/*
+  "TERM TYPE",   "END OF RECORD",  "TACACS UID",    "OUTPUT MARKING",
- * amount of authentication done
+  "TTYLOC",      "3270 REGIME",    "X3 PAD",        "NAWS",
- */
+  "TERM SPEED",  "LFLOW",          "LINEMODE",      "XDISPLOC",
-#define	AUTH_HOW_ONE_WAY	0
+  "OLD-ENVIRON", "AUTHENTICATION", "ENCRYPT",       "NEW-ENVIRON"
-#define	AUTH_HOW_MUTUAL		2
-#define	AUTH_HOW_MASK		2
-
-#define	AUTHTYPE_NULL		0
-#define	AUTHTYPE_KERBEROS_V4	1
-#define	AUTHTYPE_KERBEROS_V5	2
-#define	AUTHTYPE_SPX		3
-#define	AUTHTYPE_MINK		4
-#define	AUTHTYPE_CNT		5
-
-#define	AUTHTYPE_TEST		99
-
-#ifdef	AUTH_NAMES
-char *authtype_names[] = {
-	"NULL", "KERBEROS_V4", "KERBEROS_V5", "SPX", "MINK", 0,
 };
-#else
+
-extern char *authtype_names[];
+#define TELOPT_MAXIMUM TELOPT_NEW_ENVIRON
+
+#define TELOPT_OK(x) ((x) <= TELOPT_MAXIMUM)
+#define TELOPT(x)    telnetoptions[x]
+
+#define NTELOPTS 40 
+
+/*
+ * First some defines
+ */
+#define xEOF 236 /* End Of File */ 
+#define SE   240 /* Sub negotiation End */
+#define NOP  241 /* No OPeration */
+#define DM   242 /* Data Mark */
+#define GA   249 /* Go Ahead, reverse the line */
+#define SB   250 /* SuBnegotiation */
+#define WILL 251 /* Our side WILL use this option */
+#define WONT 252 /* Our side WON'T use this option */
+#define DO   253 /* DO use this option! */
+#define DONT 254 /* DON'T use this option! */
+#define IAC  255 /* Interpret As Command */
+
+/*
+ * Then those numbers represented as strings:
+ */
+static const char *telnetcmds[]=
+{
+  "EOF",  "SUSP",  "ABORT", "EOR",  "SE",
+  "NOP",  "DMARK", "BRK",   "IP",   "AO",
+  "AYT",  "EC",    "EL",    "GA",   "SB",
+  "WILL", "WONT",  "DO",    "DONT", "IAC"
+};
+
+#define TELCMD_MINIMUM xEOF /* the first one */
+#define TELCMD_MAXIMUM  IAC  /* surprise, 255 is the last one! ;-) */
+
+#define TELQUAL_IS   0
+#define TELQUAL_SEND 1
+#define TELQUAL_INFO 2
+#define TELQUAL_NAME 3
+
+#define TELCMD_OK(x) ( ((unsigned int)(x) >= TELCMD_MINIMUM) && \
+                       ((unsigned int)(x) <= TELCMD_MAXIMUM) )
+#define TELCMD(x)    telnetcmds[(x)-TELCMD_MINIMUM]
+
 #endif
-
-#define	AUTHTYPE_NAME_OK(x)	((unsigned int)(x) < AUTHTYPE_CNT)
-#define	AUTHTYPE_NAME(x)	authtype_names[x]
-
-/*
- * ENCRYPTion suboptions
- */
-#define	ENCRYPT_IS		0	/* I pick encryption type ... */
-#define	ENCRYPT_SUPPORT		1	/* I support encryption types ... */
-#define	ENCRYPT_REPLY		2	/* Initial setup response */
-#define	ENCRYPT_START		3	/* Am starting to send encrypted */
-#define	ENCRYPT_END		4	/* Am ending encrypted */
-#define	ENCRYPT_REQSTART	5	/* Request you start encrypting */
-#define	ENCRYPT_REQEND		6	/* Request you send encrypting */
-#define	ENCRYPT_ENC_KEYID	7
-#define	ENCRYPT_DEC_KEYID	8
-#define	ENCRYPT_CNT		9
-
-#define	ENCTYPE_ANY		0
-#define	ENCTYPE_DES_CFB64	1
-#define	ENCTYPE_DES_OFB64	2
-#define	ENCTYPE_CNT		3
-
-#ifdef	ENCRYPT_NAMES
-char *encrypt_names[] = {
-	"IS", "SUPPORT", "REPLY", "START", "END",
-	"REQUEST-START", "REQUEST-END", "ENC-KEYID", "DEC-KEYID",
-	0,
-};
-char *enctype_names[] = {
-	"ANY", "DES_CFB64",  "DES_OFB64",  0,
-};
-#else
-extern char *encrypt_names[];
-extern char *enctype_names[];
-#endif
-
-
-#define	ENCRYPT_NAME_OK(x)	((unsigned int)(x) < ENCRYPT_CNT)
-#define	ENCRYPT_NAME(x)		encrypt_names[x]
-
-#define	ENCTYPE_NAME_OK(x)	((unsigned int)(x) < ENCTYPE_CNT)
-#define	ENCTYPE_NAME(x)		enctype_names[x]
-#endif /* _ARPA_TELNET_H */

lib/base64.c

@@ -1,152 +1,262 @@
-/*
+/*****************************************************************************
- * Copyright (c) 1995 - 1999 Kungliga Tekniska H<>gskolan
+ *                                  _   _ ____  _     
- * (Royal Institute of Technology, Stockholm, Sweden).
+ *  Project                     ___| | | |  _ \| |    
- * All rights reserved.
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
  *
- * Redistribution and use in source and binary forms, with or without
+ * Copyright (C) 2001, Andrew Francis and Daniel Stenberg
- * modification, are permitted provided that the following conditions
- * are met:
  *
- * 1. Redistributions of source code must retain the above copyright
+ * In order to be useful for every potential user, curl and libcurl are
- *    notice, this list of conditions and the following disclaimer.
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
  *
- * 2. Redistributions in binary form must reproduce the above copyright
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
- *    notice, this list of conditions and the following disclaimer in the
+ * copies of the Software, and permit persons to whom the Software is
- *    documentation and/or other materials provided with the distribution.
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
  *
- * 3. Neither the name of the Institute nor the names of its contributors
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- *    may be used to endorse or promote products derived from this software
+ * KIND, either express or implied.
- *    without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * $Id$
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *****************************************************************************/
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+/* Base64 encoding/decoding
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * Test harnesses down the bottom - compile with -DTEST_ENCODE for
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * a program that will read in raw data from stdin and write out
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * a base64-encoded version to stdout, and the length returned by the
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * encoding function to stderr. Compile with -DTEST_DECODE for a program that
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * will go the other way.
- * SUCH DAMAGE.
+ * 
+ * This code will break if int is smaller than 32 bits
  */
 
-#ifdef HAVE_CONFIG_H
+#include "setup.h"
-#include <config.h>
+
-#endif
 #include <stdlib.h>
 #include <string.h>
+
+#define _MPRINTF_REPLACE /* use our functions only */
+#include <curl/mprintf.h>
+
 #include "base64.h"
 
-/* The last #include file should be: */
 #ifdef MALLOCDEBUG
 #include "memdebug.h"
 #endif
 
-static char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static void decodeQuantum(unsigned char *dest, char *src)
-
-static int pos(char c)
 {
-  char *p;
+  unsigned int x = 0;
-  for(p = base64; *p; p++)
-    if(*p == c)
-      return p - base64;
-  return -1;
-}
-
-#if 1
-int Curl_base64_encode(const void *data, int size, char **str)
-{
-  char *s, *p;
   int i;
-  int c;
+  for(i = 0; i < 4; i++) {
-  const unsigned char *q;
+    if(src[i] >= 'A' && src[i] <= 'Z')
-
+      x = (x << 6) + (unsigned int)(src[i] - 'A' + 0);
-  p = s = (char*)malloc(size*4/3+4);
+    else if(src[i] >= 'a' && src[i] <= 'z')
-  if (p == NULL)
+      x = (x << 6) + (unsigned int)(src[i] - 'a' + 26);
-      return -1;
+    else if(src[i] >= '0' && src[i] <= '9') 
-  q = (const unsigned char*)data;
+      x = (x << 6) + (unsigned int)(src[i] - '0' + 52);
-  i=0;
+    else if(src[i] == '+')
-  for(i = 0; i < size;){
+      x = (x << 6) + 62;
-    c=q[i++];
+    else if(src[i] == '/')
-    c*=256;
+      x = (x << 6) + 63;
-    if(i < size)
-      c+=q[i];
-    i++;
-    c*=256;
-    if(i < size)
-      c+=q[i];
-    i++;
-    p[0]=base64[(c&0x00fc0000) >> 18];
-    p[1]=base64[(c&0x0003f000) >> 12];
-    p[2]=base64[(c&0x00000fc0) >> 6];
-    p[3]=base64[(c&0x0000003f) >> 0];
-    if(i > size)
-      p[3]='=';
-    if(i > size+1)
-      p[2]='=';
-    p+=4;
   }
-  *p=0;
+
-  *str = s;
+  dest[2] = (unsigned char)(x & 255); x >>= 8;
-  return strlen(s);
+  dest[1] = (unsigned char)(x & 255); x >>= 8;
+  dest[0] = (unsigned char)(x & 255); x >>= 8;
 }
-#endif
+
+/* base64Decode
+ * Given a base64 string at src, decode it into the memory pointed
+ * to by dest. If rawLength points to a valid address (ie not NULL),
+ * store the length of the decoded data to it.
+ */
+static void base64Decode(unsigned char *dest, char *src, int *rawLength)
+{
+  int length = 0;
+  int equalsTerm = 0;
+  int i;
+  unsigned char lastQuantum[3];
+	
+  while((src[length] != '=') && src[length])
+    length++;
+  while(src[length+equalsTerm] == '=')
+    equalsTerm++;
+  
+  if(rawLength)
+    *rawLength = (length * 3 / 4) - equalsTerm;
+  
+  for(i = 0; i < length/4 - 1; i++) {
+    decodeQuantum(dest, src);
+    dest += 3; src += 4;
+  }
+
+  decodeQuantum(lastQuantum, src);
+  for(i = 0; i < 3 - equalsTerm; i++) dest[i] = lastQuantum[i];
+	
+}
+
+/* ---- Base64 Encoding --- */
+static char table64[]=
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  
+/*
+ * Curl_base64_encode()
+ *
+ * Returns the length of the newly created base64 string. The third argument
+ * is a pointer to an allocated area holding the base64 data. If something
+ * went wrong, -1 is returned.
+ *
+ */
+int Curl_base64_encode(const void *inp, int insize, char **outptr)
+{
+  unsigned char ibuf[3];
+  unsigned char obuf[4];
+  int i;
+  int inputparts;
+  char *output;
+  char *base64data;
+
+  char *indata = (char *)inp;
+
+  if(0 == insize)
+    insize = strlen(indata);
+
+  base64data = output = (char*)malloc(insize*4/3+4);
+  if(NULL == output)
+    return -1;
+
+  while(insize > 0) {
+    for (i = inputparts = 0; i < 3; i++) { 
+      if(*indata) {
+        inputparts++;
+        ibuf[i] = *indata;
+        indata++;
+        insize--;
+      }
+      else
+        ibuf[i] = 0;
+    }
+                       
+    obuf [0] = (ibuf [0] & 0xFC) >> 2;
+    obuf [1] = ((ibuf [0] & 0x03) << 4) | ((ibuf [1] & 0xF0) >> 4);
+    obuf [2] = ((ibuf [1] & 0x0F) << 2) | ((ibuf [2] & 0xC0) >> 6);
+    obuf [3] = ibuf [2] & 0x3F;
+
+    switch(inputparts) {
+    case 1: /* only one byte read */
+      sprintf(output, "%c%c==", 
+              table64[obuf[0]],
+              table64[obuf[1]]);
+      break;
+    case 2: /* two bytes read */
+      sprintf(output, "%c%c%c=", 
+              table64[obuf[0]],
+              table64[obuf[1]],
+              table64[obuf[2]]);
+      break;
+    default:
+      sprintf(output, "%c%c%c%c", 
+              table64[obuf[0]],
+              table64[obuf[1]],
+              table64[obuf[2]],
+              table64[obuf[3]] );
+      break;
+    }
+    output += 4;
+  }
+  *output=0;
+  *outptr = base64data; /* make it return the actual data memory */
+
+  return strlen(base64data); /* return the length of the new data */
+}
+/* ---- End of Base64 Encoding ---- */
 
 int Curl_base64_decode(const char *str, void *data)
 {
-  const char *p;
+  int ret;
-  unsigned char *q;
-  int c;
-  int x;
-  int done = 0;
-  q=(unsigned char*)data;
-  for(p=str; *p && !done; p+=4){
-    x = pos(p[0]);
-    if(x >= 0)
-      c = x;
-    else{
-      done = 3;
-      break;
-    }
-    c*=64;
 
-    x = pos(p[1]);
+  base64Decode((unsigned char *)data, (char *)str, &ret);
-    if(x >= 0)
+  return ret;
-      c += x;
-    else
-      return -1;
-    c*=64;
-    
-    if(p[2] == '=')
-      done++;
-    else{
-      x = pos(p[2]);
-      if(x >= 0)
-	c += x;
-      else
-	return -1;
-    }
-    c*=64;
-    
-    if(p[3] == '=')
-      done++;
-    else{
-      if(done)
-	return -1;
-      x = pos(p[3]);
-      if(x >= 0)
-	c += x;
-      else
-	return -1;
-    }
-    if(done < 3)
-      *q++=(c&0x00ff0000)>>16;
-      
-    if(done < 2)
-      *q++=(c&0x0000ff00)>>8;
-    if(done < 1)
-      *q++=(c&0x000000ff)>>0;
-  }
-  return q - (unsigned char*)data;
 }
+
+/************* TEST HARNESS STUFF ****************/
+
+
+#ifdef TEST_ENCODE
+/* encoding test harness. Read in standard input and write out the length
+ * returned by Curl_base64_encode, followed by the base64'd data itself
+ */
+#include <stdio.h>
+
+#define TEST_NEED_SUCK
+void *suck(int *);
+
+int main(int argc, char **argv, char **envp) {
+	char *base64;
+	int base64Len;
+	unsigned char *data;
+	int dataLen;
+	
+	data = (unsigned char *)suck(&dataLen);
+	base64Len = Curl_base64_encode(data, dataLen, &base64);
+
+	fprintf(stderr, "%d\n", base64Len);
+	fprintf(stdout, "%s",   base64);
+
+	free(base64); free(data);
+	return 0;
+}
+#endif
+
+#ifdef TEST_DECODE
+/* decoding test harness. Read in a base64 string from stdin and write out the 
+ * length returned by Curl_base64_decode, followed by the decoded data itself
+ */
+#include <stdio.h>
+
+#define TEST_NEED_SUCK
+void *suck(int *);
+
+int main(int argc, char **argv, char **envp) {
+	char *base64;
+	int base64Len;
+	unsigned char *data;
+	int dataLen;
+	
+	base64 = (char *)suck(&base64Len);
+	data = (unsigned char *)malloc(base64Len * 3/4 + 8);
+	dataLen = Curl_base64_decode(base64, data);
+
+	fprintf(stderr, "%d\n", dataLen);
+	fwrite(data,1,dataLen,stdout);
+	
+
+	free(base64); free(data);
+	return 0;
+}
+#endif
+
+#ifdef TEST_NEED_SUCK
+/* this function 'sucks' in as much as possible from stdin */
+void *suck(int *lenptr) {
+	int cursize = 8192;
+	unsigned char *buf = NULL;
+	int lastread;
+	int len = 0;
+	
+	do {
+		cursize *= 2;
+		buf = (unsigned char *)realloc(buf, cursize);
+		memset(buf + len, 0, cursize - len);
+		lastread = fread(buf + len, 1, cursize - len, stdin);
+		len += lastread;
+	} while(!feof(stdin));
+	
+	lenptr[0] = len;
+	return (void *)buf;
+}
+#endif
+

lib/base64.h

@@ -1,40 +1,27 @@
-/*
- * Copyright (c) 1995, 1996, 1997 Kungliga Tekniska H<>gskolan
- * (Royal Institute of Technology, Stockholm, Sweden).
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 
- * 3. Neither the name of the Institute nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
 #ifndef __BASE64_H
 #define __BASE64_H
-
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * 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 MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
 int Curl_base64_encode(const void *data, int size, char **str);
 int Curl_base64_decode(const char *str, void *data);
-
 #endif

lib/cookie.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -95,7 +95,7 @@ Example set of cookies:
 
 /****************************************************************************
  *
- * cookie_add()
+ * Curl_cookie_add()
  *
  * Add a single cookie line to the cookie keeping object.
  *
@@ -112,6 +112,7 @@ Curl_cookie_add(struct CookieInfo *c,
   char *ptr;
   char *semiptr;
   struct Cookie *co;
+  struct Cookie *lastc=NULL;
   time_t now = time(NULL);
   bool replace_old = FALSE;
 
@@ -129,13 +130,11 @@ Curl_cookie_add(struct CookieInfo *c,
     semiptr=strchr(lineptr, ';'); /* first, find a semicolon */
     ptr = lineptr;
     do {
-      if(semiptr)
-        *semiptr='\0'; /* zero terminate for a while */
       /* we have a <what>=<this> pair or a 'secure' word here */
       if(strchr(ptr, '=')) {
         name[0]=what[0]=0; /* init the buffers */
         if(1 <= sscanf(ptr, "%" MAX_NAME_TXT "[^=]=%"
-                       MAX_COOKIE_LINE_TXT "[^\r\n]",
+                       MAX_COOKIE_LINE_TXT "[^;\r\n]",
                        name, what)) {
           /* this is a legal <what>=<this> pair */
           if(strequal("path", name)) {
@@ -169,8 +168,8 @@ Curl_cookie_add(struct CookieInfo *c,
             co->name = strdup(name);
             co->value = strdup(what);
           }
-          else
+          /*
-            ;/* this is the second (or more) name we don't know
+            else this is the second (or more) name we don't know
             about! */
         }
         else {
@@ -178,18 +177,18 @@ Curl_cookie_add(struct CookieInfo *c,
         }
       }
       else {
-        if(sscanf(ptr, "%" MAX_COOKIE_LINE_TXT "[^\r\n]",
+        if(sscanf(ptr, "%" MAX_COOKIE_LINE_TXT "[^;\r\n]",
                   what)) {
           if(strequal("secure", what))
             co->secure = TRUE;
-          else
+          /* else,
-            ; /* unsupported keyword without assign! */
+             unsupported keyword without assign! */
+
         }
       }
       if(!semiptr)
         continue; /* we already know there are no more cookies */
 
-      *semiptr=';'; /* put the semicolon back */
       ptr=semiptr+1;
       while(ptr && *ptr && isspace((int)*ptr))
         ptr++;
@@ -244,6 +243,7 @@ Curl_cookie_add(struct CookieInfo *c,
 
            We don't currently take advantage of this knowledge.
         */
+        co->field1=strequal(ptr, "TRUE")+1; /* store information */
         break;
       case 2:
         /* It turns out, that sometimes the file format allows the path
@@ -292,6 +292,8 @@ Curl_cookie_add(struct CookieInfo *c,
 
   }
 
+  co->livecookie = c->running;
+
   /* now, we have parsed the incoming line, we must now check if this
      superceeds an already existing cookie, which it may if the previous have
      the same domain and path as this */
@@ -326,6 +328,26 @@ Curl_cookie_add(struct CookieInfo *c,
         
       }
 
+      if(replace_old && !co->livecookie && clist->livecookie) {
+        /* Both cookies matched fine, except that the already present
+           cookie is "live", which means it was set from a header, while
+           the new one isn't "live" and thus only read from a file. We let
+           live cookies stay alive */
+
+        /* Free the newcomer and get out of here! */
+        if(co->domain)
+          free(co->domain);
+        if(co->path)
+          free(co->path);
+        if(co->name)
+          free(co->name);
+        if(co->value)
+          free(co->value);
+
+        free(co);
+        return NULL;
+      }
+
       if(replace_old) {
         co->next = clist->next; /* get the next-pointer first */
 
@@ -350,39 +372,51 @@ Curl_cookie_add(struct CookieInfo *c,
       }
 
     }
+    lastc = clist;
     clist = clist->next;
   }
 
   if(!replace_old) {
-
+    /* then make the last item point on this new one */
-    /* first, point to our "next" */
+    if(lastc)
-    co->next = c->cookies;
+      lastc->next = co;
-    /* then make ourselves first in the list */
+    else
       c->cookies = co;
   }
+
+  c->numcookies++; /* one more cookie in the jar */
+
   return co;
 }
 
 /*****************************************************************************
  *
- * cookie_init()
+ * Curl_cookie_init()
  *
  * Inits a cookie struct to read data from a local file. This is always
  * called before any cookies are set. File may be NULL.
  *
  ****************************************************************************/
-struct CookieInfo *Curl_cookie_init(char *file)
+struct CookieInfo *Curl_cookie_init(char *file, struct CookieInfo *inc)
 {
   char line[MAX_COOKIE_LINE];
   struct CookieInfo *c;
   FILE *fp;
   bool fromfile=TRUE;
   
+  if(NULL == inc) {
+    /* we didn't get a struct, create one */
     c = (struct CookieInfo *)malloc(sizeof(struct CookieInfo));
     if(!c)
       return NULL; /* failed to get memory */
     memset(c, 0, sizeof(struct CookieInfo));
     c->filename = strdup(file?file:"none"); /* copy the name just in case */
+  }
+  else {
+    /* we got an already existing one, use that */
+    c = inc;
+  }
+  c->running = FALSE; /* this is not running, this is init */
 
   if(strequal(file, "-")) {
     fp = stdin;
@@ -392,34 +426,35 @@ struct CookieInfo *Curl_cookie_init(char *file)
     fp = file?fopen(file, "r"):NULL;
 
   if(fp) {
+    char *lineptr;
+    bool headerline;
     while(fgets(line, MAX_COOKIE_LINE, fp)) {
       if(strnequal("Set-Cookie:", line, 11)) {
         /* This is a cookie line, get it! */
-        char *lineptr=&line[11];
+        lineptr=&line[11];
-        while(*lineptr && isspace((int)*lineptr))
+        headerline=TRUE;
-          lineptr++;
-
-        Curl_cookie_add(c, TRUE, lineptr);
       }
       else {
-        /* This might be a netscape cookie-file line, get it! */
+        lineptr=line;
-        char *lineptr=line;
+        headerline=FALSE;
+      }
       while(*lineptr && isspace((int)*lineptr))
         lineptr++;
 
-        Curl_cookie_add(c, FALSE, lineptr);
+      Curl_cookie_add(c, headerline, lineptr);
-      }
     }
     if(fromfile)
       fclose(fp);
   }
 
+  c->running = TRUE; /* now, we're running */
+
   return c;
 }
 
 /*****************************************************************************
  *
- * cookie_getlist()
+ * Curl_cookie_getlist()
  *
  * For a given host and path, return a linked list of cookies that the
  * client should send to the server if used now. The secure boolean informs
@@ -491,9 +526,9 @@ struct Cookie *Curl_cookie_getlist(struct CookieInfo *c,
 
 /*****************************************************************************
  *
- * cookie_freelist()
+ * Curl_cookie_freelist()
  *
- * Free a list previously returned by cookie_getlist();
+ * Free a list of cookies previously returned by Curl_cookie_getlist();
  *
  ****************************************************************************/
 
@@ -512,7 +547,7 @@ void Curl_cookie_freelist(struct Cookie *co)
 
 /*****************************************************************************
  *
- * cookie_cleanup()
+ * Curl_cookie_cleanup()
  *
  * Free a "cookie object" previous created with cookie_init().
  *
@@ -551,3 +586,93 @@ void Curl_cookie_cleanup(struct CookieInfo *c)
    }
 }
 
+/*
+ * Curl_cookie_output()
+ *
+ * Writes all internally known cookies to the specified file. Specify
+ * "-" as file name to write to stdout.
+ *
+ * The function returns non-zero on write failure.
+ */
+int Curl_cookie_output(struct CookieInfo *c, char *dumphere)
+{
+  struct Cookie *co;
+  FILE *out;
+  bool use_stdout=FALSE;
+
+  if(0 == c->numcookies)
+    /* If there are no known cookies, we don't write or even create any
+       destination file */
+    return 0;
+
+  if(strequal("-", dumphere)) {
+    /* use stdout */
+    out = stdout;
+    use_stdout=TRUE;
+  }
+  else {
+    out = fopen(dumphere, "w");
+    if(!out)
+      return 1; /* failure */
+  }
+
+  if(c) {
+    fputs("# Netscape HTTP Cookie File\n"
+          "# http://www.netscape.com/newsref/std/cookie_spec.html\n"
+          "# This is generated by libcurl! Edit on your own risk.\n\n",
+          out);
+    co = c->cookies;
+     
+    while(co) {
+      fprintf(out,
+              "%s\t" /* domain */
+              "%s\t" /* field1 */
+              "%s\t" /* path */
+              "%s\t" /* secure */
+              "%u\t" /* expires */
+              "%s\t" /* name */
+              "%s\n", /* value */
+              co->domain,
+              co->field1==2?"TRUE":"FALSE",
+              co->path,
+              co->secure?"TRUE":"FALSE",
+              (unsigned int)co->expires,
+              co->name,
+              co->value);
+
+      co=co->next;
+    }
+  }
+
+  if(!use_stdout)
+    fclose(out);
+
+  return 0;
+}
+
+#ifdef CURL_COOKIE_DEBUG
+
+/*
+ * On my Solaris box, this command line builds this test program:
+ *
+ * gcc -g -o cooktest -DCURL_COOKIE_DEBUG -DHAVE_CONFIG_H -I.. -I../include cookie.c strequal.o getdate.o memdebug.o mprintf.o strtok.o -lnsl -lsocket
+ *
+ */
+
+int main(int argc, char **argv)
+{
+  struct CookieInfo *c=NULL;
+  if(argc>1) {
+    c = Curl_cookie_init(argv[1], c);
+    Curl_cookie_add(c, TRUE, "PERSONALIZE=none;expires=Monday, 13-Jun-1988 03:04:55 GMT; domain=.fidelity.com; path=/ftgw; secure");
+    Curl_cookie_add(c, TRUE, "foobar=yes; domain=.haxx.se; path=/looser;");
+    c = Curl_cookie_init(argv[1], c);
+
+    Curl_cookie_output(c);
+    Curl_cookie_cleanup(c);
+    return 0;
+  }
+  return 1;
+}
+
+#endif

lib/cookie.h

@@ -41,11 +41,14 @@ struct Cookie {
   time_t expires;    /* expires = <this> */
   char *expirestr;   /* the plain text version */
 
+  char field1;       /* read from a cookie file, 1 => FALSE, 2=> TRUE */
+  
   /* RFC 2109 keywords. Version=1 means 2109-compliant cookie sending */
   char *version;     /* Version = <value> */
   char *maxage;      /* Max-Age = <value> */
   
   bool secure;       /* whether the 'secure' keyword was used */
+  bool livecookie;   /* updated from a server, not a stored file */
 };
 
 struct CookieInfo {
@@ -53,6 +56,8 @@ struct CookieInfo {
   struct Cookie *cookies;
 
   char *filename; /* file we read from/write to */
+  bool running;   /* state info, for cookie adding information */
+  long numcookies; /* number of cookies in the "jar" */
 };
 
 /* This is the maximum line length we accept for a cookie line */
@@ -64,9 +69,10 @@ struct CookieInfo {
 #define MAX_NAME_TXT "255"
 
 struct Cookie *Curl_cookie_add(struct CookieInfo *, bool, char *);
-struct CookieInfo *Curl_cookie_init(char *);
+struct CookieInfo *Curl_cookie_init(char *, struct CookieInfo *);
 struct Cookie *Curl_cookie_getlist(struct CookieInfo *, char *, char *, bool);
 void Curl_cookie_freelist(struct Cookie *);
 void Curl_cookie_cleanup(struct CookieInfo *);
+int Curl_cookie_output(struct CookieInfo *, char *);
 
 #endif

lib/curllib.dsp

@@ -43,7 +43,8 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /Zi /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /FR /FD /c
+# SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
@@ -53,7 +54,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /machine:I386 /out:"Release/curl.dll"
+# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /map /debug /machine:I386 /out:"Release/libcurl.dll"
 
 !ELSEIF  "$(CFG)" == "curllib - Win32 Debug"
 
@@ -69,7 +70,8 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /FR /FD /GZ /c
+# SUBTRACT CPP /WX /YX
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -79,7 +81,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /debug /machine:I386 /out:"Debug/curl.dll" /pdbtype:sept
+# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /incremental:no /map /debug /machine:I386 /out:"Debug/libcurl.dll" /pdbtype:sept
 # SUBTRACT LINK32 /nodefaultlib
 
 !ENDIF 

lib/dict.c

@@ -80,11 +80,6 @@
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
 
-CURLcode Curl_dict_done(struct connectdata *conn)
-{
-  return CURLE_OK;
-}
-
 CURLcode Curl_dict(struct connectdata *conn)
 {
   int nth;
@@ -129,10 +124,10 @@ CURLcode Curl_dict(struct connectdata *conn)
       failf(data, "lookup word is missing\n");
     }
     if ((database == NULL) || (*database == (char)0)) {
-      database = "!";
+      database = (char *)"!";
     }
     if ((strategy == NULL) || (*strategy == (char)0)) {
-      strategy = ".";
+      strategy = (char *)".";
     }
     if ((nthdef == NULL) || (*nthdef == (char)0)) {
       nth = 0;
@@ -182,7 +177,7 @@ CURLcode Curl_dict(struct connectdata *conn)
       failf(data, "lookup word is missing\n");
     }
     if ((database == NULL) || (*database == (char)0)) {
-      database = "!";
+      database = (char *)"!";
     }
     if ((nthdef == NULL) || (*nthdef == (char)0)) {
       nth = 0;

lib/dllinit.c

@@ -1,3 +1,4 @@
+#ifdef WIN32
 /* dllinit.c -- Portable DLL initialization. 
    Copyright (C) 1998, 1999 Free Software Foundation, Inc.
    Contributed by Mumit Khan (khan@xraylith.wisc.edu).
@@ -80,3 +81,4 @@ DllMain (
     }
   return TRUE;
 }
+#endif

lib/easy.c

@@ -74,31 +74,102 @@
 #include <curl/curl.h>
 #include "transfer.h"
 #include "ssluse.h"
+#include "url.h"
+#include "getinfo.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
 
-/* true globals */
+
+/* Silly win32 socket initialization functions */
+
+#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
+static void win32_cleanup(void)
+{
+  WSACleanup();
+}
+
+static CURLcode win32_init(void)
+{
+  WORD wVersionRequested;  
+  WSADATA wsaData; 
+  int err; 
+  wVersionRequested = MAKEWORD(1, 1); 
+    
+  err = WSAStartup(wVersionRequested, &wsaData); 
+    
+  if (err != 0) 
+    /* Tell the user that we couldn't find a useable */ 
+    /* winsock.dll.     */ 
+    return CURLE_FAILED_INIT; 
+    
+  /* Confirm that the Windows Sockets DLL supports 1.1.*/ 
+  /* Note that if the DLL supports versions greater */ 
+  /* than 1.1 in addition to 1.1, it will still return */ 
+  /* 1.1 in wVersion since that is the version we */ 
+  /* requested. */ 
+    
+  if ( LOBYTE( wsaData.wVersion ) != 1 || 
+       HIBYTE( wsaData.wVersion ) != 1 ) { 
+    /* Tell the user that we couldn't find a useable */ 
+
+    /* winsock.dll. */ 
+    WSACleanup(); 
+    return CURLE_FAILED_INIT; 
+  }
+  return CURLE_OK;
+}
+/* The Windows Sockets DLL is acceptable. Proceed. */ 
+#else
+/* These functions exist merely to prevent compiler warnings */
+static CURLcode win32_init(void) { return CURLE_OK; }
+static void win32_cleanup(void) { }
+#endif
+
+
+/* true globals -- for curl_global_init() and curl_global_cleanup() */
 static unsigned int  initialized = 0;
 static long          init_flags  = 0;
 
+/**
+ * Globally initializes cURL given a bitwise set of 
+ * the different features to initialize.
+ */
 CURLcode curl_global_init(long flags)
 {
-  if(flags & CURL_GLOBAL_SSL)
+  if (initialized)
+    return CURLE_OK;
+ 
+  if (flags & CURL_GLOBAL_SSL)
     Curl_SSL_init();
 
+  if (flags & CURL_GLOBAL_WIN32)
+    if (win32_init() != CURLE_OK)
+      return CURLE_FAILED_INIT;
+
   initialized = 1;
   init_flags  = flags;
   
   return CURLE_OK;
 }
 
+/**
+ * Globally cleanup cURL, uses the value of "init_flags" to determine
+ * what needs to be cleaned up and what doesn't
+ */
 void curl_global_cleanup(void)
 {
+  if (!initialized)
+    return;
+
   if (init_flags & CURL_GLOBAL_SSL)
     Curl_SSL_cleanup();
 
+  if (init_flags & CURL_GLOBAL_WIN32)
+    win32_cleanup();
+
   initialized = 0;
+  init_flags  = 0;
 }
 
 CURL *curl_easy_init(void)
@@ -111,7 +182,7 @@ CURL *curl_easy_init(void)
     curl_global_init(CURL_GLOBAL_DEFAULT);
 
   /* We use curl_open() with undefined URL so far */
-  res = Curl_open((CURL **)&data, NULL);
+  res = Curl_open(&data);
   if(res != CURLE_OK)
     return NULL;
 
@@ -160,20 +231,25 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...)
 
 CURLcode curl_easy_perform(CURL *curl)
 {
-  return Curl_perform(curl);
+  struct UrlData *data = (struct UrlData *)curl;
+
+  return Curl_perform(data);
 }
 
 void curl_easy_cleanup(CURL *curl)
 {
-  Curl_close(curl);
+  struct UrlData *data = (struct UrlData *)curl;
+  Curl_close(data);
 }
 
 CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...)
 {
   va_list arg;
   void *paramp;
+  struct UrlData *data = (struct UrlData *)curl;
+
   va_start(arg, info);
   paramp = va_arg(arg, void *);
 
-  return Curl_getinfo(curl, info, paramp);
+  return Curl_getinfo(data, info, paramp);
 }

lib/escape.c

@@ -37,9 +37,9 @@
 #include "memdebug.h"
 #endif
 
-char *curl_escape(char *string, int length)
+char *curl_escape(const char *string, int length)
 {
-  int alloc = (length?length:strlen(string))+1;  
+  int alloc = (length?length:(int)strlen(string))+1;  
   char *ns = malloc(alloc);
   unsigned char in;
   int newlen = alloc;
@@ -54,19 +54,6 @@ char *curl_escape(char *string, int length)
             !(in >= 'A' && in <= 'Z') &&
             !(in >= '0' && in <= '9')) {
       /* encode it */
-      if(('%' == in) &&
-         (length>=2) &&
-         isxdigit((int)string[1]) &&
-         isxdigit((int)string[2]) ) {
-        /*
-         * This is an already encoded letter, leave it!
-         */
-        memcpy(&ns[index], string, 3);
-        string+=2;
-      }
-      else {
-        /* encode this now */
-
       newlen += 2; /* the size grows with two, since this'll become a %XX */
       if(newlen > alloc) {
         alloc *= 2;
@@ -75,7 +62,7 @@ char *curl_escape(char *string, int length)
           return NULL;
       }
       sprintf(&ns[index], "%%%02X", in);
-      }
+
       index+=3;
     }
     else {
@@ -88,9 +75,9 @@ char *curl_escape(char *string, int length)
   return ns;
 }
 
-char *curl_unescape(char *string, int length)
+char *curl_unescape(const char *string, int length)
 {
-  int alloc = (length?length:strlen(string))+1;
+  int alloc = (length?length:(int)strlen(string))+1;
   char *ns = malloc(alloc);
   unsigned char in;
   int index=0;

lib/escape.h

@@ -26,7 +26,7 @@
 /* Escape and unescape URL encoding in strings. The functions return a new
  * allocated string or NULL if an error occurred.  */
 
-char *curl_escape(char *string, int length);
+char *curl_escape(const char *string, int length);
-char *curl_unescape(char *string, int length);
+char *curl_unescape(const char *string, int length);
 
 #endif

lib/file.c

@@ -140,8 +140,8 @@ CURLcode Curl_file(struct connectdata *conn)
   */
   CURLcode res = CURLE_OK;
   struct stat statbuf;
-  size_t expected_size=-1;
+  ssize_t expected_size=-1;
-  size_t nread;
+  ssize_t nread;
   struct UrlData *data = conn->data;
   char *buf = data->buffer;
   int bytecount = 0;
@@ -152,6 +152,7 @@ CURLcode Curl_file(struct connectdata *conn)
   /* get the fd from the connection phase */
   fd = conn->proto.file->fd;
 
+/*VMS?? -- This only works reliable for STREAMLF files */
   if( -1 != fstat(fd, &statbuf)) {
     /* we could stat it, then read out the size */
     expected_size = statbuf.st_size;
@@ -167,11 +168,12 @@ CURLcode Curl_file(struct connectdata *conn)
   while (res == CURLE_OK) {
     nread = read(fd, buf, BUFSIZE-1);
 
-    if (0 <= nread)
+    if ( nread > 0)
       buf[nread] = 0;
 
     if (nread <= 0)
       break;
+
     bytecount += nread;
     /* NOTE: The following call to fwrite does CR/LF translation on
        Windows systems if the target is stdout. Use -O or -o parameters

lib/formdata.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -24,7 +24,65 @@
 /*
   Debug the form generator stand-alone by compiling this source file with:
 
-  gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -o formdata -I../include formdata.c
+  gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
+
+  run the 'formdata' executable the output should end with:
+  All Tests seem to have worked ...
+  and the following parts should be there:
+
+Content-Disposition: form-data; name="simple_COPYCONTENTS"
+value for simple COPYCONTENTS
+
+Content-Disposition: form-data; name="COPYCONTENTS_+_CONTENTTYPE"
+Content-Type: image/gif
+value for COPYCONTENTS + CONTENTTYPE
+
+Content-Disposition: form-data; name="PRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH"
+vlue for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH
+(or you might see P^@RNAME and v^@lue at the start)
+
+Content-Disposition: form-data; name="simple_PTRCONTENTS"
+value for simple PTRCONTENTS
+
+Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH"
+vlue for PTRCONTENTS + CONTENTSLENGTH
+(or you might see v^@lue at the start)
+
+Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE"
+Content-Type: text/plain
+vlue for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE
+(or you might see v^@lue at the start)
+
+Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="inet_ntoa_r.h"
+Content-Type: text/html
+...
+
+Content-Disposition: form-data; name="FILE1_+_FILE2"
+Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="Makefile.b32.resp"
+Content-Type: text/plain
+...
+
+Content-Disposition: form-data; name="FILE1_+_FILE2_+_FILE3"
+Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="Makefile.b32.resp"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+
+  For the old FormParse used by curl_formparse use:
+
+  gcc -DHAVE_CONFIG_H -I../ -g -D_OLD_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
 
   run the 'formdata' executable and make sure the output is ok!
 
@@ -64,7 +122,7 @@
 /* This is a silly duplicate of the function in main.c to enable this source
    to compile stand-alone for better debugging */
 static void GetStr(char **string,
-		   char *value)
+		   const char *value)
 {
   if(*string)
     free(*string);
@@ -102,12 +160,12 @@ int FormParse(char *input,
   /* nextarg MUST be a string in the format 'name=contents' and we'll
      build a linked list with the info */
   char name[256];
-  char contents[4096]="";
+  char *contents;
   char major[128];
   char minor[128];
   long flags = 0;
   char *contp;
-  char *type = NULL;
+  const char *type = NULL;
   char *prevtype = NULL;
   char *sep;
   char *sep2;
@@ -115,7 +173,12 @@ int FormParse(char *input,
   struct HttpPost *subpost; /* a sub-node */
   unsigned int i;
 
-  if(1 <= sscanf(input, "%255[^ =] = %4095[^\n]", name, contents)) {
+  /* Preallocate contents to the length of input to make sure we don't
+     overwrite anything. */
+  contents = malloc(strlen(input));
+  contents[0] = '\000';
+ 
+  if(1 <= sscanf(input, "%255[^=]=%[^\n]", name, contents)) {
     /* the input was using the correct format */
     contp = contents;
 
@@ -156,10 +219,11 @@ int FormParse(char *input,
 	    if(2 != sscanf(type, "%127[^/]/%127[^,\n]",
 			   major, minor)) {
 	      fprintf(stderr, "Illegally formatted content-type field!\n");
+              free(contents);
 	      return 2; /* illegal content-type syntax! */
 	    }
 	    /* now point beyond the content-type specifier */
-	    sep = type + strlen(major)+strlen(minor)+1;
+	    sep = (char *)type + strlen(major)+strlen(minor)+1;
 
 	    /* find the following comma */
 	    sep=strchr(sep, FORM_FILE_SEPARATOR);
@@ -180,8 +244,8 @@ int FormParse(char *input,
 	   * extensions and pick the first we match!
 	   */
 	  struct ContentType {
-	    char *extension;
+	    const char *extension;
-	    char *type;
+	    const char *type;
 	  };
           static struct ContentType ctts[]={
 	    {".gif",  "image/gif"},
@@ -221,9 +285,10 @@ int FormParse(char *input,
 	    memset(post, 0, sizeof(struct HttpPost));
 	    GetStr(&post->name, name);      /* get the name */
 	    GetStr(&post->contents, contp); /* get the contents */
+            post->contentslength = 0;
 	    post->flags = flags;
 	    if(type) {
-	      GetStr(&post->contenttype, type); /* get type */
+	      GetStr(&post->contenttype, (char *)type); /* get type */
 	      prevtype=post->contenttype; /* point to the allocated string! */
 	    }
 	    /* make the previous point to this */
@@ -244,10 +309,11 @@ int FormParse(char *input,
 	     memset(subpost, 0, sizeof(struct HttpPost));
 	     GetStr(&subpost->name, name);      /* get the name */
 	     GetStr(&subpost->contents, contp); /* get the contents */
+             subpost->contentslength = 0;
 	     subpost->flags = flags;
 	     if(type) {
-	       GetStr(&subpost->contenttype, type); /* get type */
+	       GetStr(&subpost->contenttype, (char *)type); /* get type */
-	       prevtype=subpost->contenttype; /* point to the allocated string! */
+	       prevtype=subpost->contenttype; /* point to allocated string! */
 	     }
 	     /* now, point our 'more' to the original 'more' */
 	     subpost->more = post->more;
@@ -266,10 +332,12 @@ int FormParse(char *input,
 	GetStr(&post->name, name);      /* get the name */
 	if( contp[0]=='<' ) {
 	  GetStr(&post->contents, contp+1); /* get the contents */
+          post->contentslength = 0;
 	  post->flags = HTTPPOST_READFILE;
 	}
 	else {
 	  GetStr(&post->contents, contp); /* get the contents */
+          post->contentslength = 0;
 	  post->flags = 0;
 	}
 
@@ -287,8 +355,10 @@ int FormParse(char *input,
   }
   else {
     fprintf(stderr, "Illegally formatted input field!\n");
+    free(contents);
     return 1;
   }
+  free(contents);
   return 0;
 }
 
@@ -299,8 +369,430 @@ int curl_formparse(char *input,
   return FormParse(input, httppost, last_post);
 }
 
+/***************************************************************************
+ *
+ * AddHttpPost()
+ *	
+ * Adds a HttpPost structure to the list, if parent_post is given becomes
+ * a subpost of parent_post instead of a direct list element.
+ *
+ * Returns newly allocated HttpPost on success and NULL if malloc failed.
+ *
+ ***************************************************************************/
+static struct HttpPost * AddHttpPost (char * name,
+                                      long namelength,
+                                      char * value,
+                                      long contentslength,
+				      char *contenttype,
+                                      long flags,
+                                      struct HttpPost *parent_post,
+                                      struct HttpPost **httppost,
+                                      struct HttpPost **last_post)
+{
+  struct HttpPost *post;
+  post = (struct HttpPost *)malloc(sizeof(struct HttpPost));
+  if(post) {
+    memset(post, 0, sizeof(struct HttpPost));
+    post->name = name;
+    post->namelength = namelength;
+    post->contents = value;
+    post->contentslength = contentslength;
+    post->contenttype = contenttype;
+    post->flags = flags;
+  }
+  else
+    return NULL;
+  
+  if (parent_post) {
+    /* now, point our 'more' to the original 'more' */
+    post->more = parent_post->more;
+    
+    /* then move the original 'more' to point to ourselves */
+    parent_post->more = post;	         
+  }
+  else {
+    /* make the previous point to this */
+    if(*last_post)
+      (*last_post)->next = post;
+    else
+      (*httppost) = post;
+    
+    (*last_post) = post;  
+  }
+  return post;
+}
+
+/***************************************************************************
+ *
+ * AddFormInfo()
+ *	
+ * Adds a FormInfo structure to the list presented by parent_form_info.
+ *
+ * Returns newly allocated FormInfo on success and NULL if malloc failed/
+ * parent_form_info is NULL.
+ *
+ ***************************************************************************/
+static FormInfo * AddFormInfo (char *value,
+			       char *contenttype,
+			       FormInfo *parent_form_info)
+{
+  FormInfo *form_info;
+  form_info = (FormInfo *)malloc(sizeof(FormInfo));
+  if(form_info) {
+    memset(form_info, 0, sizeof(FormInfo));
+    if (value)
+      form_info->value = value;
+    if (contenttype)
+      form_info->contenttype = contenttype;
+    form_info->flags = HTTPPOST_FILENAME;
+  }
+  else
+    return NULL;
+  
+  if (parent_form_info) {
+    /* now, point our 'more' to the original 'more' */
+    form_info->more = parent_form_info->more;
+    
+    /* then move the original 'more' to point to ourselves */
+    parent_form_info->more = form_info;
+  }
+  else
+    return NULL;
+
+  return form_info;
+}
+
+/***************************************************************************
+ *
+ * ContentTypeForFilename()
+ *	
+ * Provides content type for filename if one of the known types (else
+ * (either the prevtype or the default is returned).
+ *
+ * Returns some valid contenttype for filename.
+ *
+ ***************************************************************************/
+static const char * ContentTypeForFilename (char *filename,
+					    const char *prevtype)
+{
+  const char *contenttype = NULL;
+  unsigned int i;
+  /*
+   * No type was specified, we scan through a few well-known
+   * extensions and pick the first we match!
+   */
+  struct ContentType {
+    const char *extension;
+    const char *type;
+  };
+  static struct ContentType ctts[]={
+    {".gif",  "image/gif"},
+    {".jpg",  "image/jpeg"},
+    {".jpeg", "image/jpeg"},
+    {".txt",  "text/plain"},
+    {".html", "text/plain"}
+  };
+  
+  if(prevtype)
+    /* default to the previously set/used! */
+    contenttype = prevtype;
+  else
+    /* It seems RFC1867 defines no Content-Type to default to
+       text/plain so we don't actually need to set this: */
+    contenttype = HTTPPOST_CONTENTTYPE_DEFAULT;
+  
+  for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) {
+    if(strlen(filename) >= strlen(ctts[i].extension)) {
+      if(strequal(filename +
+		  strlen(filename) - strlen(ctts[i].extension),
+		  ctts[i].extension)) {
+	contenttype = ctts[i].type;
+	break;
+      }	      
+    }
+  }
+  /* we have a contenttype by now */
+  return contenttype;
+}
+
+/***************************************************************************
+ *
+ * AllocAndCopy()
+ *	
+ * Copies the data currently available under *buffer using newly allocated
+ * buffer (that becomes *buffer). Uses buffer_length if not null, else
+ * uses strlen to determine the length of the buffer to be copied
+ *
+ * Returns 0 on success and 1 if the malloc failed.
+ *
+ ***************************************************************************/
+static int AllocAndCopy (char **buffer, int buffer_length)
+{
+  char *src = *buffer;
+  int length;
+  if (buffer_length)
+    length = buffer_length;
+  else
+    length = strlen(*buffer);
+  *buffer = (char*)malloc(length);
+  if (!*buffer)
+    return 1;
+  memcpy(*buffer, src, length);
+  return 0;
+}
+
+/***************************************************************************
+ *
+ * FormAdd()
+ *	
+ * Stores a 'name=value' formpost parameter and builds the appropriate
+ * linked list.
+ *
+ * Has two principal functionalities: using files and byte arrays as
+ * post parts. Byte arrays are either copied or just the pointer is stored
+ * (as the user requests) while for files only the filename and not the
+ * content is stored.
+ *
+ * While you may have only one byte array for each name, multiple filenames
+ * are allowed (and because of this feature CURLFORM_END is needed after
+ * using CURLFORM_FILE).
+ *
+ * Examples:
+ *
+ * Simple name/value pair with copied contents:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_COPYCONTENTS, "value");
+ *
+ * name/value pair where only the content pointer is remembered:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10);
+ * (if CURLFORM_CONTENTSLENGTH is missing strlen () is used)
+ *
+ * storing a filename (CONTENTTYPE is optional!):
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_FILE, "filename1", CURLFORM_CONTENTTYPE, "plain/text",
+ * CURLFORM_END);
+ *
+ * storing multiple filenames:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END);
+ *
+ * Returns 0 on success, 1 if the FormInfo allocation fails, 2 if one
+ * option is given twice for one Form, 3 if a null pointer was given for
+ * a char *, 4 if the allocation of a FormInfo struct failed, 5 if an
+ * unknown option was used, 6 if the some FormInfo is not complete (or
+ * has an error), 7 if a HttpPost struct cannot be allocated, and 8
+ * if some allocation for string copying failed.
+ *
+ ***************************************************************************/
+
+static
+int FormAdd(struct HttpPost **httppost,
+            struct HttpPost **last_post,
+            va_list params)
+{
+  FormInfo *first_form_info, *current_form_info, *form_info;
+  int return_value = 0;
+  const char *prevtype = NULL;
+  struct HttpPost *post = NULL;
+  CURLformoption next_option;
+
+  first_form_info = (FormInfo *)malloc(sizeof(struct FormInfo));
+  if(first_form_info) {
+    memset(first_form_info, 0, sizeof(FormInfo));
+    current_form_info = first_form_info;
+  }
+  else
+    return 1;
+
+  /** TODO: first check whether char * is not NULL
+      TODO: transfer.c
+  */
+  while ( ((next_option = va_arg(params, CURLformoption)) != CURLFORM_END) &&
+          (return_value == 0) )
+  {
+    switch (next_option)
+    {
+      case CURLFORM_PTRNAME:
+        current_form_info->flags |= HTTPPOST_PTRNAME; /* fall through */
+      case CURLFORM_COPYNAME:
+        if (current_form_info->name)
+          return_value = 2;
+        else {
+          if (next_option == CURLFORM_PTRNAME)
+            current_form_info->name = va_arg(params, char *);
+          else {
+	    char *name = va_arg(params, char *);
+	    if (name)
+	      current_form_info->name = name; /* store for the moment */
+	    else
+	      return_value = 3;
+	  }
+        }
+        break;
+      case CURLFORM_NAMELENGTH:
+        if (current_form_info->namelength)
+          return_value = 2;
+        else
+          current_form_info->namelength = va_arg(params, long);
+        break;
+      case CURLFORM_PTRCONTENTS:
+        current_form_info->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
+      case CURLFORM_COPYCONTENTS:
+        if (current_form_info->value)
+          return_value = 2;
+        else {
+          if (next_option == CURLFORM_PTRCONTENTS)
+            current_form_info->value = va_arg(params, char *);
+          else {
+	    char *value = va_arg(params, char *);
+	    if (value)
+	      current_form_info->value = value; /* store for the moment */
+	    else
+	      return_value = 3;
+	  }
+        }
+        break;
+      case CURLFORM_CONTENTSLENGTH:
+        if (current_form_info->contentslength)
+          return_value = 2;
+        else
+          current_form_info->contentslength = va_arg(params, long);
+        break;
+      case CURLFORM_FILE: {
+	char *filename = va_arg(params, char *);
+	if (current_form_info->value) {
+          if (current_form_info->flags & HTTPPOST_FILENAME) {
+	    if (filename) {
+	      if (!(current_form_info = AddFormInfo (strdup(filename),
+						     NULL, current_form_info)))
+		return_value = 4;
+	    }
+	    else
+	      return_value = 3;
+          }
+          else
+            return_value = 2;
+        }
+        else {
+	  if (filename)
+	    current_form_info->value = strdup(filename);
+	  else
+	    return_value = 3;
+          current_form_info->flags |= HTTPPOST_FILENAME;
+        }
+        break;
+      }
+      case CURLFORM_CONTENTTYPE: {
+	char *contenttype = va_arg(params, char *);
+        if (current_form_info->contenttype) {
+          if (current_form_info->flags & HTTPPOST_FILENAME) {
+            if (contenttype) {
+              if (!(current_form_info = AddFormInfo (NULL,
+                                                     strdup(contenttype),
+                                                     current_form_info)))
+                return_value = 4;
+            }
+	    else
+	      return_value = 3;
+          }
+          else
+            return_value = 2;
+        }
+        else {
+	  if (contenttype)
+	    current_form_info->contenttype = strdup(contenttype);
+	  else
+	    return_value = 3;
+	}
+        break;
+      }
+      default:
+        fprintf (stderr, "got unknown CURLFORM_OPTION: %d\n", next_option);
+        return_value = 5;
+    };
+  };
+
+  /* go through the list, check for copleteness and if everything is
+   * alright add the HttpPost item otherwise set return_value accordingly */
+  form_info = first_form_info;
+  while (form_info != NULL)
+  {
+    if ( (!first_form_info->name) ||
+         (!form_info->value) ||
+         ( (!form_info->namelength) &&
+           (form_info->flags & HTTPPOST_PTRNAME) ) ||
+	 ( (form_info->contentslength) &&
+	   (form_info->flags & HTTPPOST_FILENAME) ) ||
+	 ( (form_info->flags & HTTPPOST_FILENAME) &&
+	   (form_info->flags & HTTPPOST_PTRCONTENTS) )
+         ) {
+      return_value = 6;
+      break;
+    }
+    else {
+      if ( (form_info->flags & HTTPPOST_FILENAME) &&
+	   (!form_info->contenttype) ) {
+	/* our contenttype is missing */
+	form_info->contenttype
+	  = strdup(ContentTypeForFilename(form_info->value, prevtype));
+      }
+      if ( !(form_info->flags & HTTPPOST_PTRNAME) &&
+	   (form_info == first_form_info) ) {
+	/* copy name (without strdup; possibly contains null characters) */
+	if (AllocAndCopy(&form_info->name, form_info->namelength)) {
+	  return_value = 8;
+	  break;
+	}
+      }
+      if ( !(form_info->flags & HTTPPOST_FILENAME) &&
+	   !(form_info->flags & HTTPPOST_PTRCONTENTS) ) {
+	/* copy value (without strdup; possibly contains null characters) */
+	if (AllocAndCopy(&form_info->value, form_info->contentslength)) {
+	  return_value = 8;
+	  break;
+	}
+      }
+      if ( (post = AddHttpPost (form_info->name, form_info->namelength,
+                                form_info->value, form_info->contentslength,
+                                form_info->contenttype, form_info->flags,
+				post, httppost,
+                                last_post)) == NULL) {
+        return_value = 7;
+      }
+      if (form_info->contenttype)
+	prevtype = form_info->contenttype;
+    }
+    form_info = form_info->more;
+  };
+
+  /* and finally delete the allocated memory */
+  form_info = first_form_info;
+  while (form_info != NULL) {
+    FormInfo *delete_form_info;
+    
+    delete_form_info = form_info;
+    form_info = form_info->more;
+    free (delete_form_info);
+  };
+
+  return return_value;
+}
+
+int curl_formadd(struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...)
+{
+  va_list arg;
+  int result;
+  va_start(arg, last_post);
+  result = FormAdd(httppost, last_post, arg);
+  va_end(arg);
+  return result;
+}
+
 static int AddFormData(struct FormData **formp,
-			void *line,
+                       const void *line,
                        long length)
 {
   struct FormData *newform = (struct FormData *)
@@ -328,7 +820,7 @@ static int AddFormData(struct FormData **formp,
 
 
 static int AddFormDataf(struct FormData **formp,
-			 char *fmt, ...)
+                        const char *fmt, ...)
 {
   char s[4096];
   va_list ap;
@@ -367,8 +859,8 @@ char *Curl_FormBoundary(void)
   return retstring;
 }
 
-/* Used from http.c */ 
+/* Used from http.c, this cleans a built FormData linked list */ 
-void Curl_FormFree(struct FormData *form)
+void Curl_formclean(struct FormData *form)
 {
   struct FormData *next;
 
@@ -396,9 +888,9 @@ void curl_formfree(struct HttpPost *form)
     if(form->more)
       curl_formfree(form->more);
 
-    if(form->name)
+    if( !(form->flags & HTTPPOST_PTRNAME) && form->name)
       free(form->name); /* free the name */
-    if(form->contents)
+    if( !(form->flags & HTTPPOST_PTRCONTENTS) && form->contents)
       free(form->contents); /* free the contents */
     if(form->contenttype)
       free(form->contenttype); /* free the content type */
@@ -438,9 +930,12 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
     /* boundary */
     size += AddFormDataf(&form, "\r\n--%s\r\n", boundary);
 
-    size += AddFormDataf(&form,
+    size += AddFormData(&form,
-			 "Content-Disposition: form-data; name=\"%s\"",
+                        "Content-Disposition: form-data; name=\"", 0);
-			 post->name);
+
+    size += AddFormData(&form, post->name, post->namelength);
+
+    size += AddFormData(&form, "\"", 0);
 
     if(post->more) {
       /* If used, this is a link to more file names, we must then do
@@ -501,7 +996,9 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
 
 	fileread = strequal("-", file->contents)?stdin:
           /* binary read for win32 crap */
-          fopen(file->contents, "rb");
+/*VMS??*/ fopen(file->contents, "rb");  /* ONLY ALLOWS FOR STREAM FILES ON VMS */
+/*VMS?? Stream files are OK, as are FIXED & VAR files WITHOUT implied CC */
+/*VMS?? For implied CC, every record needs to have a \n appended & 1 added to SIZE */
 	if(fileread) {
 	  while((nread = fread(buffer, 1, 1024, fileread))) {
 	    size += AddFormData(&form,
@@ -515,7 +1012,7 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
 	}
       } else {
 	/* include the contents we got */
-	size += AddFormData(&form, post->contents, 0);
+	size += AddFormData(&form, post->contents, post->contentslength);
       }
     } while((file = file->more)); /* for each specified file for this field */
 
@@ -558,6 +1055,52 @@ int Curl_FormReader(char *buffer,
                     size_t size,
                     size_t nitems,
                     FILE *mydata)
+{
+  struct Form *form;
+  int wantedsize;
+  int gotsize = 0;
+
+  form=(struct Form *)mydata;
+
+  wantedsize = size * nitems;
+
+  if(!form->data)
+    return -1; /* nothing, error, empty */
+
+  do {
+  
+    if( (form->data->length - form->sent ) > wantedsize - gotsize) {
+
+      memcpy(buffer + gotsize , form->data->line + form->sent,
+             wantedsize - gotsize);
+
+      form->sent += wantedsize-gotsize;
+
+      return wantedsize;
+    }
+
+    memcpy(buffer+gotsize,
+           form->data->line + form->sent,
+           (form->data->length - form->sent) );
+    gotsize += form->data->length - form->sent;
+    
+    form->sent = 0;
+
+    form->data = form->data->next; /* advance */
+
+  } while(form->data);
+  /* If we got an empty line and we have more data, we proceed to the next
+     line immediately to avoid returning zero before we've reached the end.
+     This is the bug reported November 22 1999 on curl 6.3. (Daniel) */
+
+  return gotsize;
+}
+
+/* possible (old) fread() emulation that copies at most one line */
+int Curl_FormReadOneLine(char *buffer,
+                         size_t size,
+                         size_t nitems,
+                         FILE *mydata)
 {
   struct Form *form;
   int wantedsize;
@@ -599,6 +1142,134 @@ int Curl_FormReader(char *buffer,
 
 
 #ifdef _FORM_DEBUG
+int FormAddTest(const char * errormsg,
+                 struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...)
+{
+  int result;
+  va_list arg;
+  va_start(arg, last_post);
+  if ((result = FormAdd(httppost, last_post, arg)))
+    fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result,
+             errormsg);
+  va_end(arg);
+  return result;
+}
+
+
+int main()
+{
+  char name1[] = "simple_COPYCONTENTS";
+  char name2[] = "COPYCONTENTS_+_CONTENTTYPE";
+  char name3[] = "PTRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH";
+  char name4[] = "simple_PTRCONTENTS";
+  char name5[] = "PTRCONTENTS_+_CONTENTSLENGTH";
+  char name6[] = "PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE";
+  char name7[] = "FILE1_+_CONTENTTYPE";
+  char name8[] = "FILE1_+_FILE2";
+  char name9[] = "FILE1_+_FILE2_+_FILE3";
+  char value1[] = "value for simple COPYCONTENTS";
+  char value2[] = "value for COPYCONTENTS + CONTENTTYPE";
+  char value3[] = "value for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH";
+  char value4[] = "value for simple PTRCONTENTS";
+  char value5[] = "value for PTRCONTENTS + CONTENTSLENGTH";
+  char value6[] = "value for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE";
+  char value7[] = "inet_ntoa_r.h";
+  char value8[] = "Makefile.b32.resp";
+  char type2[] = "image/gif";
+  char type6[] = "text/plain";
+  char type7[] = "text/html";
+  int name3length = strlen(name3);
+  int value3length = strlen(value3);
+  int value5length = strlen(value4);
+  int value6length = strlen(value5);
+  int errors = 0;
+  int size;
+  int nread;
+  char buffer[4096];
+  struct HttpPost *httppost=NULL;
+  struct HttpPost *last_post=NULL;
+
+  struct FormData *form;
+  struct Form formread;
+
+  if (FormAddTest("simple COPYCONTENTS test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name1, CURLFORM_COPYCONTENTS, value1,
+                  CURLFORM_END))
+    ++errors;
+  if (FormAddTest("COPYCONTENTS  + CONTENTTYPE test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2,
+                  CURLFORM_CONTENTTYPE, type2, CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  name3[1] = '\0';
+  value3[1] = '\0';
+  if (FormAddTest("PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH test",
+		  &httppost, &last_post,
+                  CURLFORM_PTRNAME, name3, CURLFORM_COPYCONTENTS, value3,
+                  CURLFORM_CONTENTSLENGTH, value3length,
+		  CURLFORM_NAMELENGTH, name3length, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4,
+                  CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  value5[1] = '\0';
+  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5,
+                  CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  value6[1] = '\0';
+  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
+                  &httppost, &last_post,
+                  CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6,
+                  CURLFORM_CONTENTSLENGTH, value6length,
+                  CURLFORM_CONTENTTYPE, type6, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name7, CURLFORM_FILE, value7,
+                  CURLFORM_CONTENTTYPE, type7, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name8, CURLFORM_FILE, value7,
+                  CURLFORM_FILE, value8, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE1 + FILE2 + FILE3 test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name9, CURLFORM_FILE, value7,
+                  CURLFORM_FILE, value8, CURLFORM_FILE, value7, CURLFORM_END))
+    ++errors;
+
+  form=Curl_getFormData(httppost, &size);
+
+  Curl_FormInit(&formread, form);
+
+  do {
+    nread = Curl_FormReader(buffer, 1, sizeof(buffer),
+                            (FILE *)&formread);
+
+    if(-1 == nread)
+      break;
+    fwrite(buffer, nread, 1, stderr);
+  } while(1);
+
+  fprintf(stderr, "size: %d\n", size);
+  if (errors)
+    fprintf(stderr, "\n==> %d Test(s) failed!\n", errors);
+  else
+    fprintf(stdout, "\nAll Tests seem to have worked (please check output)\n");
+
+  return 0;
+}
+
+#endif
+
+#ifdef _OLD_FORM_DEBUG
 
 int main(int argc, char **argv)
 {

lib/formdata.h

@@ -36,6 +36,17 @@ struct Form {
 	       been sent in a previous invoke */
 };
 
+/* used by FormAdd for temporary storage */
+typedef struct FormInfo {
+  char *name;
+  long namelength;
+  char *value;
+  long contentslength;
+  char *contenttype;
+  long flags;
+  struct FormInfo *more;
+} FormInfo;
+
 int Curl_FormInit(struct Form *form, struct FormData *formdata );
 
 struct FormData *Curl_getFormData(struct HttpPost *post,
@@ -47,8 +58,15 @@ int Curl_FormReader(char *buffer,
                     size_t nitems,
                     FILE *mydata);
 
+/* possible (old) fread() emulation that copies at most one line */
+int Curl_FormReadOneLine(char *buffer,
+                         size_t size,
+                         size_t nitems,
+                         FILE *mydata);
+
 char *Curl_FormBoundary(void);
 
-void Curl_FormFree(struct FormData *);
+void Curl_formclean(struct FormData *);
 
 #endif
+

lib/ftp.c

@@ -54,6 +54,9 @@
 #ifdef HAVE_NETDB_H
 #include <netdb.h>
 #endif
+#ifdef	VMS
+#include <inet.h>
+#endif
 #endif
 
 #if defined(WIN32) && defined(__GNUC__) || defined(__MINGW32__)
@@ -88,6 +91,10 @@
 #include "memdebug.h"
 #endif
 
+/* Local API functions */
+static CURLcode _ftp_sendquote(struct connectdata *conn, struct curl_slist *quote);
+static CURLcode _ftp_cwd(struct connectdata *conn, char *path);
+
 /* easy-to-use macro: */
 #define ftpsendf Curl_ftpsendf
 
@@ -106,7 +113,7 @@ static CURLcode AllowServerConnect(struct UrlData *data,
   dt.tv_sec = 10;
   dt.tv_usec = 0;
 
-  switch ( select(sock+1, &rdset, NULL, NULL, &dt)) {
+  switch (select(sock+1, &rdset, NULL, NULL, &dt)) {
   case -1: /* error */
     /* let's die here */
     failf(data, "Error while waiting for server connect");
@@ -144,9 +151,11 @@ static CURLcode AllowServerConnect(struct UrlData *data,
 
 /* --- parse FTP server responses --- */
 
-#define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
+/*
-			isdigit((int)line[2]) && (' ' == line[3]))
+ * Curl_GetFTPResponse() is supposed to be invoked after each command sent to
-
+ * a remote FTP server. This function will wait and read all lines of the
+ * response and extract the relevant return code for the invoking function.
+ */
 
 int Curl_GetFTPResponse(int sockfd,
                         char *buf,
@@ -158,8 +167,7 @@ int Curl_GetFTPResponse(int sockfd,
    * as it seems that the OpenSSL read() stuff doesn't grok that properly.
    *
    * Alas, read as much as possible, split up into lines, use the ending
-   * line in a response or continue reading.
+   * line in a response or continue reading.  */
-   */
 
   int nread;   /* total size read */
   int perline; /* count bytes per line */
@@ -172,7 +180,7 @@ int Curl_GetFTPResponse(int sockfd,
   fd_set readfd;
   struct UrlData *data = conn->data;
   char *line_start;
-  int code;
+  int code=0; /* default "error code" to return */
 
 #define SELECT_OK      0
 #define SELECT_ERROR   1
@@ -249,19 +257,22 @@ int Curl_GetFTPResponse(int sockfd,
             /* output debug output if that is requested */
             if(data->bits.verbose) {
               fputs("< ", data->err);
-              fwrite(line_start, 1, perline, data->err);
+              fwrite(line_start, perline, 1, data->err);
               /* no need to output LF here, it is part of the data */
             }
 
+#define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
+			isdigit((int)line[2]) && (' ' == line[3]))
+
             if(perline>3 && lastline(line_start)) {
               /* This is the end of the last line, copy the last
                * line to the start of the buffer and zero terminate,
                * for old times sake (and krb4)! */
-              char *moo;
+              char *meow;
               int i;
-              for(moo=line_start, i=0; moo<ptr; moo++, i++)
+              for(meow=line_start, i=0; meow<ptr; meow++, i++)
-                buf[i] = *moo;
+                buf[i] = *meow;
-              moo[i]=0; /* zero terminate */
+              meow[i]=0; /* zero terminate */
               keepon=FALSE;
               break;
             }
@@ -282,13 +293,13 @@ int Curl_GetFTPResponse(int sockfd,
   /* FIXME: some errorchecking perhaps... ***/
   switch(code) {
   case 631:
-    sec_read_msg(conn, buf, prot_safe);
+    Curl_sec_read_msg(conn, buf, prot_safe);
     break;
   case 632:
-    sec_read_msg(conn, buf, prot_private);
+    Curl_sec_read_msg(conn, buf, prot_private);
     break;
   case 633:
-    sec_read_msg(conn, buf, prot_confidential);
+    Curl_sec_read_msg(conn, buf, prot_confidential);
     break;
   default:
     /* normal ftp stuff we pass through! */
@@ -305,125 +316,8 @@ int Curl_GetFTPResponse(int sockfd,
   return nread; /* total amount of bytes read */
 }
 
-#if 0
-/*
- * We allow the ftpcode pointer to be NULL if no reply integer is wanted
- */
-
-int Curl_GetFTPResponse(int sockfd, char *buf,
-                        struct connectdata *conn,
-                        int *ftpcode)
-{
-  int nread;
-  ssize_t keepon=TRUE;
-  size_t got;
-  char *ptr;
-  int timeout = 3600; /* in seconds */
-  struct timeval interval;
-  fd_set rkeepfd;
-  fd_set readfd;
-  struct UrlData *data = conn->data;
-
-#define SELECT_OK      0
-#define SELECT_ERROR   1
-#define SELECT_TIMEOUT 2
-  int error = SELECT_OK;
-
-  if(ftpcode)
-    *ftpcode=0; /* 0 for errors */
-
-  if(data->timeout) {
-    /* if timeout is requested, find out how much remaining time we have */
-    timeout = data->timeout - /* timeout time */
-      (Curl_tvlong(Curl_tvnow()) - Curl_tvlong(conn->now)); /* spent time */
-    if(timeout <=0 ) {
-      failf(data, "Transfer aborted due to timeout");
-      return -SELECT_TIMEOUT; /* already too little time */
-    }
-  }
-
-  FD_ZERO (&readfd);		/* clear it */
-  FD_SET (sockfd, &readfd);     /* read socket */
-
-  /* get this in a backup variable to be able to restore it on each lap in the
-     select() loop */
-  rkeepfd = readfd;
-
-  do {
-    ptr=buf;
-
-    /* get us a full line, terminated with a newline */
-    nread=0;
-    keepon=TRUE;
-    while((nread<BUFSIZE) && (keepon && !error)) {
-      readfd = rkeepfd;		   /* set every lap */
-      interval.tv_sec = timeout;
-      interval.tv_usec = 0;
-
-      switch (select (sockfd+1, &readfd, NULL, NULL, &interval)) {
-      case -1: /* select() error, stop reading */
-        error = SELECT_ERROR;
-        failf(data, "Transfer aborted due to select() error");
-        break;
-      case 0: /* timeout */
-        error = SELECT_TIMEOUT;
-        failf(data, "Transfer aborted due to timeout");
-        break;
-      default:
-        /*
-         * This code previously didn't use the kerberos sec_read() code
-         * to read, but when we use Curl_read() it may do so. Do confirm
-         * that this is still ok and then remove this comment!
-         */
-        if(CURLE_OK != Curl_read(conn, sockfd, ptr, 1, &keepon))
-          keepon = FALSE;
-        else if(keepon <= 0) {
-          error = SELECT_ERROR;
-          failf(data, "Connection aborted");
-        }
-        else if ((*ptr == '\n') || (*ptr == '\r'))
-          keepon = FALSE;
-      }
-      if(keepon) {
-        nread++;
-        ptr++;
-      }
-    }
-    *ptr=0; /* zero terminate */
-
-#if KRB4
-    { /* handle the security-oriented responses 6xx ***/
-      /* FIXME: some errorchecking perhaps... ***/
-      if(strncmp(buf, "631", 3) == 0)
-        sec_read_msg(conn, buf, prot_safe);
-      else if(strncmp(buf, "632", 3) == 0)
-        sec_read_msg(conn, buf, prot_private);
-      else if(strncmp(buf, "633", 3) == 0)
-        sec_read_msg(conn, buf, prot_confidential);
-      nread = strlen(buf);
-    }
-#endif
-
-    if(data->bits.verbose && buf[0]) {
-      fputs("< ", data->err);
-      fwrite(buf, 1, nread, data->err);
-      fputs("\n", data->err);
-    }
-  } while(!error &&
-	  (nread<4 || !lastline(buf)) );
-  
-  if(error)
-    return -error;
-
-  if(ftpcode)
-    *ftpcode=atoi(buf); /* return the initial number like this */
-
-  return nread;
-}
-#endif
-
 /* -- who are we? -- */
-char *Curl_getmyhost(char *buf, int buf_size)
+static char *getmyhost(char *buf, int buf_size)
 {
 #if defined(HAVE_GETHOSTNAME)
   gethostname(buf, buf_size);
@@ -502,13 +396,13 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
   if(data->bits.krb4) {
 
     /* request data protection level (default is 'clear') */
-    sec_request_prot(conn, "private");
+    Curl_sec_request_prot(conn, "private");
 
     /* We set private first as default, in case the line below fails to
        set a valid level */
-    sec_request_prot(conn, data->krb4_level);
+    Curl_sec_request_prot(conn, data->krb4_level);
 
-    if(sec_login(conn) != 0)
+    if(Curl_sec_login(conn) != 0)
       infof(data, "Logging in with password in cleartext!\n");
     else
       infof(data, "Authentication successful\n");
@@ -563,13 +457,13 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
 	 * now set the requested protection level
 	 */
     if(conn->sec_complete)
-      sec_set_protection_level(conn);
+      Curl_sec_set_protection_level(conn);
 
     /* we may need to issue a KAUTH here to have access to the files
      * do it if user supplied a password
      */
     if(conn->data->passwd && *conn->data->passwd)
-      krb_kauth(conn);
+      Curl_krb_kauth(conn);
 #endif
   }
   else {
@@ -638,9 +532,8 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
 {
   struct UrlData *data = conn->data;
   struct FTP *ftp = conn->proto.ftp;
-  size_t nread;
+  ssize_t nread;
   char *buf = data->buffer; /* this is our buffer */
-  struct curl_slist *qitem; /* QUOTE item */
   int ftpcode;
 
   if(data->bits.upload) {
@@ -665,7 +558,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
   }
 
 #ifdef KRB4
-  sec_fflush_fd(conn, conn->secondarysocket);
+  Curl_sec_fflush_fd(conn, conn->secondarysocket);
 #endif
   /* shut down the socket to inform the server we're done */
   sclose(conn->secondarysocket);
@@ -680,7 +573,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
 
     /* 226 Transfer complete, 250 Requested file action okay, completed. */
     if((ftpcode != 226) && (ftpcode != 250)) {
-      failf(data, "%s", buf+4);
+      failf(data, "server did not report OK, got %d", ftpcode);
       return CURLE_FTP_WRITE_ERROR;
     }
   }
@@ -689,116 +582,74 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
 
   /* Send any post-transfer QUOTE strings? */
   if(data->postquote) {
-    qitem = data->postquote;
+    CURLcode result = _ftp_sendquote(conn, data->postquote);
-    /* Send all QUOTE strings in same order as on command-line */
+    return result;
-    while (qitem) {
-      /* Send string */
-      if (qitem->data) {
-        ftpsendf(conn->firstsocket, conn, "%s", qitem->data);
-
-        nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-        if(nread < 0)
-          return CURLE_OPERATION_TIMEOUTED;
-
-        if (ftpcode >= 400) {
-          failf(data, "QUOT string not accepted: %s",
-                qitem->data);
-          return CURLE_FTP_QUOTE_ERROR;
-        }
-      }
-      qitem = qitem->next;
-    }
   }
 
   return CURLE_OK;
 }
 
 
-
 static 
-CURLcode _ftp(struct connectdata *conn)
+CURLcode _ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
 {
-  /* this is FTP and no proxy */
+  struct curl_slist *item;
-  size_t nread;
+  ssize_t            nread;
-  CURLcode result;
+  int                ftpcode;
-  struct UrlData *data=conn->data;
-  char *buf = data->buffer; /* this is our buffer */
-  /* for the ftp PORT mode */
-  int portsock=-1;
-#if defined (HAVE_INET_NTOA_R)
-  char ntoa_buf[64];
-#endif
-#ifdef ENABLE_IPV6
-  struct addrinfo *ai;
-#else
-  struct sockaddr_in serv_addr;
-  char hostent_buf[8192];
-#endif
 
-  struct curl_slist *qitem; /* QUOTE item */
+  item = quote;
-  /* the ftp struct is already inited in ftp_connect() */
+  while (item) {
-  struct FTP *ftp = conn->proto.ftp;
+    if (item->data) {
+      ftpsendf(conn->firstsocket, conn, "%s", item->data);
 
-  long *bytecountp = ftp->bytecountp;
+      nread = Curl_GetFTPResponse(conn->firstsocket, 
-  int ftpcode; /* for ftp status */
+                                  conn->data->buffer, conn, &ftpcode);
-
+      if (nread < 0)
-  /* Send any QUOTE strings? */
-  if(data->quote) {
-    qitem = data->quote;
-    /* Send all QUOTE strings in same order as on command-line */
-    while (qitem) {
-      /* Send string */
-      if (qitem->data) {
-        ftpsendf(conn->firstsocket, conn, "%s", qitem->data);
-
-        nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-        if(nread < 0)
         return CURLE_OPERATION_TIMEOUTED;
 
       if (ftpcode >= 400) {
-          failf(data, "QUOT string not accepted: %s",
+        failf(conn->data, "QUOT string not accepted: %s", item->data);
-                qitem->data);
         return CURLE_FTP_QUOTE_ERROR;
       }
     }
-      qitem = qitem->next;
+
-    }
+    item = item->next;
   }
 
-  if(conn->bits.reuse) {
+  return CURLE_OK;
-    /* This is a re-used connection. Since we change directory to where the
+}
-       transfer is taking place, we must now get back to the original dir
+
-       where we ended up after login: */
+static 
-    ftpsendf(conn->firstsocket, conn, "CWD %s", ftp->entrypath);
+CURLcode _ftp_cwd(struct connectdata *conn, char *path)
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+{
-    if(nread < 0)
+  ssize_t nread;
+  int     ftpcode;
+  
+  ftpsendf(conn->firstsocket, conn, "CWD %s", path);
+  nread = Curl_GetFTPResponse(conn->firstsocket, 
+                              conn->data->buffer, conn, &ftpcode);
+  if (nread < 0)
     return CURLE_OPERATION_TIMEOUTED;
 
-    if(ftpcode != 250) {
+  if (ftpcode != 250) {
-      failf(data, "Couldn't change back to directory %s", ftp->entrypath);
+    failf(conn->data, "Couldn't change back to directory %s", path);
     return CURLE_FTP_ACCESS_DENIED;
   }
-  }
 
+  return CURLE_OK;
+}
 
+static
+CURLcode _ftp_getfiletime(struct connectdata *conn, char *file)
+{
+  CURLcode result=CURLE_OK;
+  int ftpcode; /* for ftp status */
+  ssize_t nread;
+  char *buf = conn->data->buffer;
 
-  /* change directory first! */
-  if(ftp->dir && ftp->dir[0]) {
-    ftpsendf(conn->firstsocket, conn, "CWD %s", ftp->dir);
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
-
-    if(ftpcode != 250) {
-      failf(data, "Couldn't change to directory %s", ftp->dir);
-      return CURLE_FTP_ACCESS_DENIED;
-    }
-  }
-
-  if(data->bits.get_filetime && ftp->file) {
   /* we have requested to get the modified-time of the file, this is yet
      again a grey area as the MDTM is not kosher RFC959 */
-    ftpsendf(conn->firstsocket, conn, "MDTM %s", ftp->file);
+  ftpsendf(conn->firstsocket, conn, "MDTM %s", file);
 
   nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
   if(nread < 0)
@@ -815,13 +666,114 @@ CURLcode _ftp(struct connectdata *conn)
       sprintf(buf, "%04d%02d%02d %02d:%02d:%02d",
               year, month, day, hour, minute, second);
       /* now, convert this into a time() value: */
-        data->progress.filetime = curl_getdate(buf, &secs);
+      conn->data->progress.filetime = curl_getdate(buf, &secs);
     }
     else {
-        infof(data, "unsupported MDTM reply format\n");
+      infof(conn->data, "unsupported MDTM reply format\n");
     }
   }
+  return  result;
+}
+
+static CURLcode _ftp_transfertype(struct connectdata *conn,
+                                  bool ascii)
+{
+  struct UrlData *data = conn->data;
+  int ftpcode;
+  ssize_t nread;
+  char *buf=data->buffer;
+
+  ftpsendf(conn->firstsocket, conn, "TYPE %s", ascii?"A":"I");
+
+  nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+  if(nread < 0)
+    return CURLE_OPERATION_TIMEOUTED;
+  
+  if(ftpcode != 200) {
+    failf(data, "Couldn't set %s mode",
+          ascii?"ASCII":"binary");
+    return ascii? CURLE_FTP_COULDNT_SET_ASCII:CURLE_FTP_COULDNT_SET_BINARY;
+  }
 
+  return CURLE_OK;
+}
+
+static
+CURLcode _ftp_getsize(struct connectdata *conn, char *file,
+                      ssize_t *size)
+{
+  struct UrlData *data = conn->data;
+  int ftpcode;
+  ssize_t nread;
+  char *buf=data->buffer;
+
+  ftpsendf(conn->firstsocket, conn, "SIZE %s", file);
+  nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+  if(nread < 0)
+    return CURLE_OPERATION_TIMEOUTED;
+
+  if(ftpcode == 213) {
+    /* get the size from the ascii string: */
+    *size = atoi(buf+4);
+  }
+  else
+    return CURLE_FTP_COULDNT_GET_SIZE;
+
+  return CURLE_OK;
+}
+
+
+static
+CURLcode _ftp(struct connectdata *conn)
+{
+  /* this is FTP and no proxy */
+  ssize_t nread;
+  CURLcode result;
+  struct UrlData *data=conn->data;
+  char *buf = data->buffer; /* this is our buffer */
+  /* for the ftp PORT mode */
+  int portsock=-1;
+#if defined (HAVE_INET_NTOA_R)
+  char ntoa_buf[64];
+#endif
+#ifdef ENABLE_IPV6
+  struct addrinfo *ai;
+#else
+  struct sockaddr_in serv_addr;
+  char hostent_buf[8192];
+#endif
+
+  /* the ftp struct is already inited in ftp_connect() */
+  struct FTP *ftp = conn->proto.ftp;
+
+  long *bytecountp = ftp->bytecountp;
+  int ftpcode; /* for ftp status */
+
+  /* Send any QUOTE strings? */
+  if(data->quote) {
+    if ((result = _ftp_sendquote(conn, data->quote)) != CURLE_OK)
+      return result;
+  }
+    
+  /* This is a re-used connection. Since we change directory to where the
+     transfer is taking place, we must now get back to the original dir
+     where we ended up after login: */
+  if (conn->bits.reuse) {
+    if ((result = _ftp_cwd(conn, ftp->entrypath)) != CURLE_OK)
+      return result;
+  }
+
+  /* change directory first! */
+  if(ftp->dir && ftp->dir[0]) {
+    if ((result = _ftp_cwd(conn, ftp->dir)) != CURLE_OK)
+        return result;
+  }
+
+  /* Requested time of file? */
+  if(data->bits.get_filetime && ftp->file) {
+    result = _ftp_getfiletime(conn, ftp->file);
+    if(result)
+      return result;
   }
 
   /* If we have selected NOBODY, it means that we only want file information.
@@ -830,39 +782,26 @@ CURLcode _ftp(struct connectdata *conn)
     /* The SIZE command is _not_ RFC 959 specified, and therefor many servers
        may not support it! It is however the only way we have to get a file's
        size! */
-    int filesize;
+    ssize_t filesize;
 
     /* Some servers return different sizes for different modes, and thus we
        must set the proper type before we check the size */
-    ftpsendf(conn->firstsocket, conn, "TYPE %s",
+    result = _ftp_transfertype(conn, data->bits.ftp_ascii);
-             (data->bits.ftp_ascii)?"A":"I");
+    if(result)
+      return result;
 
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+    /* failing to get size is not a serious error */
-    if(nread < 0)
+    result = _ftp_getsize(conn, ftp->file, &filesize);
-      return CURLE_OPERATION_TIMEOUTED;
-
-    if(ftpcode != 200) {
-      failf(data, "Couldn't set %s mode",
-            (data->bits.ftp_ascii)?"ASCII":"binary");
-      return (data->bits.ftp_ascii)? CURLE_FTP_COULDNT_SET_ASCII:
-        CURLE_FTP_COULDNT_SET_BINARY;
-    }
-
-    ftpsendf(conn->firstsocket, conn, "SIZE %s", ftp->file);
-
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
-
-    if(ftpcode == 213) {
-
-      /* get the size from the ascii string: */
-      filesize = atoi(buf+4);
 
+    if(CURLE_OK == result) {
       sprintf(buf, "Content-Length: %d\r\n", filesize);
       result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
       if(result)
         return result;
+    }
+
+    /* If we asked for a time of the file and we actually got one as
+       well, we "emulate" a HTTP-style header in our output. */
 
 #ifdef HAVE_STRFTIME
     if(data->bits.get_filetime && data->progress.filetime) {
@@ -881,7 +820,6 @@ CURLcode _ftp(struct connectdata *conn)
         return result;
     }
 #endif
-    }
 
     return CURLE_OK;
   }
@@ -905,7 +843,7 @@ CURLcode _ftp(struct connectdata *conn)
     int alen, plen;
     char portmsgbuf[4096], tmp[4096];
 
-    char *mode[] = { "EPRT", "LPRT", "PORT", NULL };
+    const char *mode[] = { "EPRT", "LPRT", "PORT", NULL };
     char **modep;
 
     /*
@@ -963,7 +901,7 @@ CURLcode _ftp(struct connectdata *conn)
       return CURLE_FTP_PORT_FAILED;
     }
 
-    for (modep = mode; modep && *modep; modep++) {
+    for (modep = (char *)mode; modep && *modep; modep++) {
       int lprtaf, eprtaf;
 
       switch (sa->sa_family) {
@@ -1043,7 +981,7 @@ CURLcode _ftp(struct connectdata *conn)
       }
 
       nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-      if (nread < 0)
+      if(nread < 0)
 	return CURLE_OPERATION_TIMEOUTED;
 
       if (ftpcode != 200) {
@@ -1051,7 +989,6 @@ CURLcode _ftp(struct connectdata *conn)
 	continue;
       } else
         break;
-again:;
     }
 
     if (!*modep) {
@@ -1081,7 +1018,7 @@ again:;
     }
     if(! *myhost) {
       h=Curl_gethost(data,
-                     Curl_getmyhost(myhost, sizeof(myhost)),
+                     getmyhost(myhost, sizeof(myhost)),
                      &hostdataptr);
     }
     infof(data, "We connect from %s\n", myhost);
@@ -1176,7 +1113,7 @@ again:;
     char *mode[] = { "EPSV", "LPSV", "PASV", NULL };
     int results[] = { 229, 228, 227, 0 };
 #else
-    char *mode[] = { "PASV", NULL };
+    const char *mode[] = { "PASV", NULL };
     int results[] = { 227, 0 };
 #endif
     int modeoff;
@@ -1426,19 +1363,9 @@ again:;
   if(data->bits.upload) {
 
     /* Set type to binary (unless specified ASCII) */
-    ftpsendf(conn->firstsocket, conn, "TYPE %s",
+    result = _ftp_transfertype(conn, data->bits.ftp_ascii);
-          (data->bits.ftp_ascii)?"A":"I");
+    if(result)
-
+      return result;
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
-
-    if(ftpcode != 200) {
-      failf(data, "Couldn't set %s mode",
-            (data->bits.ftp_ascii)?"ASCII":"binary");
-      return (data->bits.ftp_ascii)? CURLE_FTP_COULDNT_SET_ASCII:
-        CURLE_FTP_COULDNT_SET_BINARY;
-    }
 
     if(conn->resume_from) {
       /* we're about to continue the uploading of a file */
@@ -1458,19 +1385,10 @@ again:;
         /* we could've got a specified offset from the command line,
            but now we know we didn't */
 
-        ftpsendf(conn->firstsocket, conn, "SIZE %s", ftp->file);
+        if(CURLE_OK != _ftp_getsize(conn, ftp->file, &conn->resume_from)) {
-
+          failf(data, "Couldn't get remote file size");
-        nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-        if(nread < 0)
-          return CURLE_OPERATION_TIMEOUTED;
-
-        if(ftpcode != 213) {
-          failf(data, "Couldn't get file size: %s", buf+4);
           return CURLE_FTP_COULDNT_GET_SIZE;
         }
-
-        /* get the size from the ascii string: */
-        conn->resume_from = atoi(buf+4);
       }
 
       if(conn->resume_from) {
@@ -1494,8 +1412,7 @@ again:;
 
           passed += actuallyread;
           if(actuallyread != readthisamountnow) {
-            failf(data, "Could only read %d bytes from the input\n",
+            failf(data, "Could only read %d bytes from the input\n", passed);
-                  passed);
             return CURLE_FTP_COULDNT_USE_REST;
           }
         }
@@ -1541,6 +1458,7 @@ again:;
     }
 
     if(data->bits.ftp_use_port) {
+      /* PORT means we are now awaiting the server to connect to us. */
       result = AllowServerConnect(data, conn, portsock);
       if( result )
         return result;
@@ -1609,16 +1527,9 @@ again:;
       dirlist = TRUE;
 
       /* Set type to ASCII */
-      ftpsendf(conn->firstsocket, conn, "TYPE A");
+      result = _ftp_transfertype(conn, TRUE /* ASCII enforced */);
-	
+      if(result)
-      nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+        return result;
-      if(nread < 0)
-        return CURLE_OPERATION_TIMEOUTED;
-	
-      if(ftpcode != 200) {
-        failf(data, "Couldn't set ascii mode");
-        return CURLE_FTP_COULDNT_SET_ASCII;
-      }
 
       /* if this output is to be machine-parsed, the NLST command will be
          better used since the LIST command output is not specified or
@@ -1630,19 +1541,9 @@ again:;
     }
     else {
       /* Set type to binary (unless specified ASCII) */
-      ftpsendf(conn->firstsocket, conn, "TYPE %s",
+      result = _ftp_transfertype(conn, data->bits.ftp_ascii);
-               (data->bits.ftp_ascii)?"A":"I");
+      if(result)
-
+        return result;
-      nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-      if(nread < 0)
-        return CURLE_OPERATION_TIMEOUTED;
-
-      if(ftpcode != 200) {
-        failf(data, "Couldn't set %s mode",
-              (data->bits.ftp_ascii)?"ASCII":"binary");
-        return (data->bits.ftp_ascii)? CURLE_FTP_COULDNT_SET_ASCII:
-          CURLE_FTP_COULDNT_SET_BINARY;
-      }
 
       if(conn->resume_from) {
 
@@ -1651,22 +1552,18 @@ again:;
          * We start with trying to use the SIZE command to figure out the size
          * of the file we're gonna get. If we can get the size, this is by far
          * the best way to know if we're trying to resume beyond the EOF.  */
+        int foundsize=-1;
         
-        ftpsendf(conn->firstsocket, conn, "SIZE %s", ftp->file);
+        result = _ftp_getsize(conn, ftp->file, &foundsize);
 
-        nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
+        if(CURLE_OK != result) {
-        if(nread < 0)
+          infof(data, "ftp server doesn't support SIZE");
-          return CURLE_OPERATION_TIMEOUTED;
-
-        if(ftpcode != 213) {
-          infof(data, "server doesn't support SIZE: %s", buf+4);
           /* We couldn't get the size and therefore we can't know if there
              really is a part of the file left to get, although the server
              will just close the connection when we start the connection so it
              won't cause us any harm, just not make us exit as nicely. */
         }
         else {
-          int foundsize=atoi(buf+4);
           /* We got a file size report, so we check that there actually is a
              part of the file left to get, or else we go home.  */
           if(conn->resume_from< 0) {
@@ -1885,7 +1782,8 @@ CURLcode Curl_ftp(struct connectdata *conn)
  * restrictions on the command!
  *
  */
-size_t Curl_ftpsendf(int fd, struct connectdata *conn, char *fmt, ...)
+size_t Curl_ftpsendf(int fd, struct connectdata *conn,
+                     const char *fmt, ...)
 {
   size_t bytes_written;
   char s[256];

lib/ftp.h

@@ -28,7 +28,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn);
 CURLcode Curl_ftp_connect(struct connectdata *conn);
 CURLcode Curl_ftp_disconnect(struct connectdata *conn);
 
-size_t Curl_ftpsendf(int fd, struct connectdata *, char *fmt, ...);
+size_t Curl_ftpsendf(int fd, struct connectdata *, const char *fmt, ...);
 
 /* The kerberos stuff needs this: */
 int Curl_GetFTPResponse(int sockfd, char *buf,

lib/getdate.c

@@ -1524,9 +1524,11 @@ yyerrhandle:
    the same signature as the function definition does. */
 #include "getdate.h"
 
+#ifndef WIN32 /* the windows dudes don't need these, does anyone really? */
 extern struct tm	*gmtime ();
 extern struct tm	*localtime ();
 extern time_t		mktime ();
+#endif
 
 /* Month and day table. */
 static TABLE const MonthDayTable[] = {

lib/getdate.y

@@ -477,9 +477,11 @@ o_merid	: /* NULL */
    the same signature as the function definition does. */
 #include "getdate.h"
 
+#ifndef WIN32 /* the windows dudes don't need these, does anyone really? */
 extern struct tm	*gmtime ();
 extern struct tm	*localtime ();
 extern time_t		mktime ();
+#endif
 
 /* Month and day table. */
 static TABLE const MonthDayTable[] = {

lib/getenv.c

@@ -29,12 +29,16 @@
 #include <windows.h>
 #endif
 
+#ifdef VMS
+#include <unixlib.h>
+#endif
+
 #ifdef MALLOCDEBUG
 #include "memdebug.h"
 #endif
 
 static
-char *GetEnv(char *variable)
+char *GetEnv(const char *variable)
 {
 #ifdef WIN32
   /* This shit requires windows.h (HUGE) to be included */
@@ -43,14 +47,22 @@ char *GetEnv(char *variable)
   env[0] = '\0';
   if (temp != NULL)
     ExpandEnvironmentStrings(temp, env, sizeof(env));
+#else
+#ifdef	VMS
+  char *env = getenv(variable);
+  if (env && strcmp("HOME",variable) == 0) {
+	env = decc$translate_vms(env);
+  }
+/*  printf ("Getenv: %s=%s\n",variable,env); */
 #else
   /* no length control */
   char *env = getenv(variable);
+#endif
 #endif
   return (env && env[0])?strdup(env):NULL;
 }
 
-char *curl_getenv(char *v)
+char *curl_getenv(const char *v)
 {
   return GetEnv(v);
 }

lib/getinfo.c

@@ -31,13 +31,31 @@
 #include <string.h>
 #include <stdarg.h>
 
-CURLcode Curl_getinfo(CURL *curl, CURLINFO info, ...)
+/*
+ * This is supposed to be called in the beginning of a permform() session
+ * and should reset all session-info variables
+ */
+CURLcode Curl_initinfo(struct UrlData *data)
+{
+  struct Progress *pro = &data->progress;
+
+  pro->t_nslookup = 0;
+  pro->t_connect = 0;
+  pro->t_pretransfer = 0;
+
+  pro->httpcode = 0;
+  pro->httpversion=0;
+  pro->filetime=0;
+
+  return CURLE_OK;
+}
+
+CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
 {
   va_list arg;
   long *param_longp;
   double *param_doublep;
   char **param_charp;
-  struct UrlData *data = (struct UrlData *)curl;
   va_start(arg, info);
 
   switch(info&CURLINFO_TYPEMASK) {
@@ -62,7 +80,7 @@ CURLcode Curl_getinfo(CURL *curl, CURLINFO info, ...)
   
   switch(info) {
   case CURLINFO_EFFECTIVE_URL:
-    *param_charp = data->url?data->url:"";
+    *param_charp = data->url?data->url:(char *)"";
     break;
   case CURLINFO_HTTP_CODE:
     *param_longp = data->progress.httpcode;

lib/getinfo.h

@@ -0,0 +1,28 @@
+#ifndef __GETINFO_H
+#define __GETINFO_H
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * 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 MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...);
+CURLcode Curl_initinfo(struct UrlData *data);
+
+#endif

lib/getpass.c

@@ -42,6 +42,30 @@
 #ifndef HAVE_GETPASS_R
 
 #ifndef WIN32
+#ifdef	VMS
+#include <stdio.h>
+#include <string.h>
+#include descrip
+#include starlet
+#include iodef
+#include iosbdef
+char *getpass_r(const char *prompt, char *buffer, size_t buflen)
+{
+	long sts;
+	short chan;
+	struct _iosb iosb;
+	$DESCRIPTOR(ttdesc, "TT");
+
+	buffer[0]='\0';
+	if ((sts = sys$assign(&ttdesc, &chan,0,0)) & 1) {
+		if (((sts = sys$qiow(0, chan, IO$_READPROMPT | IO$M_NOECHO, &iosb, 0, 0, buffer, buflen, 0, 0, prompt, strlen(prompt))) & 1) && (iosb.iosb$w_status&1)) {
+			buffer[iosb.iosb$w_bcnt] = '\0';
+		} 
+		sts = sys$dassgn(chan);
+	}
+	return buffer; /* we always return success */
+}
+#else /* VMS */
 #ifdef HAVE_TERMIOS_H
 #  if !defined(HAVE_TCGETATTR) && !defined(HAVE_TCSETATTR) 
 #    undef HAVE_TERMIOS_H
@@ -186,6 +210,7 @@ char *getpass_r(const char *prompt, char *buffer, size_t buflen)
 
   return buffer; /* we always return success */
 }
+#endif /* VMS */
 #else /* WIN32 */
 #include <stdio.h>
 #include <conio.h>

lib/getpass.h

@@ -29,7 +29,7 @@
 /*
  * Returning NULL will abort the continued operation!
  */
-char* getpass_r(char *prompt, char* buffer, size_t buflen );
+char* getpass_r(const char *prompt, char* buffer, size_t buflen );
 #endif
 
 #endif

lib/hostip.c

@@ -28,6 +28,7 @@
 
 #define _REENTRANT
 
+
 #if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
 #include <winsock.h>
 #else
@@ -46,6 +47,10 @@
 #ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
 #endif
+#ifdef	VMS
+#include <inet.h>
+#include <stdlib.h>
+#endif
 #endif
 
 #include "urldata.h"

lib/http.c

@@ -104,7 +104,7 @@
  * be sent in one go.
  */
 static CURLcode
- add_buffer(send_buffer *in, void *inptr, size_t size);
+ add_buffer(send_buffer *in, const void *inptr, size_t size);
 
 /*
  * add_buffer_init() returns a fine buffer struct
@@ -148,7 +148,7 @@ size_t add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in)
  * add_bufferf() builds a buffer from the formatted input
  */
 static
-CURLcode add_bufferf(send_buffer *in, char *fmt, ...)
+CURLcode add_bufferf(send_buffer *in, const char *fmt, ...)
 {
   CURLcode result = CURLE_OUT_OF_MEMORY;
   char *s;
@@ -168,12 +168,11 @@ CURLcode add_bufferf(send_buffer *in, char *fmt, ...)
  * add_buffer() appends a memory chunk to the existing one
  */
 static
-CURLcode add_buffer(send_buffer *in, void *inptr, size_t size)
+CURLcode add_buffer(send_buffer *in, const void *inptr, size_t size)
 {
   char *new_rb;
   int new_size;
 
-  if(size > 0) {
   if(!in->buffer ||
      ((in->size_used + size) > (in->size_max - 1))) {
     new_size = (in->size_used+size)*2;
@@ -193,7 +192,6 @@ CURLcode add_buffer(send_buffer *in, void *inptr, size_t size)
   memcpy(&in->buffer[in->size_used], inptr, size);
       
   in->size_used += size;
-  }
 
   return CURLE_OK;
 }
@@ -240,7 +238,7 @@ int GetLine(int sockfd, char *buf, struct connectdata *conn)
  * This function checks the linked list of custom HTTP headers for a particular
  * header (prefix).
  */
-bool static checkheaders(struct UrlData *data, char *thisheader)
+static bool checkheaders(struct UrlData *data, const char *thisheader)
 {
   struct curl_slist *head;
   size_t thislen = strlen(thisheader);
@@ -361,15 +359,15 @@ CURLcode Curl_http_done(struct connectdata *conn)
   data=conn->data;
   http=conn->proto.http;
 
-  if(data->bits.http_formpost) {
+  if(HTTPREQ_POST_FORM == data->httpreq) {
     *bytecount = http->readbytecount + http->writebytecount;
       
-    Curl_FormFree(http->sendit); /* Now free that whole lot */
+    Curl_formclean(http->sendit); /* Now free that whole lot */
 
     data->fread = http->storefread; /* restore */
     data->in = http->in; /* restore */
   }
-  else if(data->bits.http_put) {
+  else if(HTTPREQ_PUT == data->httpreq) {
     *bytecount = http->readbytecount + http->writebytecount;
   }
 
@@ -405,7 +403,7 @@ CURLcode Curl_http(struct connectdata *conn)
 
   if ( (conn->protocol&(PROT_HTTP|PROT_FTP)) &&
        data->bits.upload) {
-    data->bits.http_put=1;
+    data->httpreq = HTTPREQ_PUT;
   }
   
   /* The User-Agent string has been built in url.c already, because it might
@@ -457,7 +455,7 @@ CURLcode Curl_http(struct connectdata *conn)
     /* The path sent to the proxy is in fact the entire URL */
     ppath = data->url;
   }
-  if(data->bits.http_formpost) {
+  if(HTTPREQ_POST_FORM == data->httpreq) {
     /* we must build the whole darned post sequence first, so that we have
        a size of the whole shebang before we start to send it */
     http->sendit = Curl_getFormData(data->httppost, &http->postsize);
@@ -488,9 +486,9 @@ CURLcode Curl_http(struct connectdata *conn)
   if(!checkheaders(data, "Accept:"))
     http->p_accept = "Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*\r\n";
 
-  if((data->bits.http_post ||
+  if(( (HTTPREQ_POST == data->httpreq) ||
-      data->bits.http_formpost ||
+       (HTTPREQ_POST_FORM == data->httpreq) ||
-      data->bits.http_put) &&
+       (HTTPREQ_PUT == data->httpreq) ) &&
      conn->resume_from) {
     /**********************************************************************
      * Resuming upload in HTTP means that we PUT or POST and that we have
@@ -597,8 +595,9 @@ CURLcode Curl_http(struct connectdata *conn)
 
                 data->customrequest?data->customrequest:
                 (data->bits.no_body?"HEAD":
-                 (data->bits.http_post || data->bits.http_formpost)?"POST":
+                 ((HTTPREQ_POST == data->httpreq) ||
-                 (data->bits.http_put)?"PUT":"GET"),
+                  (HTTPREQ_POST_FORM == data->httpreq))?"POST":
+                 (HTTPREQ_PUT == data->httpreq)?"PUT":"GET"),
                 ppath,
                 (conn->bits.proxy_user_passwd &&
                  conn->allocptr.proxyuserpwd)?conn->allocptr.proxyuserpwd:"",
@@ -703,7 +702,9 @@ CURLcode Curl_http(struct connectdata *conn)
       headers = headers->next;
     }
 
-    if(data->bits.http_formpost) {
+    if(HTTPREQ_POST_FORM == data->httpreq) {
+      char contentType[256];
+      int linelength=0;
       if(Curl_FormInit(&http->form, http->sendit)) {
         failf(data, "Internal HTTP POST error!\n");
         return CURLE_HTTP_POST_ERROR;
@@ -720,21 +721,46 @@ CURLcode Curl_http(struct connectdata *conn)
       add_bufferf(req_buffer,
                   "Content-Length: %d\r\n", http->postsize-2);
 
+      if(!checkheaders(data, "Expect:")) {
+        /* if not disabled explicitly we add a Expect: 100-continue
+           to the headers which actually speeds up post operations (as
+           there is one packet coming back from the web server) */
+        add_bufferf(req_buffer,
+                    "Expect: 100-continue\r\n");
+        data->bits.expect100header = TRUE;
+
+        /* Get Content-Type: line from Curl_FormReadOneLine, which happens
+           to always be the first line. We can know this for sure since
+           we always build the formpost linked list the same way! */
+        linelength = Curl_FormReadOneLine (contentType,
+                                           sizeof(contentType),
+                                           1,
+                                           (FILE *)&http->form);
+        if(linelength == -1) {
+          failf(data, "Could not get Content-Type header line!\n");
+          return CURLE_HTTP_POST_ERROR;
+        }
+        add_buffer(req_buffer, contentType, linelength);
+      }
+
       /* set upload size to the progress meter */
       Curl_pgrsSetUploadSize(data, http->postsize);
 
+      /* fire away the whole request to the server */
       data->request_size = 
         add_buffer_send(conn->firstsocket, conn, req_buffer);
+
+      /* setup variables for the upcoming transfer */
       result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
                              &http->readbytecount,
                              conn->firstsocket,
                              &http->writebytecount);
       if(result) {
-        Curl_FormFree(http->sendit); /* free that whole lot */
+        Curl_formclean(http->sendit); /* free that whole lot */
         return result;
       }
     }
-    else if(data->bits.http_put) {
+    else if(HTTPREQ_PUT == data->httpreq) {
       /* Let's PUT the data to the server! */
 
       if(data->infilesize>0) {
@@ -762,9 +788,20 @@ CURLcode Curl_http(struct connectdata *conn)
       
     }
     else {
-      if(data->bits.http_post) {
+      if(HTTPREQ_POST == data->httpreq) {
         /* this is the simple POST, using x-www-form-urlencoded style */
 
+        if(!data->postfields) {
+          /*
+           * This is an attempt to do a POST without having anything to
+           * actually send. Let's make a NULL pointer equal "" here. Good/bad
+           * ?
+           */
+          data->postfields = (char *)"";
+          data->postfieldsize = 0; /* it might been set to something illegal,
+                                      anything > 0 would be! */
+        }
+
         if(!checkheaders(data, "Content-Length:"))
           /* we allow replacing this header, although it isn't very wise to
              actually set your own */

lib/http_chunks.c

@@ -96,8 +96,8 @@ void Curl_httpchunk_init(struct connectdata *conn)
  */
 CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
                               char *datap,
-                              ssize_t length,
+                              size_t length,
-                              ssize_t *wrote)
+                              size_t *wrote)
 {
   CURLcode result;
   struct Curl_chunker *ch = &conn->proto.http->chunk;

lib/if2ip.c

@@ -66,6 +66,11 @@
 #include "inet_ntoa_r.h"
 #endif
 
+#ifdef	VMS
+#define	IOCTL_3_ARGS
+#include <inet.h>
+#endif
+
 /* The last #include file should be: */
 #ifdef MALLOCDEBUG
 #include "memdebug.h"
@@ -90,7 +95,11 @@ char *Curl_if2ip(char *interface, char *buf, int buf_size)
     memset(&req, 0, sizeof(req));
     strcpy(req.ifr_name, interface);
     req.ifr_addr.sa_family = AF_INET;
+#ifdef	IOCTL_3_ARGS
+    if (SYS_ERROR == ioctl(dummy, SIOCGIFADDR, &req)) {
+#else
     if (SYS_ERROR == ioctl(dummy, SIOCGIFADDR, &req, sizeof(req))) {
+#endif
       sclose(dummy);
       return NULL;
     }

lib/krb4.c

@@ -1,8 +1,12 @@
-/* modified by Martin Hedenfalk <mhe@stacken.kth.se> for use in Curl
+/* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
- * last modified 2000-09-18
+ * use in Curl. His latest changes were done 2000-09-18.
- */
+ *
-
+ * It has since been patched away like a madman by Daniel Stenberg
-/*
+ * <daniel@haxx.se> to make it better applied to curl conditions, and to make
+ * it not use globals, pollute name space and more. This source code awaits a
+ * rewrite to work around the paragraph 2 in the BSD licenses as explained
+ * below.
+ *
  * Copyright (c) 1995, 1996, 1997, 1998, 1999 Kungliga Tekniska H<>gskolan
  * (Royal Institute of Technology, Stockholm, Sweden).
  * All rights reserved.
@@ -32,8 +36,7 @@
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * SUCH DAMAGE.  */
- */
 
 #include "setup.h"
 
@@ -47,6 +50,10 @@
 #include <string.h>
 #include <krb.h>
 
+#ifdef HAVE_UNISTD_H
+#include <unistd.h> /* for getpid() */
+#endif
+
 #include "ftp.h"
 #include "sendf.h"
 
@@ -55,23 +62,11 @@
 #include "memdebug.h"
 #endif
 
-#ifdef FTP_SERVER
+#define LOCAL_ADDR (&conn->local_addr)
-#define LOCAL_ADDR ctrl_addr
-#define REMOTE_ADDR his_addr
-#else
-/*#define LOCAL_ADDR myctladdr***/
-/*#define REMOTE_ADDR hisctladdr***/
-#endif
-
-/*extern struct sockaddr *LOCAL_ADDR, *REMOTE_ADDR;***/
-
-#define LOCAL_ADDR (&local_addr)
 #define REMOTE_ADDR (&conn->serv_addr)
 #define myctladdr LOCAL_ADDR
 #define hisctladdr REMOTE_ADDR
 
-static struct sockaddr_in local_addr;
-
 struct krb4_data {
     des_cblock key;
     des_key_schedule schedule;
@@ -105,6 +100,7 @@ size_t strlcpy (char *dst, const char *src, size_t dst_sz);
 static int
 krb4_check_prot(void *app_data, int level)
 {
+  app_data = NULL; /* prevent compiler warning */
   if(level == prot_confidential)
     return -1;
   return 0;
@@ -137,6 +133,10 @@ krb4_decode(void *app_data, void *buf, int len, int level,
 static int
 krb4_overhead(void *app_data, int level, int len)
 {
+  /* no arguments are used, just init them to prevent compiler warnings */
+  app_data = NULL;
+  level = 0;
+  len = 0;
   return 31;
 }
 
@@ -158,98 +158,9 @@ krb4_encode(void *app_data, void *from, int length, int level, void **to,
 	return -1;
 }
 
-#ifdef FTP_SERVER
-
-static int
-krb4_adat(void *app_data, void *buf, size_t len)
-{
-    KTEXT_ST tkt;
-    AUTH_DAT auth_dat;
-    char *p;
-    int kerror;
-    u_int32_t cs;
-    char msg[35]; /* size of encrypted block */
-    int tmp_len;
-    struct krb4_data *d = app_data;
-    char inst[INST_SZ];
-    struct sockaddr_in *his_addr_sin = (struct sockaddr_in *)his_addr;
-
-    memcpy(tkt.dat, buf, len);
-    tkt.length = len;
-
-    k_getsockinst(0, inst, sizeof(inst));
-    kerror = krb_rd_req(&tkt, "ftp", inst, 
-			his_addr_sin->sin_addr.s_addr, &auth_dat, "");
-    if(kerror == RD_AP_UNDEC){
-	k_getsockinst(0, inst, sizeof(inst));
-	kerror = krb_rd_req(&tkt, "rcmd", inst, 
-			    his_addr_sin->sin_addr.s_addr, &auth_dat, "");
-    }
-
-    if(kerror){
-	reply(535, "Error reading request: %s.", krb_get_err_text(kerror));
-	return -1;
-    }
-    
-    memcpy(d->key, auth_dat.session, sizeof(d->key));
-    des_set_key(&d->key, d->schedule);
-
-    strlcpy(d->name, auth_dat.pname, sizeof(d->name));
-    strlcpy(d->instance, auth_dat.pinst, sizeof(d->instance));
-    strlcpy(d->realm, auth_dat.prealm, sizeof(d->instance));
-
-    cs = auth_dat.checksum + 1;
-    {
-	unsigned char tmp[4];
-	KRB_PUT_INT(cs, tmp, 4, sizeof(tmp));
-	tmp_len = krb_mk_safe(tmp, msg, 4, &d->key,
-			      (struct sockaddr_in *)LOCAL_ADDR,
-			      (struct sockaddr_in *)REMOTE_ADDR);
-    }
-    if(tmp_len < 0){
-	reply(535, "Error creating reply: %s.", strerror(errno));
-	return -1;
-    }
-    len = tmp_len;
-    if(base64_encode(msg, len, &p) < 0) {
-	reply(535, "Out of memory base64-encoding.");
-	return -1;
-    }
-    reply(235, "ADAT=%s", p);
-    sec_complete = 1;
-    free(p);
-    return 0;
-}
-
-static int
-krb4_userok(void *app_data, char *user)
-{
-    struct krb4_data *d = app_data;
-    return krb_kuserok(d->name, d->instance, d->realm, user);
-}
-
-struct sec_server_mech krb4_server_mech = {
-    "KERBEROS_V4",
-    sizeof(struct krb4_data),
-    NULL, /* init */
-    NULL, /* end */
-    krb4_check_prot,
-    krb4_overhead,
-    krb4_encode,
-    krb4_decode,
-    /* */
-    NULL,
-    krb4_adat,
-    NULL, /* pbsz */
-    NULL, /* ccc */
-    krb4_userok
-};
-
-#else /* FTP_SERVER */
-
 static int
 mk_auth(struct krb4_data *d, KTEXT adat, 
-	char *service, char *host, int checksum)
+	const char *service, char *host, int checksum)
 {
     int ret;
     CREDENTIALS cred;
@@ -283,12 +194,9 @@ krb4_auth(void *app_data, struct connectdata *conn)
   u_int32_t cs;
   struct krb4_data *d = app_data;
   struct sockaddr_in *localaddr  = (struct sockaddr_in *)LOCAL_ADDR;
-#if 0
-    struct sockaddr_in *remoteaddr = (struct sockaddr_in *)REMOTE_ADDR;
-#endif
   char *host = conn->hp->h_name;
-    size_t nread;
+  ssize_t nread;
-    int l = sizeof(local_addr);
+  int l = sizeof(conn->local_addr);
 
   if(getsockname(conn->firstsocket,
                  (struct sockaddr *)LOCAL_ADDR, &l) < 0)
@@ -298,7 +206,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
   ret = mk_auth(d, &adat, "ftp", host, checksum);
   if(ret == KDC_PR_UNKNOWN)
     ret = mk_auth(d, &adat, "rcmd", host, checksum);
-    if(ret){
+  if(ret) {
     printf("%s\n", krb_get_err_text(ret));
     return AUTH_CONTINUE;
   }
@@ -319,10 +227,8 @@ krb4_auth(void *app_data, struct connectdata *conn)
         localaddr->sin_addr = natAddr;
         
         /*
-	   * This not the best place to do this, but it
+         * This not the best place to do this, but it is here we know that
-	   * is here we know that (probably) NAT is in
+         * (probably) NAT is in use!  */
-	   * use!
-	   */
 
         /*passivemode = 1;***/
         /*printf("Setting: Passive mode on.\n");***/
@@ -338,9 +244,9 @@ krb4_auth(void *app_data, struct connectdata *conn)
     printf("Out of memory base64-encoding.\n");
     return AUTH_CONTINUE;
   }
-    /*ret = command("ADAT %s", p)*/
+
   Curl_ftpsendf(conn->firstsocket, conn, "ADAT %s", p);
-    /* wait for feedback */
+
   nread = Curl_GetFTPResponse(conn->firstsocket,
                               conn->data->buffer, conn, NULL);
   if(nread < 0)
@@ -352,7 +258,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
     return AUTH_ERROR;
   }
 
-    p = strstr(/*reply_string*/conn->data->buffer, "ADAT=");
+  p = strstr(conn->data->buffer, "ADAT=");
   if(!p){
     printf("Remote host didn't send adat reply.\n");
     return AUTH_ERROR;
@@ -380,7 +286,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
   return AUTH_OK;
 }
 
-struct sec_client_mech krb4_client_mech = {
+struct Curl_sec_client_mech Curl_krb4_client_mech = {
     "KERBEROS_V4",
     sizeof(struct krb4_data),
     NULL, /* init */
@@ -392,9 +298,7 @@ struct sec_client_mech krb4_client_mech = {
     krb4_decode
 };
 
-#endif /* FTP_SERVER */
+void Curl_krb_kauth(struct connectdata *conn)
-
-void krb_kauth(struct connectdata *conn)
 {
   des_cblock key;
   des_key_schedule schedule;
@@ -403,63 +307,54 @@ void krb_kauth(struct connectdata *conn)
   char *p;
   char passwd[100];
   int tmp;
-    size_t nread;
+  ssize_t nread;
 	
   int save;
 
-    save = set_command_prot(conn, prot_private);
+  save = Curl_set_command_prot(conn, prot_private);
-    /*ret = command("SITE KAUTH %s", name);***/
+
   Curl_ftpsendf(conn->firstsocket, conn,
                 "SITE KAUTH %s", conn->data->user);
-    /* wait for feedback */
+
   nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer,
                               conn, NULL);
   if(nread < 0)
     return /*CURLE_OPERATION_TIMEOUTED*/;
 
   if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){
-	set_command_prot(conn, save);
+    Curl_set_command_prot(conn, save);
     /*code = -1;***/
     return;
   }
-    p = strstr(/*reply_string***/conn->data->buffer, "T=");
+
-    if(!p){
+  p = strstr(conn->data->buffer, "T=");
+  if(!p) {
     printf("Bad reply from server.\n");
-	set_command_prot(conn, save);
+    Curl_set_command_prot(conn, save);
-	/*code = -1;***/
     return;
   }
+
   p += 2;
   tmp = Curl_base64_decode(p, &tkt.dat);
-    if(tmp < 0){
+  if(tmp < 0) {
     printf("Failed to decode base64 in reply.\n");
-	set_command_prot(conn, save);
+    Curl_set_command_prot(conn, save);
-	/*code = -1;***/
     return;
   }
   tkt.length = tmp;
   tktcopy.length = tkt.length;
     
-    p = strstr(/*reply_string***/conn->data->buffer, "P=");
+  p = strstr(conn->data->buffer, "P=");
-    if(!p){
+  if(!p) {
     printf("Bad reply from server.\n");
-	set_command_prot(conn, save);
+    Curl_set_command_prot(conn, save);
-	/*code = -1;***/
     return;
   }
   name = p + 2;
   for(; *p && *p != ' ' && *p != '\r' && *p != '\n'; p++);
   *p = 0;
 
-#if 0
-    snprintf(buf, sizeof(buf), "Password for %s:", name);
-    if (des_read_pw_string (passwd, sizeof(passwd)-1, buf, 0))
-        *passwd = '\0';
-    des_string_to_key (passwd, &key);
-#else
   des_string_to_key (conn->data->passwd, &key);
-#endif
-
   des_key_sched(&key, schedule);
     
   des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
@@ -468,7 +363,7 @@ void krb_kauth(struct connectdata *conn)
   if (strcmp ((char*)tktcopy.dat + 8,
               KRB_TICKET_GRANTING_TICKET) != 0) {
     afs_string_to_key (passwd,
-			   krb_realmofhost(/*hostname***/conn->hp->h_name),
+                       krb_realmofhost(/*hostname*/conn->hp->h_name),
                        &key);
     des_key_sched (&key, schedule);
     des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
@@ -480,21 +375,20 @@ void krb_kauth(struct connectdata *conn)
   memset(passwd, 0, sizeof(passwd));
   if(Curl_base64_encode(tktcopy.dat, tktcopy.length, &p) < 0) {
     failf(conn->data, "Out of memory base64-encoding.\n");
-      set_command_prot(conn, save);
+    Curl_set_command_prot(conn, save);
-      /*code = -1;***/
     return;
   }
   memset (tktcopy.dat, 0, tktcopy.length);
-    /*ret = command("SITE KAUTH %s %s", name, p);***/
+
   Curl_ftpsendf(conn->firstsocket, conn,
                 "SITE KAUTH %s %s", name, p);
-    /* wait for feedback */
+
   nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer,
                               conn, NULL);
   if(nread < 0)
     return /*CURLE_OPERATION_TIMEOUTED*/;
   free(p);
-    set_command_prot(conn, save);
+  Curl_set_command_prot(conn, save);
 }
 
 #endif /* KRB4 */

lib/krb4.h

@@ -22,6 +22,6 @@
  *
  * $Id$
  *****************************************************************************/
-void krb_kauth(struct connectdata *conn);
+void Curl_krb_kauth(struct connectdata *conn);
 
 #endif

lib/ldap.c

@@ -101,7 +101,7 @@ static void DynaClose(void)
 #endif
 }
 
-static void * DynaGetFunction(char *name)
+static void * DynaGetFunction(const char *name)
 {
   void *func = NULL;
 
@@ -117,15 +117,11 @@ static void * DynaGetFunction(char *name)
 static int WriteProc(void *param, char *text, int len)
 {
   struct UrlData *data = (struct UrlData *)param;
+  len = 0; /* prevent compiler warning */
   Curl_client_write(data, CLIENTWRITE_BODY, text, 0);
   return 0;
 }
 
-CURLcode Curl_ldap_done(struct connectdata *conn)
-{
-  return CURLE_OK;
-}
-
 /***********************************************************************
  */
 CURLcode Curl_ldap(struct connectdata *conn)
@@ -194,7 +190,7 @@ CURLcode Curl_ldap(struct connectdata *conn)
 	    if (ldaptext) {
 	      rc = ldap_entry2text(server, NULL, entryIterator, NULL,
 				   NULL, NULL, WriteProc, data,
-				   "", 0, 0);
+				   (char *)"", 0, 0);
 	      if (rc != 0) {
 		failf(data, "LDAP: %s", ldap_err2string(rc));
 		status = CURLE_LDAP_SEARCH_FAILED;
@@ -202,7 +198,7 @@ CURLcode Curl_ldap(struct connectdata *conn)
 	    } else {
 	      rc = ldap_entry2html(server, NULL, entryIterator, NULL,
 				   NULL, NULL, WriteProc, data,
-				   "", 0, 0, NULL, NULL);
+				   (char *)"", 0, 0, NULL, NULL);
 	      if (rc != 0) {
 		failf(data, "LDAP: %s", ldap_err2string(rc));
 		status = CURLE_LDAP_SEARCH_FAILED;

lib/libcurl.def

@@ -22,14 +22,13 @@ EXPORTS
 	curl_global_init @ 13 ;
 	curl_slist_append @ 14 ;
 	curl_slist_free_all @ 15 ;
-	curl_unescape @ 16 ;
+	curl_version @ 16 ;
-	curl_version @ 17 ;
+	curl_maprintf @ 17 ;
-	curl_maprintf @ 18 ;
+ 	curl_mfprintf @ 18 ;
- 	curl_mfprintf @ 19 ;
+	curl_mprintf @ 19 ;
-	curl_mprintf @ 20 ;
+ 	curl_msprintf @ 20 ;
- 	curl_msprintf @ 21 ;
+ 	curl_msnprintf @ 21 ;
- 	curl_msnprintf @ 22 ;
+ 	curl_mvfprintf @ 22 ;
- 	curl_mvfprintf @ 23 ;
+	curl_strequal @ 23 ;
-	curl_strequal @ 24 ;
+	curl_strnequal @ 24 ;
-	curl_strnequal @ 25 ;
 

lib/memdebug.c

@@ -58,13 +58,13 @@
 FILE *logfile;
 
 /* this sets the log file name */
-void curl_memdebug(char *logname)
+void curl_memdebug(const char *logname)
 {
   logfile = fopen(logname, "w");
 }
 
 
-void *curl_domalloc(size_t size, int line, char *source)
+void *curl_domalloc(size_t size, int line, const char *source)
 {
   void *mem=(malloc)(size);
   fprintf(logfile?logfile:stderr, "MEM %s:%d malloc(%d) = %p\n",
@@ -72,7 +72,7 @@ void *curl_domalloc(size_t size, int line, char *source)
   return mem;
 }
 
-char *curl_dostrdup(const char *str, int line, char *source)
+char *curl_dostrdup(const char *str, int line, const char *source)
 {
   char *mem;
   size_t len;
@@ -90,7 +90,7 @@ char *curl_dostrdup(const char *str, int line, char *source)
   return mem;
 }
 
-void *curl_dorealloc(void *ptr, size_t size, int line, char *source)
+void *curl_dorealloc(void *ptr, size_t size, int line, const char *source)
 {
   void *mem=(realloc)(ptr, size);
   fprintf(logfile?logfile:stderr, "MEM %s:%d realloc(%p, %d) = %p\n",
@@ -98,7 +98,7 @@ void *curl_dorealloc(void *ptr, size_t size, int line, char *source)
   return mem;
 }
 
-void curl_dofree(void *ptr, int line, char *source)
+void curl_dofree(void *ptr, int line, const char *source)
 {
   if(NULL == ptr) {
     fprintf(stderr, "ILLEGAL free() on NULL at %s:%d\n",
@@ -121,7 +121,7 @@ int curl_socket(int domain, int type, int protocol, int line, char *source)
 }
 
 int curl_accept(int s, struct sockaddr *addr, socklen_t *addrlen,
-                int line, char *source)
+                int line, const char *source)
 {
   int sockfd=(accept)(s, addr, addrlen);
   fprintf(logfile?logfile:stderr, "FD %s:%d accept() = %d\n",
@@ -138,7 +138,8 @@ int curl_sclose(int sockfd, int line, char *source)
   return res;
 }
 
-FILE *curl_fopen(char *file, char *mode, int line, char *source)
+FILE *curl_fopen(const char *file, const char *mode,
+                 int line, const char *source)
 {
   FILE *res=(fopen)(file, mode);
   fprintf(logfile?logfile:stderr, "FILE %s:%d fopen(\"%s\") = %p\n",
@@ -146,7 +147,7 @@ FILE *curl_fopen(char *file, char *mode, int line, char *source)
   return res;
 }
 
-int curl_fclose(FILE *file, int line, char *source)
+int curl_fclose(FILE *file, int line, const char *source)
 {
   int res=(fclose)(file);
   fprintf(logfile?logfile:stderr, "FILE %s:%d fclose(%p)\n",

lib/memdebug.h

@@ -2,23 +2,27 @@
 
 #include <sys/socket.h>
 #include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
 
 /* memory functions */
-void *curl_domalloc(size_t size, int line, char *source);
+void *curl_domalloc(size_t size, int line, const char *source);
-void *curl_dorealloc(void *ptr, size_t size, int line, char *source);
+void *curl_dorealloc(void *ptr, size_t size, int line, const char *source);
-void curl_dofree(void *ptr, int line, char *source);
+void curl_dofree(void *ptr, int line, const char *source);
-char *curl_dostrdup(const char *str, int line, char *source);
+char *curl_dostrdup(const char *str, int line, const char *source);
-void curl_memdebug(char *logname);
+void curl_memdebug(const char *logname);
 
 /* file descriptor manipulators */
-int curl_socket(int domain, int type, int protocol, int, char *);
+int curl_socket(int domain, int type, int protocol, int, const char *);
-int curl_sclose(int sockfd, int, char *);
+int curl_sclose(int sockfd, int, const char *source);
 int curl_accept(int s, struct sockaddr *addr, socklen_t *addrlen,
-                int line, char *source);
+                int line, const char *source);
 
 /* FILE functions */
-FILE *curl_fopen(char *file, char *mode, int line, char *source);
+FILE *curl_fopen(const char *file, const char *mode, int line,
-int curl_fclose(FILE *file, int line, char *source);
+                 const char *source);
+int curl_fclose(FILE *file, int line, const char *source);
 
 /* Set this symbol on the command-line, recompile all lib-sources */
 #define strdup(ptr) curl_dostrdup(ptr, __LINE__, __FILE__)

lib/mprintf.c

@@ -446,7 +446,7 @@ static int dprintf_Pass1(char *format, va_stack_t *vto, char **endpos, va_list a
 	case '1': case '2': case '3': case '4':
 	case '5': case '6': case '7': case '8': case '9':
 	  flags |= FLAGS_WIDTH;
-	  width = strtol(--fmt, &fmt, 10);
+	  width = strtol(fmt-1, &fmt, 10);
 	  break;
 	case '*':  /* Special case */
 	  flags |= FLAGS_WIDTHPARAM;
@@ -864,7 +864,7 @@ static int dprintf_formatf(
 	    p->flags &= (~FLAGS_ALT);
 	  }
 	  else {
-	    str = "";
+	    str = (char *)"";
 	    len = 0;
 	  }
 	}
@@ -1151,7 +1151,9 @@ int curl_msprintf(char *buffer, const char *format, ...)
   return retcode;
 }
 
+#ifndef WIN32 /* not needed on win32 */
 extern int fputc(int, FILE *);
+#endif
 
 int curl_mprintf(const char *format, ...)
 {

lib/netrc.c

@@ -36,7 +36,9 @@
 #ifdef HAVE_PWD_H
 #include <pwd.h>
 #endif
-
+#ifdef VMS
+#include <unixlib.h>
+#endif
 
 #include <curl/curl.h>
 
@@ -88,8 +90,13 @@ int Curl_parsenetrc(char *host,
 #if defined(HAVE_GETPWUID) && defined(HAVE_GETEUID)
   struct passwd *pw;
   pw= getpwuid(geteuid());
-  if (pw)
+  if (pw) {
+#ifdef	VMS
+    home = decc$translate_vms(pw->pw_dir);
+#else
     home = pw->pw_dir;
+#endif
+  }
 #else
   void *pw=NULL;
 #endif

lib/progress.c

@@ -97,6 +97,8 @@ void Curl_pgrsDone(struct connectdata *conn)
   if(!(data->progress.flags & PGRS_HIDE)) {
     data->progress.lastshow=0;
     Curl_pgrsUpdate(conn); /* the final (forced) update */
+    if(!data->progress.callback)
+      /* only output if we don't use progress callback */
       fprintf(data->err, "\n");
   }
 }
@@ -223,20 +225,19 @@ int Curl_pgrsUpdate(struct connectdata *conn)
   /* The exact time spent so far */
   data->progress.timespent = Curl_tvdiff (now, data->progress.start);
 
-  if(data->progress.lastshow == Curl_tvlong(now))
-    return 0; /* never update this more than once a second if the end isn't 
-                 reached */
-  data->progress.lastshow = now.tv_sec;
-
   /* The average download speed this far */
   data->progress.dlspeed = data->progress.downloaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0);
 
   /* The average upload speed this far */
   data->progress.ulspeed = data->progress.uploaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0);
 
+  if(data->progress.lastshow == Curl_tvlong(now))
+    return 0; /* never update this more than once a second if the end isn't 
+                 reached */
+  data->progress.lastshow = now.tv_sec;
+
   /* Let's do the "current speed" thing, which should use the fastest
          of the dl/ul speeds */
-
   data->progress.speeder[ nowindex ] =
     data->progress.downloaded>data->progress.uploaded?
     data->progress.downloaded:data->progress.uploaded;
@@ -326,5 +327,8 @@ int Curl_pgrsUpdate(struct connectdata *conn)
           max5data(data->progress.current_speed, max5[5]) /* current speed */
           );
 
+  /* we flush the output stream to make it appear as soon as possible */
+  fflush(data->err);
+
   return 0;
 }

lib/security.c

@@ -1,9 +1,12 @@
-/* modified by Martin Hedenfalk <mhe@stacken.kth.se> for use in Curl
+/* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
- * last modified 2000-09-18
+ * use in Curl. His latest changes were done 2000-09-18.
- * Even more obscurified to merge better into libcurl by Daniel Stenberg.
+ *
- */
+ * It has since been patched and modified a lot by Daniel Stenberg
-
+ * <daniel@haxx.se> to make it better applied to curl conditions, and to make
-/*
+ * it not use globals, pollute name space and more. This source code awaits a
+ * rewrite to work around the paragraph 2 in the BSD licenses as explained
+ * below.
+ *
  * Copyright (c) 1998, 1999 Kungliga Tekniska H<>gskolan
  * (Royal Institute of Technology, Stockholm, Sweden).
  * All rights reserved.
@@ -33,8 +36,7 @@
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * SUCH DAMAGE.  */
- */
 
 #include "setup.h"
 
@@ -73,69 +75,36 @@ static struct {
     { prot_private, "private" }
 };
 
-#if 0
-static const char *
-level_to_name(enum protection_level level)
-{
-    int i;
-    for(i = 0; i < sizeof(level_names) / sizeof(level_names[0]); i++)
-	if(level_names[i].level == level)
-	    return level_names[i].name;
-    return "unknown";
-}
-#endif
-
-#ifndef FTP_SERVER /* not used in server */
 static enum protection_level 
 name_to_level(const char *name)
 {
   int i;
-    for(i = 0; i < sizeof(level_names) / sizeof(level_names[0]); i++)
+  for(i = 0; i < (int)sizeof(level_names)/(int)sizeof(level_names[0]); i++)
     if(!strncasecmp(level_names[i].name, name, strlen(name)))
       return level_names[i].level;
   return (enum protection_level)-1;
 }
-#endif
 
-#ifdef FTP_SERVER
+static struct Curl_sec_client_mech *mechs[] = {
-
-static struct sec_server_mech *mechs[] = {
 #ifdef KRB5
-    &gss_server_mech,
+  /* not supported */
 #endif
 #ifdef KRB4
-    &krb4_server_mech,
+    &Curl_krb4_client_mech,
 #endif
     NULL
 };
 
-static struct sec_server_mech *mech;
-
-#else
-
-static struct sec_client_mech *mechs[] = {
-#ifdef KRB5
-    &gss_client_mech,
-#endif
-#ifdef KRB4
-    &krb4_client_mech,
-#endif
-    NULL
-};
-
-static struct sec_client_mech *mech;
-
-#endif
-
 int
-sec_getc(struct connectdata *conn, FILE *F)
+Curl_sec_getc(struct connectdata *conn, FILE *F)
 {
   if(conn->sec_complete && conn->data_prot) {
     char c;
-    if(sec_read(conn, fileno(F), &c, 1) <= 0)
+    if(Curl_sec_read(conn, fileno(F), &c, 1) <= 0)
       return EOF;
     return c;
-  } else
+  }
+  else
     return getc(F);
 }
 
@@ -173,7 +142,7 @@ block_write(int fd, void *buf, size_t len)
 
 static int
 sec_get_data(struct connectdata *conn,
-             int fd, struct krb4buffer *buf, int level)
+             int fd, struct krb4buffer *buf)
 {
   int len;
   int b;
@@ -190,7 +159,7 @@ sec_get_data(struct connectdata *conn,
     return 0;
   else if (b < 0)
     return -1;
-  buf->size = (*mech->decode)(conn->app_data, buf->data, len,
+  buf->size = (conn->mech->decode)(conn->app_data, buf->data, len,
                                    conn->data_prot, conn);
   buf->index = 0;
   return 0;
@@ -225,7 +194,7 @@ buffer_write(struct krb4buffer *buf, void *data, size_t len)
 }
 
 int
-sec_read(struct connectdata *conn, int fd, void *buffer, int length)
+Curl_sec_read(struct connectdata *conn, int fd, void *buffer, int length)
 {
     size_t len;
     int rx = 0;
@@ -244,7 +213,7 @@ sec_read(struct connectdata *conn, int fd, void *buffer, int length)
     buffer = (char*)buffer + len;
     
     while(length) {
-      if(sec_get_data(conn, fd, &conn->in_buffer, conn->data_prot) < 0)
+      if(sec_get_data(conn, fd, &conn->in_buffer) < 0)
         return -1;
       if(conn->in_buffer.size == 0) {
         if(rx)
@@ -264,7 +233,8 @@ sec_send(struct connectdata *conn, int fd, char *from, int length)
 {
   int bytes;
   void *buf;
-  bytes = (*mech->encode)(conn->app_data, from, length, conn->data_prot, &buf, conn);
+  bytes = (conn->mech->encode)(conn->app_data, from, length, conn->data_prot,
+                               &buf, conn);
   bytes = htonl(bytes);
   block_write(fd, &bytes, sizeof(bytes));
   block_write(fd, buf, ntohl(bytes));
@@ -273,26 +243,11 @@ sec_send(struct connectdata *conn, int fd, char *from, int length)
 }
 
 int
-sec_fflush(struct connectdata *conn, FILE *F)
+Curl_sec_fflush_fd(struct connectdata *conn, int fd)
 {
   if(conn->data_prot != prot_clear) {
     if(conn->out_buffer.index > 0){
-      sec_write(conn, fileno(F),
+      Curl_sec_write(conn, fd,
-                conn->out_buffer.data, conn->out_buffer.index);
-      conn->out_buffer.index = 0;
-    }
-    sec_send(conn, fileno(F), NULL, 0);
-  }
-  fflush(F);
-  return 0;
-}
-
-int
-sec_fflush_fd(struct connectdata *conn, int fd)
-{
-  if(conn->data_prot != prot_clear) {
-    if(conn->out_buffer.index > 0){
-      sec_write(conn, fd,
                 conn->out_buffer.data, conn->out_buffer.index);
       conn->out_buffer.index = 0;
     }
@@ -302,7 +257,7 @@ sec_fflush_fd(struct connectdata *conn, int fd)
 }
 
 int
-sec_write(struct connectdata *conn, int fd, char *buffer, int length)
+Curl_sec_write(struct connectdata *conn, int fd, char *buffer, int length)
 {
   int len = conn->buffer_size;
   int tx = 0;
@@ -310,7 +265,7 @@ sec_write(struct connectdata *conn, int fd, char *buffer, int length)
   if(conn->data_prot == prot_clear)
     return write(fd, buffer, length);
 
-  len -= (*mech->overhead)(conn->app_data, conn->data_prot, len);
+  len -= (conn->mech->overhead)(conn->app_data, conn->data_prot, len);
   while(length){
     if(length < len)
       len = length;
@@ -323,7 +278,7 @@ sec_write(struct connectdata *conn, int fd, char *buffer, int length)
 }
 
 int
-sec_vfprintf2(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
+Curl_sec_vfprintf2(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 {
   char *buf;
   int ret;
@@ -338,18 +293,18 @@ sec_vfprintf2(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 }
 
 int
-sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...)
+Curl_sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...)
 {
     int ret;
     va_list ap;
     va_start(ap, fmt);
-    ret = sec_vfprintf2(conn, f, fmt, ap);
+    ret = Curl_sec_vfprintf2(conn, f, fmt, ap);
     va_end(ap);
     return ret;
 }
 
 int
-sec_putc(struct connectdata *conn, int c, FILE *F)
+Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
 {
   char ch = c;
   if(conn->data_prot == prot_clear)
@@ -357,14 +312,14 @@ sec_putc(struct connectdata *conn, int c, FILE *F)
     
   buffer_write(&conn->out_buffer, &ch, 1);
   if(c == '\n' || conn->out_buffer.index >= 1024 /* XXX */) {
-    sec_write(conn, fileno(F), conn->out_buffer.data, conn->out_buffer.index);
+    Curl_sec_write(conn, fileno(F), conn->out_buffer.data, conn->out_buffer.index);
     conn->out_buffer.index = 0;
   }
   return c;
 }
 
 int
-sec_read_msg(struct connectdata *conn, char *s, int level)
+Curl_sec_read_msg(struct connectdata *conn, char *s, int level)
 {
     int len;
     char *buf;
@@ -373,7 +328,7 @@ sec_read_msg(struct connectdata *conn, char *s, int level)
     buf = malloc(strlen(s));
     len = Curl_base64_decode(s + 4, buf); /* XXX */
     
-    len = (*mech->decode)(conn->app_data, buf, len, level, conn);
+    len = (conn->mech->decode)(conn->app_data, buf, len, level, conn);
     if(len < 0)
 	return -1;
     
@@ -392,7 +347,7 @@ sec_read_msg(struct connectdata *conn, char *s, int level)
 
 /* modified to return how many bytes written, or -1 on error ***/
 int
-sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
+Curl_sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 {
     int ret = 0;
     char *buf;
@@ -402,7 +357,7 @@ sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 	return vfprintf(f, fmt, ap);
     
     buf = aprintf(fmt, ap);
-    len = (*mech->encode)(conn->app_data, buf, strlen(buf),
+    len = (conn->mech->encode)(conn->app_data, buf, strlen(buf),
                                conn->command_prot, &enc,
                                conn);
     free(buf);
@@ -414,67 +369,43 @@ sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
       failf(conn->data, "Out of memory base64-encoding.\n");
       return -1;
     }
-#ifdef FTP_SERVER
-    if(command_prot == prot_safe)
-	fprintf(f, "631 %s\r\n", buf);
-    else if(command_prot == prot_private)
-	fprintf(f, "632 %s\r\n", buf);
-    else if(command_prot == prot_confidential)
-	fprintf(f, "633 %s\r\n", buf);
-#else
     if(conn->command_prot == prot_safe)
 	ret = fprintf(f, "MIC %s", buf);
     else if(conn->command_prot == prot_private)
 	ret = fprintf(f, "ENC %s", buf);
     else if(conn->command_prot == prot_confidential)
 	ret = fprintf(f, "CONF %s", buf);
-#endif
+
     free(buf);
     return ret;
 }
 
 int
-sec_fprintf(struct connectdata *conn, FILE *f, const char *fmt, ...)
+Curl_sec_fprintf(struct connectdata *conn, FILE *f, const char *fmt, ...)
 {
     va_list ap;
     int ret;
     va_start(ap, fmt);
-    ret = sec_vfprintf(conn, f, fmt, ap);
+    ret = Curl_sec_vfprintf(conn, f, fmt, ap);
     va_end(ap);
     return ret;
 }
 
-/* end common stuff */
 
-#ifdef FTP_SERVER
+enum protection_level
-
+Curl_set_command_prot(struct connectdata *conn, enum protection_level level)
-/* snip */
-
-#else /* FTP_SERVER */
-
-#if 0
-void
-sec_status(void)
 {
-    if(conn->sec_complete){
+    enum protection_level old = conn->command_prot;
-	printf("Using %s for authentication.\n", mech->name);
+    conn->command_prot = level;
-	printf("Using %s command channel.\n", level_to_name(command_prot));
+    return old;
-	printf("Using %s data channel.\n", level_to_name(data_prot));
-	if(buffer_size > 0)
-	    printf("Protection buffer size: %lu.\n", 
-		   (unsigned long)buffer_size);
-    }else{
-	printf("Not using any security mechanism.\n");
-    }
 }
-#endif
 
 static int
 sec_prot_internal(struct connectdata *conn, int level)
 {
   char *p;
   unsigned int s = 1048576;
-    size_t nread;
+  ssize_t nread;
 
   if(!conn->sec_complete){
     infof(conn->data, "No security data exchange has taken place.\n");
@@ -517,59 +448,8 @@ sec_prot_internal(struct connectdata *conn, int level)
   return 0;
 }
 
-enum protection_level
-set_command_prot(struct connectdata *conn, enum protection_level level)
-{
-    enum protection_level old = conn->command_prot;
-    conn->command_prot = level;
-    return old;
-}
-
-#if 0
 void
-sec_prot(int argc, char **argv)
+Curl_sec_set_protection_level(struct connectdata *conn)
-{
-    int level = -1;
-
-    if(argc < 2 || argc > 3)
-	goto usage;
-    if(!sec_complete) {
-	printf("No security data exchange has taken place.\n");
-	code = -1;
-	return;
-    }
-    level = name_to_level(argv[argc - 1]);
-    
-    if(level == -1)
-	goto usage;
-    
-    if((*mech->check_prot)(conn->app_data, level)) {
-	printf("%s does not implement %s protection.\n", 
-	       mech->name, level_to_name(level));
-	code = -1;
-	return;
-    }
-    
-    if(argc == 2 || strncasecmp(argv[1], "data", strlen(argv[1])) == 0) {
-	if(sec_prot_internal(level) < 0){
-	    code = -1;
-	    return;
-	}
-    } else if(strncasecmp(argv[1], "command", strlen(argv[1])) == 0)
-	set_command_prot(level);
-    else
-	goto usage;
-    code = 0;
-    return;
- usage:
-    printf("usage: %s [command|data] [clear|safe|confidential|private]\n",
-	   argv[0]);
-    code = -1;
-}
-#endif
-
-void
-sec_set_protection_level(struct connectdata *conn)
 {
   if(conn->sec_complete && conn->data_prot != conn->request_data_prot)
     sec_prot_internal(conn, conn->request_data_prot);
@@ -577,7 +457,7 @@ sec_set_protection_level(struct connectdata *conn)
 
 
 int
-sec_request_prot(struct connectdata *conn, char *level)
+Curl_sec_request_prot(struct connectdata *conn, const char *level)
 {
   int l = name_to_level(level);
   if(l == -1)
@@ -587,11 +467,11 @@ sec_request_prot(struct connectdata *conn, char *level)
 }
 
 int
-sec_login(struct connectdata *conn)
+Curl_sec_login(struct connectdata *conn)
 {
   int ret;
-    struct sec_client_mech **m;
+  struct Curl_sec_client_mech **m;
-    size_t nread;
+  ssize_t nread;
   struct UrlData *data=conn->data;
 
   for(m = mechs; *m && (*m)->name; m++) {
@@ -641,7 +521,7 @@ sec_login(struct connectdata *conn)
       /* mechanism is supposed to output error string */
       return -1;
     }
-	mech = *m;
+    conn->mech = *m;
     conn->sec_complete = 1;
     conn->command_prot = prot_safe;
     break;
@@ -651,19 +531,18 @@ sec_login(struct connectdata *conn)
 }
 
 void
-sec_end(struct connectdata *conn)
+Curl_sec_end(struct connectdata *conn)
 {
-    if (mech != NULL) {
+  if (conn->mech != NULL) {
-	if(mech->end)
+    if(conn->mech->end)
-	    (*mech->end)(conn->app_data);
+      (conn->mech->end)(conn->app_data);
-	memset(conn->app_data, 0, mech->size);
+    memset(conn->app_data, 0, conn->mech->size);
     free(conn->app_data);
     conn->app_data = NULL;
   }
   conn->sec_complete = 0;
   conn->data_prot = (enum protection_level)0;
+  conn->mech=NULL;
 }
 
-#endif /* FTP_SERVER */
-
 #endif /* KRB4 */

lib/security.h

@@ -1,50 +1,35 @@
-/* modified by Martin Hedenfalk <mhe@stacken.kth.se> for use in Curl
+#ifndef __SECURITY_H
- * last modified 2000-09-18
+#define __SECURITY_H
- */
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * 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 MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
 
-/*
+/* this is a re-write */
- * Copyright (c) 1998, 1999 Kungliga Tekniska H<>gskolan
- * (Royal Institute of Technology, Stockholm, Sweden). 
- * All rights reserved. 
- *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
- * are met: 
- *
- * 1. Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer. 
- *
- * 2. Redistributions in binary form must reproduce the above copyright 
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the distribution. 
- *
- * 3. Neither the name of the Institute nor the names of its contributors 
- *    may be used to endorse or promote products derived from this software 
- *    without specific prior written permission. 
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
- * SUCH DAMAGE. 
- */
-
-/* $Id$ */
-
-#ifndef __security_h__
-#define __security_h__
 
 #include <stdarg.h>
 #include "urldata.h"  /* for struct connectdata * */
 
-struct sec_client_mech {
+struct Curl_sec_client_mech {
-    char *name;
+  const char *name;
   size_t size;
   int (*init)(void *);
   int (*auth)(void *, struct connectdata *);
@@ -55,80 +40,33 @@ struct sec_client_mech {
   int (*decode)(void *, void*, int, int, struct connectdata *);
 };
 
-struct sec_server_mech {
-    char *name;
-    size_t size;
-    int (*init)(void *);
-    void (*end)(void *);
-    int (*check_prot)(void *, int);
-    int (*overhead)(void *, int, int);
-    int (*encode)(void *, void*, int, int, void**);
-    int (*decode)(void *, void*, int, int);
-
-    int (*auth)(void *);
-    int (*adat)(void *, void*, size_t);
-    size_t (*pbsz)(void *, size_t);
-    int (*ccc)(void*);
-    int (*userok)(void*, char*);
-};
 
 #define AUTH_OK		0
 #define AUTH_CONTINUE	1
 #define AUTH_ERROR	2
 
-#ifdef FTP_SERVER
+extern struct Curl_sec_client_mech Curl_krb4_client_mech;
-extern struct sec_server_mech krb4_server_mech, gss_server_mech;
-#else
-extern struct sec_client_mech krb4_client_mech, gss_client_mech;
-#endif
 
-extern int sec_complete;
+int Curl_sec_fflush_fd(struct connectdata *conn, int fd);
+int Curl_sec_fprintf (struct connectdata *, FILE *, const char *, ...);
+int Curl_sec_getc (struct connectdata *conn, FILE *);
+int Curl_sec_putc (struct connectdata *conn, int, FILE *);
+int Curl_sec_read (struct connectdata *conn, int, void *, int);
+int Curl_sec_read_msg (struct connectdata *conn, char *, int);
 
-#ifdef FTP_SERVER
+int Curl_sec_vfprintf(struct connectdata *, FILE *, const char *, va_list);
-extern char *ftp_command;
+int Curl_sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...);
-void new_ftp_command(char*);
+int Curl_sec_vfprintf2(struct connectdata *conn, FILE *, const char *, va_list);
-void delete_ftp_command(void);
+int Curl_sec_write (struct connectdata *conn, int, char *, int);
-#endif
 
-/* ---- */
+void Curl_sec_end (struct connectdata *);
+int Curl_sec_login (struct connectdata *);
+void Curl_sec_prot (int, char **);
+int Curl_sec_request_prot (struct connectdata *conn, const char *level);
+void Curl_sec_set_protection_level(struct connectdata *conn);
+void Curl_sec_status (void);
 
-
+enum protection_level Curl_set_command_prot(struct connectdata *,
-int sec_fflush (struct connectdata *conn, FILE *);
-int sec_fflush_fd(struct connectdata *conn, int fd);
-int sec_fprintf (struct connectdata *, FILE *, const char *, ...);
-int sec_getc (struct connectdata *conn, FILE *);
-int sec_putc (struct connectdata *conn, int, FILE *);
-int sec_read (struct connectdata *conn, int, void *, int);
-int sec_read_msg (struct connectdata *conn, char *, int);
-
-int sec_vfprintf(struct connectdata *, FILE *, const char *, va_list);
-int sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...);
-int sec_vfprintf2(struct connectdata *conn, FILE *, const char *, va_list);
-int sec_write (struct connectdata *conn, int, char *, int);
-
-#ifdef FTP_SERVER
-void adat (char *);
-void auth (char *);
-void ccc (void);
-void mec (char *, enum protection_level);
-void pbsz (int);
-void prot (char *);
-void delete_ftp_command (void);
-void new_ftp_command (char *);
-int sec_userok (char *);
-int secure_command (void);
-enum protection_level get_command_prot(void);
-#else
-void sec_end (struct connectdata *);
-int sec_login (struct connectdata *);
-void sec_prot (int, char **);
-int sec_request_prot (struct connectdata *conn, char *);
-void sec_set_protection_level(struct connectdata *conn);
-void sec_status (void);
-
-enum protection_level set_command_prot(struct connectdata *,
                                             enum protection_level);
 
 #endif
-
-#endif /* __security_h__ */  

lib/sendf.c

@@ -122,7 +122,7 @@ void curl_slist_free_all(struct curl_slist *list)
 
 /* Curl_infof() is for info message along the way */
 
-void Curl_infof(struct UrlData *data, char *fmt, ...)
+void Curl_infof(struct UrlData *data, const char *fmt, ...)
 {
   va_list ap;
   if(data->bits.verbose) {
@@ -136,7 +136,7 @@ void Curl_infof(struct UrlData *data, char *fmt, ...)
 /* Curl_failf() is for messages stating why we failed, the LAST one will be
    returned for the user (if requested) */
 
-void Curl_failf(struct UrlData *data, char *fmt, ...)
+void Curl_failf(struct UrlData *data, const char *fmt, ...)
 {
   va_list ap;
   va_start(ap, fmt);
@@ -147,7 +147,7 @@ void Curl_failf(struct UrlData *data, char *fmt, ...)
 
 /* Curl_sendf() sends formated data to the server */
 size_t Curl_sendf(int sockfd, struct connectdata *conn,
-                  char *fmt, ...)
+                  const char *fmt, ...)
 {
   struct UrlData *data = conn->data;
   size_t bytes_written;
@@ -181,21 +181,27 @@ CURLcode Curl_write(struct connectdata *conn, int sockfd,
   size_t bytes_written;
 
 #ifdef USE_SSLEAY
+  /* SSL_write() is said to return 'int' while write() and send() returns
+     'size_t' */
+  int ssl_bytes;
   if (conn->ssl.use) {
     int loop=100; /* just a precaution to never loop endlessly */
     while(loop--) {
-      bytes_written = SSL_write(conn->ssl.handle, mem, len);
+      ssl_bytes = SSL_write(conn->ssl.handle, mem, len);
-      if((-1 != bytes_written) ||
+      if((0 >= ssl_bytes) ||
          (SSL_ERROR_WANT_WRITE != SSL_get_error(conn->ssl.handle,
-                                                bytes_written) ))
+                                                ssl_bytes) )) {
+        /* this converts from signed to unsigned... */
+        bytes_written = ssl_bytes;
         break;
       }
     }
+  }
   else {
 #endif
 #ifdef KRB4
     if(conn->sec_complete) {
-      bytes_written = sec_write(conn, sockfd, mem, len);
+      bytes_written = Curl_sec_write(conn, sockfd, mem, len);
     }
     else
 #endif /* KRB4 */
@@ -230,7 +236,8 @@ CURLcode Curl_client_write(struct UrlData *data,
       return CURLE_WRITE_ERROR;
     }
   }
-  if((type & CLIENTWRITE_HEADER) && data->writeheader) {
+  if((type & CLIENTWRITE_HEADER) &&
+     (data->fwrite_header || data->writeheader) ) {
     /*
      * Write headers to the same callback or to the especially setup
      * header callback function (added after version 7.7.1).
@@ -273,7 +280,7 @@ CURLcode Curl_read(struct connectdata *conn, int sockfd,
 #endif
 #ifdef KRB4
     if(conn->sec_complete)
-      nread = sec_read(conn, sockfd, buf, buffersize);
+      nread = Curl_sec_read(conn, sockfd, buf, buffersize);
     else
 #endif
       nread = sread (sockfd, buf, buffersize);

lib/sendf.h

@@ -23,17 +23,17 @@
  * $Id$
  *****************************************************************************/
 
-size_t Curl_sendf(int fd, struct connectdata *, char *fmt, ...);
+size_t Curl_sendf(int fd, struct connectdata *, const char *fmt, ...);
-void Curl_infof(struct UrlData *, char *fmt, ...);
+void Curl_infof(struct UrlData *, const char *fmt, ...);
-void Curl_failf(struct UrlData *, char *fmt, ...);
+void Curl_failf(struct UrlData *, const char *fmt, ...);
 
 #define infof Curl_infof
 #define failf Curl_failf
 
 struct send_buffer {
   char *buffer;
-  long size_max;
+  size_t size_max;
-  long size_used;
+  size_t size_used;
 };
 typedef struct send_buffer send_buffer;
 

lib/setup.h

@@ -32,7 +32,13 @@
 #endif
 
 #ifdef HAVE_CONFIG_H
+
+#ifdef VMS
+#include "config-vms.h"
+#else
 #include "config.h" /* the configure script results */
+#endif
+
 #else
 #ifdef WIN32
 /* include the hand-modified win32 adjusted config.h! */
@@ -79,31 +85,17 @@ defined(HAVE_LIBSSL) && defined(HAVE_LIBCRYPTO)
 #endif
 
 #ifndef STDC_HEADERS /* no standard C headers! */
+#ifdef	VMS
+#include "../include/curl/stdcheaders.h"
+#else
 #include "curl/stdcheaders.h"
+#endif
 #else
 #ifdef _AIX
 #include "curl/stdcheaders.h"
 #endif
 #endif
 
-#if 0 /* zlib experiments are halted 17th october, 1999 (Daniel) */
-#if defined(HAVE_ZLIB_H) && defined(HAVE_LIBZ)
-     /* Both lib and header file exist, we have libz! */
-#define USE_ZLIB
-#endif
-#endif
-
-#if 0
-#ifdef HAVE_STRCASECMP
-#define strnequal(x,y,z) !(strncasecmp)(x,y,z)
-#define strequal(x,y) !(strcasecmp)(x,y)
-
-#else
-#define strnequal(x,y,z) !strnicmp(x,y,z)
-#define strequal(x,y) !stricmp(x,y)
-#endif
-#endif
-
 /* Below we define four functions. They should
    1. close a socket
    2. read from a socket

lib/ssluse.c

@@ -42,21 +42,29 @@
 #include "memdebug.h"
 #endif
 
+#if OPENSSL_VERSION_NUMBER >= 0x00904100L
+#define HAVE_USERDATA_IN_PWD_CALLBACK 1
+#else
+#undef HAVE_USERDATA_IN_PWD_CALLBACK
+#endif
+
+#ifndef HAVE_USERDATA_IN_PWD_CALLBACK
 static char global_passwd[64];
+#endif
 
 static int passwd_callback(char *buf, int num, int verify
-#if OPENSSL_VERSION_NUMBER >= 0x00904100L
+#if HAVE_USERDATA_IN_PWD_CALLBACK
                            /* This was introduced in 0.9.4, we can set this
                               using SSL_CTX_set_default_passwd_cb_userdata()
                               */
-                           , void *userdata
+                           , void *global_passwd
 #endif
                            )
 {
   if(verify)
     fprintf(stderr, "%s\n", buf);
   else {
-    if(num > strlen(global_passwd)) {
+    if(num > (int)strlen((char *)global_passwd)) {
       strcpy(buf, global_passwd);
       return strlen(buf);
     }
@@ -68,7 +76,10 @@ static
 bool seed_enough(struct connectdata *conn, /* unused for now */
                  int nread)
 {
+  conn = NULL; /* to prevent compiler warnings */
 #ifdef HAVE_RAND_STATUS
+  nread = 0; /* to prevent compiler warnings */
+
   /* only available in OpenSSL 0.9.5a and later */
   if(RAND_status())
     return TRUE;
@@ -171,11 +182,18 @@ int cert_stuff(struct connectdata *conn,
     X509 *x509;
 
     if(data->cert_passwd) {
+#ifndef HAVE_USERDATA_IN_PWD_CALLBACK
       /*
        * If password has been given, we store that in the global
        * area (*shudder*) for a while:
        */
       strcpy(global_passwd, data->cert_passwd);
+#else
+      /*
+       * We set the password in the callback userdata
+       */
+      SSL_CTX_set_default_passwd_cb_userdata(conn->ssl.ctx, data->cert_passwd);
+#endif
       /* Set passwd callback: */
       SSL_CTX_set_default_passwd_cb(conn->ssl.ctx, passwd_callback);
     }
@@ -214,9 +232,10 @@ int cert_stuff(struct connectdata *conn,
       failf(data, "Private key does not match the certificate public key\n");
       return(0);
     }
-    
+#ifndef HAVE_USERDATA_IN_PWD_CALLBACK    
     /* erase it now */
     memset(global_passwd, 0, sizeof(global_passwd));
+#endif
   }
   return(1);
 }
@@ -230,7 +249,7 @@ int cert_verify_callback(int ok, X509_STORE_CTX *ctx)
   err_cert=X509_STORE_CTX_get_current_cert(ctx);
   X509_NAME_oneline(X509_get_subject_name(err_cert),buf,256);
 
-  return 1;
+  return ok;
 }
 
 #endif
@@ -259,10 +278,43 @@ void Curl_SSL_init(void)
 #endif
 }
 
+/*
+ * This function is called when an SSL connection is closed.
+ */
+void Curl_SSL_Close(struct connectdata *conn)
+{
+  if (conn->ssl.use) {
+    /*
+      ERR_remove_state() frees the error queue associated with
+      thread pid.  If pid == 0, the current thread will have its
+      error queue removed.
+
+      Since error queue data structures are allocated
+      automatically for new threads, they must be freed when
+      threads are terminated in oder to avoid memory leaks.
+    */
+    ERR_remove_state(0);
+
+    if(conn->ssl.handle) {
+      (void)SSL_shutdown(conn->ssl.handle);
+      SSL_set_connect_state(conn->ssl.handle);
+
+      SSL_free (conn->ssl.handle);
+      conn->ssl.handle = NULL;
+    }
+    if(conn->ssl.ctx) {
+      SSL_CTX_free (conn->ssl.ctx);
+      conn->ssl.ctx = NULL;
+    }
+    conn->ssl.use = FALSE; /* get back to ordinary socket usage */
+  }
+}
+
 /* Global cleanup */
 void Curl_SSL_cleanup(void)
 {
 #ifdef USE_SSLEAY
+  
   if(init_ssl) {
     /* only cleanup if we did a previous init */
 
@@ -276,6 +328,142 @@ void Curl_SSL_cleanup(void)
 #endif  
 }
 
+/*
+ * This sets up a session cache to the specified size.
+ */
+CURLcode Curl_SSL_InitSessions(struct UrlData *data, long amount)
+{
+  struct curl_ssl_session *session;
+
+  if(data->ssl.session)
+    /* this is just a precaution to prevent multiple inits */
+    return CURLE_OK;
+
+  session = (struct curl_ssl_session *)
+    malloc(amount * sizeof(struct curl_ssl_session));
+  if(!session)
+    return CURLE_OUT_OF_MEMORY;
+
+  /* "blank out" the newly allocated memory */
+  memset(session, 0, amount * sizeof(struct curl_ssl_session));
+
+  /* store the info in the SSL section */
+  data->ssl.numsessions = amount;
+  data->ssl.session = session;
+  data->ssl.sessionage = 1; /* this is brand new */
+
+  return CURLE_OK;
+}
+
+/*
+ * Check if there's a session ID for the given connection in the cache,
+ * and if there's one suitable, it is returned.
+ */
+static int Get_SSL_Session(struct connectdata *conn,
+                           SSL_SESSION **ssl_sessionid)
+{
+  struct curl_ssl_session *check;
+  struct UrlData *data = conn->data;
+  long i;
+
+  for(i=0; i< data->ssl.numsessions; i++) {
+    check = &data->ssl.session[i];
+    if(!check->sessionid)
+      /* not session ID means blank entry */
+      continue;
+    if(strequal(conn->name, check->name) &&
+       (conn->remote_port == check->remote_port) ) {
+      /* yes, we have a session ID! */
+      data->ssl.sessionage++;            /* increase general age */
+      check->age = data->ssl.sessionage; /* set this as used in this age */
+      *ssl_sessionid = check->sessionid;
+      return FALSE;
+    }
+  }
+  *ssl_sessionid = (SSL_SESSION *)NULL;
+  return TRUE;
+}
+
+/*
+ * Kill a single session ID entry in the cache.
+ */
+static int Kill_Single_Session(struct curl_ssl_session *session)
+{
+  if(session->sessionid) {
+    /* defensive check */
+
+    /* free the ID */
+    SSL_SESSION_free(session->sessionid);
+    session->sessionid=NULL;
+    session->age = 0; /* fresh */
+    free(session->name);
+    session->name = NULL; /* no name */
+
+    return 0; /* ok */
+  }
+  else
+    return 1;
+}
+
+/*
+ * This function is called when the 'data' struct is going away. Close
+ * down everything and free all resources!
+ */
+int Curl_SSL_Close_All(struct UrlData *data)
+{
+  int i;
+  for(i=0; i< data->ssl.numsessions; i++)
+    /* the single-killer function handles empty table slots */
+    Kill_Single_Session(&data->ssl.session[i]);
+
+  /* free the cache data */
+  free(data->ssl.session);
+
+  return 0;
+}
+
+/*
+ * Extract the session id and store it in the session cache.
+ */
+static int Store_SSL_Session(struct connectdata *conn)
+{
+  SSL_SESSION *ssl_sessionid;
+  struct curl_ssl_session *store;
+  int i;
+  struct UrlData *data=conn->data; /* the mother of all structs */
+  int oldest_age=data->ssl.session[0].age; /* zero if unused */
+
+  /* ask OpenSSL, say please */
+  ssl_sessionid = SSL_get1_session(conn->ssl.handle);
+
+  /* SSL_get1_session() will increment the reference
+     count and the session will stay in memory until explicitly freed with
+     SSL_SESSION_free(3), regardless of its state. */
+
+  /* Now we should add the session ID and the host name to the cache, (remove
+     the oldest if necessary) */
+
+  /* find an empty slot for us, or find the oldest */
+  for(i=0; (i<data->ssl.numsessions) && data->ssl.session[i].sessionid; i++) {
+    if(data->ssl.session[i].age < oldest_age) {
+      oldest_age = data->ssl.session[i].age;
+      store = &data->ssl.session[i];
+    }
+  }
+  if(i == data->ssl.numsessions)
+    /* cache is full, we must "kill" the oldest entry! */
+    Kill_Single_Session(store);
+  else
+    store = &data->ssl.session[i]; /* use this slot */
+  
+  /* now init the session struct wisely */
+  store->sessionid = ssl_sessionid;
+  store->age = data->ssl.sessionage;      /* set current age */
+  store->name = strdup(conn->name);       /* clone host name */
+  store->remote_port = conn->remote_port; /* port number */
+
+  return 0;
+}
 
 /* ====================================================== */
 CURLcode
@@ -288,6 +476,7 @@ Curl_SSLConnect(struct connectdata *conn)
   int err;
   char * str;
   SSL_METHOD *req_method;
+  SSL_SESSION *ssl_sessionid=NULL;
 
   /* mark this is being ssl enabled from here on out. */
   conn->ssl.use = TRUE;
@@ -316,7 +505,7 @@ Curl_SSLConnect(struct connectdata *conn)
     
   if(data->cert) {
     if (!cert_stuff(conn, data->cert, data->cert)) {
-      failf(data, "couldn't use certificate!\n");
+      /* failf() is already done in cert_stuff() */
       return CURLE_SSL_CONNECT_ERROR;
     }
   }
@@ -343,6 +532,17 @@ Curl_SSLConnect(struct connectdata *conn)
 
   conn->ssl.server_cert = 0x0;
 
+  if(!conn->bits.reuse) {
+    /* We're not re-using a connection, check if there's a cached ID we
+       can/should use here! */
+    if(!Get_SSL_Session(conn, &ssl_sessionid)) {
+      /* we got a session id, use it! */
+      SSL_set_session(conn->ssl.handle, ssl_sessionid);
+      /* Informational message */
+      infof (data, "SSL re-using session ID\n");
+    }
+  }
+
   /* pass the raw socket into the SSL layers */
   SSL_set_fd (conn->ssl.handle, conn->firstsocket);
   err = SSL_connect (conn->ssl.handle);
@@ -357,6 +557,13 @@ Curl_SSLConnect(struct connectdata *conn)
   infof (data, "SSL connection using %s\n",
          SSL_get_cipher(conn->ssl.handle));
 
+  if(!ssl_sessionid) {
+    /* Since this is not a cached session ID, then we want to stach this one
+       in the cache! */
+    Store_SSL_Session(conn);
+  }
+
+  
   /* Get server's certificate (note: beware of dynamic allocation) - opt */
   /* major serious hack alert -- we should check certificates
    * to authenticate the server; otherwise we risk man-in-the-middle
@@ -374,15 +581,39 @@ Curl_SSLConnect(struct connectdata *conn)
                            NULL, 0);
   if(!str) {
     failf(data, "SSL: couldn't get X509-subject!");
+    X509_free(conn->ssl.server_cert);
     return CURLE_SSL_CONNECT_ERROR;
   }
   infof(data, "\t subject: %s\n", str);
   CRYPTO_free(str);
 
+  if (data->ssl.verifyhost) {
+    char peer_CN[257];
+    if (X509_NAME_get_text_by_NID(X509_get_subject_name(conn->ssl.server_cert), NID_commonName, peer_CN, sizeof(peer_CN)) < 0) {
+      failf(data, "SSL: unable to obtain common name from peer certificate");
+      X509_free(conn->ssl.server_cert);
+      return CURLE_SSL_PEER_CERTIFICATE;
+    }
+
+    if (!strequal(peer_CN, conn->hostname)) {
+      if (data->ssl.verifyhost > 1) {
+        failf(data, "SSL: certificate subject name '%s' does not match target host name '%s'",
+            peer_CN, conn->hostname);
+        X509_free(conn->ssl.server_cert);
+        return CURLE_SSL_PEER_CERTIFICATE;
+      }
+      else
+        infof(data, "\t common name: %s (does not match '%s')\n", peer_CN, conn->hostname);
+    }
+    else
+      infof(data, "\t common name: %s (matched)\n", peer_CN);
+  }
+
   str = X509_NAME_oneline (X509_get_issuer_name  (conn->ssl.server_cert),
                            NULL, 0);
   if(!str) {
     failf(data, "SSL: couldn't get X509-issuer name!");
+    X509_free(conn->ssl.server_cert);
     return CURLE_SSL_CONNECT_ERROR;
   }
   infof(data, "\t issuer: %s\n", str);
@@ -393,10 +624,12 @@ Curl_SSLConnect(struct connectdata *conn)
 
   if(data->ssl.verifypeer) {
     data->ssl.certverifyresult=SSL_get_verify_result(conn->ssl.handle);
+    if (data->ssl.certverifyresult != X509_V_OK) {
       failf(data, "SSL certificate verify result: %d\n",
             data->ssl.certverifyresult);
       retcode = CURLE_SSL_PEER_CERTIFICATE;
     }
+  }
   else
     data->ssl.certverifyresult=0;
 

lib/ssluse.h

@@ -24,8 +24,14 @@
  *****************************************************************************/
 #include "urldata.h"
 CURLcode Curl_SSLConnect(struct connectdata *conn);
-/* Global SSL init */
+void Curl_SSL_init(void);    /* Global SSL init */
-void Curl_SSL_init(void);
+void Curl_SSL_cleanup(void); /* Global SSL cleanup */
-/* Global SSL cleanup */
+
-void Curl_SSL_cleanup(void);
+/* init the SSL session ID cache */
+CURLcode Curl_SSL_InitSessions(struct UrlData *, long);
+void Curl_SSL_Close(struct connectdata *conn); /* close a SSL connection */
+
+/* tell the SSL stuff to close down all open information regarding 
+   connections (and thus session ID caching etc) */
+int Curl_SSL_Close_All(struct UrlData *data);
 #endif

lib/strequal.c

@@ -28,11 +28,11 @@
 int curl_strequal(const char *first, const char *second)
 {
 #if defined(HAVE_STRCASECMP)
-  return !strcasecmp(first, second);
+  return !(strcasecmp)(first, second);
 #elif defined(HAVE_STRCMPI)
-  return !strcmpi(first, second);
+  return !(strcmpi)(first, second);
 #elif defined(HAVE_STRICMP)
-  return !stricmp(first, second);
+  return !(stricmp)(first, second);
 #else
   while (*first && *second) {
     if (toupper(*first) != toupper(*second)) {

lib/strtok.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -21,108 +21,47 @@
  * $Id$
  *****************************************************************************/
 
-
 #include "setup.h"
 
 #ifndef HAVE_STRTOK_R
-
-/*
- * Copyright (c) 1998 Softweyr LLC.  All rights reserved.
- *
- * strtok_r, from Berkeley strtok
- * Oct 13, 1998 by Wes Peters <wes@softweyr.com>
- *
- * Copyright (c) 1988, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notices, this list of conditions and the following disclaimer.
- * 
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notices, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *
- *	This product includes software developed by Softweyr LLC, the
- *      University of California, Berkeley, and its contributors.
- *
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY SOFTWEYR LLC, THE REGENTS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL SOFTWEYR LLC, THE
- * REGENTS, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
 #include <stddef.h>
+#include <string.h>
 
 char *
-Curl_strtok_r(char *s, const char *delim, char **last)
+Curl_strtok_r(char *ptr, const char *sep, char **end)
 {
-  char *spanp;
+  if (!ptr)
-  int c, sc;
+    /* we got NULL input so then we get our last position instead */
-  char *tok;
+    ptr = *end;
 
-  if (s == NULL && (s = *last) == NULL) {
+  /* pass all letters that are including in the separator string */
+  while (*ptr && strchr(sep, *ptr))
+    ++ptr;
+
+  if (*ptr) {
+    /* so this is where the next piece of string starts */
+    char *start = ptr;
+
+    /* set the end pointer to the first byte after the start */
+    *end = start + 1;
+
+    /* scan through the string to find where it ends, it ends on a
+       null byte or a character that exists in the separator string */
+    while (**end && !strchr(sep, **end))
+      ++*end;
+
+    if (**end) {
+      /* the end is not a null byte */
+      **end = '\0';  /* zero terminate it! */
+      ++*end;        /* advance the last pointer to beyond the null byte */
+    }
+
+    return start; /* return the position where the string starts */
+  }
+
+  /* we ended up on a null byte, there are no more strings to find! */
   return NULL;
-  }
-
-  /*
-   * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
-   */
- cont:
-  c = *s++;
-  for (spanp = (char *)delim; (sc = *spanp++) != 0; ) {
-    if (c == sc) {
-      goto cont;
-    }
-  }
-
-  if (c == 0) {		/* no non-delimiter characters */
-    *last = NULL;
-    return NULL;
-  }
-  tok = s - 1;
-  
-  /*
-   * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
-   * Note that delim must have one NUL; we stop if we see that, too.
-   */
-  for (;;) {
-    c = *s++;
-    spanp = (char *)delim;
-    do {
-      if ((sc = *spanp++) == c) {
-        if (c == 0) {
-          s = NULL;
-        }
-        else {
-          char *w = s - 1;
-          *w = '\0';
-        }
-        *last = s;
-        return tok;
-      }
-    }
-    while (sc != 0);
-  }
-  /* NOTREACHED */
 }
 
-#endif
+#endif /* this was only compiled if strtok_r wasn't present */
 

lib/telnet.c

@@ -218,8 +218,8 @@ static void negotiate(struct connectdata *conn)
 static void printoption(struct UrlData *data,
 			const char *direction, int cmd, int option)
 {
-  char *fmt;
+  const char *fmt;
-  char *opt;
+  const char *opt;
    
   if (data->bits.verbose)
   {
@@ -843,7 +843,7 @@ static void suboption(struct connectdata *conn)
       for(v = tn->telnet_vars;v;v = v->next) {
         tmplen = (strlen(v->data) + 1);
         /* Add the variable only if it fits */
-        if(len + tmplen < sizeof(temp)-6) {
+        if(len + tmplen < (int)sizeof(temp)-6) {
           sscanf(v->data, "%127[^,],%s", varname, varval);
           snprintf((char *)&temp[len], sizeof(temp) - len,
                    "%c%s%c%s", NEW_ENV_VAR, varname,

lib/transfer.c

@@ -90,6 +90,9 @@
 #include "progress.h"
 #include "getdate.h"
 #include "http.h"
+#include "url.h"
+#include "getinfo.h"
+#include "ssluse.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
@@ -111,8 +114,8 @@
  */
 static bool
 compareheader(char *headerline, /* line to check */
-              char *header,     /* header keyword _with_ colon */
+              const char *header,     /* header keyword _with_ colon */
-              char *content)    /* content string to find */
+              const char *content)    /* content string to find */
 {
   /* RFC2616, section 4.2 says: "Each header field consists of a name followed
    * by a colon (":") and the field value. Field names are case-insensitive.
@@ -172,7 +175,7 @@ compareheader(char *headerline, /* line to check */
  * <butlerm@xmission.com>.
  */
 
-CURLcode static
+static CURLcode
 Transfer(struct connectdata *c_conn)
 {
   ssize_t nread;                /* number of bytes read */
@@ -194,7 +197,10 @@ Transfer(struct connectdata *c_conn)
   int offset = 0;		/* possible resume offset read from the
                                    Content-Range: header */
   int httpcode = 0;		/* error code from the 'HTTP/1.? XXX' line */
-  int httpversion = -1;         /* the last digit in the HTTP/1.1 string */
+  int httpversion = -1;			/* the HTTP version*10 */
+  bool write_after_100_header = FALSE;  /* should we enable the write after
+                                           we received a 100-continue/timeout
+                                           or directly */
 
   /* for the low speed checks: */
   CURLcode urg;
@@ -261,9 +267,14 @@ Transfer(struct connectdata *c_conn)
 
     FD_ZERO (&writefd);		/* clear it */
     if(conn->writesockfd != -1) {
+      if (data->bits.expect100header)
+        /* wait with write until we either got 100-continue or a timeout */
+        write_after_100_header = TRUE;
+      else {
         FD_SET (conn->writesockfd, &writefd); /* write socket */
         keepon |= KEEP_WRITE;
       }
+    }
 
     /* get these in backup variables to be able to restore them on each lap in
        the select() loop */
@@ -288,6 +299,12 @@ Transfer(struct connectdata *c_conn)
           keepon = 0; /* no more read or write */
 	continue;
       case 0:			/* timeout */
+        if (write_after_100_header) {
+          write_after_100_header = FALSE;
+          FD_SET (conn->writesockfd, &writefd); /* write socket */
+          keepon |= KEEP_WRITE;
+          wkeepfd = writefd;
+        }
 	break;
       default:
         if((keepon & KEEP_READ) && FD_ISSET(conn->sockfd, &readfd)) {
@@ -302,6 +319,7 @@ Transfer(struct connectdata *c_conn)
              we bail out from this! */
           else if (0 >= (signed int) nread) {
             keepon &= ~KEEP_READ;
+            FD_ZERO(&rkeepfd);
             break;
           }
 
@@ -405,10 +423,29 @@ Transfer(struct connectdata *c_conn)
                    */
                   header = TRUE;
                   headerline = 0; /* we restart the header line counter */
+                  /* if we did wait for this do enable write now! */
+                  if (write_after_100_header) {
+                    write_after_100_header = FALSE;
+                    FD_SET (conn->writesockfd, &writefd); /* write socket */
+                    keepon |= KEEP_WRITE;
+                    wkeepfd = writefd;
+                  }
                 }
 		else
                   header = FALSE;	/* no more header to parse! */
 
+		if (417 == httpcode) {
+		  /*
+		   * we got: "417 Expectation Failed" this means:
+		   * we have made a HTTP call and our Expect Header
+		   * seems to cause a problem => abort the write operations
+		   * (or prevent them from starting
+		   */
+		  write_after_100_header = FALSE;
+		  keepon &= ~KEEP_WRITE;
+		  FD_ZERO(&wkeepfd);
+		}
+
                 /* now, only output this if the header AND body are requested:
                  */
                 writetype = CLIENTWRITE_HEADER;
@@ -464,8 +501,21 @@ Transfer(struct connectdata *c_conn)
               if (!headerline++) {
                 /* This is the first header, it MUST be the error code line
                    or else we consiser this to be the body right away! */
-                if (2 == sscanf (p, " HTTP/1.%d %3d", &httpversion,
+                int httpversion_major;
-                                 &httpcode)) {
+                int nc=sscanf (p, " HTTP/%d.%d %3d",
+                               &httpversion_major ,&httpversion, &httpcode);
+                if (nc==3) {
+                  httpversion+=10*httpversion_major;
+                }
+                else {
+                  /* this is the real world, not a Nirvana
+                     NCSA 1.5.x returns this crap when asked for HTTP/1.1
+                  */
+                  nc=sscanf (p, " HTTP %3d", &httpcode);
+                  httpversion = 10;
+                }
+
+                if (nc) {
                   data->progress.httpcode = httpcode;
                   data->progress.httpversion = httpversion;
 
@@ -484,7 +534,7 @@ Transfer(struct connectdata *c_conn)
                     return CURLE_HTTP_NOT_FOUND;
                   }
 
-                  if(httpversion == 0)
+                  if(httpversion == 10)
                     /* Default action for HTTP/1.0 must be to close, unless
                        we get one of those fancy headers that tell us the
                        server keeps it open for us! */
@@ -510,7 +560,7 @@ Transfer(struct connectdata *c_conn)
                 conn->size = contentlength;
                 Curl_pgrsSetDownloadSize(data, contentlength);
               }
-              else if((httpversion == 0) &&
+              else if((httpversion == 10) &&
                       conn->bits.httpproxy &&
                       compareheader(p, "Proxy-Connection:", "keep-alive")) {
                 /*
@@ -522,7 +572,7 @@ Transfer(struct connectdata *c_conn)
                 conn->bits.close = FALSE; /* don't close when done */
                 infof(data, "HTTP/1.0 proxy connection set to keep alive!\n");
               }
-              else if((httpversion == 0) &&
+              else if((httpversion == 10) &&
                       compareheader(p, "Connection:", "keep-alive")) {
                 /*
                  * A HTTP/1.0 reply with the 'Connection: keep-alive' line
@@ -711,6 +761,7 @@ Transfer(struct connectdata *c_conn)
               else if(CHUNKE_STOP == res) {
                 /* we're done reading chunks! */
                 keepon &= ~KEEP_READ; /* read no more */
+                FD_ZERO(&rkeepfd);
 
                 /* There are now possibly N number of bytes at the end of the
                    str buffer that weren't written to the client, but we don't
@@ -724,7 +775,9 @@ Transfer(struct connectdata *c_conn)
               nread = conn->maxdownload - bytecount;
               if((signed int)nread < 0 ) /* this should be unusual */
                 nread = 0;
+
               keepon &= ~KEEP_READ; /* we're done reading */
+              FD_ZERO(&rkeepfd);
             }
 
             bytecount += nread;
@@ -758,6 +811,7 @@ Transfer(struct connectdata *c_conn)
           if ((signed int)nread<=0) {
             /* done */
             keepon &= ~KEEP_WRITE; /* we're done writing */
+            FD_ZERO(&wkeepfd);
             break;
           }
           writebytecount += nread;
@@ -782,7 +836,7 @@ Transfer(struct connectdata *c_conn)
           urg = Curl_write(conn, conn->writesockfd, buf, nread,
                            &bytes_written);
 
-          if(nread != bytes_written) {
+          if(nread != (int)bytes_written) {
             failf(data, "Failed uploading data");
             return CURLE_WRITE_ERROR;
           }
@@ -844,10 +898,9 @@ Transfer(struct connectdata *c_conn)
   return CURLE_OK;
 }
 
-CURLcode Curl_perform(CURL *curl)
+CURLcode Curl_perform(struct UrlData *data)
 {
   CURLcode res;
-  struct UrlData *data = (struct UrlData *)curl;
   struct connectdata *conn=NULL;
   bool port=TRUE; /* allow data->use_port to set port to use */
   char *newurl = NULL; /* possibly a new URL to follow to! */
@@ -856,9 +909,18 @@ CURLcode Curl_perform(CURL *curl)
     /* we can't do anything wihout URL */
     return CURLE_URL_MALFORMAT;
 
+#ifdef USE_SSLEAY
+  /* Init the SSL session ID cache here. We do it here since we want to
+     do it after the *_setopt() calls (that could change the size) but
+     before any transfer. */
+  Curl_SSL_InitSessions(data, data->ssl.numsessions);
+#endif
+
   data->followlocation=0; /* reset the location-follow counter */
   data->bits.this_is_a_follow = FALSE; /* reset this */
 
+  Curl_initinfo(data); /* reset session-specific information "variables" */
+
   Curl_pgrsStartNow(data);
 
   do {
@@ -1041,10 +1103,8 @@ CURLcode Curl_perform(CURL *curl)
         case 303: /* See Other */
           /* Disable both types of POSTs, since doing a second POST when
            * following isn't what anyone would want! */
-          data->bits.http_post = FALSE;
+          data->httpreq = HTTPREQ_GET; /* enforce GET request */
-          data->bits.http_formpost = FALSE;
+          infof(data, "Disables POST, goes with GET\n");
-          data->httpreq = HTTPREQ_GET; /* enfore GET request */
-          infof(data, "Disables POST\n");
           break;
         case 304: /* Not Modified */
           /* 304 means we did a conditional request and it was "Not modified".

lib/transfer.h

@@ -22,7 +22,7 @@
  *
  * $Id$
  *****************************************************************************/
-CURLcode Curl_perform(CURL *curl);
+CURLcode Curl_perform(struct UrlData *data);
 
 /* This sets up a forthcoming transfer */
 CURLcode 

lib/url.c

@@ -67,6 +67,12 @@
 #include <sys/select.h>
 #endif
 
+#ifdef	VMS
+#include <in.h>
+#include <inet.h>
+#endif
+
+
 #ifndef HAVE_SELECT
 #error "We can't compile without select() support!"
 #endif
@@ -100,6 +106,7 @@
 #include "http.h"
 #include "file.h"
 #include "ldap.h"
+#include "url.h"
 
 #include <curl/types.h>
 
@@ -136,13 +143,16 @@ RETSIGTYPE alarmfunc(int signal)
 }
 #endif
 
-CURLcode Curl_close(CURL *curl)
+CURLcode Curl_close(struct UrlData *data)
 {
-  struct UrlData *data=(struct UrlData *)curl;
-  
   /* Loop through all open connections and kill them one by one */
   while(-1 != ConnectionKillOne(data));
 
+#ifdef USE_SSLEAY
+  /* Close down all open info open SSL and sessions */
+  Curl_SSL_Close_All(data);
+#endif
+
   if(data->bits.proxystringalloc) {
     data->bits.proxystringalloc=FALSE;;
     free(data->proxy);
@@ -168,6 +178,10 @@ CURLcode Curl_close(CURL *curl)
     /* the URL is allocated, free it! */
     free(data->url);
 
+  if(data->cookiejar)
+    /* we have a "destination" for all the cookies to get dumped to */
+    Curl_cookie_output(data->cookies, data->cookiejar);
+    
   Curl_cookie_cleanup(data->cookies);
 
   /* free the connection cache */
@@ -178,9 +192,11 @@ CURLcode Curl_close(CURL *curl)
 }
 
 static
-int my_getpass(void *clientp, char *prompt, char* buffer, int buflen )
+int my_getpass(void *clientp, const char *prompt, char* buffer, int buflen )
 {
   char *retbuf;
+  clientp=NULL; /* prevent compiler warning */
+
   retbuf = getpass_r(prompt, buffer, buflen);
   if(NULL == retbuf)
     return 1;
@@ -189,7 +205,7 @@ int my_getpass(void *clientp, char *prompt, char* buffer, int buflen )
 }
 
 
-CURLcode Curl_open(CURL **curl, char *url)
+CURLcode Curl_open(struct UrlData **curl)
 {
   /* We don't yet support specifying the URL at this point */
   struct UrlData *data;
@@ -235,6 +251,9 @@ CURLcode Curl_open(CURL **curl, char *url)
     data->bits.hide_progress = TRUE;  /* CURLOPT_NOPROGRESS changes these */
     data->progress.flags |= PGRS_HIDE;
 
+    /* Set the default size of the SSL session ID cache */
+    data->ssl.numsessions = 5;
+
     /* create an array with connection data struct pointers */
     data->numconnects = 5; /* hard-coded right now */
     data->connects = (struct connectdata **)
@@ -275,9 +294,8 @@ CURLcode Curl_open(CURL **curl, char *url)
   return CURLE_OUT_OF_MEMORY;
 }
 
-CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
+CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...)
 {
-  struct UrlData *data = curl;
   va_list param;
   char *cookiefile;
 
@@ -424,18 +442,21 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
      */
     data->bits.http_follow_location = va_arg(param, long)?TRUE:FALSE;
     break;
-  case CURLOPT_FTPASCII:
+  case CURLOPT_TRANSFERTEXT:
     /*
-     * Transfer FTP using ASCII instead of BINARY.
+     * This option was previously named 'FTPASCII'. Renamed to work with
+     * more protocols than merely FTP.
+     *
+     * Transfer using ASCII (instead of BINARY).
      */
     data->bits.ftp_ascii = va_arg(param, long)?TRUE:FALSE;
     break;
   case CURLOPT_PUT:
     /*
-     * Use the HTTP PUT request to transfer data.
+     * Use the HTTP PUT request to transfer data if this is TRUE.  If this is
+     * FALSE, don't set the httpreq. We can't know what to revert it to!
      */
-    data->bits.http_put = va_arg(param, long)?TRUE:FALSE;
+    if(va_arg(param, long))
-    if(data->bits.http_put)
       data->httpreq = HTTPREQ_PUT;
     break;
 #if 0
@@ -471,18 +492,24 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
 
   case CURLOPT_COOKIEFILE:
     /*
-     * Set cookie file to read and parse.
+     * Set cookie file to read and parse. Can be used multiple times.
      */
     cookiefile = (char *)va_arg(param, void *);
-    if(cookiefile) {
+    if(cookiefile)
-      data->cookies = Curl_cookie_init(cookiefile);
+      data->cookies = Curl_cookie_init(cookiefile, data->cookies);
-    }
+    break;
+
+  case CURLOPT_COOKIEJAR:
+    /*
+     * Set cookie file name to dump all cookies to when we're done.
+     */
+    data->cookiejar = cookiefile = (char *)va_arg(param, void *);
     break;
   case CURLOPT_WRITEHEADER:
     /*
-     * Callback function for header data
+     * Custom pointer to pass the header write callback function
      */
-    data->writeheader = (FILE *)va_arg(param, FILE *);
+    data->writeheader = (void *)va_arg(param, void *);
     break;
   case CURLOPT_COOKIE:
     /*
@@ -529,10 +556,18 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
      * Set to make us do HTTP POST
      */
     data->httppost = va_arg(param, struct HttpPost *);
-    data->bits.http_formpost = data->httppost?1:0;
+    if(data->httppost)
-    if(data->bits.http_formpost)
       data->httpreq = HTTPREQ_POST_FORM;
     break;
+
+  case CURLOPT_HTTPGET:
+    /*
+     * Set to force us do HTTP GET
+     */
+    if(va_arg(param, long))
+      data->httpreq = HTTPREQ_GET;
+    break;
+
   case CURLOPT_INFILE:
     /*
      * FILE pointer to read the file to be uploaded from. Or possibly
@@ -565,6 +600,11 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
     /*
      * The URL to fetch.
      */
+    if(data->bits.urlstringalloc) {
+      /* the already set URL is allocated, free it first! */
+      free(data->url);
+      data->bits.urlstringalloc=FALSE;
+    }
     data->url = va_arg(param, char *);
     break;
   case CURLOPT_PORT:
@@ -575,8 +615,8 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
     break;
   case CURLOPT_POST:
     /* Does this option serve a purpose anymore? */
-    data->bits.http_post = va_arg(param, long)?TRUE:FALSE;
+
-    if(data->bits.http_post)
+    if(va_arg(param, long))
       data->httpreq = HTTPREQ_POST;
     break;
   case CURLOPT_POSTFIELDS:
@@ -584,8 +624,7 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
      * A string with POST data. Makes curl HTTP POST.
      */
     data->postfields = va_arg(param, char *);
-    data->bits.http_post = data->postfields?TRUE:FALSE;
+    if(data->postfields)
-    if(data->bits.http_post)
       data->httpreq = HTTPREQ_POST;
     break;
   case CURLOPT_POSTFIELDSIZE:
@@ -612,6 +651,13 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
     /*
      * Set proxy server:port to use as HTTP proxy
      */
+    if(data->bits.proxystringalloc) {
+      /*
+       * The already set string is allocated, free that first
+       */
+      data->bits.proxystringalloc=FALSE;;
+      free(data->proxy);
+    }
     data->proxy = va_arg(param, char *);
     data->bits.httpproxy = data->proxy?1:0;
     break;
@@ -779,6 +825,12 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
      */
     data->ssl.verifypeer = va_arg(param, long);
     break;
+  case CURLOPT_SSL_VERIFYHOST:
+    /*
+     * Enable verification of the CN contained in the peer certificate
+     */
+    data->ssl.verifyhost = va_arg(param, long);
+    break;
   case CURLOPT_CAINFO:
     /*
      * Set CA info for SSL connection. Specify file name of the CA certificate
@@ -842,31 +894,7 @@ CURLcode Curl_disconnect(struct connectdata *conn)
     free(conn->path);
 
 #ifdef USE_SSLEAY
-  if (conn->ssl.use) {
+  Curl_SSL_Close(conn);
-    /*
-      ERR_remove_state() frees the error queue associated with
-      thread pid.  If pid == 0, the current thread will have its
-      error queue removed.
-
-      Since error queue data structures are allocated
-      automatically for new threads, they must be freed when
-      threads are terminated in oder to avoid memory leaks.
-    */
-    ERR_remove_state(0);
-
-    if(conn->ssl.handle) {
-      (void)SSL_shutdown(conn->ssl.handle);
-      SSL_set_connect_state(conn->ssl.handle);
-
-      SSL_free (conn->ssl.handle);
-      conn->ssl.handle = NULL;
-    }
-    if(conn->ssl.ctx) {
-      SSL_CTX_free (conn->ssl.ctx);
-      conn->ssl.ctx = NULL;
-    }
-    conn->ssl.use = FALSE; /* get back to ordinary socket usage */
-  }
 #endif /* USE_SSLEAY */
 
   /* close possibly still open sockets */
@@ -934,7 +962,7 @@ ConnectionExists(struct UrlData *data,
                  struct connectdata *needle,
                  struct connectdata **usethis)
 {
-  size_t i;
+  long i;
   struct connectdata *check;
 
   for(i=0; i< data->numconnects; i++) {
@@ -997,7 +1025,7 @@ ConnectionExists(struct UrlData *data,
 static int
 ConnectionKillOne(struct UrlData *data)
 {
-  size_t i;
+  long i;
   struct connectdata *conn;
   int highscore=-1;
   int connindex=-1;
@@ -1063,7 +1091,7 @@ static unsigned int
 ConnectionStore(struct UrlData *data,
                 struct connectdata *conn)
 {
-  size_t i;
+  long i;
   for(i=0; i< data->numconnects; i++) {
     if(!data->connects[i])
       break;
@@ -1422,12 +1450,34 @@ static CURLcode Connect(struct UrlData *data,
      * hostname other than "localhost" and "127.0.0.1", which is unique among
      * the URL protocols specified in RFC 1738
      */
+    if(conn->path[0] != '/') {
+      /* the URL included a host name, we ignore host names in file:// URLs
+         as the standards don't define what to do with them */
+      char *ptr=strchr(conn->path, '/');
+      if(ptr) {
+        /* there was a slash present
            
-    if (strnequal(conn->path, "localhost/", 10) ||
+           RFC1738 (section 3.1, page 5) says:
-        strnequal(conn->path, "127.0.0.1/", 10))
+ 
-      /* If there's another host name than the one we support, <host>/ is
+           The rest of the locator consists of data specific to the scheme,
-       * quietly ommitted */
+           and is known as the "url-path". It supplies the details of how the
-      strcpy(conn->path, &conn->path[10]);
+           specified resource can be accessed. Note that the "/" between the
+           host (or port) and the url-path is NOT part of the url-path.
+ 
+           As most agents use file://localhost/foo to get '/foo' although the
+           slash preceeding foo is a separator and not a slash for the path,
+           a URL as file://localhost//foo must be valid as well, to refer to
+           the same file with an absolute path.
+        */
+
+        if(ptr[1] && ('/' == ptr[1]))
+          /* if there was two slashes, we skip the first one as that is then
+             used truly as a separator */
+          ptr++; 
+        
+        strcpy(conn->path, ptr);
+      }
+    }
 
     strcpy(conn->protostr, "file"); /* store protocol string lowercase */
   }
@@ -1829,14 +1879,14 @@ static CURLcode Connect(struct UrlData *data,
     conn->port = (data->use_port && allow_port)?data->use_port:PORT_DICT;
     conn->remote_port = PORT_DICT;
     conn->curl_do = Curl_dict;
-    conn->curl_done = Curl_dict_done;
+    conn->curl_done = NULL; /* no DICT-specific done */
   }
   else if (strequal(conn->protostr, "LDAP")) {
     conn->protocol |= PROT_LDAP;
     conn->port = (data->use_port && allow_port)?data->use_port:PORT_LDAP;
     conn->remote_port = PORT_LDAP;
     conn->curl_do = Curl_ldap;
-    conn->curl_done = Curl_ldap_done;
+    conn->curl_done = NULL; /* no LDAP-specific done */
   }
   else if (strequal(conn->protostr, "FILE")) {
     conn->protocol |= PROT_FILE;
@@ -1948,14 +1998,17 @@ static CURLcode Connect(struct UrlData *data,
    * IPv6-specified addresses in the [0::1] style.
    *************************************************************/
 
-  if((1 == sscanf(conn->name, "[%*39[0-9a-fA-F:]%c", &endbracket)) &&
+  if((1 == sscanf(conn->name, "[%*39[0-9a-fA-F:.]%c", &endbracket)) &&
      (']' == endbracket)) {
     /* this is a IPv6-style specified IP-address */
 #ifndef ENABLE_IPV6
     failf(data, "You haven't enabled IPv6 support");
     return CURLE_URL_MALFORMAT;
 #else
+    conn->name++; /* pass the starting bracket */
+
     tmp = strchr(conn->name, ']');
+    *tmp = 0; /* zero terminate */
 
     tmp++; /* pass the ending bracket */
     if(':' != *tmp)
@@ -2080,6 +2133,12 @@ static CURLcode Connect(struct UrlData *data,
         conn->bits.use_range = TRUE;        /* enable range download */
         conn->bits.rangestringalloc = TRUE; /* mark range string allocated */
     }
+    else if (data->set_range) {
+      /* There is a range, but is not a resume, useful for random ftp access */
+      conn->range = strdup(data->set_range);
+      conn->bits.rangestringalloc = TRUE; /* mark range string allocated */
+      conn->bits.use_range = TRUE;        /* enable range download */
+    }
     
     *in_connect = conn;      /* return this instead! */
 

lib/url.h

@@ -23,6 +23,18 @@
  * $Id$
  *****************************************************************************/
 
-/* empty */
+/*
+ * Prototypes for library-wide functions provided by url.c
+ */
+
+CURLcode Curl_open(struct UrlData **curl);
+CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...);
+CURLcode Curl_close(struct UrlData *data); /* the opposite of curl_open() */
+CURLcode Curl_connect(struct UrlData *,
+                      struct connectdata **,
+                      bool allow_port);
+CURLcode Curl_do(struct connectdata *);
+CURLcode Curl_done(struct connectdata *);
+CURLcode Curl_disconnect(struct connectdata *);
 
 #endif

lib/urldata.h

@@ -125,14 +125,27 @@ struct ssl_connect_data {
 #endif /* USE_SSLEAY */
 };
 
+/* information about one single SSL session */
+struct curl_ssl_session {
+  char *name;       /* host name for which this ID was used */
+  void *sessionid;  /* as returned from the SSL layer */
+  long age;         /* just a number, the higher the more recent */
+  unsigned short remote_port; /* remote port to connect to */
+};
+
 struct ssl_config_data {
   long version;          /* what version the client wants to use */
   long certverifyresult; /* result from the certificate verification */
   long verifypeer;       /* set TRUE if this is desired */
+  long verifyhost;       /* 0: no verif, 1: check that CN exists, 2: CN must match hostname */
   char *CApath;          /* DOES NOT WORK ON WINDOWS */
   char *CAfile;          /* cerficate to verify peer against */
   char *random_file;     /* path to file containing "random" data */
   char *egdsocket;       /* path to file containing the EGD daemon socket */
+
+  struct curl_ssl_session *session; /* array of 'numsessions' size */
+  long numsessions;                 /* SSL session id cache size */
+  long sessionage;                  /* number of the most recent session */
 };
 
 /****************************************************************************
@@ -141,8 +154,8 @@ struct ssl_config_data {
 struct HTTP {
   struct FormData *sendit;
   int postsize;
-  char *p_pragma;      /* Pragma: string */
+  const char *p_pragma;      /* Pragma: string */
-  char *p_accept;      /* Accept: string */
+  const char *p_accept;      /* Accept: string */
   long readbytecount; 
   long writebytecount;
 
@@ -314,6 +327,9 @@ struct connectdata {
   int sec_complete;
   void *app_data;
 
+  struct Curl_sec_client_mech *mech;
+  struct sockaddr_in local_addr;
+
 #endif
 
   /*************** Request - specific items ************/
@@ -382,12 +398,6 @@ typedef enum {
 /* This struct is for boolean settings that define how to behave during
    this session. */
 struct Configbits {
-  /* these four request types mirror the httpreq field */
-  bool http_formpost;
-  bool http_post;
-  bool http_put;
-  bool http_get;
-
   bool get_filetime;
   bool tunnel_thru_httpproxy;
   bool ftp_append;
@@ -415,6 +425,8 @@ struct Configbits {
                             after use */
   bool reuse_fresh;      /* do not re-use an existing connection for this
                             transfer */
+  bool expect100header;  /* TRUE if we added Expect: 100-continue to the
+                            HTTP header */
 };
 
 /*
@@ -481,7 +493,7 @@ struct UrlData {
                         allocated */
   char *useragent;   /* User-Agent string */
   char *postfields; /* if POST, set the fields' values here */
-  long postfieldsize; /* if POST, this might have a size to use instead of
+  size_t postfieldsize; /* if POST, this might have a size to use instead of
                            strlen(), and then the data *may* be binary (contain
                            zero bytes) */
 
@@ -530,6 +542,7 @@ struct UrlData {
   char *cert_passwd; /* plain text certificate password */
 
   struct CookieInfo *cookies;
+  char *cookiejar; /* dump all cookies to this file */
 
   long crlf;
   struct curl_slist *quote;     /* before the transfer */
@@ -570,7 +583,7 @@ struct UrlData {
   /* 'connects' will be an allocated array with pointers. If the pointer is
      set, it holds an allocated connection. */
   struct connectdata **connects;
-  size_t numconnects; /* size of the 'connects' array */
+  long numconnects; /* size of the 'connects' array */
   curl_closepolicy closepolicy;
 
 };
@@ -578,26 +591,5 @@ struct UrlData {
 #define LIBCURL_NAME "libcurl"
 #define LIBCURL_ID LIBCURL_NAME " " LIBCURL_VERSION " " SSL_ID
 
-CURLcode Curl_getinfo(CURL *curl, CURLINFO info, ...);
-
-/*
- * Here follows function prototypes from what we used to plan to call
- * the "low level" interface. It is no longer prioritized and it is not likely
- * to ever be supported to external users.
- *
- * I removed all the comments to them as well, as they were no longer accurate
- * and they're not meant for "public use" anymore.
- */
-
-CURLcode Curl_open(CURL **curl, char *url);
-CURLcode Curl_setopt(CURL *handle, CURLoption option, ...);
-CURLcode Curl_close(CURL *curl); /* the opposite of curl_open() */
-CURLcode Curl_connect(struct UrlData *,
-                      struct connectdata **,
-                      bool allow_port);
-CURLcode Curl_do(struct connectdata *);
-CURLcode Curl_done(struct connectdata *);
-CURLcode Curl_disconnect(struct connectdata *);
-
 
 #endif

maketgz

@@ -76,6 +76,12 @@ else
   automake --include-deps Makefile
 fi
 
+############################################################################
+#
+# Make sure we have updated HTML versions of all man pages:
+#
+make html
+
 ############################################################################
 #
 # Now run make dist

missing

@@ -1,7 +1,7 @@
 #! /bin/sh
 # Common stub for a few missing GNU programs while installing.
-# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+# Copyright 1996, 1997, 1999, 2000 Free Software Foundation, Inc.
-# Franc,ois Pinard <pinard@iro.umontreal.ca>, 1996.
+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,11 +18,37 @@
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 # 02111-1307, USA.
 
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
 if test $# -eq 0; then
   echo 1>&2 "Try \`$0 --help' for more information"
   exit 1
 fi
 
+run=:
+
+# In the cases where this matters, `missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+  configure_ac=configure.ac
+else
+  configure_ac=configure.in
+fi
+
+case "$1" in
+--run)
+  # Try to run requested program, and just exit if it succeeds.
+  run=
+  shift
+  "$@" && exit 0
+  ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
 case "$1" in
 
   -h|--h|--he|--hel|--help)
@@ -35,6 +61,7 @@ error status if there is no known handling for PROGRAM.
 Options:
   -h, --help      display this help and exit
   -v, --version   output version information and exit
+  --run           try to run the given command, and emulate it if it fails
 
 Supported PROGRAM values:
   aclocal      touch file \`aclocal.m4'
@@ -43,13 +70,15 @@ Supported PROGRAM values:
   automake     touch all \`Makefile.in' files
   bison        create \`y.tab.[ch]', if possible, from existing .[ch]
   flex         create \`lex.yy.c', if possible, from existing .c
+  help2man     touch the output file
   lex          create \`lex.yy.c', if possible, from existing .c
   makeinfo     touch the output file
+  tar          try tar, gnutar, gtar, then tar without non-portable flags
   yacc         create \`y.tab.[ch]', if possible, from existing .[ch]"
     ;;
 
   -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
-    echo "missing - GNU libit 0.0"
+    echo "missing 0.3 - GNU automake"
     ;;
 
   -*)
@@ -61,7 +90,7 @@ Supported PROGRAM values:
   aclocal)
     echo 1>&2 "\
 WARNING: \`$1' is missing on your system.  You should only need it if
-         you modified \`acinclude.m4' or \`configure.in'.  You might want
+         you modified \`acinclude.m4' or \`${configure_ac}'.  You might want
          to install the \`Automake' and \`Perl' packages.  Grab them from
          any GNU archive site."
     touch aclocal.m4
@@ -70,7 +99,7 @@ WARNING: \`$1' is missing on your system.  You should only need it if
   autoconf)
     echo 1>&2 "\
 WARNING: \`$1' is missing on your system.  You should only need it if
-         you modified \`configure.in'.  You might want to install the
+         you modified \`${configure_ac}'.  You might want to install the
          \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
          archive site."
     touch configure
@@ -79,29 +108,31 @@ WARNING: \`$1' is missing on your system.  You should only need it if
   autoheader)
     echo 1>&2 "\
 WARNING: \`$1' is missing on your system.  You should only need it if
-         you modified \`acconfig.h' or \`configure.in'.  You might want
+         you modified \`acconfig.h' or \`${configure_ac}'.  You might want
          to install the \`Autoconf' and \`GNU m4' packages.  Grab them
          from any GNU archive site."
-    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER([^):]*:\([^)]*\)).*/\1/p' configure.in`
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
-    if test -z "$files"; then
+    test -z "$files" && files="config.h"
-      files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^):]*\)).*/\1/p' configure.in`
+    touch_files=
-      test -z "$files" || files="$files.in"
+    for f in $files; do
-    else
+      case "$f" in
-      files=`echo "$files" | sed -e 's/:/ /g'`
+      *:*) touch_files="$touch_files "`echo "$f" |
-    fi
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
-    test -z "$files" && files="config.h.in"
+      *) touch_files="$touch_files $f.in";;
-    touch $files
+      esac
+    done
+    touch $touch_files
     ;;
 
   automake)
     echo 1>&2 "\
 WARNING: \`$1' is missing on your system.  You should only need it if
-         you modified \`Makefile.am', \`acinclude.m4' or \`configure.in'.
+         you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
          You might want to install the \`Automake' and \`Perl' packages.
          Grab them from any GNU archive site."
-    find . -type f -name Makefile.am -print \
+    find . -type f -name Makefile.am -print |
-      | sed 's/^\(.*\).am$/touch \1.in/' \
+	   sed 's/\.am$/.in/' |
-      | sh
+	   while read f; do touch "$f"; done
     ;;
 
   bison|yacc)
@@ -157,7 +188,32 @@ WARNING: \`$1' is missing on your system.  You should only need it if
     fi
     ;;
 
+  help2man)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+	 you modified a dependency of a manual page.  You may need the
+	 \`Help2man' package in order for those modifications to take
+	 effect.  You can get \`Help2man' from any GNU archive site."
+
+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
+    if test -z "$file"; then
+	file=`echo "$*" | sed -n 's/.*--output=\([^ ]*\).*/\1/p'`
+    fi
+    if [ -f "$file" ]; then
+	touch $file
+    else
+	test -z "$file" || exec >$file
+	echo ".ab help2man is required to generate this page"
+	exit 1
+    fi
+    ;;
+
   makeinfo)
+    if test -z "$run" && (makeinfo --version) > /dev/null 2>&1; then
+       # We have makeinfo, but it failed.
+       exit 1
+    fi
+
     echo 1>&2 "\
 WARNING: \`$1' is missing on your system.  You should only need it if
          you modified a \`.texi' or \`.texinfo' file, or any other file
@@ -173,6 +229,45 @@ WARNING: \`$1' is missing on your system.  You should only need it if
     touch $file
     ;;
 
+  tar)
+    shift
+    if test -n "$run"; then
+      echo 1>&2 "ERROR: \`tar' requires --run"
+      exit 1
+    fi
+
+    # We have already tried tar in the generic part.
+    # Look for gnutar/gtar before invocation to avoid ugly error
+    # messages.
+    if (gnutar --version > /dev/null 2>&1); then
+       gnutar ${1+"$@"} && exit 0
+    fi
+    if (gtar --version > /dev/null 2>&1); then
+       gtar ${1+"$@"} && exit 0
+    fi
+    firstarg="$1"
+    if shift; then
+	case "$firstarg" in
+	*o*)
+	    firstarg=`echo "$firstarg" | sed s/o//`
+	    tar "$firstarg" ${1+"$@"} && exit 0
+	    ;;
+	esac
+	case "$firstarg" in
+	*h*)
+	    firstarg=`echo "$firstarg" | sed s/h//`
+	    tar "$firstarg" ${1+"$@"} && exit 0
+	    ;;
+	esac
+    fi
+
+    echo 1>&2 "\
+WARNING: I can't seem to be able to run \`tar' with the given arguments.
+         You may want to install GNU tar or Free paxutils, or check the
+         command line arguments."
+    exit 1
+    ;;
+
   *)
     echo 1>&2 "\
 WARNING: \`$1' is needed, and you do not seem to have it handy on your

src/Makefile.am

@@ -26,7 +26,7 @@ BUILT_SOURCES = hugehelp.c
 CLEANFILES = hugehelp.c
 NROFF=@NROFF@
 
-EXTRA_DIST = mkhelp.pl config-win32.h \
+EXTRA_DIST = mkhelp.pl config-win32.h curlmsg.msg\
 	Makefile.vc6 Makefile.b32 Makefile.m32 config.h.in
 
 AUTOMAKE_OPTIONS = foreign no-dependencies