7.8.1

configure fixes, libtool cleanups

CHANGES

@@ -6,6 +6,125 @@
 
                                History of Changes
 
+Daniel (20 August 2001)
+- Brad pointed out that we ship two extra libtool files in the tarballs that
+  we really don't need to! Removing them makes the gz-archive about 60K
+  smaller!
+
+- Albert Chin brought fixes for the configure script to detect socklen_t
+  properly as well as moving lots of our custom autoconf macros to
+  acinclude.m4.
+
+Daniel (19 August 2001)
+- Moonesamy improved his -G feature for host names only URLs...
+
+Daniel (17 August 2001)
+- Finally cleaned up the kerberos code to use Curl_ prefixes on all global
+  symbols and to not use global variables.
+
+Version 7.8.1-pre6
+
+Daniel (16 August 2001)
+- S. Moonesamy added the -G option to curl, that converts the data specified
+  with -d to a GET request. Default action when using -d is POST. When -G is
+  used, the -d specified data will be appended to the URL with a '?'
+  separator. As suggested previously by Kevin Roth.
+
+- curl-config --libs should now display all linker options required to link
+  with libcurl. It includes the path and options for libcurl itself.
+  curl-config --cflags displays the compiler option(s) needed to compile
+  source files that use libcurl functions. Basically, that sets the include
+  path correct.
+
+Daniel (15 August 2001)
+- Arkadiusz Miskiewicz pointed out a mistake in how IPv6-style IP-addresses
+  were parsed and used. (RFC2732-format)
+
+- Bug #12733 over on php.net identified a problem in libcurl that made it core
+  dump if you used CURLOPT_POST without setting any data to post with
+  CURLOPT_POSTFIELDS! This is no longer the case. Not using CURLOPT_POSTFIELDS
+  now equals setting it to no data at all.
+
+- Ramana Mokkapati reported that curl with '-w %{http_code}' didn't work
+  properly when used for multiple URLs on a single command line. Indeed, the
+  variable was not reset between the requests. This is now fixed.
+
+- David James fixed the Borland makefile so that libcurl still compiles and
+  builds with that compiler.
+
+Daniel (14 August 2001)
+- Oops. I ruined Nico's socklen_t define in config-vms.h, corrected it now.
+
+- An older item not mentioned here before: CURL_GLOBAL_WIN32 is a define for
+  windows users to curl_global_init(), that makes libcurl init the winsock
+  stuff. If libcurl is all socket stuff you do, then allowing it to fiddle
+  with this is a comfortable shortcut to fame.
+
+Version 7.8.1-pre5
+
+Daniel (14 August 2001)
+- Nico Baggus provided more feedback from his VMS porting efforts and a few
+  minor changes were necessary.
+
+- I modified configure.in so that --enable-debug sets more picky gcc options.
+  I then removed almost all the new warnings that appeared, and by doing so I
+  corrected the size_t-treated-as-signed problem that has been discussed on
+  the mailing list previously. I also removed a bunch of the just recently
+  added #ifdef VMS lines.
+
+- I removed the use of a global variable in the SSL code. It was once
+  necessary but hasn't been needed since OpenSSL 0.9.4. The old code should
+  (hopefully) still work if libcurl is built against an ancient version of
+  OpenSSL.
+
+Daniel (13 August 2001)
+- Peter Todd posted a patch that now allows non-file rc1867-style form posts
+  to be larger than 4K.
+
+Daniel (10 August 2001)
+- S. Moonesamy fixed bugs for building debug and SSL lib in VC makefile
+
+Daniel (9 August 2001)
+- The redirected error stream was closed before the curl_easy_cleanup() call
+  was made, and when VERBOSE was enabled, the cleanup function tried to use
+  the stream. It could lead to a segmentation fault. Also, the stream was
+  closed even if we looped to get more files.  Corrects Dustin Boswell's bug
+  report #441610
+
+- Now generates the release configure script with autoconf 2.52
+
+Version 7.8.1-pre4
+
+Daniel (8 August 2001)
+- curl -E uses a colon to separate a file name from a passphrase. This turned
+  out really bad for the windows people who wants to include a drive letter in
+  the file name like "c:\cert.pem". There's now a win32 work-around
+  implemented that tries work around that, when the colon seems to be used for
+  this kind of construct.
+
+- Patrick Bihan-Faou introduced CURLOPT_SSL_VERIFYHOST, which makes curl
+  verify the server's CN field when talking https://. If --cacert is not used,
+  any failures in matching is only displayed as information (-v).
+
+Daniel (7 August 2001)
+- Wrote up nine more test cases, more or less converted from the former test
+  suite.
+
+Daniel (6 August 2001)
+- Heikki Korpela posted a patch that makes 'curl-config --libs' include the
+  directory in which libcurl itself is installed in. While this wasn't my
+  initial intention with this option, it makes sense and makes linking with
+  libcurl easier.
+
+- Stefan Ulrich pointed out to us that other tools and libraries treat file://
+  URLs with only one slash after the host name slighly different than libcurl
+  does. Since all the others seem to agree, we better follow them.
+
+- Nico Baggus provided us with a huge set of fixes to make curl compile and
+  build under OpenVMS.
+
+Version 7.8.1-pre3
+
 Daniel (6 August 2001)
 - Jonathan Hseu noticed that you couldn't get a header callback unless you
   set CURLOPT_WRITEHEADER to non-NULL, even if you didn't care about that

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

@@ -4,10 +4,11 @@
 
 AUTOMAKE_OPTIONS = foreign no-dependencies
 
-EXTRA_DIST = \
-	CHANGES LEGAL maketgz MITX.txt MPL-1.1.txt \
-	config-win32.h reconf packages/README Makefile.dist \
-	curl-config.in libtool
+EXTRA_DIST =						\
+	CHANGES LEGAL maketgz MITX.txt MPL-1.1.txt	\
+	config-win32.h reconf Makefile.dist		\
+	curl-config.in build_vms.com config-riscos.h	\
+	config-vms.h
 
 bin_SCRIPTS = curl-config
 

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
+])

build_vms.com

@@ -0,0 +1,55 @@
+$!
+$	def = "sys_users:[nbaggus.curl]"
+$	set def 'def'
+$	cc_qual = "/define=HAVE_CONFIG_H=1/include=(""../include/"",""../"")"
+$	if p1 .eqs. "LISTING" then cc_qual = cc_qual + "/LIST/MACHINE"
+$	if p1 .eqs. "DEBUG" then cc_qual = cc_qual + "/LIST/MACHINE/DEBUG"
+$	msg_qual = ""
+$	call build "[.lib]" "*.c"
+$	call build "[.src]" "*.c"
+$	call build "[.src]" "*.msg"
+$	link /exe=curl.exe [.src]curl/lib/include=main,[.lib]curl/lib
+$
+$
+$	goto Exit
+$build:	subroutine
+$	set noon
+$	set default 'p1'
+$	search = p2
+$Loop:
+$	file = f$search(search,1)
+$	if file .eqs. "" then goto EndLoop
+$		obj = f$search(f$parse(".OBJ;",file),2)
+$		if (obj .nes. "") 
+$		then
+$			if (f$cvtime(f$file(file,"rdt")) .gts. f$cvtime(f$file(obj,"rdt")))
+$			then
+$				call compile 'file'
+$				lib/object curl.OLB 'f$parse(".obj;",file)'
+$			else
+$!				write sys$output "File: ''file' is up to date"
+$			endif
+$		else
+$!			write sys$output "Object for file: ''file' does not exist"
+$			call compile 'file'
+$			lib/object curl.OLB 'f$parse(".obj;",file)'
+$		endif
+$	goto Loop
+$EndLoop:
+$	purge
+$	set def 'def'
+$	endsubroutine	! Build
+$
+$compile:	subroutine
+$	set noon
+$	file = p1
+$	qual = p2+p3+p4+p5+p6+p7+p8
+$	typ = f$parse(file,,,"TYPE") - "."
+$	cmd_c = "CC "+cc_qual
+$	cmd_msg = "MESSAGE "+msg_qual
+$	x = cmd_'typ' 
+$	'x' 'file'
+$	ENDSUBROUTINE	! Compile
+$
+$Exit:
+$	exit

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
+

configure.in

@@ -58,298 +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 "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
-
-])
-
 dnl **********************************************************************
 dnl Checks for IPv6
 dnl **********************************************************************
@@ -782,26 +496,7 @@ AC_CHECK_SIZEOF(long long, 4)
 # check for ssize_t
 AC_CHECK_TYPE(ssize_t, int)
 
-dnl
-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
+TYPE_SOCKLEN_T
 
 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 7, 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
@@ -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

docs/INSTALL

@@ -6,12 +6,10 @@
 
                                 How To Compile
 
-Curl has been compiled and built on numerous different operating systems. The
-way to proceed is mainly divided in two different ways: the unix way or the 
-windows way.
+Curl has been compiled and built on numerous different operating systems.
 
-If you're using Windows (95/98/NT/ME/2000 or whatever) or OS/2, you should
-continue reading from the Win32 or OS/2 headers further down. All other
+If you're using Windows (95/98/NT/ME/2000 or whatever), VMS, RISC OS or OS/2,
+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
-   operating systems that curl has been compiled for:
+   This is a probably incomplete list of known hardware and operating systems
+   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/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

@@ -12,6 +12,16 @@ TODO
 
 To do in a future release (random order):
 
+ * Make the connect non-blocking so that timeouts work for connect in 
+   multi-threaded programs 
+
+ * Using FILE * in the libcurl API introduces a serious limitation since (at
+   least in the *nix falvours I know) you can fopen only the first 256
+   files. This means, that an application that first opens or fopens 256 files
+   has no chance to use libcurl. Using open and file descriptors instead of
+   FILE * would solve the problem. This implies a minor API
+   change/enhancement. ck1 <ck1@swissonline.ch>
+
  * It would be nice to be able to use "-d" (or something similar) to attach
    parameters of EITHER the GET or POST type... It would either require
    another curl argument to specify "GET" (obviously the default should remain

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
-debug option that serves no particular use to most people.
+Set of compiler options (CFLAGS) to use when compiling files that use
+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?
-
-  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?
+What 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 "3 Aug 2001" "Curl 7.8" "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.
@@ -233,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_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
-not do that for you. WSAStartup() and WSACleanup() should be used accordingly.
+On win32 systems, if you want to init the winsock stuff manually, libcurl will
+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 "20 August 2001" "libcurl 7.8.1" "libcurl Manual"
 .SH NAME
 curl_easy_setopt - Set curl easy-session options
 .SH SYNOPSIS
@@ -202,10 +202,12 @@ 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
-maky take a considerable time and that limiting the operation to less than a
-few minutes risk aborting perfectly normal operations. This option will cause
-curl to use the SIGALRM to enable timeouting system calls.
+the libcurl transfer operation to take. Normally, name lookups can take a
+considerable time and limiting operations to less than a few minutes risk
+aborting perfectly normal operations. This option will cause curl to use the
+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
@@ -498,6 +500,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_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
@@ -33,7 +33,7 @@ Initialize everything possible. This sets all known bits.
 Initialize SSL
 .TP
 .B CURL_GLOBAL_WIN32
-Initialize the Win32 socket libraries.
+Initialize the Win32 socket libraries. (added in libcurl 7.8.1)
 .TP
 .B CURL_GLOBAL_NOTHING
 Initialise nothing extra. This sets no bit.

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
@@ -101,7 +101,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

@@ -84,7 +84,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 +286,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),
@@ -448,6 +443,11 @@ typedef enum {
    */
   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),
+  
   CURLOPT_LASTENTRY /* the last unusued */
 } CURLoption;
 
@@ -488,7 +488,7 @@ 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);
@@ -506,10 +506,8 @@ CURLcode curl_global_init(long flags);
    that uses libcurl */
 void curl_global_cleanup(void);
 
-
-
 /* This is the version number */
-#define LIBCURL_VERSION "7.8.1-pre3"
+#define LIBCURL_VERSION "7.8.1"
 #define LIBCURL_VERSION_NUM 0x070801
 
 /* linked-list structure for the CURLOPT_QUOTE option (and other) */

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/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 \
@@ -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

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,4 +1,6 @@
 #############################################################
+# $Id: Makefile.am,v 1.20 2001/08/08 07:46:44 bagder Exp $
+#
 ## Makefile for building libcurl.lib with MSVC6
 ## Use: nmake -f makefile.vc6 [release | release-ssl | debug]
 ##      (default is release)
@@ -9,7 +11,7 @@
 
 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!
@@ -292,7 +294,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
@@ -354,7 +356,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

@@ -39,7 +39,7 @@
 /*
  * The telnet options represented as strings
  */
-static char *telnetoptions[]=
+static const char *telnetoptions[]=
 {
   "BINARY",      "ECHO",           "RCP",           "SUPPRESS GO AHEAD",
   "NAME",        "STATUS"          "TIMING MARK",   "RCTE",
@@ -78,7 +78,7 @@ static char *telnetoptions[]=
 /*
  * Then those numbers represented as strings:
  */
-static char *telnetcmds[]=
+static const char *telnetcmds[]=
 {
   "EOF",  "SUSP",  "ABORT", "EOR",  "SE",
   "NOP",  "DMARK", "BRK",   "IP",   "AO",

lib/base64.c

@@ -37,6 +37,10 @@
 #endif
 #include <stdlib.h>
 #include <string.h>
+
+#define _MPRINTF_REPLACE /* use our functions only */
+#include <curl/mprintf.h>
+
 #include "base64.h"
 
 #ifdef MALLOCDEBUG

lib/cookie.c

@@ -169,9 +169,9 @@ 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
-                about! */
+          /*
+            else this is the second (or more) name we don't know
+            about! */
         }
         else {
           /* this is an "illegal" <what>=<this> pair */
@@ -182,8 +182,9 @@ Curl_cookie_add(struct CookieInfo *c,
                   what)) {
           if(strequal("secure", what))
             co->secure = TRUE;
-          else
-            ; /* unsupported keyword without assign! */
+          /* else,
+             unsupported keyword without assign! */
+
         }
       }
       if(!semiptr)

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,6 +74,8 @@
 #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>
@@ -119,8 +121,9 @@ static CURLcode win32_init(void)
 }
 /* The Windows Sockets DLL is acceptable. Proceed. */ 
 #else
+/* These functions exist merely to prevent compiler warnings */
 static CURLcode win32_init(void) { return CURLE_OK; }
-#define win32_cleanup()
+static void win32_cleanup(void) { }
 #endif
 
 
@@ -179,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;
 
@@ -228,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

@@ -39,7 +39,7 @@
 
 char *curl_escape(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;
@@ -77,7 +77,7 @@ char *curl_escape(char *string, int length)
 
 char *curl_unescape(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/file.c

@@ -140,8 +140,8 @@ CURLcode Curl_file(struct connectdata *conn)
   */
   CURLcode res = CURLE_OK;
   struct stat statbuf;
-  size_t expected_size=-1;
-  size_t nread;
+  ssize_t expected_size=-1;
+  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

@@ -102,12 +102,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 +115,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 +161,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,10 +186,10 @@ int FormParse(char *input,
 	   * extensions and pick the first we match!
 	   */
 	  struct ContentType {
-	    char *extension;
-	    char *type;
+	    const char *extension;
+	    const char *type;
 	  };
-	  static struct ContentType ctts[]={
+          static struct ContentType ctts[]={
 	    {".gif",  "image/gif"},
 	    {".jpg",  "image/jpeg"},
 	    {".jpeg", "image/jpeg"},
@@ -223,7 +229,7 @@ int FormParse(char *input,
 	    GetStr(&post->contents, contp); /* get the contents */
 	    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 */
@@ -246,8 +252,8 @@ int FormParse(char *input,
 	     GetStr(&subpost->contents, contp); /* get the contents */
 	     subpost->flags = flags;
 	     if(type) {
-	       GetStr(&subpost->contenttype, type); /* get type */
-	       prevtype=subpost->contenttype; /* point to the allocated string! */
+	       GetStr(&subpost->contenttype, (char *)type); /* get type */
+	       prevtype=subpost->contenttype; /* point to allocated string! */
 	     }
 	     /* now, point our 'more' to the original 'more' */
 	     subpost->more = post->more;
@@ -287,8 +293,10 @@ int FormParse(char *input,
   }
   else {
     fprintf(stderr, "Illegally formatted input field!\n");
+    free(contents);
     return 1;
   }
+  free(contents);
   return 0;
 }
 
@@ -300,8 +308,8 @@ int curl_formparse(char *input,
 }
 
 static int AddFormData(struct FormData **formp,
-			void *line,
-			long length)
+                       const void *line,
+                       long length)
 {
   struct FormData *newform = (struct FormData *)
     malloc(sizeof(struct FormData));
@@ -328,7 +336,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 +375,8 @@ char *Curl_FormBoundary(void)
   return retstring;
 }
 
-/* Used from http.c */ 
-void Curl_FormFree(struct FormData *form)
+/* Used from http.c, this cleans a built FormData linked list */ 
+void Curl_formclean(struct FormData *form)
 {
   struct FormData *next;
 
@@ -501,7 +509,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,

lib/formdata.h

@@ -49,6 +49,6 @@ int Curl_FormReader(char *buffer,
 
 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");
@@ -249,7 +256,7 @@ 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 */
             }
 
@@ -257,11 +264,11 @@ int Curl_GetFTPResponse(int sockfd,
               /* 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++)
-                buf[i] = *moo;
-              moo[i]=0; /* zero terminate */
+              for(meow=line_start, i=0; meow<ptr; meow++, i++)
+                buf[i] = *meow;
+              meow[i]=0; /* zero terminate */
               keepon=FALSE;
               break;
             }
@@ -282,13 +289,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 +312,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 +392,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 +453,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 +528,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 +554,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);
@@ -689,37 +578,68 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
 
   /* Send any post-transfer QUOTE strings? */
   if(data->postquote) {
-    qitem = data->postquote;
-    /* 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",
-                qitem->data);
-          return CURLE_FTP_QUOTE_ERROR;
-        }
-      }
-      qitem = qitem->next;
-    }
+    CURLcode result = _ftp_sendquote(conn, data->postquote);
+    return result;
   }
 
   return CURLE_OK;
 }
 
 
+static 
+CURLcode _ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
+{
+  struct curl_slist *item;
+  ssize_t            nread;
+  int                ftpcode;
+
+  item = quote;
+  while (item) {
+    if (item->data) {
+      ftpsendf(conn->firstsocket, conn, "%s", item->data);
+
+      nread = Curl_GetFTPResponse(conn->firstsocket, 
+          conn->data->buffer, conn, &ftpcode);
+      if (nread < 0)
+        return CURLE_OPERATION_TIMEOUTED;
+
+      if (ftpcode >= 400) {
+        failf(conn->data, "QUOT string not accepted: %s", item->data);
+        return CURLE_FTP_QUOTE_ERROR;
+      }
+    }
+
+    item = item->next;
+  }
+
+  return CURLE_OK;
+}
+
+static 
+CURLcode _ftp_cwd(struct connectdata *conn, char *path)
+{
+  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) {
+    failf(conn->data, "Couldn't change back to directory %s", path);
+    return CURLE_FTP_ACCESS_DENIED;
+  }
+
+  return CURLE_OK;
+}
 
 static
 CURLcode _ftp(struct connectdata *conn)
 {
   /* this is FTP and no proxy */
-  size_t nread;
+  ssize_t nread;
   CURLcode result;
   struct UrlData *data=conn->data;
   char *buf = data->buffer; /* this is our buffer */
@@ -735,7 +655,6 @@ CURLcode _ftp(struct connectdata *conn)
   char hostent_buf[8192];
 #endif
 
-  struct curl_slist *qitem; /* QUOTE item */
   /* the ftp struct is already inited in ftp_connect() */
   struct FTP *ftp = conn->proto.ftp;
 
@@ -744,55 +663,23 @@ CURLcode _ftp(struct connectdata *conn)
 
   /* 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",
-                qitem->data);
-          return CURLE_FTP_QUOTE_ERROR;
-        }
-      }
-      qitem = qitem->next;
-    }
+    if ((result = _ftp_sendquote(conn, data->quote)) != CURLE_OK)
+      return result;
   }
-
-  if(conn->bits.reuse) {
-    /* 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: */
-    ftpsendf(conn->firstsocket, conn, "CWD %s", ftp->entrypath);
-    nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
     
-    if(ftpcode != 250) {
-      failf(data, "Couldn't change back to directory %s", ftp->entrypath);
-      return CURLE_FTP_ACCESS_DENIED;
-    }
+  /* 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]) {
-    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 ((result = _ftp_cwd(conn, ftp->dir)) != CURLE_OK)
+        return result;
   }
 
   if(data->bits.get_filetime && ftp->file) {
@@ -905,7 +792,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 +850,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,15 +930,14 @@ 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) {
 	failf(data, "Server does not grok %s", *modep);
 	continue;
       } else
-	      break;
-again:;
+        break;
     }
 
     if (!*modep) {
@@ -1081,7 +967,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 +1062,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;
@@ -1885,7 +1771,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/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,32 +168,30 @@ 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;
-      if(in->buffer)
-        /* we have a buffer, enlarge the existing one */
-        new_rb = (char *)realloc(in->buffer, new_size);
-      else
-        /* create a new buffer */
-        new_rb = (char *)malloc(new_size);
+  if(!in->buffer ||
+     ((in->size_used + size) > (in->size_max - 1))) {
+    new_size = (in->size_used+size)*2;
+    if(in->buffer)
+      /* we have a buffer, enlarge the existing one */
+      new_rb = (char *)realloc(in->buffer, new_size);
+    else
+      /* create a new buffer */
+      new_rb = (char *)malloc(new_size);
 
-      if(!new_rb)
-        return CURLE_OUT_OF_MEMORY;
+    if(!new_rb)
+      return CURLE_OUT_OF_MEMORY;
 
-      in->buffer = new_rb;
-      in->size_max = new_size;
-    }
-    memcpy(&in->buffer[in->size_used], inptr, size);
-      
-    in->size_used += size;
+    in->buffer = new_rb;
+    in->size_max = new_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);
@@ -364,7 +362,7 @@ CURLcode Curl_http_done(struct connectdata *conn)
   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 */
@@ -731,7 +729,7 @@ CURLcode Curl_http(struct connectdata *conn)
                           conn->firstsocket,
                         &http->writebytecount);
       if(result) {
-        Curl_FormFree(http->sendit); /* free that whole lot */
+        Curl_formclean(http->sendit); /* free that whole lot */
         return result;
       }
     }
@@ -766,6 +764,17 @@ CURLcode Curl_http(struct connectdata *conn)
       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,
-                              ssize_t *wrote)
+                              size_t length,
+                              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
- * last modified 2000-09-18
- */
-
-/*
+/* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
+ * 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 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 LOCAL_ADDR (&conn->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,9 +100,10 @@ size_t strlcpy (char *dst, const char *src, size_t dst_sz);
 static int
 krb4_check_prot(void *app_data, int level)
 {
-    if(level == prot_confidential)
-	return -1;
-    return 0;
+  app_data = NULL; /* prevent compiler warning */
+  if(level == prot_confidential)
+    return -1;
+  return 0;
 }
 
 static int
@@ -137,7 +133,11 @@ krb4_decode(void *app_data, void *buf, int len, int level,
 static int
 krb4_overhead(void *app_data, int level, int len)
 {
-    return 31;
+  /* no arguments are used, just init them to prevent compiler warnings */
+  app_data = NULL;
+  level = 0;
+  len = 0;
+  return 31;
 }
 
 static int
@@ -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;
@@ -274,113 +185,108 @@ mk_auth(struct krb4_data *d, KTEXT adat,
 static int
 krb4_auth(void *app_data, struct connectdata *conn)
 {
-    int ret;
-    char *p;
-    int len;
-    KTEXT_ST adat;
-    MSG_DAT msg_data;
-    int checksum;
-    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;
-    int l = sizeof(local_addr);
+  int ret;
+  char *p;
+  int len;
+  KTEXT_ST adat;
+  MSG_DAT msg_data;
+  int checksum;
+  u_int32_t cs;
+  struct krb4_data *d = app_data;
+  struct sockaddr_in *localaddr  = (struct sockaddr_in *)LOCAL_ADDR;
+  char *host = conn->hp->h_name;
+  ssize_t nread;
+  int l = sizeof(conn->local_addr);
 
-    if(getsockname(conn->firstsocket,
-                   (struct sockaddr *)LOCAL_ADDR, &l) < 0)
-	perror("getsockname()");
-
-    checksum = getpid();
-    ret = mk_auth(d, &adat, "ftp", host, checksum);
-    if(ret == KDC_PR_UNKNOWN)
-	ret = mk_auth(d, &adat, "rcmd", host, checksum);
-    if(ret){
-	printf("%s\n", krb_get_err_text(ret));
-	return AUTH_CONTINUE;
-    }
+  if(getsockname(conn->firstsocket,
+                 (struct sockaddr *)LOCAL_ADDR, &l) < 0)
+    perror("getsockname()");
 
+  checksum = getpid();
+  ret = mk_auth(d, &adat, "ftp", host, checksum);
+  if(ret == KDC_PR_UNKNOWN)
+    ret = mk_auth(d, &adat, "rcmd", host, checksum);
+  if(ret) {
+    printf("%s\n", krb_get_err_text(ret));
+    return AUTH_CONTINUE;
+  }
+  
 #ifdef HAVE_KRB_GET_OUR_IP_FOR_REALM
-    if (krb_get_config_bool("nat_in_use")) {
-      struct in_addr natAddr;
+  if (krb_get_config_bool("nat_in_use")) {
+    struct in_addr natAddr;
 
-      if (krb_get_our_ip_for_realm(krb_realmofhost(host),
-				   &natAddr) != KSUCCESS
-	  && krb_get_our_ip_for_realm(NULL, &natAddr) != KSUCCESS)
-	printf("Can't get address for realm %s\n",
-	       krb_realmofhost(host));
-      else {
-	if (natAddr.s_addr != localaddr->sin_addr.s_addr) {
-	  printf("Using NAT IP address (%s) for kerberos 4\n",
-		 (char *)inet_ntoa(natAddr));
-	  localaddr->sin_addr = natAddr;
-	  
-	  /*
-	   * This not the best place to do this, but it
-	   * is here we know that (probably) NAT is in
-	   * use!
-	   */
+    if (krb_get_our_ip_for_realm(krb_realmofhost(host),
+                                 &natAddr) != KSUCCESS
+        && krb_get_our_ip_for_realm(NULL, &natAddr) != KSUCCESS)
+      printf("Can't get address for realm %s\n",
+             krb_realmofhost(host));
+    else {
+      if (natAddr.s_addr != localaddr->sin_addr.s_addr) {
+        printf("Using NAT IP address (%s) for kerberos 4\n",
+               (char *)inet_ntoa(natAddr));
+        localaddr->sin_addr = natAddr;
+        
+        /*
+         * This not the best place to do this, but it is here we know that
+         * (probably) NAT is in use!  */
 
-	  /*passivemode = 1;***/
-	  /*printf("Setting: Passive mode on.\n");***/
-	}
+        /*passivemode = 1;***/
+        /*printf("Setting: Passive mode on.\n");***/
       }
     }
+  }
 #endif
 
-    /*printf("Local address is %s\n", inet_ntoa(localaddr->sin_addr));***/
-    /*printf("Remote address is %s\n", inet_ntoa(remoteaddr->sin_addr));***/
+  /*printf("Local address is %s\n", inet_ntoa(localaddr->sin_addr));***/
+  /*printf("Remote address is %s\n", inet_ntoa(remoteaddr->sin_addr));***/
 
-    if(Curl_base64_encode(adat.dat, adat.length, &p) < 0) {
-	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)
-	return /*CURLE_OPERATION_TIMEOUTED*/-1;
-    free(p);
+  if(Curl_base64_encode(adat.dat, adat.length, &p) < 0) {
+    printf("Out of memory base64-encoding.\n");
+    return AUTH_CONTINUE;
+  }
 
-    if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
-	printf("Server didn't accept auth data.\n");
-	return AUTH_ERROR;
-    }
+  Curl_ftpsendf(conn->firstsocket, conn, "ADAT %s", p);
 
-    p = strstr(/*reply_string*/conn->data->buffer, "ADAT=");
-    if(!p){
-	printf("Remote host didn't send adat reply.\n");
-	return AUTH_ERROR;
-    }
-    p += 5;
-    len = Curl_base64_decode(p, adat.dat);
-    if(len < 0){
-	printf("Failed to decode base64 from server.\n");
-	return AUTH_ERROR;
-    }
-    adat.length = len;
-    ret = krb_rd_safe(adat.dat, adat.length, &d->key, 
-		      (struct sockaddr_in *)hisctladdr, 
-		      (struct sockaddr_in *)myctladdr, &msg_data);
-    if(ret){
-	printf("Error reading reply from server: %s.\n", 
-	       krb_get_err_text(ret));
-	return AUTH_ERROR;
-    }
-    krb_get_int(msg_data.app_data, &cs, 4, 0);
-    if(cs - checksum != 1){
-	printf("Bad checksum returned from server.\n");
-	return AUTH_ERROR;
-    }
-    return AUTH_OK;
+  nread = Curl_GetFTPResponse(conn->firstsocket,
+                              conn->data->buffer, conn, NULL);
+  if(nread < 0)
+    return /*CURLE_OPERATION_TIMEOUTED*/-1;
+  free(p);
+
+  if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
+    printf("Server didn't accept auth data.\n");
+    return AUTH_ERROR;
+  }
+
+  p = strstr(conn->data->buffer, "ADAT=");
+  if(!p){
+    printf("Remote host didn't send adat reply.\n");
+    return AUTH_ERROR;
+  }
+  p += 5;
+  len = Curl_base64_decode(p, adat.dat);
+  if(len < 0){
+    printf("Failed to decode base64 from server.\n");
+    return AUTH_ERROR;
+  }
+  adat.length = len;
+  ret = krb_rd_safe(adat.dat, adat.length, &d->key, 
+                    (struct sockaddr_in *)hisctladdr, 
+                    (struct sockaddr_in *)myctladdr, &msg_data);
+  if(ret){
+    printf("Error reading reply from server: %s.\n", 
+           krb_get_err_text(ret));
+    return AUTH_ERROR;
+  }
+  krb_get_int(msg_data.app_data, &cs, 4, 0);
+  if(cs - checksum != 1){
+    printf("Bad checksum returned from server.\n");
+    return AUTH_ERROR;
+  }
+  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,109 +298,97 @@ struct sec_client_mech krb4_client_mech = {
     krb4_decode
 };
 
-#endif /* FTP_SERVER */
-
-void krb_kauth(struct connectdata *conn)
+void Curl_krb_kauth(struct connectdata *conn)
 {
-    des_cblock key;
-    des_key_schedule schedule;
-    KTEXT_ST tkt, tktcopy;
-    char *name;
-    char *p;
-    char passwd[100];
-    int tmp;
-    size_t nread;
+  des_cblock key;
+  des_key_schedule schedule;
+  KTEXT_ST tkt, tktcopy;
+  char *name;
+  char *p;
+  char passwd[100];
+  int tmp;
+  ssize_t nread;
 	
-    int save;
+  int save;
 
-    save = 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*/;
+  save = Curl_set_command_prot(conn, prot_private);
 
-    if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){
-	set_command_prot(conn, save);
-	/*code = -1;***/
-	return;
-    }
-    p = strstr(/*reply_string***/conn->data->buffer, "T=");
-    if(!p){
-	printf("Bad reply from server.\n");
-	set_command_prot(conn, save);
-	/*code = -1;***/
-	return;
-    }
-    p += 2;
-    tmp = Curl_base64_decode(p, &tkt.dat);
-    if(tmp < 0){
-	printf("Failed to decode base64 in reply.\n");
-	set_command_prot(conn, save);
-	/*code = -1;***/
-	return;
-    }
-    tkt.length = tmp;
-    tktcopy.length = tkt.length;
+  Curl_ftpsendf(conn->firstsocket, conn,
+                "SITE KAUTH %s", conn->data->user);
+
+  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'){
+    Curl_set_command_prot(conn, save);
+    /*code = -1;***/
+    return;
+  }
+
+  p = strstr(conn->data->buffer, "T=");
+  if(!p) {
+    printf("Bad reply from server.\n");
+    Curl_set_command_prot(conn, save);
+    return;
+  }
+
+  p += 2;
+  tmp = Curl_base64_decode(p, &tkt.dat);
+  if(tmp < 0) {
+    printf("Failed to decode base64 in reply.\n");
+    Curl_set_command_prot(conn, save);
+    return;
+  }
+  tkt.length = tmp;
+  tktcopy.length = tkt.length;
     
-    p = strstr(/*reply_string***/conn->data->buffer, "P=");
-    if(!p){
-	printf("Bad reply from server.\n");
-	set_command_prot(conn, save);
-	/*code = -1;***/
-	return;
-    }
-    name = p + 2;
-    for(; *p && *p != ' ' && *p != '\r' && *p != '\n'; p++);
-    *p = 0;
+  p = strstr(conn->data->buffer, "P=");
+  if(!p) {
+    printf("Bad reply from server.\n");
+    Curl_set_command_prot(conn, save);
+    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_string_to_key (conn->data->passwd, &key);
+  des_key_sched(&key, schedule);
     
+  des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
+                   tkt.length,
+                   schedule, &key, DES_DECRYPT);
+  if (strcmp ((char*)tktcopy.dat + 8,
+              KRB_TICKET_GRANTING_TICKET) != 0) {
+    afs_string_to_key (passwd,
+                       krb_realmofhost(/*hostname*/conn->hp->h_name),
+                       &key);
+    des_key_sched (&key, schedule);
     des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
-		     tkt.length,
-		     schedule, &key, DES_DECRYPT);
-    if (strcmp ((char*)tktcopy.dat + 8,
-		KRB_TICKET_GRANTING_TICKET) != 0) {
-        afs_string_to_key (passwd,
-			   krb_realmofhost(/*hostname***/conn->hp->h_name),
-			   &key);
-	des_key_sched (&key, schedule);
-	des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
-			 tkt.length,
-			 schedule, &key, DES_DECRYPT);
-    }
-    memset(key, 0, sizeof(key));
-    memset(schedule, 0, sizeof(schedule));
-    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);
-      /*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);
+                     tkt.length,
+                     schedule, &key, DES_DECRYPT);
+  }
+  memset(key, 0, sizeof(key));
+  memset(schedule, 0, sizeof(schedule));
+  memset(passwd, 0, sizeof(passwd));
+  if(Curl_base64_encode(tktcopy.dat, tktcopy.length, &p) < 0) {
+    failf(conn->data, "Out of memory base64-encoding.\n");
+    Curl_set_command_prot(conn, save);
+    return;
+  }
+  memset (tktcopy.dat, 0, tktcopy.length);
+
+  Curl_ftpsendf(conn->firstsocket, conn,
+                "SITE KAUTH %s %s", name, p);
+
+  nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer,
+                              conn, NULL);
+  if(nread < 0)
+    return /*CURLE_OPERATION_TIMEOUTED*/;
+  free(p);
+  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/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_dorealloc(void *ptr, size_t size, int line, char *source);
-void curl_dofree(void *ptr, int line, char *source);
-char *curl_dostrdup(const char *str, int line, char *source);
-void curl_memdebug(char *logname);
+void *curl_domalloc(size_t size, int line, const char *source);
+void *curl_dorealloc(void *ptr, size_t size, int line, const char *source);
+void curl_dofree(void *ptr, int line, const char *source);
+char *curl_dostrdup(const char *str, int line, const char *source);
+void curl_memdebug(const char *logname);
 
 /* file descriptor manipulators */
-int curl_socket(int domain, int type, int protocol, int, char *);
-int curl_sclose(int sockfd, int, char *);
+int curl_socket(int domain, int type, int protocol, int, const 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);
-int curl_fclose(FILE *file, int line, char *source);
+FILE *curl_fopen(const char *file, const char *mode, int line,
+                 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;
 	  }
 	}

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

@@ -225,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;

lib/security.c

@@ -1,9 +1,12 @@
-/* modified by Martin Hedenfalk <mhe@stacken.kth.se> for use in Curl
- * last modified 2000-09-18
- * Even more obscurified to merge better into libcurl by Daniel Stenberg.
- */
-
-/*
+/* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
+ * use in Curl. His latest changes were done 2000-09-18.
+ *
+ * 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,111 +75,78 @@ 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++)
-	if(!strncasecmp(level_names[i].name, name, strlen(name)))
-	    return level_names[i].level;
-    return (enum protection_level)-1;
+  int 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 sec_server_mech *mechs[] = {
+static struct Curl_sec_client_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);
 }
 
 static int
 block_read(int fd, void *buf, size_t len)
 {
-    unsigned char *p = buf;
-    int b;
-    while(len) {
-	b = read(fd, p, len);
-	if (b == 0)
-	    return 0;
-	else if (b < 0)
-	    return -1;
-	len -= b;
-	p += b;
-    }
-    return p - (unsigned char*)buf;
+  unsigned char *p = buf;
+  int b;
+  while(len) {
+    b = read(fd, p, len);
+    if (b == 0)
+      return 0;
+    else if (b < 0)
+      return -1;
+    len -= b;
+    p += b;
+  }
+  return p - (unsigned char*)buf;
 }
 
 static int
 block_write(int fd, void *buf, size_t len)
 {
-    unsigned char *p = buf;
-    int b;
-    while(len) {
-	b = write(fd, p, len);
-	if(b < 0)
-	    return -1;
-	len -= b;
-	p += b;
-    }
-    return p - (unsigned char*)buf;
+  unsigned char *p = buf;
+  int b;
+  while(len) {
+    b = write(fd, p, len);
+    if(b < 0)
+      return -1;
+    len -= b;
+    p += b;
+  }
+  return p - (unsigned char*)buf;
 }
 
 static int
 sec_get_data(struct connectdata *conn,
-             int fd, struct krb4buffer *buf, int level)
+             int fd, struct krb4buffer *buf)
 {
   int len;
   int b;
-
+  
   b = block_read(fd, &len, sizeof(len));
   if (b == 0)
     return 0;
@@ -190,8 +159,8 @@ sec_get_data(struct connectdata *conn,
     return 0;
   else if (b < 0)
     return -1;
-  buf->size = (*mech->decode)(conn->app_data, buf->data, len,
-                              conn->data_prot, conn);
+  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),
-                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,
+      Curl_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,9 +357,9 @@ 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),
-                          conn->command_prot, &enc,
-			  conn);
+    len = (conn->mech->encode)(conn->app_data, buf, strlen(buf),
+                               conn->command_prot, &enc,
+                               conn);
     free(buf);
     if(len < 0) {
 	failf(conn->data, "Failed to encode command.\n");
@@ -414,162 +369,87 @@ 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
-
-/* snip */
-
-#else /* FTP_SERVER */
-
-#if 0
-void
-sec_status(void)
-{
-    if(conn->sec_complete){
-	printf("Using %s for authentication.\n", mech->name);
-	printf("Using %s command channel.\n", level_to_name(command_prot));
-	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;
-
-    if(!conn->sec_complete){
-      infof(conn->data, "No security data exchange has taken place.\n");
-      return -1;
-    }
-
-    if(level){
-      Curl_ftpsendf(conn->firstsocket, conn,
-                    "PBSZ %u", s);
-      /* wait for feedback */
-      nread = Curl_GetFTPResponse(conn->firstsocket,
-                                  conn->data->buffer, conn, NULL);
-      if(nread < 0)
-        return /*CURLE_OPERATION_TIMEOUTED*/-1;
-      if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
-        failf(conn->data, "Failed to set protection buffer size.\n");
-        return -1;
-      }
-      conn->buffer_size = s;
-      p = strstr(/*reply_string*/conn->data->buffer, "PBSZ=");
-      if(p)
-        sscanf(p, "PBSZ=%u", &s);
-      if(s < conn->buffer_size)
-        conn->buffer_size = s;
-    }
-
-    Curl_ftpsendf(conn->firstsocket, conn,
-                  "PROT %c", level["CSEP"]);
-    /* wait for feedback */
-    nread = Curl_GetFTPResponse(conn->firstsocket,
-                                conn->data->buffer, conn, NULL);
-    if(nread < 0)
-      return /*CURLE_OPERATION_TIMEOUTED*/-1;
-    if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
-      failf(conn->data, "Failed to set protection level.\n");
-      return -1;
-    }
-    
-    conn->data_prot = (enum protection_level)level;
-    return 0;
-}
 
 enum protection_level
-set_command_prot(struct connectdata *conn, enum protection_level level)
+Curl_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)
+static int
+sec_prot_internal(struct connectdata *conn, int level)
 {
-    int level = -1;
+  char *p;
+  unsigned int s = 1048576;
+  ssize_t nread;
 
-    if(argc < 2 || argc > 3)
-	goto usage;
-    if(!sec_complete) {
-	printf("No security data exchange has taken place.\n");
-	code = -1;
-	return;
+  if(!conn->sec_complete){
+    infof(conn->data, "No security data exchange has taken place.\n");
+    return -1;
+  }
+
+  if(level){
+    Curl_ftpsendf(conn->firstsocket, conn,
+                  "PBSZ %u", s);
+    /* wait for feedback */
+    nread = Curl_GetFTPResponse(conn->firstsocket,
+                                conn->data->buffer, conn, NULL);
+    if(nread < 0)
+      return /*CURLE_OPERATION_TIMEOUTED*/-1;
+    if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
+      failf(conn->data, "Failed to set protection buffer size.\n");
+      return -1;
     }
-    level = name_to_level(argv[argc - 1]);
+    conn->buffer_size = s;
+    p = strstr(/*reply_string*/conn->data->buffer, "PBSZ=");
+    if(p)
+      sscanf(p, "PBSZ=%u", &s);
+    if(s < conn->buffer_size)
+      conn->buffer_size = s;
+  }
+
+  Curl_ftpsendf(conn->firstsocket, conn,
+                "PROT %c", level["CSEP"]);
+  /* wait for feedback */
+  nread = Curl_GetFTPResponse(conn->firstsocket,
+                              conn->data->buffer, conn, NULL);
+  if(nread < 0)
+    return /*CURLE_OPERATION_TIMEOUTED*/-1;
+  if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
+    failf(conn->data, "Failed to set protection level.\n");
+    return -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;
+  conn->data_prot = (enum protection_level)level;
+  return 0;
 }
-#endif
 
 void
-sec_set_protection_level(struct connectdata *conn)
+Curl_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,83 +467,82 @@ 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;
-    size_t nread;
-    struct UrlData *data=conn->data;
+  int ret;
+  struct Curl_sec_client_mech **m;
+  ssize_t nread;
+  struct UrlData *data=conn->data;
 
-    for(m = mechs; *m && (*m)->name; m++) {
-	void *tmp;
+  for(m = mechs; *m && (*m)->name; m++) {
+    void *tmp;
 
-	tmp = realloc(conn->app_data, (*m)->size);
-	if (tmp == NULL) {
-          failf (data, "realloc %u failed", (*m)->size);
-          return -1;
-	}
-	conn->app_data = tmp;
-	    
-	if((*m)->init && (*(*m)->init)(conn->app_data) != 0) {
-	    infof(data, "Skipping %s...\n", (*m)->name);
-	    continue;
-	}
-	infof(data, "Trying %s...\n", (*m)->name);
-	/*ret = command("AUTH %s", (*m)->name);***/
-	Curl_ftpsendf(conn->firstsocket, conn,
-                 "AUTH %s", (*m)->name);
-	/* wait for feedback */
-	nread = Curl_GetFTPResponse(conn->firstsocket,
-                                    conn->data->buffer, conn, NULL);
-	if(nread < 0)
-	    return /*CURLE_OPERATION_TIMEOUTED*/-1;
-	if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){
-	    if(/*code == 504*/strncmp(conn->data->buffer,"504",3) == 0) {
-		infof(data,
-                      "%s is not supported by the server.\n", (*m)->name);
-	    }
-            else if(/*code == 534*/strncmp(conn->data->buffer,"534",3) == 0) {
-              infof(data, "%s rejected as security mechanism.\n", (*m)->name);
-	    }
-            else if(/*ret == ERROR*/conn->data->buffer[0] == '5') {
-              infof(data, "The server doesn't support the FTP "
-                    "security extensions.\n");
-              return -1;
-	    }
-	    continue;
-	}
-
-	ret = (*(*m)->auth)(conn->app_data, /*host***/conn);
-	
-	if(ret == AUTH_CONTINUE)
-          continue;
-	else if(ret != AUTH_OK){
-          /* mechanism is supposed to output error string */
-	    return -1;
-	}
-	mech = *m;
-	conn->sec_complete = 1;
-	conn->command_prot = prot_safe;
-	break;
+    tmp = realloc(conn->app_data, (*m)->size);
+    if (tmp == NULL) {
+      failf (data, "realloc %u failed", (*m)->size);
+      return -1;
     }
+    conn->app_data = tmp;
+	    
+    if((*m)->init && (*(*m)->init)(conn->app_data) != 0) {
+      infof(data, "Skipping %s...\n", (*m)->name);
+      continue;
+    }
+    infof(data, "Trying %s...\n", (*m)->name);
+    /*ret = command("AUTH %s", (*m)->name);***/
+    Curl_ftpsendf(conn->firstsocket, conn,
+                  "AUTH %s", (*m)->name);
+    /* wait for feedback */
+    nread = Curl_GetFTPResponse(conn->firstsocket,
+                                conn->data->buffer, conn, NULL);
+    if(nread < 0)
+      return /*CURLE_OPERATION_TIMEOUTED*/-1;
+    if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){
+      if(/*code == 504*/strncmp(conn->data->buffer,"504",3) == 0) {
+        infof(data,
+              "%s is not supported by the server.\n", (*m)->name);
+      }
+      else if(/*code == 534*/strncmp(conn->data->buffer,"534",3) == 0) {
+        infof(data, "%s rejected as security mechanism.\n", (*m)->name);
+      }
+      else if(/*ret == ERROR*/conn->data->buffer[0] == '5') {
+        infof(data, "The server doesn't support the FTP "
+              "security extensions.\n");
+        return -1;
+      }
+      continue;
+    }
+
+    ret = (*(*m)->auth)(conn->app_data, /*host***/conn);
+	
+    if(ret == AUTH_CONTINUE)
+      continue;
+    else if(ret != AUTH_OK){
+      /* mechanism is supposed to output error string */
+      return -1;
+    }
+    conn->mech = *m;
+    conn->sec_complete = 1;
+    conn->command_prot = prot_safe;
+    break;
+  }
     
-    return *m == NULL;
+  return *m == NULL;
 }
 
 void
-sec_end(struct connectdata *conn)
+Curl_sec_end(struct connectdata *conn)
 {
-    if (mech != NULL) {
-	if(mech->end)
-	    (*mech->end)(conn->app_data);
-	memset(conn->app_data, 0, mech->size);
-	free(conn->app_data);
-	conn->app_data = NULL;
-    }
-    conn->sec_complete = 0;
-    conn->data_prot = (enum protection_level)0;
+  if (conn->mech != NULL) {
+    if(conn->mech->end)
+      (conn->mech->end)(conn->app_data);
+    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,134 +1,72 @@
-/* modified by Martin Hedenfalk <mhe@stacken.kth.se> for use in Curl
- * last modified 2000-09-18
- */
+#ifndef __SECURITY_H
+#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$
+ *****************************************************************************/
 
-/*
- * 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__
+/* this is a re-write */
 
 #include <stdarg.h>
 #include "urldata.h"  /* for struct connectdata * */
 
-struct sec_client_mech {
-    char *name;
-    size_t size;
-    int (*init)(void *);
-    int (*auth)(void *, struct connectdata *);
-    void (*end)(void *);
-    int (*check_prot)(void *, int);
-    int (*overhead)(void *, int, int);
-    int (*encode)(void *, void*, int, int, void**, struct connectdata *);
-    int (*decode)(void *, void*, int, int, struct connectdata *);
+struct Curl_sec_client_mech {
+  const char *name;
+  size_t size;
+  int (*init)(void *);
+  int (*auth)(void *, struct connectdata *);
+  void (*end)(void *);
+  int (*check_prot)(void *, int);
+  int (*overhead)(void *, int, int);
+  int (*encode)(void *, void*, int, int, void**, struct connectdata *);
+  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 sec_server_mech krb4_server_mech, gss_server_mech;
-#else
-extern struct sec_client_mech krb4_client_mech, gss_client_mech;
-#endif
+extern struct Curl_sec_client_mech Curl_krb4_client_mech;
 
-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
-extern char *ftp_command;
-void new_ftp_command(char*);
-void delete_ftp_command(void);
-#endif
+int Curl_sec_vfprintf(struct connectdata *, FILE *, const char *, va_list);
+int Curl_sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...);
+int Curl_sec_vfprintf2(struct connectdata *conn, FILE *, const char *, va_list);
+int Curl_sec_write (struct connectdata *conn, int, char *, int);
 
-/* ---- */
+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);
 
-
-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);
+enum protection_level Curl_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);
-      if((-1 != bytes_written) ||
+      ssl_bytes = SSL_write(conn->ssl.handle, mem, len);
+      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 */
@@ -274,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, ...);
-void Curl_infof(struct UrlData *, char *fmt, ...);
-void Curl_failf(struct UrlData *, char *fmt, ...);
+size_t Curl_sendf(int fd, struct connectdata *, const char *fmt, ...);
+void Curl_infof(struct UrlData *, const 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;
-  long size_used;
+  size_t size_max;
+  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,7 +85,11 @@ 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"

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);
 }
@@ -374,15 +393,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 (strcasecmp(peer_CN, conn->hostname) != 0) {
+      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,9 +436,11 @@ Curl_SSLConnect(struct connectdata *conn)
 
   if(data->ssl.verifypeer) {
     data->ssl.certverifyresult=SSL_get_verify_result(conn->ssl.handle);
-    failf(data, "SSL certificate verify result: %d\n",
-          data->ssl.certverifyresult);
-    retcode = CURLE_SSL_PEER_CERTIFICATE;
+    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/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;
-  char *opt;
+  const char *fmt;
+  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,8 @@
 #include "progress.h"
 #include "getdate.h"
 #include "http.h"
+#include "url.h"
+#include "getinfo.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
@@ -111,8 +113,8 @@
  */
 static bool
 compareheader(char *headerline, /* line to check */
-              char *header,     /* header keyword _with_ colon */
-              char *content)    /* content string to find */
+              const char *header,     /* header keyword _with_ colon */
+              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 +174,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 */
@@ -524,7 +526,7 @@ Transfer(struct connectdata *c_conn)
                 conn->size = contentlength;
                 Curl_pgrsSetDownloadSize(data, contentlength);
               }
-			  else if((httpversion == 10) &&
+              else if((httpversion == 10) &&
                       conn->bits.httpproxy &&
                       compareheader(p, "Proxy-Connection:", "keep-alive")) {
                 /*
@@ -536,7 +538,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 == 10) &&
+              else if((httpversion == 10) &&
                       compareheader(p, "Connection:", "keep-alive")) {
                 /*
                  * A HTTP/1.0 reply with the 'Connection: keep-alive' line
@@ -800,7 +802,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;
           }
@@ -862,10 +864,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! */
@@ -877,6 +878,8 @@ CURLcode Curl_perform(CURL *curl)
   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 {

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,10 +143,8 @@ 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));
 
@@ -178,9 +183,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 +196,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;
@@ -275,9 +282,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;
 
@@ -786,6 +792,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
@@ -941,7 +953,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++) {
@@ -1004,7 +1016,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;
@@ -1070,7 +1082,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;
@@ -1429,12 +1441,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
+           
+           RFC1738 (section 3.1, page 5) says:
+ 
+           The rest of the locator consists of data specific to the scheme,
+           and is known as the "url-path". It supplies the details of how the
+           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 (strnequal(conn->path, "localhost/", 10) ||
-        strnequal(conn->path, "127.0.0.1/", 10))
-      /* If there's another host name than the one we support, <host>/ is
-       * quietly ommitted */
-      strcpy(conn->path, &conn->path[10]);
+        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 */
   }
@@ -1836,14 +1870,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;
@@ -1955,14 +1989,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)

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

@@ -129,6 +129,7 @@ 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 */
@@ -141,8 +142,8 @@ struct ssl_config_data {
 struct HTTP {
   struct FormData *sendit;
   int postsize;
-  char *p_pragma;      /* Pragma: string */
-  char *p_accept;      /* Accept: string */
+  const char *p_pragma;      /* Pragma: string */
+  const char *p_accept;      /* Accept: string */
   long readbytecount; 
   long writebytecount;
 
@@ -314,6 +315,9 @@ struct connectdata {
   int sec_complete;
   void *app_data;
 
+  struct Curl_sec_client_mech *mech;
+  struct sockaddr_in local_addr;
+
 #endif
 
   /*************** Request - specific items ************/
@@ -475,9 +479,9 @@ 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
-                         strlen(), and then the data *may* be binary (contain
-                         zero bytes) */
+  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) */
 
   /* stuff related to FTP */
   char *ftpport; /* port to send with the PORT command */
@@ -564,7 +568,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;
 
 };
@@ -572,26 +576,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

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

src/Makefile.b32

@@ -1,4 +1,6 @@
 ############################################################
+# $Id$
+#
 #  Makefile.b32 - Borland's C++ Compiler 5.X
 #
 #  'src' directory

src/Makefile.m32

@@ -1,4 +1,6 @@
 #############################################################
+# $Id$
+#
 ## Makefile for building curl.exe with MingW32 (GCC-2.95) and
 ## optionally OpenSSL (0.9.6)
 ##

src/curlmsg.msg

@@ -0,0 +1,51 @@
+.TITLE		CURLMSG Message files
+.FACILITY	CURL,1793	/PREFIX=CURL_
+.SEVERITY	ERROR
+.BASE		1
+UNSUPPROTO		<Unsupported Protocol>				
+FAILINIT		<Failed Initialisation>				
+BADURLSYN		<Malformed URL Syntax>				
+BADURLUSER		<Malformed URL User-part>				
+BADPROXY		<Couldn't resolve proxy>			
+BADHOST			<Couldn't resolve host>				
+FAILHOST		<Couldn't connect to host>			
+FTPUNKREPLY		<FTP Unknown server reply>			
+FTPNOACC		<FTP Access denied>				
+FTPUSRPW		<FTP User/Password incorrect>			
+FTPBADPASS		<FTP unknown answer to PASS request>		
+FTPBADUSER		<FTP unknown answer to USER request>		
+FTPBADPASV		<FTP unknown answer to PASV request>		
+FTPBAD227		<FTP unknown 227 reply>				
+FTPBADHOST227		<FTP cannot resolve host from 227 reply>	
+FTPNORECONN		<FTP Unable to reconnect to 227 Host>		
+FTPNOBIN		<FTP Cannot select BINARY mode>			
+PARTIALFILE		<Only a part of the file was transferred>	
+FTPNORETR		<FTP Couldn't retrieve file>			
+FTPWRITERR		<FTP Server reported write problems>		
+FTPNOQUOTE		<FTP Quote command error>			
+HTTPPNF			<HTTP page not found>				
+WRITERR			<Local write error>				
+BADUSER			<Username badly specified>			
+FTPNOSTOR		<FTP STOR command failed>			
+READERR			<Local Read error>				
+OUTOFMEM		<Out of memory>					
+TIMEOUT			<Operation Timed out>				
+FTPNOASCII		<FTP Cannot select ASCII mode>			
+FTPNOPORT		<FTP PORT command failed>			
+FTPNOREST		<FTP REST command failed>			
+FTPNOSIZE		<FTP SIZE command failed>			
+HTTPRNGERR		<HTTP Range error>				
+HTTPPOSTERR		<HTTP Post error>				
+SSLNOCONN		<SSL Handshaking failed>			
+FTPBADRESUME		<FTP Download resume failed>			
+FILENOACC		<FILE couldn't open faile>			
+LDAPNOBIND		<LDAP Bind failed>				
+LDAPNOSRCH		<LDAP Search Failed>				
+LDAPNOLIB		<LDAP Library not found>			
+LDAPNOFUNC		<LDAP Function not found>			
+ABORTCB			<Callback aborted operation>			
+BADPARAM		<Internal Error, Bad parameter to function>	
+BADORDER		<Internal Error, Bad function calling order>	
+BADPWD			<Bad password entered>				
+MNYREDIR		<Too many redirects>				
+.END

src/main.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.
@@ -124,6 +124,115 @@ char *strdup(char *str)
 }
 #endif 
 
+#ifdef	VMS
+int	vms_show = 0;
+#define	FAC_CURL	0xC01
+#define	FAC_SYSTEM	0
+#define	MSG_NORMAL	0
+#define	VMS_STS(c,f,e,s) (((c&0xF)<<28)|((f&0xFFF)<<16)|((e&0x1FFF)<3)|(s&7))
+#define	VMSSTS_HIDE	VMS_STS(1,0,0,0)
+#define	SEV_WARNING	0
+#define	SEV_SUCCESS	1
+#define	SEV_ERROR	2
+#define	SEV_INFO	3	/* success, with an extra hint */
+#define	SEV_FATAL	4
+globalvalue int  CURL_UNSUPPROTO;		/* these are from curlmsg.msg file..... */
+globalvalue int  CURL_FAILINIT;
+globalvalue int  CURL_BADURLSYN;
+globalvalue int  CURL_BADURLUSER;
+globalvalue int  CURL_BADPROXY;
+globalvalue int  CURL_BADHOST;
+globalvalue int  CURL_FAILHOST;
+globalvalue int  CURL_FTPUNKREPLY;
+globalvalue int  CURL_FTPNOACC;
+globalvalue int  CURL_FTPUSRPW;
+globalvalue int  CURL_FTPBADPASS;
+globalvalue int  CURL_FTPBADUSER;
+globalvalue int  CURL_FTPBADPASV;
+globalvalue int  CURL_FTPBAD227;
+globalvalue int  CURL_FTPBADHOST227;
+globalvalue int  CURL_FTPNORECONN;
+globalvalue int  CURL_FTPNOBIN;
+globalvalue int  CURL_PARTIALFILE;
+globalvalue int  CURL_FTPNORETR;
+globalvalue int  CURL_FTPWRITERR;
+globalvalue int  CURL_FTPNOQUOTE;
+globalvalue int  CURL_HTTPPNF;
+globalvalue int  CURL_WRITERR;
+globalvalue int  CURL_BADUSER;
+globalvalue int  CURL_FTPNOSTOR;
+globalvalue int  CURL_READERR;
+globalvalue int  CURL_OUTOFMEM;
+globalvalue int  CURL_TIMEOUT;
+globalvalue int  CURL_FTPNOASCII;
+globalvalue int  CURL_FTPNOPORT;
+globalvalue int  CURL_FTPNOREST;
+globalvalue int  CURL_FTPNOSIZE;
+globalvalue int  CURL_HTTPRNGERR;
+globalvalue int  CURL_HTTPPOSTERR;
+globalvalue int  CURL_SSLNOCONN;
+globalvalue int  CURL_FTPBADRESUME;
+globalvalue int  CURL_FILENOACC;
+globalvalue int  CURL_LDAPNOBIND;
+globalvalue int  CURL_LDAPNOSRCH;
+globalvalue int  CURL_LDAPNOLIB;
+globalvalue int  CURL_LDAPNOFUNC;
+globalvalue int  CURL_ABORTCB;
+globalvalue int  CURL_BADPARAM;
+globalvalue int  CURL_BADORDER;
+globalvalue int  CURL_BADPWD;
+globalvalue int  CURL_MNYREDIR;
+long	vms_cond[] = {
+	VMS_STS(1,FAC_SYSTEM,MSG_NORMAL,SEV_SUCCESS),
+	CURL_UNSUPPROTO,		/* these are from curlmsg.msg file..... */
+	CURL_FAILINIT,
+	CURL_BADURLSYN,
+	CURL_BADURLUSER,
+	CURL_BADPROXY,
+	CURL_BADHOST,
+	CURL_FAILHOST,
+	CURL_FTPUNKREPLY,
+	CURL_FTPNOACC,
+	CURL_FTPUSRPW,
+	CURL_FTPBADPASS,
+	CURL_FTPBADUSER,
+	CURL_FTPBADPASV,
+	CURL_FTPBAD227,
+	CURL_FTPBADHOST227,
+	CURL_FTPNORECONN,
+	CURL_FTPNOBIN,
+	CURL_PARTIALFILE,
+	CURL_FTPNORETR,
+	CURL_FTPWRITERR,
+	CURL_FTPNOQUOTE,
+	CURL_HTTPPNF,
+	CURL_WRITERR,
+	CURL_BADUSER,
+	CURL_FTPNOSTOR,
+	CURL_READERR,
+	CURL_OUTOFMEM,
+	CURL_TIMEOUT,
+	CURL_FTPNOASCII,
+	CURL_FTPNOPORT,
+	CURL_FTPNOREST,
+	CURL_FTPNOSIZE,
+	CURL_HTTPRNGERR,
+	CURL_HTTPPOSTERR,
+	CURL_SSLNOCONN,
+	CURL_FTPBADRESUME,
+	CURL_FILENOACC,
+	CURL_LDAPNOBIND,
+	CURL_LDAPNOSRCH,
+	CURL_LDAPNOLIB,
+	CURL_LDAPNOFUNC,
+	CURL_ABORTCB,
+	CURL_BADPARAM,
+	CURL_BADORDER,
+	CURL_BADPWD,
+	CURL_MNYREDIR
+};
+#endif
+
 extern void hugehelp(void);
 
 /*
@@ -156,7 +265,7 @@ int SetHTTPrequest(HttpReq req, HttpReq *store)
   return 1;
 }
 
-static void helpf(char *fmt, ...)
+static void helpf(const char *fmt, ...)
 {
   va_list ap;
   if(fmt) {
@@ -205,9 +314,10 @@ static void help(void)
        " -f/--fail          Fail silently (no output at all) on errors (H)\n"
        " -F/--form <name=content> Specify HTTP POST data (H)\n"
        " -g/--globoff       Disable URL sequences and ranges using {} and []\n"
-       " -h/--help          This help text\n"
-       " -H/--header <line> Custom header to pass to server. (H)");
-  puts(" -i/--include       Include the HTTP-header in the output (H)\n"
+       " -G/--get           Send the -d data with a HTTP GET (H)\n");
+  puts(" -h/--help          This help text\n"
+       " -H/--header <line> Custom header to pass to server. (H)"
+       " -i/--include       Include the HTTP-header in the output (H)\n"
        " -I/--head          Fetch document info only (HTTP HEAD/FTP SIZE)\n"
        "    --interface <interface> Specify the interface to be used\n"
        "    --krb4 <level>  Enable krb4 with specified security level (F)\n"
@@ -250,8 +360,8 @@ static void help(void)
 }
 
 struct LongShort {
-  char *letter;
-  char *lname;
+  const char *letter;
+  const char *lname;
   bool extraparam;
 };
 
@@ -301,6 +411,7 @@ struct Configurable {
   bool progressmode;
   bool nobuffer;
   bool globoff;
+  bool use_httpget;
 
   char *writeout; /* %-styled format string to output */
 
@@ -460,9 +571,9 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
   char letter;
   char subletter=0; /* subletters can only occur on long options */
 
-  char *parse=NULL;
+  const char *parse=NULL;
   int res;
-  int j;
+  unsigned int j;
   time_t now;
   int hit=-1;
   bool longopt=FALSE;
@@ -488,7 +599,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
     {"a", "append",      FALSE},
     {"A", "user-agent",  TRUE},
     {"b", "cookie",      TRUE},
-    {"B", "ftp-ascii",   FALSE}, /* this long format is OBSOLETEE now! */
+    {"B", "ftp-ascii",   FALSE}, /* this long format is OBSOLETE now! */
     {"B", "use-ascii",   FALSE},
     {"c", "continue",    FALSE},
     {"C", "continue-at", TRUE},
@@ -502,6 +613,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
     {"f", "fail",        FALSE},
     {"F", "form",        TRUE},
     {"g", "globoff",     FALSE},
+    {"G", "get",         FALSE},
     {"h", "help",        FALSE},
     {"H", "header",      TRUE},
     {"i", "include",     FALSE},
@@ -602,7 +714,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
       return PARAM_OPTION_UNKNOWN;
     }    
     if(!longopt && aliases[hit].extraparam && parse[1]) {
-      nextarg=&parse[1]; /* this is the actual extra parameter */
+      nextarg=(char *)&parse[1]; /* this is the actual extra parameter */
       singleopt=TRUE;   /* don't loop anymore after this */
     }
     else if((!nextarg || !*nextarg) && aliases[hit].extraparam) {
@@ -760,8 +872,8 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
           config->postfields=postdata;
       }
 
-      if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq))
-        return PARAM_BAD_USE;
+/*      if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq))
+        return PARAM_BAD_USE;*/
       break;
     case 'D':
       /* dump-header to given file name */
@@ -786,7 +898,23 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
       }
       else {
 	char *ptr = strchr(nextarg, ':');
-	if(ptr) {
+        /* Since we live in a world of weirdness and confusion, the win32
+           dudes can use : when using drive letters and thus
+           c:\file:password needs to work. In order not to break
+           compatibility, we still use : as separator, but we try to detect
+           when it is used for a file name! On windows. */
+#ifdef WIN32
+        if(ptr &&
+           (ptr == &nextarg[1]) &&
+           (nextarg[2] == '\\') &&
+           (isalpha((int)nextarg[0])) )
+          /* colon in the second column, followed by a backslash, and the
+             first character is an alphabetic letter:
+
+             this is a drive letter colon */
+          ptr = strchr(&nextarg[3], ':'); /* find the next one instead */
+#endif
+        if(ptr) {
 	  /* we have a password too */
 	  *ptr=0;
 	  ptr++;
@@ -814,6 +942,10 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
       config->globoff ^= TRUE;
       break;
 
+    case 'G': /* HTTP GET */
+      config->use_httpget = TRUE;
+      break;
+
     case 'h': /* h for help */
       help();
       return PARAM_HELP_REQUESTED;
@@ -1017,7 +1149,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
       }
       now=time(NULL);
       config->condtime=curl_getdate(nextarg, &now);
-      if(-1 == config->condtime) {
+      if(-1 == (int)config->condtime) {
         /* now let's see if it is a file name to get the time from instead! */
         struct stat statbuf;
         if(-1 == stat(nextarg, &statbuf)) {
@@ -1061,7 +1193,6 @@ static int parseconfig(char *filename,
 #define CURLRC DOT_CHAR "curlrc"
 
     home = curl_getenv("HOME"); /* portable environment reader */
-
     if(!home)
       return 0;
     if(strlen(home)>(sizeof(filebuffer)-strlen(CURLRC))) {
@@ -1183,10 +1314,10 @@ static int parseconfig(char *filename,
       if(res != PARAM_OK) {
         /* the help request isn't really an error */
         if(!strcmp(filename, "-")) {
-          filename="<stdin>";
+          filename=(char *)"<stdin>";
         }
         if(PARAM_HELP_REQUESTED != res) {
-          char *reason;
+          const char *reason;
           switch(res) {
           default:
           case PARAM_GOT_EXTRA_PARAMETER:
@@ -1414,6 +1545,8 @@ operate(struct Configurable *config, int argc, char *argv[])
 
   bool allocuseragent=FALSE;
 
+  char *httpgetfields=NULL;
+
   CURL *curl;
   int res;
   int i;
@@ -1427,6 +1560,7 @@ operate(struct Configurable *config, int argc, char *argv[])
 
   config->showerror=TRUE;
   config->conf=CONF_DEFAULT;
+  config->use_httpget=FALSE;
 
   if(argc>1 &&
      (!strnequal("--", argv[1], 2) && (argv[1][0] == '-')) &&
@@ -1495,7 +1629,7 @@ operate(struct Configurable *config, int argc, char *argv[])
     else {
       bool used;
       /* just add the URL please */
-      res = getparameter("--url", argv[i], &used, config);
+      res = getparameter((char *)"--url", argv[i], &used, config);
       if(res)
         return res;
     }
@@ -1514,6 +1648,23 @@ operate(struct Configurable *config, int argc, char *argv[])
   else
     allocuseragent = TRUE;
 
+  if (config->postfields) {
+    if (config->use_httpget) {
+      /* Use the postfields data for a http get */
+      httpgetfields = strdup(config->postfields);
+      free(config->postfields);
+      config->postfields = NULL;
+      if(SetHTTPrequest(HTTPREQ_GET, &config->httpreq)) {
+        free(httpgetfields);
+        return PARAM_BAD_USE;
+      }
+    }
+    else {
+      if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq))
+        return PARAM_BAD_USE;
+    }
+  }
+
   /*
    * Get a curl handle to use for all forthcoming curl transfers.  Cleanup
    * when all transfers are done. This is supported with libcurl 7.7 and
@@ -1604,6 +1755,7 @@ operate(struct Configurable *config, int argc, char *argv[])
 
           struct stat fileinfo;
 
+/*VMS?? -- Danger, the filesize is only valid for stream files */
           if(0 == stat(outfile, &fileinfo)) {
             /* set offset to current file size: */
             config->resume_from = fileinfo.st_size;
@@ -1656,6 +1808,15 @@ operate(struct Configurable *config, int argc, char *argv[])
           
           url = urlbuffer; /* use our new URL instead! */
         }
+/*VMS??-- Reading binary from files can be a problem... */
+/*VMS??   Only FIXED, VAR etc WITHOUT implied CC will work */
+/*VMS??   Others need a \n appended to a line */
+/*VMS??-- Stat gives a size but this is UNRELIABLE in VMS */
+/*VMS??   As a f.e. a fixed file with implied CC needs to have a byte added */
+/*VMS??   for every record processed, this can by derived from Filesize & recordsize */
+/*VMS??   for VARiable record files the records need to be counted! */
+/*VMS??   for every record add 1 for linefeed and subtract 2 for the record header */
+/*VMS??   for VARIABLE header files only the bare record data needs to be considered with one appended if implied CC */
 
         infd=(FILE *) fopen(config->infile, "rb");
         if (!infd || stat(config->infile, &fileinfo)) {
@@ -1694,6 +1855,34 @@ operate(struct Configurable *config, int argc, char *argv[])
         if (separator)
           printf("%s%s\n", CURLseparator, url);
       }
+      if (httpgetfields) {
+        /* Find out whether the url contains a file name */
+        char *pc =strstr(url, "://");
+        if(pc)
+          pc+=3;
+        else
+          pc=url;
+        pc = strrchr(pc, '/');
+
+        /*
+         * Then append ? followed by the get fields to the url.
+         */
+        urlbuffer=(char *)malloc(strlen(url) + strlen(httpgetfields) + 2);
+        if(!urlbuffer) {
+          helpf("out of memory\n");
+          return CURLE_OUT_OF_MEMORY;
+        }
+        /* Append  / before the ? to create a well-formed url
+           if the url contains a hostname only
+        */
+        if (pc)
+          sprintf(urlbuffer, "%s?%s", url, httpgetfields);
+        else
+          sprintf(urlbuffer, "%s/?%s", url, httpgetfields);
+ 
+        free(url); /* free previous URL */
+        url = urlbuffer; /* use our new URL instead! */
+      }
 
       if(!config->errors)
         config->errors = stderr;
@@ -1759,7 +1948,10 @@ operate(struct Configurable *config, int argc, char *argv[])
         /* available from libcurl 7.5: */
         curl_easy_setopt(curl, CURLOPT_CAINFO, config->cacert);
         curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, TRUE);
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
       }
+      else
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 1);
       
       if(config->conf&(CONF_NOBODY|CONF_USEREMOTETIME)) {
         /* no body or use remote time */
@@ -1813,14 +2005,15 @@ operate(struct Configurable *config, int argc, char *argv[])
         ourWriteOut(curl, config->writeout);
       }
         
+#ifdef	VMS
+	if (!config->showerror)  {
+		vms_show = VMSSTS_HIDE;
+	}
+#else
       if((res!=CURLE_OK) && config->showerror)
         fprintf(config->errors, "curl: (%d) %s\n", res, errorbuffer);
+#endif
 
-      if((config->errors != stderr) &&
-         (config->errors != stdout))
-        /* it wasn't directed to stdout or stderr so close the file! */
-        fclose(config->errors);
-    
       if(config->headerfile && !headerfilep && heads.stream)
         fclose(heads.stream);
 
@@ -1833,6 +2026,9 @@ operate(struct Configurable *config, int argc, char *argv[])
       if(headerfilep)
         fclose(headerfilep);
       
+      if (httpgetfields)
+        free(httpgetfields);
+
       if(url)
         free(url);
 
@@ -1865,6 +2061,11 @@ operate(struct Configurable *config, int argc, char *argv[])
   /* cleanup the curl handle! */
   curl_easy_cleanup(curl);
 
+  if((config->errors != stderr) &&
+     (config->errors != stdout))
+    /* it wasn't directed to stdout or stderr so close the file! */
+    fclose(config->errors);
+
   main_free(); /* cleanup */
 
   return res;
@@ -1880,7 +2081,11 @@ int main(int argc, char *argv[])
   res = operate(&config, argc, argv);
   free_config_fields(&config);
 
+#ifdef	VMS
+  return (vms_cond[res]|vms_show);
+#else
   return res;
+#endif
 }
 
 static char *my_get_line(FILE *fp)

src/urlglob.c

@@ -395,7 +395,7 @@ char *match_url(char *filename, URLGlob *glob)
   int stringlen=0;
   char numbuf[18];
   char *appendthis;
-  size_t appendlen;
+  int appendlen;
 
   /* We cannot use the glob_buffer for storage here since the filename may
    * be longer than the URL we use. We allocate a good start size, then
@@ -424,7 +424,7 @@ char *match_url(char *filename, URLGlob *glob)
       switch (pat.type) {
       case UPTSet:
 	appendthis = pat.content.Set.elements[pat.content.Set.ptr_s];
-	appendlen = strlen(pat.content.Set.elements[pat.content.Set.ptr_s]);
+	appendlen = (int)strlen(pat.content.Set.elements[pat.content.Set.ptr_s]);
 	break;
       case UPTCharRange:
         numbuf[0]=pat.content.CharRange.ptr_c;
@@ -435,7 +435,7 @@ char *match_url(char *filename, URLGlob *glob)
       case UPTNumRange:
 	sprintf(numbuf, "%0*d", pat.content.NumRange.padlength, pat.content.NumRange.ptr_n);
         appendthis = numbuf;
-        appendlen = strlen(numbuf);
+        appendlen = (int)strlen(numbuf);
 	break;
       default:
 	printf("internal error: invalid pattern type (%d)\n", pat.type);

src/version.h

@@ -1,3 +1,3 @@
 #define CURL_NAME "curl"
-#define CURL_VERSION "7.8.1-pre3"
+#define CURL_VERSION "7.8.1"
 #define CURL_ID CURL_NAME " " CURL_VERSION " (" OS ") "

src/writeout.c

@@ -49,7 +49,7 @@ typedef enum {
 } replaceid;
 
 struct variable {
-  char *name;
+  const char *name;
   replaceid id;
 };
 
@@ -67,7 +67,7 @@ static struct variable replacements[]={
   {"size_upload", VAR_SIZE_UPLOAD},
   {"speed_download", VAR_SPEED_DOWNLOAD},
   {"speed_upload", VAR_SPEED_UPLOAD},
-  {NULL}
+  {NULL, 0}
 };
 
 void ourWriteOut(CURL *curl, char *writeinfo)

tests/data/Makefile.am

@@ -5,7 +5,9 @@ test:
 	[ -f test1 ] || ln -s $(srcdir)/test* .
 
 EXTRA_DIST = \
-test1    test102  test106  test13   test17   test300  test43   test8 \
-test10   test103  test107  test14   test2    test33   test5    test9 \
-test100  test104  test11   test15   test200  test4    test6    \
-test101  test105  test12   test16   test3    test400  test7    
+test1    test104  test13   test19   test21   test3    test5    \
+test10   test105  test14   test2    test22   test300  test6    \
+test100  test106  test15   test20   test23   test33   test7    \
+test101  test107  test16   test200  test24   test4    test8    \
+test102  test11   test17   test201  test25   test400  test9    \
+test103  test12   test18   test202  test26   test43   

tests/data/test18

@@ -0,0 +1,75 @@
+# Server-side
+<reply>
+<data nocheck=1>
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+moo
+</data>
+<data2>
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+foo
+</data2>
+<data3>
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+hoo
+</data3>
+</reply>
+
+# Client-side
+<client>
+ <name>
+multiple requests using {} in URL
+ </name>
+ <command>
+'%HOSTIP:%HOSTPORT/{18,180002,180003}'
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<strip>
+^User-Agent:.*
+</strip>
+<protocol>
+GET /18 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /180002 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /180003 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+</protocol>
+<stdout>
+--_curl_--127.0.0.1:8999/18
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+moo
+--_curl_--127.0.0.1:8999/180002
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+foo
+--_curl_--127.0.0.1:8999/180003
+HTTP/1.1 200 OK
+Funny-head: yesyes
+
+hoo
+</stdout>
+</verify>

tests/data/test19

@@ -0,0 +1,22 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+attempt connect to non-listening socket
+ </name>
+ <command>
+%HOSTIP:60000
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<errorcode>
+7
+</errorcode>
+</verify>

tests/data/test20

@@ -0,0 +1,22 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+attempt connect to non-existing host name
+ </name>
+ <command>
+non-existing-and-weeeeeeirdname
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<errorcode>
+6
+</errorcode>
+</verify>

tests/data/test200

@@ -12,10 +12,10 @@ moo
 # Client-side
 <client>
  <name>
-file:// with relative path
+basic file:// file
  </name>
  <command>
-file://log/test200.txt
+file://localhost/%PWD/log/test200.txt
 </command>
 <file name="log/test200.txt">
 foo

tests/data/test201

@@ -0,0 +1,22 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+missing file:// file
+ </name>
+ <command>
+file://localhost/%PWD/log/non-existant-file.txt
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<errorcode>
+37
+</errorcode>
+</verify>

tests/data/test202

@@ -0,0 +1,26 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+two file:// URLs to stdout
+ </name>
+ <command>
+file://localhost/%PWD/log/test202.txt file://localhost/%PWD/log/test202.txt
+</command>
+<file name="log/test202.txt">
+contents in a single file
+</file>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<stdout>
+contents in a single file
+contents in a single file
+</stdout>
+</verify>

tests/data/test21

@@ -0,0 +1,22 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+use curl with multiple request methods
+ </name>
+ <command>
+-I -X FOOO localhost
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<errorcode>
+2
+</errorcode>
+</verify>

tests/data/test23

@@ -0,0 +1,22 @@
+# Server-side
+<reply>
+<data>
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+unsupported protocol:// URL
+ </name>
+ <command>
+htfp://%HOSTIP:%HOSTPORT/none.htfml
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<errorcode>
+1
+</errorcode>
+</verify>

tests/data/test24

@@ -0,0 +1,37 @@
+# Server-side
+<reply>
+<data nocheck=1>
+HTTP/1.0 404 BAD BOY
+Content-Type: text/html
+
+This silly page doesn't reaaaaaly exist so you should not get it.
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+HTTP GET fail silently on HTTP error return
+ </name>
+ <command>
+http://%HOSTIP:%HOSTPORT/24 --fail
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<strip>
+^User-Agent: curl/.*
+</strip>
+<protocol>
+GET /24 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+</protocol>
+<errorcode>
+22
+</errorcode>
+</verify>

tests/data/test25

@@ -0,0 +1,109 @@
+# Server-side
+<reply>
+<data>
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+Redirect to the same URL again!
+</data>
+<datacheck>
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+HTTP/1.1 301 This is a weirdo text message
+Server: test-server/fake
+Location: data/reply/25
+Content-Length: 32
+Connection: close
+
+</datacheck>
+</reply>
+
+# Client-side
+<client>
+ <name>
+looping HTTP Location: following with --max-redirs, no persistance
+ </name>
+ <command>
+http://%HOSTIP:%HOSTPORT/want/25 -L --max-redirs 5
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<strip>
+^User-Agent: curl/.*
+</strip>
+<protocol>
+GET /want/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /want/data/reply/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /want/data/reply/data/reply/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /want/data/reply/data/reply/data/reply/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /want/data/reply/data/reply/data/reply/data/reply/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+GET /want/data/reply/data/reply/data/reply/data/reply/data/reply/25 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+</protocol>
+
+<errorcode>
+47
+</errorcode>
+</verify>

tests/data/test26

@@ -0,0 +1,35 @@
+# Server-side
+<reply>
+<data>
+HTTP/1.1 200 Mooo
+Server: test-server/fake
+Connection: close
+
+*flopp*
+</data>
+</reply>
+
+# Client-side
+<client>
+ <name>
+specify more -o than URLs
+ </name>
+ <command>
+http://%HOSTIP:%HOSTPORT/want/26 -o - -o -
+</command>
+</test>
+
+# Verify data after the test has been "shot"
+<verify>
+<strip>
+^User-Agent: curl.*
+</strip>
+<protocol>
+GET /want/26 HTTP/1.1
+User-Agent: curl/7.8.1-pre3 (sparc-sun-solaris2.7) libcurl 7.8.1-pre3 (OpenSSL 0.9.6a) (krb4 enabled)
+Host: 127.0.0.1:8999
+Pragma: no-cache
+Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
+
+</protocol>
+</verify>

tests/runtests.pl

@@ -68,6 +68,9 @@ my $debugprotocol;
 my $anyway;
 my $gdbthis;      # run test case with gdb debugger
 my $keepoutfiles; # keep stdout and stderr files after tests
+my $pwd;          # current working directory
+
+chomp($pwd = `pwd`);
 
 #######################################################################
 # Return the pid of the server as found in the given pid file
@@ -443,6 +446,8 @@ sub singletest {
     $cmd =~ s/%FTPPORT/$FTPPORT/g;
     $cmd =~ s/%FTPSPORT/$FTPSPORT/g;
     $cmd =~ s/%SRCDIR/$srcdir/g;
+    $cmd =~ s/%PWD/$pwd/g;
+
     #$cmd =~ s/%HOSTNAME/$HOSTNAME/g;
 
     if($memory_debug) {
@@ -512,7 +517,7 @@ sub singletest {
         }
         else {
             if(!$short) {
-                print "curl returned $res\n";
+                print "curl returned $res, ".(0+$errorcode)." was expected\n";
             }
             print " error FAILED\n";
             return 1;