7.8-pre2

release archive

CHANGES

@@ -6,6 +6,414 @@
 
                                History of Changes
 
+Daniel (30 May 2001)
+- Cris Bailiff wrote a makefile for building Solaris packages.
+
+- Sterling Hughes brought fixes for 'buildconf' (the build-from-CVS tool) and
+  we discussed and added a few CURL_GLOBAL_* flags in include/curl.h
+
+- Kjetil Jacobsen privately announced his python interface to libcurl,
+  available at http://pycurl.sourceforge.net/
+
+Daniel (29 May 2001)
+- Sterling Hughes fixed a strtok() problem in libcurl. It is not a thread-
+  safe function. Now configure checks for a thread-safe version, and
+  lib/strtok.c offers one for the systems that don't come with one included!
+
+- Mettgut Jamalla correctly pointed out that the -# progress bar was written
+  to stderr even though --stderr redirection was used. This is now corrected.
+
+- I moved out the list of contributors from the curl.1 man page and made a
+  separate docs/THANKS file. It makes the list easier to find, and made it
+  easier for me to make a separate web page with that same information.
+
+  I really do want all you guys mentioned in there to feel you get the credit
+  you deserve.
+
+- lib/easy.c didn't compile properly in the 7.8-pre1 due to a silly mistake
+
+Version 7.8-pre1
+
+Daniel (28 May 2001)
+- curl-config now supports '--vernum' that outputs a plain hexadecimal version
+  of the libcurl version number (using 8 bits for each 3 numbers). Version
+  7.7.4 appears as 070704
+
+- Wrote man pages for curl_global_init and curl_global_cleanup...
+
+- T. Bharath brought news about the usage of the OpenSSL interface that was
+  not previously taken into consideration and thus caused libcurl to leak
+  memory.  The only somewhat sane approach to fix this dilemma, is adding two
+  two new functions curl_global_init() and curl_global_cleanup() that should
+  be called *ONCE* by the application using libcurl. The init should be done
+  only at startup, no matter how many threads the application is gonna use,
+  and the cleanup should be called when the application has finished using
+  libcurl completely.
+
+  *** UPGRADE NOTICE ***
+
+  If you write applications using libcurl, you really want to use the two
+  functions mentioned above !!!
+
+  I can't say I think this is a very beautiful solution, but as OpenSSL
+  insists on making lots of stuff on a "global" scope, we're forced to walk
+  the path they point us to.
+
+- Moving more test cases into the new file format.
+
+Version 7.7.4-pre3
+
+Daniel (23 May 2001)
+- Introduced a new file format for storing test cases, and thus I had to
+  modify all the perl test scripts and more (I added a new one). I have not
+  "ported" all the old test cases to the new format yet, but it'll come.
+
+  The main advantage of this new format is that all test data for each test
+  case is stored in a single file. It gives a better overview for each test
+  case and a lot less files.
+
+- Andr<64>s Garc<72>a brought a fix for the netscape/mozilla cookie file parsing
+  function, as it turns out it doesn't always store the path!
+
+Daniel (22 May 2001)
+- As was reported anonymously, when FAILONERROR was used, the httpcode was
+  not stored properly and thus wasn't possibly to read after a transfer with
+  the curl_easy_getinfo() function. This is now corrected.
+
+- Installed and made use of the following tool versions:
+    autoconf 2.50
+    libtool 1.4
+    automake 1.4-p1
+
+  I wouldn't recommend any developer to try to generate things with older
+  versions than these. Building from CVS will probably more or less require
+  at least these versions.
+
+  As a result of this, the configure script grew to more than double its
+  previous size!
+
+  Arkadiusz Miskiewicz helped me by pointing out I had to remove my
+  acinclude.m4 file before I could get it working!
+
+Daniel (21 May 2001)
+- I made ftps:// work. Added test case 400 to the release archive, as the
+  first ftps:// test case. Requires stunnel.
+
+- Also made the test cases that runs ssl tests not run if libcurl isn't built
+  with ssl support.
+
+Daniel (19 May 2001)
+- Made the configure not add any extra -L LDFLAGS or -I CPPFLAGS unless they
+  are actually needed. Albert Chin's and Domenico Andreoli's suggestions
+  helped out.
+
+Version 7.7.4-pre2
+
+Daniel (18 May 2001)
+- Nicer configure-check for the OpenSSL headers, which then sets the proper
+  variable to have curl-config be good. (Albert Chin provided the fix)
+
+- For systems that don't have theiw own 'strlcat()' libcurl provides its own.
+  It was now renamed to prevent collides with other libs. (After discussions
+  with Sterling Hughes and the implications this had on PHP builds.)
+
+Daniel (17 May 2001)
+- Colm Buckley posted a detailed bug report on (the debianized) 7.7.3, that
+  turned out to be a problem with the debian-built 7.7.3-package that
+  contained files from the 7.7.2 release!
+
+- I added the CURLE_ALREADY_COMPLETE again, but with a fake value, just to
+  make programs that use it, not fail when compiling against this version of
+  libcurl.
+
+Daniel (14 May 2001)
+- Pawel A. Gajda fixed a problem with resumed transfers on re-used persistent
+  connections.
+
+Version 7.7.4-pre1
+
+Daniel (14 May 2001)
+- Jun-ichiro itojun Hagino fixed FTP PORT for IPv6-enabled libcurl.
+
+- Added the first HTTPS test to the test suite in the release archive.
+
+Daniel (12 May 2001)
+- Jukka Pihl suggested that if (lib)curl is told to verify the peer's
+  certificate and the peer can't be verified, it should fail and return a
+  proper error code. I added a brand new error code named
+  CURLE_SSL_PEER_CERTIFICATE for this purpose.
+
+Daniel (11 May 2001)
+- As was discussed with Frederic Lepied a while ago, I now made libcurl not
+  return error even though no data was transfered on upload/download resume
+  when the no transfer is needed. The CURLE_ALREADY_COMPLETE error was removed
+  from the header file to make any implemenator that uses that to be aware of
+  the fact that it can't be returned anymore!
+
+- Improved general header-parsing to better allow white spaces and more.
+
+- Rodney Simmons proved the fix I did yesterday was bad and I had to post
+  another one.
+
+- Ingo Wilken patched away two redirect problems more!
+  
+Daniel (10 May 2001)
+- Cris Bailiff correctly noted that the space-after-header problem with
+  Location: is present on several other places in the libcurl sources.
+
+- Ingo Wilken patched away a problem libcurl had when following Location:
+  headers with an extra space after the colon.
+
+- Rodney Simmons found out that multiple FTP transfers did not treat relative
+  directories correctly.
+
+Daniel (9 May 2001)
+- Getting an FTP file with CURLOPT_NOBODY set (or -I from the command line),
+  makes curl use the non-standard ftp command "SIZE". If it failed, libcurl
+  returned error. Starting now, it just don't output the file size instead.
+  Anonymous bug report.
+
+- stunnel.pm was accidentally left out from the release archive, it is now
+  added (stunnel is needed to run the https-tests in the test suite)
+  
+Daniel (7 May 2001)
+- Corrected two minor compiler warnings due to the FILE * to void * conversion
+  that I missed at two places. J<>rn Hartroth brought me patches. Sander Gates
+  filed a bug report on this.
+
+Version 7.7.3
+
+Daniel (4 May 2001)
+- All callback functions now take 'void *' instead of 'FILE *'. This is made
+  this way to make it more obvious to people that anything can be passed to
+  them (by using the apropriate option). After discussions with Sterling
+  Hughes.
+
+Daniel (3 May 2001)
+- Cris Bailiff fixed a chunked transfer encoding problem with persistent
+  connection that made libcurl fail if the persistent connection used mixed
+  chunked and non-chunked transfers.
+
+- Cris Bailiff fixed a bad treatment of 304-replies, as they would not be
+  treated as content-length 0 replies but would cause a "hang" until the
+  server timed-out and closed the connection.
+
+- Brad Burdick found a minor problem in the docs/examples/Makefile.am
+
+Daniel (27 April 2001)
+- Updated the INTERALS document again. It was lagging a bit. I think I made it
+  more easy to follow now as well.
+
+- Brad Burdick found a problem with persistent connections when curl received
+  a "Content-Length: 0" header.
+
+- Giuseppe D'Ambrosio was first out to report that TELNET doesn't work in curl
+  compiled/built on win32. It seems to work for unixes though!
+
+- Dave Hamilton reported weird problems with CURL/PHP that I really can't
+  explain at the moment. I'm hoping on some help from the PHP crew.
+
+Daniel (26 April 2001)
+- I rewrote the FTP command response function. I had to do it to make ftps
+  work, as the OpenSSL read()-function didn't work the same way the normal
+  unix read() does, but it was also a huge performance boost. Previously the
+  function read one byte at a time, now it reads very large chunks, and it
+  makes a notable speed difference.
+
+Daniel (25 April 2001)
+- Connection re-use when not using a proxy didn't work properly for
+  non-default port numbers.
+
+Daniel (24 April 2001)
+- I've noticed that FTPS doesn't work. We attempt to use ssl even for the
+  data transfer, which causes the transfer to 'hang'... We need to fix this.
+
+- Improved the test suite to use 'stunnel' to do HTTPS and FTPS testing on
+  the alredy written perl servers easily.
+
+Daniel (23 April 2001)
+- The OpenSSL version string recently modified didn't zero terminate one
+  of the generated strings properly, which could lead to a crash or simply
+  weird version string output!
+
+Version 7.7.2
+
+Daniel (22 April 2001)
+- Rosimildo da Silva updated the Makefiles for Borland/Windows.
+
+- Eric Rautman pointed out a problem with persistent connections that would
+  lead to broken Host: headers in the second HTTP request.
+
+Daniel (20 April 2001)
+- Added man pages for the curl_strequal() and curl_mprintf() families. Wrote
+  a 'libcurl overview' man page.
+
+- Spell-fixed some documents.
+
+- S. Moonesamy corrected mistakes in the man page.
+
+- Cris Bailiff fixed the curl_slists options in the perl interface, present
+  separately in the Curl::easy 1.1.4 package.
+
+Daniel (19 April 2001)
+- Linus Nielsen Feltzing removed the decimals from the size variables in the
+  --write-out output. We hardly ever get fraction of bytes! :-)
+
+Version 7.7.2-pre1
+
+Daniel (19 April 2001)
+
+- Albert Chin provided a configure patch for the AC_SYS_LARGEFILE macro.
+
+Daniel (18 April 2001)
+- Input from Michael Mealling made me add --feature to curl-config. It
+  displays a list of features that have been built-in in the current
+  libcurl. The currently available features that can be listed are: SSL, KRB4
+  and IPv6.
+
+- I committed Cris and Georg's perl interface work. They've got callbacks
+  working and options that receives those slist pointers.
+
+- Puneet Pawaia detected a problem with resumed downloads that use persistent
+  connections and I made a rather large writeup to correct this. It is
+  important that all session-data is stored in the connectdata struct and not
+  in the main struct as this previously did.
+
+Daniel (17 April 2001)
+- Frederic Lepied fixed a ftp resumed download problem and introduced a new
+  error code that lets applications be able to detect when a resumed download
+  actually didn't download anything since the whole file is already present.
+  Should this return OK instead?
+
+- I added 'curl-config.in' to the root dir and configure script. Now, a
+  curl-config script is made when curl is built. The script can be used to
+  figure out compile time options used when libcurl was built, which in turn
+  should be options YOU should use to build applications that use libcurl.
+
+  This *-config style is not a new idea, but something that has been used
+  successfully in other (library based) projects.
+
+- Phil Karn pointed out that libcurl wrongly did not always use GMT time zone
+  for the If-Modified-Since style headers.
+
+- Georg Schwarz pointed out an extra needed #include file needed in src/main.c
+  for curl to build on Ultrix.
+
+Daniel (11 April 2001)
+- Cris Bailiff pointed out two problems that I corrected. First, libcurl's use
+  of the environment variable HTTP_PROXY in uppercase may become a security
+  hazard when people use libcurl in a server/cgi situation where the server
+  sets the HTTP_*-variables according to incoming headers in the HTTP
+  request. Thus, a "Proxy:"-header would set that environment variable!
+
+  Then, invoking curl_easy_perform() without having an URL set caused a crash.
+
+- S. Moonesamy brought a patch that make curl use non-blocking connects on
+  windows when connection timeout is set, as it allows windows users to set
+  that timeout!
+
+- Hirotaka Matsuyuki wrote a Ruby interface to libcurl!
+
+- Cris Bailiff, Forrest Cahoon and Georg Horn work on the Perl interface.
+
+- I've written a first shot at a Java interface to libcurl. Many thanks to
+  Daniel Marell for tirelessly answering to all my basic Java questions. It
+  works, but it is still very basic.
+
+Daniel (10 April 2001)
+- The progress display could get silly when doing multiple file transfers, as
+  it wasn't properly reset between transfers!
+
+- Discussions with Cris Bailiff who writes a Perl interface to libcurl, made
+  me add CURLOPT_HEADERFUNCTION. It can be used to set a separate callback
+  function for writing headers. Previously you could only set a different FILE
+  * when headers are written from within libcurl.
+
+Daniel (7 April 2001)
+- Andr<64>s Garc<72>a fixed a problem in curl_escape() and pointed out a flaw in
+  the curl_easy_setopt man page.
+
+Daniel (6 April 2001)
+- Adjusted the version code to properly display OpenSSL 0.9.6a. They sure
+  change their version define format often...
+
+- curl_formfree() now accepts a NULL pointer without crashing!
+
+Version 7.7.1
+
+Daniel (3 April 2001)
+- Puneet Pawaia pointed out two serious problems. Libcurl would attempt to
+  read bad memory during situations when an (ftp) connection attempt failed.
+  Also, the lib/Makefile.vc6 was corrected.
+
+- More investigations in the Location: following code made me realize that
+  it was not clean enough to work transparantly with persistent and non-
+  persistent connections. I think I've fixed it now.
+
+Daniel (29 March 2001)
+- Georg Horn mailed me some corrections for the Curl::easy perl interface.
+
+- Experimental ftps:// support added. It is basically FTP over SSL for the
+  control connection. It still makes all data transfers going over unencrypted
+  connections. Rainer Weikusat's ftpd-ssl server hack supports this and I used
+  that to verify the functionality.
+
+Daniel (27 March 2001)
+- Guenole Bescon discovered that if you set a CURLOPT_TIMEOUT and then tried
+  to get a file from a site and it fails, the SIGALRM would still be sent
+  after the timeout-time, quite inexpectedly!
+
+- I added an ftp transfer example to docs/examples/ and I also wrote a tiny
+  example makefile that can be used as a start when building one of the
+  examples.
+
+Version 7.7.1-beta1
+
+Daniel (26 March 2001)
+- Mohamed Lrhazi reported problems with 7.6.1 and persistent HTTP/1.0
+  connections (when the server replied a Connection: Keep-Alive) and this
+  problem was not properly dealt with in 7.7 either. A patch was posted to the
+  curl-and-php mailing list.
+
+Daniel (24 March 2001)
+- Colin Watson reported about a problem and brought a patch that corrected it,
+  which was about the man page and lines starting with a single quote (') in a
+  way that gnroff doesn't like.
+
+Daniel (23 March 2001)
+- Peter Bray reported correctly that the root makefile used make instead of
+  $(MAKE) for the test target.
+
+- Corrected the Curl::easy perl interface to use curl_easy_setopt() and not
+  curl_setopt() which was removed in 7.7!
+
+- S. Moonesamy provided updates on three documents (MANUAL, INSTALL and FAQ).
+
+- When following a Location:, libcurl would sometimes write to the URL string
+  in a way it shouldn't. As the pointer is passed-in to libcurl from an
+  application, we can't be allowed to write to it. The particular bug report
+  from 'nk' that brought this up was because he had a read-only URL that then
+  caused a libcurl crash!
+
+- No longer reads HEAD responses longer than to the last header. Previously,
+  curl would read the full reply if the connection was a "close" one.
+
+- libcurl did re-use connections way too much. Doing "curl
+  http://www.{microsoft,ibm}.com" would make it re-use the connection which
+  made the second request return very odd results.
+
+Daniel (22 March 2001)
+- Edin Kadribasic made me aware that curl should not re-send POST requests
+  when following 302-redirects. I made 302 work like 303 which means curl uses
+  GET in the following request(s).
+
+- libcurl now reset the "followed-location" counter on each invoke of
+  curl_easy_perform() as it otherwise would sum up all redirects on the same
+  connection and thus could reach the maxredirs counter wrongly.
+
+- Jim Drash suggested curl_escape() should not re-encode what already looks
+  like an encoded sequence and I think that's a fair suggestion.
+
 Version 7.7
 
 Daniel (22 March 2001)
@@ -144,14 +552,14 @@ Daniel (12 March 2001)
   test cases.
 
 - Added 5 new libcurl options to curl/curl.h that can be used to control the
-  persistant connection support in libcurl. They're also documented (fairly
+  persistent connection support in libcurl. They're also documented (fairly
   thoroughly) in the curl_easy_setopt.3 man page. Three of them are now
   implemented, although not really tested at this point... Anyway, the new
   implemented options are named CURLOPT_MAXCONNECTS, CURLOPT_FRESH_CONNECT,
   CURLOPT_FORBID_REUSE. The ones still left to write code for are:
   CURLOPT_CLOSEPOLICY and its related option CURLOPT_CLOSEFUNCTION.
 
-- Made curl (the actual command line tool) use the new libcurl 7.7 persistant
+- Made curl (the actual command line tool) use the new libcurl 7.7 persistent
   connection support by re-using the same curl handle for every specified file
   transfer and after some more test case tweaking we have 100% test case OK.
   I made some test cases return HTTP/1.0 now to make sure that works as well.
@@ -171,7 +579,7 @@ Daniel (12 March 2001)
   of different HTTP proxies before I feel safe.
 
   Now I'm facing the problem with my test suite servers (both FTP and HTTP)
-  not supporting persistant connections and libcurl is doing them now. I have
+  not supporting persistent connections and libcurl is doing them now. I have
   to fix the test servers to get all the test cases do OK.
 
 Daniel (8 March 2001)
@@ -212,7 +620,7 @@ Daniel (2 March 2001)
 - Now they work intermixed as well. Major coolness!
 
 - More fiddling around, my 'tiny' client I have for testing purposes now has
-  proved to download both FTP and HTTP with persistant connections. They do
+  proved to download both FTP and HTTP with persistent connections. They do
   not work intermixed yet though.
 
 Daniel (1 March 2001)
@@ -221,7 +629,7 @@ Daniel (1 March 2001)
   now.
 
 Daniel (22 February 2001)
-- The persistant connections start to look good for HTTP. On a subsequent
+- The persistent connections start to look good for HTTP. On a subsequent
   request, it seems that libcurl now can pick an already existing connection
   if a suitable one exists, or it opens a new one.
 
@@ -246,7 +654,7 @@ Daniel (20 February 2001)
   mailing lists for discussions around how this is gonna be implemented. Docs
   and more will follow.
 
-  Studied the HTTP RFC to find out better how persistant connections should
+  Studied the HTTP RFC to find out better how persistent connections should
   work. Seems cool enough.
 
 Daniel (19 February 2001)
@@ -265,9 +673,9 @@ Daniel (15 February 2001)
   string switches off the POST again.
 
 - Excellent suggestions from Rich Gray, Rick Jones, Johan Nilsson and Bjorn
-  Reese helped me define a way how to incorporate persistant connections into
+  Reese helped me define a way how to incorporate persistent connections into
   libcurl in a very smooth way. If done right, no change may have to be made
-  to older programs and they will just start using persistant connections when
+  to older programs and they will just start using persistent connections when
   applicable!
 
 Daniel (13 February 2001)
@@ -301,16 +709,16 @@ Daniel (8 February 2001)
 Version 7.6.1-pre3
 
 Daniel (7 February 2001)
-- SM found a flaw in the response reading function for FTP that could make
-  libcurl not get out of the loop properly when it should, if libcurl got -1
-  returned when reading the socket.
+- S. Moonesamy found a flaw in the response reading function for FTP that
+  could make libcurl not get out of the loop properly when it should, if
+  libcurl got -1 returned when reading the socket.
 
 - I found a similar mistake in http.c when using a proxy and reading the
   results from the proxy connection.
 
 Daniel (6 February 2001)
-- A friendly person named "SM" (nntp at iname.com) pointed out that the VC
-  makefile in src/ needed the libpath set for the debug build to work.
+- S. Moonesamy pointed out that the VC makefile in src/ needed the libpath set
+  for the debug build to work.
 
 - Daniel Gehriger stepped in to assist with the VC++ stuff Robert Weaver
   brought up yesterday.

CVS-INFO

@@ -1,22 +1,34 @@
-This file is only present in the CVS - never in release archives.
+                                  _   _ ____  _     
+                              ___| | | |  _ \| |    
+                             / __| | | | |_) | |    
+                            | (__| |_| |  _ <| |___ 
+                             \___|\___/|_| \_\_____|
 
-This contains information about other files and things that the CVS repository
-keeps in its inner sanctum.
+CVS-INFO
 
-CHANGES.0     contains ancient changes.
+This file is only present in the CVS - never in release archives. It contains
+information about other files and things that the CVS repository keeps in its
+inner sanctum.
 
-memanalyze.pl is for analyzing the output generated by curl if -DMALLOCDEBUG
-              is used when compiling
+Use autoconf 2.50 and no earlier. Also, try having automake 1.4 and libtool
+1.4 at least.
 
-Makefile.dist is included as the root Makefile in distribution archives
 
-perl/contrib/ is a subdirectory with various perl scripts
+  CHANGES.0     contains ancient changes.
+
+  memanalyze.pl is for analyzing the output generated by curl if -DMALLOCDEBUG
+                is used when compiling
+
+  buildconf     builds the makefiles and configure stuff
+
+  Makefile.dist is included as the root Makefile in distribution archives
+
+  perl/contrib/ is a subdirectory with various perl scripts
+
+  java          is a subdirectory with the Java interface to libcurl
 
 To build after having extracted everything from CVS, do this:
 
-automake
-aclocal
-autoheader
-autoconf
+./buildconf
 ./configure
 make

Makefile.am

@@ -6,7 +6,10 @@ AUTOMAKE_OPTIONS = foreign no-dependencies
 
 EXTRA_DIST = \
 	CHANGES LEGAL maketgz MITX.txt MPL-1.1.txt \
-	config-win32.h reconf packages/README Makefile.dist
+	config-win32.h reconf packages/README Makefile.dist \
+	curl-config.in libtool
+
+bin_SCRIPTS = curl-config
 
 SUBDIRS = docs lib src include tests packages perl php
 
@@ -17,7 +20,7 @@ dist-hook:
 check: test
 
 test:
-	@(cd tests; make quiet-test)
+	@(cd tests; $(MAKE) quiet-test)
 
 #
 # Build source and binary rpms. For rpm-3.0 and above, the ~/.rpmmacros
@@ -45,3 +48,18 @@ rpm:
 	rpm -ba --clean --rmsource $$RPM_TOPDIR/SPECS/$(RPMDIST).spec ; \
 	mv $$RPM_TOPDIR/RPMS/i386/$(RPMDIST)-*.rpm . ; \
 	mv $$RPM_TOPDIR/SRPMS/$(RPMDIST)-*.src.rpm .
+
+#
+# Build a Solaris pkkgadd format file
+# run 'make pkgadd' once you've done './configure' and 'make' to make a Solaris pkgadd format
+# file (which ends up back in this directory).
+# The pkgadd file is in 'pkgtrans' format, so to install on Solaris, do
+# pkgadd -d ./HAXXcurl-*
+#
+
+# gak - libtool requires an absoulte directory, hence the pwd below...
+pkgadd:
+	umask 022 ; \
+	make install DESTDIR=`/bin/pwd`/packages/Solaris/root ; \
+	cat LEGAL MITX.txt MPL-1.1.txt > $(srcdir)/packages/Solaris/copyright ; \
+	cd $(srcdir)/packages/Solaris && $(MAKE) package

README

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

acconfig.h

@@ -51,3 +51,6 @@
 
 /* Define this to your Entropy Gathering Daemon socket pathname */
 #undef EGD_SOCKET
+
+/* Define if you have a working OpenSSL installation */
+#undef OPENSSL_ENABLED

acinclude.m4

@@ -1,75 +0,0 @@
-#serial 12
-
-dnl By default, many hosts won't let programs access large files;
-dnl one must use special compiler options to get large-file access to work.
-dnl For more details about this brain damage please see:
-dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
-
-dnl Written by Paul Eggert <eggert@twinsun.com>.
-
-dnl Internal subroutine of AC_SYS_LARGEFILE.
-dnl AC_SYS_LARGEFILE_TEST_INCLUDES
-AC_DEFUN(AC_SYS_LARGEFILE_TEST_INCLUDES,
-  [[#include <sys/types.h>
-    int a[(off_t) 9223372036854775807 == 9223372036854775807 ? 1 : -1];
-  ]])
-
-dnl Internal subroutine of AC_SYS_LARGEFILE.
-dnl AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR, COMMENT, INCLUDES, FUNCTION-BODY)
-AC_DEFUN(AC_SYS_LARGEFILE_MACRO_VALUE,
-  [AC_CACHE_CHECK([for $1 value needed for large files], $3,
-     [$3=no
-      AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES
-$5
-        ,
-	[$6], 
-	,
-	[AC_TRY_COMPILE([#define $1 $2]
-AC_SYS_LARGEFILE_TEST_INCLUDES
-$5
-	   ,
-	   [$6],
-	   [$3=$2])])])
-   if test "[$]$3" != no; then
-     AC_DEFINE_UNQUOTED([$1], [$]$3, [$4])
-   fi])
-
-AC_DEFUN(AC_SYS_LARGEFILE,
-  [AC_ARG_ENABLE(largefile,
-     [  --disable-largefile     omit support for large files])
-   if test "$enable_largefile" != no; then
-
-     AC_CACHE_CHECK([for special C compiler options needed for large files],
-       ac_cv_sys_largefile_CC,
-       [ac_cv_sys_largefile_CC=no
-        if test "$GCC" != yes; then
-	  # IRIX 6.2 and later do not support large files by default,
-	  # so use the C compiler's -n32 option if that helps.
-	  AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , ,
-	    [ac_save_CC="$CC"
-	     CC="$CC -n32"
-	     AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, ,
-	       ac_cv_sys_largefile_CC=' -n32')
-	     CC="$ac_save_CC"])
-        fi])
-     if test "$ac_cv_sys_largefile_CC" != no; then
-       CC="$CC$ac_cv_sys_largefile_CC"
-     fi
-
-     AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64,
-       ac_cv_sys_file_offset_bits,
-       [Number of bits in a file offset, on hosts where this is settable.])
-     AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1,
-       ac_cv_sys_largefile_source,
-       [Define to make ftello visible on some hosts (e.g. HP-UX 10.20).],
-       [#include <stdio.h>], [return !ftello;])
-     AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
-       ac_cv_sys_large_files,
-       [Define for large files, on AIX-style hosts.])
-dnl	lftp does not need ftello, and _XOPEN_SOURCE=500 makes resolv.h fail.
-dnl     AC_SYS_LARGEFILE_MACRO_VALUE(_XOPEN_SOURCE, 500,
-dnl       ac_cv_sys_xopen_source,
-dnl       [Define to make ftello visible on some hosts (e.g. glibc 2.1.3).],
-dnl       [#include <stdio.h>], [return !ftello;])
-   fi
-  ])

buildconf

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+die(){
+	echo "$@"
+	exit
+}
+
+MAKEFILES=`find . -name Makefile.am | sed 's/\.am$//'`
+
+automake $MAKEFILES || die "The command 'automake $MAKEFILES' failed"
+aclocal           || die "The command 'aclocal' failed"
+autoheader        || die "The command 'autoheader' failed"
+autoconf          || die "The command 'autoconf' failed"

config.guess

@@ -1,8 +1,10 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
 #   Free Software Foundation, Inc.
-#
+
+timestamp='2001-04-20'
+
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
@@ -30,26 +32,86 @@
 # exits with 0.  Otherwise, it exits with 1.
 #
 # The plan is that this can be called by configure scripts if you
-# don't specify an explicit system type (host/target name).
-#
-# Only a few systems have been added to this list; please add others
-# (but try to keep the structure clean).
-#
+# don't specify an explicit build system type.
 
-# Use $HOST_CC if defined. $CC may point to a cross-compiler
-if test x"$CC_FOR_BUILD" = x; then
-  if test x"$HOST_CC" != x; then
-    CC_FOR_BUILD="$HOST_CC"
-  else
-    if test x"$CC" != x; then
-      CC_FOR_BUILD="$CC"
-    else
-      CC_FOR_BUILD=cc
-    fi
-  fi
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 2000
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit 0 ;;
+    --version | -v )
+       echo "$version" ; exit 0 ;;
+    --help | --h* | -h )
+       echo "$usage"; exit 0 ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
 fi
 
 
+dummy=dummy-$$
+trap 'rm -f $dummy.c $dummy.o $dummy.rel $dummy; exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script.
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int dummy(){}" > $dummy.c
+	for c in cc gcc c89 ; do
+	  ($c $dummy.c -c -o $dummy.o) >/dev/null 2>&1
+	  if test $? = 0 ; then
+	     CC_FOR_BUILD="$c"; break
+	  fi
+	done
+	rm -f $dummy.c $dummy.o $dummy.rel
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac
+
 # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
 # (ghazi@noc.rutgers.edu 8/24/94.)
 if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
@@ -58,12 +120,9 @@ fi
 
 UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
 UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
 UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 
-dummy=dummy-$$
-trap 'rm -f $dummy.c $dummy.o $dummy; exit 1' 1 2 15
-
 # Note: order is significant - the case branches are not exclusive.
 
 case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
@@ -77,7 +136,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# object file format.
 	# Determine the machine/vendor (is the vendor relevant).
 	case "${UNAME_MACHINE}" in
-	    amiga) machine=m68k-cbm ;;
+	    amiga) machine=m68k-unknown ;;
 	    arm32) machine=arm-unknown ;;
 	    atari*) machine=m68k-atari ;;
 	    sun3*) machine=m68k-sun ;;
@@ -87,16 +146,24 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	    ibmrt|romp-ibm) machine=romp-ibm ;;
 	    *) machine=${UNAME_MACHINE}-unknown ;;
 	esac
-	# The Operating System including object format.
-	if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep __ELF__ >/dev/null
-	then
-	    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-	    # Return netbsd for either.  FIX?
-	    os=netbsd
-	else
-	    os=netbsdelf
-	fi
+	# The Operating System including object format, if it has switched
+	# to ELF recently, or will in the future.
+	case "${UNAME_MACHINE}" in
+	    i386|sparc|amiga|arm*|hp300|mvme68k|vax|atari|luna68k|mac68k|news68k|next68k|pc532|sun3*|x68k)
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep __ELF__ >/dev/null
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+	        os=netbsd
+		;;
+	esac
 	# The OS release
 	release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
@@ -173,7 +240,7 @@ EOF
 	echo alpha-dec-winnt3.5
 	exit 0 ;;
     Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-cbm-sysv4
+	echo m68k-unknown-sysv4
 	exit 0;;
     amiga:OpenBSD:*:*)
 	echo m68k-unknown-openbsd${UNAME_RELEASE}
@@ -205,7 +272,7 @@ EOF
     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
 	echo arm-acorn-riscix${UNAME_RELEASE}
 	exit 0;;
-    SR2?01:HI-UX/MPP:*:*)
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
 	echo hppa1.1-hitachi-hiuxmpp
 	exit 0;;
     Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
@@ -341,10 +408,13 @@ EOF
 EOF
 	$CC_FOR_BUILD $dummy.c -o $dummy \
 	  && ./$dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
-	  && rm $dummy.c $dummy && exit 0
+	  && rm -f $dummy.c $dummy && exit 0
 	rm -f $dummy.c $dummy
 	echo mips-mips-riscos${UNAME_RELEASE}
 	exit 0 ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit 0 ;;
     Night_Hawk:Power_UNIX:*:*)
 	echo powerpc-harris-powerunix
 	exit 0 ;;
@@ -392,9 +462,17 @@ EOF
     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
 	echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
 	exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
-    i?86:AIX:*:*)
+    i*86:AIX:*:*)
 	echo i386-ibm-aix
 	exit 0 ;;
+    ia64:AIX:*:*)
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+	exit 0 ;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
 		sed 's/^		//' << EOF >$dummy.c
@@ -408,7 +486,7 @@ EOF
 			exit(0);
 			}
 EOF
-		$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+		$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm -f $dummy.c $dummy && exit 0
 		rm -f $dummy.c $dummy
 		echo rs6000-ibm-aix3.2.5
 	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
@@ -417,9 +495,9 @@ EOF
 		echo rs6000-ibm-aix3.2
 	fi
 	exit 0 ;;
-    *:AIX:*:4)
+    *:AIX:*:[45])
 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -EHl ${IBM_CPU_ID} | grep POWER >/dev/null 2>&1; then
+	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
 		IBM_ARCH=rs6000
 	else
 		IBM_ARCH=powerpc
@@ -427,7 +505,7 @@ EOF
 	if [ -x /usr/bin/oslevel ] ; then
 		IBM_REV=`/usr/bin/oslevel`
 	else
-		IBM_REV=4.${UNAME_RELEASE}
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
 	fi
 	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
 	exit 0 ;;
@@ -453,10 +531,28 @@ EOF
 	echo m68k-hp-bsd4.4
 	exit 0 ;;
     9000/[34678]??:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
 	case "${UNAME_MACHINE}" in
 	    9000/31? )            HP_ARCH=m68000 ;;
 	    9000/[34]?? )         HP_ARCH=m68k ;;
 	    9000/[678][0-9][0-9])
+              case "${HPUX_REV}" in
+                11.[0-9][0-9])
+                  if [ -x /usr/bin/getconf ]; then
+                    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+                    case "${sc_cpu_version}" in
+                      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+                      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+                      532)                      # CPU_PA_RISC2_0
+                        case "${sc_kernel_bits}" in
+                          32) HP_ARCH="hppa2.0n" ;;
+                          64) HP_ARCH="hppa2.0w" ;;
+                        esac ;;
+                    esac
+                  fi ;;
+              esac
+              if [ "${HP_ARCH}" = "" ]; then
               sed 's/^              //' << EOF >$dummy.c
 
               #define _HPUX_SOURCE
@@ -491,11 +587,16 @@ EOF
               }
 EOF
 	(CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
+	if test -z "$HP_ARCH"; then HP_ARCH=hppa; fi
 	rm -f $dummy.c $dummy
+	fi ;;
 	esac
-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
 	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
 	exit 0 ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ia64-hp-hpux${HPUX_REV}
+	exit 0 ;;
     3050*:HI-UX:*:*)
 	sed 's/^	//' << EOF >$dummy.c
 	#include <unistd.h>
@@ -522,7 +623,7 @@ EOF
 	  exit (0);
 	}
 EOF
-	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm -f $dummy.c $dummy && exit 0
 	rm -f $dummy.c $dummy
 	echo unknown-hitachi-hiuxwe2
 	exit 0 ;;
@@ -541,7 +642,7 @@ EOF
     hp8??:OSF1:*:*)
 	echo hppa1.0-hp-osf
 	exit 0 ;;
-    i?86:OSF1:*:*)
+    i*86:OSF1:*:*)
 	if [ -x /usr/sbin/sysversion ] ; then
 	    echo ${UNAME_MACHINE}-unknown-osf1mk
 	else
@@ -586,27 +687,28 @@ EOF
     CRAY*TS:*:*:*)
 	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
-    CRAY*T3E:*:*:*)
+    CRAY*T3D:*:*:*)
 	echo alpha-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit 0 ;;
     CRAY*SV1:*:*:*)
 	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
     CRAY-2:*:*:*)
 	echo cray2-cray-unicos
         exit 0 ;;
-    F300:UNIX_System_V:*:*)
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
         FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
-        echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
         exit 0 ;;
-    F301:UNIX_System_V:*:*)
-       echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'`
-       exit 0 ;;
     hp300:OpenBSD:*:*)
 	echo m68k-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
-    i?86:BSD/386:*:* | i?86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
 	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
 	exit 0 ;;
     sparc*:BSD/OS:*:*)
@@ -627,6 +729,9 @@ EOF
     i*:MINGW*:*)
 	echo ${UNAME_MACHINE}-pc-mingw32
 	exit 0 ;;
+    i*:PW*:*)
+	echo ${UNAME_MACHINE}-pc-pw32
+	exit 0 ;;
     i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
 	# How do we know it's Interix rather than the generic POSIX subsystem?
 	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
@@ -645,58 +750,41 @@ EOF
     *:GNU:*:*)
 	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
 	exit 0 ;;
-    *:Linux:*:*)
-
-	# The BFD linker knows what the default object file format is, so
-	# first see if it will tell us. cd to the root directory to prevent
-	# problems with other programs or directories called `ld' in the path.
-	ld_help_string=`cd /; ld --help 2>&1`
-	ld_supported_emulations=`echo $ld_help_string \
-			 | sed -ne '/supported emulations:/!d
-				    s/[ 	][ 	]*/ /g
-				    s/.*supported emulations: *//
-				    s/ .*//
-				    p'`
-        case "$ld_supported_emulations" in
-	  *ia64)
-		echo "${UNAME_MACHINE}-unknown-linux"
-		exit 0
-		;;
-	  i?86linux)
-		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
-		exit 0
-		;;
-	  elf_i?86)
-		echo "${UNAME_MACHINE}-pc-linux"
-		exit 0
-		;;
-	  i?86coff)
-		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
-		exit 0
-		;;
-	  sparclinux)
-		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
-		exit 0
-		;;
-	  armlinux)
-		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
-		exit 0
-		;;
-	  elf32arm*)
-		echo "${UNAME_MACHINE}-unknown-linux-gnuoldld"
-		exit 0
-		;;
-	  armelf_linux*)
-		echo "${UNAME_MACHINE}-unknown-linux-gnu"
-		exit 0
-		;;
-	  m68klinux)
-		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
-		exit 0
-		;;
-	  elf32ppc | elf32ppclinux)
-		# Determine Lib Version
-		cat >$dummy.c <<EOF
+    i*86:Minix:*:*)
+	echo ${UNAME_MACHINE}-pc-minix
+	exit 0 ;;
+    arm*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit 0 ;;
+    ia64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux
+	exit 0 ;;
+    m68*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit 0 ;;
+    mips:Linux:*:*)
+	cat >$dummy.c <<EOF
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+int main (int argc, char *argv[]) {
+#else
+int main (argc, argv) int argc; char *argv[]; {
+#endif
+#ifdef __MIPSEB__
+  printf ("%s-unknown-linux-gnu\n", argv[1]);
+#endif
+#ifdef __MIPSEL__
+  printf ("%sel-unknown-linux-gnu\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
+	rm -f $dummy.c $dummy
+	;;
+    ppc:Linux:*:*)
+	# Determine Lib Version
+	cat >$dummy.c <<EOF
 #include <features.h>
 #if defined(__GLIBC__)
 extern char __libc_version[];
@@ -709,123 +797,127 @@ main(argc, argv)
 #if defined(__GLIBC__)
   printf("%s %s\n", __libc_version, __libc_release);
 #else
-  printf("unkown\n");
+  printf("unknown\n");
 #endif
   return 0;
 }
 EOF
-		LIBC=""
-		$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
+	LIBC=""
+	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
+	if test "$?" = 0 ; then
+		./$dummy | grep 1\.99 > /dev/null
+		if test "$?" = 0 ; then LIBC="libc1" ; fi
+	fi
+	rm -f $dummy.c $dummy
+	echo powerpc-unknown-linux-gnu${LIBC}
+	exit 0 ;;
+    alpha:Linux:*:*)
+	cat <<EOF >$dummy.s
+	  .data
+	  \$Lformat:
+		.byte 37,100,45,37,120,10,0	# "%d-%x\n"
+	   .text
+		.globl main
+		.align 4
+		.ent main
+	    main:
+		.frame \$30,16,\$26,0
+		ldgp \$29,0(\$27)
+		.prologue 1
+		.long 0x47e03d80 # implver \$0
+		lda \$2,-1
+		.long 0x47e20c21 # amask \$2,\$1
+		lda \$16,\$Lformat
+		mov \$0,\$17
+		not \$1,\$18
+		jsr \$26,printf
+		ldgp \$29,0(\$26)
+		mov 0,\$16
+		jsr \$26,exit
+		.end main
+EOF
+	LIBC=""
+	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
+	if test "$?" = 0 ; then
+		case `./$dummy` in
+		0-0)	UNAME_MACHINE="alpha" ;;
+		1-0)	UNAME_MACHINE="alphaev5" ;;
+		1-1)    UNAME_MACHINE="alphaev56" ;;
+		1-101)	UNAME_MACHINE="alphapca56" ;;
+		2-303)	UNAME_MACHINE="alphaev6" ;;
+		2-307)	UNAME_MACHINE="alphaev67" ;;
+		esac
+		objdump --private-headers $dummy | \
+		  grep ld.so.1 > /dev/null
 		if test "$?" = 0 ; then
-			./$dummy | grep 1\.99 > /dev/null
-			if test "$?" = 0 ; then
-				LIBC="libc1"
-			fi
+			LIBC="libc1"
 		fi
-		rm -f $dummy.c $dummy
-		echo powerpc-unknown-linux-gnu${LIBC}
+	fi
+	rm -f $dummy.s $dummy
+	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
+	exit 0 ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-gnu ;;
+	  PA8*) echo hppa2.0-unknown-linux-gnu ;;
+	  *)    echo hppa-unknown-linux-gnu ;;
+	esac
+	exit 0 ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-gnu
+	exit 0 ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo ${UNAME_MACHINE}-ibm-linux
+	exit 0 ;;
+    sh*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit 0 ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit 0 ;;
+    x86_64:Linux:*:*)
+	echo x86_64-unknown-linux-gnu
+	exit 0 ;;
+    i*86:Linux:*:*)
+	# The BFD linker knows what the default object file format is, so
+	# first see if it will tell us. cd to the root directory to prevent
+	# problems with other programs or directories called `ld' in the path.
+	ld_supported_emulations=`cd /; ld --help 2>&1 \
+			 | sed -ne '/supported emulations:/!d
+				    s/[ 	][ 	]*/ /g
+				    s/.*supported emulations: *//
+				    s/ .*//
+				    p'`
+        case "$ld_supported_emulations" in
+	  i*86linux)
+		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+		exit 0
+		;;
+	  elf_i*86)
+		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
+		;;
+	  i*86coff)
+		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
 		exit 0
 		;;
 	esac
-
-	if test "${UNAME_MACHINE}" = "alpha" ; then
-		cat <<EOF >$dummy.s
-			.data
-		\$Lformat:
-			.byte 37,100,45,37,120,10,0	# "%d-%x\n"
-
-			.text
-			.globl main
-			.align 4
-			.ent main
-		main:
-			.frame \$30,16,\$26,0
-			ldgp \$29,0(\$27)
-			.prologue 1
-			.long 0x47e03d80 # implver \$0
-			lda \$2,-1
-			.long 0x47e20c21 # amask \$2,\$1
-			lda \$16,\$Lformat
-			mov \$0,\$17
-			not \$1,\$18
-			jsr \$26,printf
-			ldgp \$29,0(\$26)
-			mov 0,\$16
-			jsr \$26,exit
-			.end main
-EOF
-		LIBC=""
-		$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
-		if test "$?" = 0 ; then
-			case `./$dummy` in
-			0-0)
-				UNAME_MACHINE="alpha"
-				;;
-			1-0)
-				UNAME_MACHINE="alphaev5"
-				;;
-			1-1)
-				UNAME_MACHINE="alphaev56"
-				;;
-			1-101)
-				UNAME_MACHINE="alphapca56"
-				;;
-			2-303)
-				UNAME_MACHINE="alphaev6"
-				;;
-			2-307)
-				UNAME_MACHINE="alphaev67"
-				;;
-			esac
-
-			objdump --private-headers $dummy | \
-			  grep ld.so.1 > /dev/null
-			if test "$?" = 0 ; then
-				LIBC="libc1"
-			fi
-		fi
-		rm -f $dummy.s $dummy
-		echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0
-	elif test "${UNAME_MACHINE}" = "mips" ; then
-	  cat >$dummy.c <<EOF
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-#ifdef __MIPSEB__
-  printf ("%s-unknown-linux-gnu\n", argv[1]);
-#endif
-#ifdef __MIPSEL__
-  printf ("%sel-unknown-linux-gnu\n", argv[1]);
-#endif
-  return 0;
-}
-EOF
-	  $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
-	  rm -f $dummy.c $dummy
-	elif test "${UNAME_MACHINE}" = "s390"; then
-	  echo s390-ibm-linux && exit 0
-	else
-	  # Either a pre-BFD a.out linker (linux-gnuoldld)
-	  # or one that does not give us useful --help.
-	  # GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
-	  # If ld does not provide *any* "supported emulations:"
-	  # that means it is gnuoldld.
-	  echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations:"
-	  test $? != 0 && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
-
-	  case "${UNAME_MACHINE}" in
-	  i?86)
-	    VENDOR=pc;
-	    ;;
-	  *)
-	    VENDOR=unknown;
-	    ;;
-	  esac
-	  # Determine whether the default compiler is a.out or elf
-	  cat >$dummy.c <<EOF
+	# Either a pre-BFD a.out linker (linux-gnuoldld)
+	# or one that does not give us useful --help.
+	# GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
+	# If ld does not provide *any* "supported emulations:"
+	# that means it is gnuoldld.
+	test -z "$ld_supported_emulations" && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
+	case "${UNAME_MACHINE}" in
+	i*86)
+	  VENDOR=pc;
+	  ;;
+	*)
+	  VENDOR=unknown;
+	  ;;
+	esac
+	# Determine whether the default compiler is a.out or elf
+	cat >$dummy.c <<EOF
 #include <features.h>
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
@@ -849,15 +941,16 @@ EOF
   return 0;
 }
 EOF
-	  $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
-	  rm -f $dummy.c $dummy
-	fi ;;
+	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
+	rm -f $dummy.c $dummy
+	test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0
+	;;
 # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
 # are messed up and put the nodename in both sysname and nodename.
-    i?86:DYNIX/ptx:4*:*)
+    i*86:DYNIX/ptx:4*:*)
 	echo i386-sequent-sysv4
 	exit 0 ;;
-    i?86:UNIX_SV:4.2MP:2.*)
+    i*86:UNIX_SV:4.2MP:2.*)
         # Unixware is an offshoot of SVR4, but it has its own version
         # number series starting with 2...
         # I am not positive that other SVR4 systems won't match this,
@@ -865,7 +958,7 @@ EOF
         # Use sysv4.2uw... so that sysv4* matches it.
 	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
 	exit 0 ;;
-    i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
 	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
 		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
@@ -873,7 +966,7 @@ EOF
 		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
 	fi
 	exit 0 ;;
-    i?86:*:5:7*)
+    i*86:*:5:7*)
         # Fixed at (any) Pentium or better
         UNAME_MACHINE=i586
         if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
@@ -882,7 +975,7 @@ EOF
 	    echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
 	fi
 	exit 0 ;;
-    i?86:*:3.2:*)
+    i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
 		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
@@ -900,7 +993,7 @@ EOF
 		echo ${UNAME_MACHINE}-pc-sysv32
 	fi
 	exit 0 ;;
-    i?86:*DOS:*:*)
+    i*86:*DOS:*:*)
 	echo ${UNAME_MACHINE}-pc-msdosdjgpp
 	exit 0 ;;
     pc:*:*:*)
@@ -928,7 +1021,7 @@ EOF
 	exit 0 ;;
     M68*:*:R3V[567]*:*)
 	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
-    3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
+    3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
 	OS_REL=''
 	test -r /etc/.relid \
 	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
@@ -939,21 +1032,24 @@ EOF
     3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
         /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
           && echo i486-ncr-sysv4 && exit 0 ;;
-    m68*:LynxOS:2.*:*)
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
 	echo m68k-unknown-lynxos${UNAME_RELEASE}
 	exit 0 ;;
     mc68030:UNIX_System_V:4.*:*)
 	echo m68k-atari-sysv4
 	exit 0 ;;
-    i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
 	echo i386-unknown-lynxos${UNAME_RELEASE}
 	exit 0 ;;
     TSUNAMI:LynxOS:2.*:*)
 	echo sparc-unknown-lynxos${UNAME_RELEASE}
 	exit 0 ;;
-    rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
+    rs6000:LynxOS:2.*:*)
 	echo rs6000-unknown-lynxos${UNAME_RELEASE}
 	exit 0 ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
+	echo powerpc-unknown-lynxos${UNAME_RELEASE}
+	exit 0 ;;
     SM[BE]S:UNIX_SV:*:*)
 	echo mips-dde-sysv${UNAME_RELEASE}
 	exit 0 ;;
@@ -987,7 +1083,7 @@ EOF
     mc68*:A/UX:*:*)
 	echo m68k-apple-aux${UNAME_RELEASE}
 	exit 0 ;;
-    news*:NEWS-OS:*:6*)
+    news*:NEWS-OS:6*:*)
 	echo mips-sony-newsos6
 	exit 0 ;;
     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
@@ -1030,15 +1126,52 @@ EOF
     *:QNX:*:4*)
 	echo i386-pc-qnx
 	exit 0 ;;
-    NSR-W:NONSTOP_KERNEL:*:*)
+    NSR-[KW]:NONSTOP_KERNEL:*:*)
 	echo nsr-tandem-nsk${UNAME_RELEASE}
 	exit 0 ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit 0 ;;
     BS2000:POSIX*:*:*)
 	echo bs2000-siemens-sysv
 	exit 0 ;;
     DS/*:UNIX_System_V:*:*)
 	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
 	exit 0 ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = "386"; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo ${UNAME_MACHINE}-unknown-plan9
+	exit 0 ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo ${UNAME_MACHINE}-pc-os2-emx
+	exit 0 ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit 0 ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit 0 ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit 0 ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit 0 ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit 0 ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit 0 ;;
 esac
 
 #echo '(No uname command or uname output not recognized.)' 1>&2
@@ -1130,11 +1263,24 @@ main ()
 #endif
 
 #if defined (vax)
-#if !defined (ultrix)
-  printf ("vax-dec-bsd\n"); exit (0);
-#else
-  printf ("vax-dec-ultrix\n"); exit (0);
-#endif
+# if !defined (ultrix)
+#  include <sys/param.h>
+#  if defined (BSD)
+#   if BSD == 43
+      printf ("vax-dec-bsd4.3\n"); exit (0);
+#   else
+#    if BSD == 199006
+      printf ("vax-dec-bsd4.3reno\n"); exit (0);
+#    else
+      printf ("vax-dec-bsd\n"); exit (0);
+#    endif
+#   endif
+#  else
+    printf ("vax-dec-bsd\n"); exit (0);
+#  endif
+# else
+    printf ("vax-dec-ultrix\n"); exit (0);
+# endif
 #endif
 
 #if defined (alliant) && defined (i860)
@@ -1145,7 +1291,7 @@ main ()
 }
 EOF
 
-$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm $dummy.c $dummy && exit 0
+$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm -f $dummy.c $dummy && exit 0
 rm -f $dummy.c $dummy
 
 # Apollos put the system type in the environment.
@@ -1178,6 +1324,48 @@ then
     esac
 fi
 
-#echo '(Unable to guess system type)' 1>&2
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+    ftp://ftp.gnu.org/pub/gnu/config/
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
 
 exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

config.sub

@@ -1,8 +1,10 @@
 #! /bin/sh
-# Configuration validation subroutine script, version 1.1.
-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+# Configuration validation subroutine script.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
 #   Free Software Foundation, Inc.
-#
+
+timestamp='2001-04-20'
+
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
 # can handle that machine.  It does not imply ALL GNU software can.
@@ -27,7 +29,6 @@
 # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.
 
-# Written by Per Bothner <bothner@cygnus.com>.
 # Please send patches to <config-patches@gnu.org>.
 #
 # Configuration subroutine to validate and canonicalize a configuration type.
@@ -50,30 +51,73 @@
 #	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
 # It is wrong to echo any other type of specification.
 
-if [ x$1 = x ]
-then
-	echo Configuration name missing. 1>&2
-	echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
-	echo "or     $0 ALIAS" 1>&2
-	echo where ALIAS is a recognized configuration type. 1>&2
-	exit 1
-fi
+me=`echo "$0" | sed -e 's,.*/,,'`
 
-# First pass through any local machine types.
-case $1 in
-	*local*)
-		echo $1
-		exit 0
-		;;
-	*)
-	;;
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit 0 ;;
+    --version | -v )
+       echo "$version" ; exit 0 ;;
+    --help | --h* | -h )
+       echo "$usage"; exit 0 ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit 0;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
 esac
 
 # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
-  nto-qnx* | linux-gnu*)
+  nto-qnx* | linux-gnu* | storm-chaos* | os2-emx*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
@@ -99,7 +143,7 @@ case $os in
 	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
 	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
 	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple)
+	-apple | -axis)
 		os=
 		basic_machine=$1
 		;;
@@ -171,30 +215,40 @@ esac
 case $basic_machine in
 	# Recognize the basic CPU types without company name.
 	# Some are omitted here because they have special meanings below.
-	tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
-		| arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
+	tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc \
+	        | arm | arme[lb] | arm[bl]e | armv[2345] | armv[345][lb] | strongarm | xscale \
+		| pyramid | mn10200 | mn10300 | tron | a29k \
 		| 580 | i960 | h8300 \
-		| x86 | ppcbe | mipsbe | mipsle | shbe | shle | armbe | armle \
+		| x86 | ppcbe | mipsbe | mipsle | shbe | shle \
 		| hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
 		| hppa64 \
 		| alpha | alphaev[4-8] | alphaev56 | alphapca5[67] \
 		| alphaev6[78] \
-		| we32k | ns16k | clipper | i370 | sh | powerpc | powerpcle \
-		| 1750a | dsp16xx | pdp11 | mips16 | mips64 | mipsel | mips64el \
+		| we32k | ns16k | clipper | i370 | sh | sh[34] \
+		| powerpc | powerpcle \
+		| 1750a | dsp16xx | pdp10 | pdp11 \
+		| mips16 | mips64 | mipsel | mips64el \
 		| mips64orion | mips64orionel | mipstx39 | mipstx39el \
 		| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
-		| mips64vr5000 | miprs64vr5000el | mcore \
-		| sparc | sparclet | sparclite | sparc64 | sparcv9 | v850 | c4x \
-		| thumb | d10v | fr30 | avr)
+		| mips64vr5000 | miprs64vr5000el | mcore | s390 | s390x \
+		| sparc | sparclet | sparclite | sparc64 | sparcv9 | sparcv9b \
+		| v850 | c4x \
+		| thumb | d10v | d30v | fr30 | avr | openrisc | tic80 \
+		| pj | pjl | h8500)
 		basic_machine=$basic_machine-unknown
 		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | h8500 | w65 | pj | pjl)
+	m6811 | m68hc11 | m6812 | m68hc12)
+		# Motorola 68HC11/12.
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | w65)
 		;;
 
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
-	i[34567]86)
+	i*86 | x86_64)
 	  basic_machine=$basic_machine-pc
 	  ;;
 	# Object if more than one company name word.
@@ -204,27 +258,30 @@ case $basic_machine in
 		;;
 	# Recognize the basic CPU types with company name.
 	# FIXME: clean up the formatting here.
-	vax-* | tahoe-* | i[34567]86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
-	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
+	vax-* | tahoe-* | i*86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
+	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | c[123]* \
+	      | arm-*  | armbe-* | armle-* | armv*-* | strongarm-* | xscale-* \
 	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
 	      | power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
 	      | xmp-* | ymp-* \
-	      | x86-* | ppcbe-* | mipsbe-* | mipsle-* | shbe-* | shle-* | armbe-* | armle-* \
+	      | x86-* | ppcbe-* | mipsbe-* | mipsle-* | shbe-* | shle-* \
 	      | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* \
 	      | hppa2.0n-* | hppa64-* \
 	      | alpha-* | alphaev[4-8]-* | alphaev56-* | alphapca5[67]-* \
 	      | alphaev6[78]-* \
 	      | we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
 	      | clipper-* | orion-* \
-	      | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
-	      | sparc64-* | sparcv9-* | sparc86x-* | mips16-* | mips64-* | mipsel-* \
+	      | sparclite-* | pdp10-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
+	      | sparc64-* | sparcv9-* | sparcv9b-* | sparc86x-* \
+	      | mips16-* | mips64-* | mipsel-* \
 	      | mips64el-* | mips64orion-* | mips64orionel-* \
 	      | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
 	      | mipstx39-* | mipstx39el-* | mcore-* \
-	      | f301-* | armv*-* | s390-* | sv1-* | t3e-* \
+	      | f30[01]-* | f700-* | s390-* | s390x-* | sv1-* | t3e-* \
+	      | [cjt]90-* \
 	      | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
-	      | thumb-* | v850-* | d30v-* | tic30-* | c30-* | fr30-* \
-	      | bs2000-*)
+	      | thumb-* | v850-* | d30v-* | tic30-* | tic80-* | c30-* | fr30-* \
+	      | bs2000-* | tic54x-* | c54x-* | x86_64-* | pj-* | pjl-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -261,14 +318,14 @@ case $basic_machine in
 		os=-sysv
 		;;
 	amiga | amiga-*)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		;;
 	amigaos | amigados)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		os=-amigaos
 		;;
 	amigaunix | amix)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		os=-sysv4
 		;;
 	apollo68)
@@ -315,13 +372,16 @@ case $basic_machine in
 		basic_machine=cray2-cray
 		os=-unicos
 		;;
-	[ctj]90-cray)
-		basic_machine=c90-cray
+	[cjt]90)
+		basic_machine=${basic_machine}-cray
 		os=-unicos
 		;;
 	crds | unos)
 		basic_machine=m68k-crds
 		;;
+	cris | cris-* | etrax*)
+		basic_machine=cris-axis
+		;;
 	da30 | da30-*)
 		basic_machine=m68k-da30
 		;;
@@ -369,6 +429,10 @@ case $basic_machine in
 		basic_machine=tron-gmicro
 		os=-sysv
 		;;
+	go32)
+		basic_machine=i386-pc
+		os=-go32
+		;;
 	h3050r* | hiux*)
 		basic_machine=hppa1.1-hitachi
 		os=-hiuxwe2
@@ -444,19 +508,19 @@ case $basic_machine in
 		basic_machine=i370-ibm
 		;;
 # I'm not sure what "Sysv32" means.  Should this be sysv3.2?
-	i[34567]86v32)
+	i*86v32)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv32
 		;;
-	i[34567]86v4*)
+	i*86v4*)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv4
 		;;
-	i[34567]86v)
+	i*86v)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv
 		;;
-	i[34567]86sol2)
+	i*86sol2)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-solaris2
 		;;
@@ -468,14 +532,6 @@ case $basic_machine in
 		basic_machine=i386-unknown
 		os=-vsta
 		;;
-	i386-go32 | go32)
-		basic_machine=i386-unknown
-		os=-go32
-		;;
-	i386-mingw32 | mingw32)
-		basic_machine=i386-unknown
-		os=-mingw32
-		;;
 	iris | iris4d)
 		basic_machine=mips-sgi
 		case $os in
@@ -501,6 +557,10 @@ case $basic_machine in
 		basic_machine=ns32k-utek
 		os=-sysv
 		;;
+	mingw32)
+		basic_machine=i386-pc
+		os=-mingw32
+		;;
 	miniframe)
 		basic_machine=m68000-convergent
 		;;
@@ -531,7 +591,7 @@ case $basic_machine in
 		os=-coff
 		;;
 	msdos)
-		basic_machine=i386-unknown
+		basic_machine=i386-pc
 		os=-msdos
 		;;
 	mvs)
@@ -595,6 +655,10 @@ case $basic_machine in
 		basic_machine=i960-intel
 		os=-mon960
 		;;
+	nonstopux)
+		basic_machine=mips-compaq
+		os=-nonstopux
+		;;
 	np1)
 		basic_machine=np1-gould
 		;;
@@ -630,28 +694,28 @@ case $basic_machine in
         pc532 | pc532-*)
 		basic_machine=ns32k-pc532
 		;;
-	pentium | p5 | k5 | k6 | nexen)
+	pentium | p5 | k5 | k6 | nexgen)
 		basic_machine=i586-pc
 		;;
-	pentiumpro | p6 | 6x86)
+	pentiumpro | p6 | 6x86 | athlon)
 		basic_machine=i686-pc
 		;;
 	pentiumii | pentium2)
-		basic_machine=i786-pc
+		basic_machine=i686-pc
 		;;
-	pentium-* | p5-* | k5-* | k6-* | nexen-*)
+	pentium-* | p5-* | k5-* | k6-* | nexgen-*)
 		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
-	pentiumpro-* | p6-* | 6x86-*)
+	pentiumpro-* | p6-* | 6x86-* | athlon-*)
 		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	pentiumii-* | pentium2-*)
-		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	pn)
 		basic_machine=pn-gould
 		;;
-	power)	basic_machine=rs6000-ibm
+	power)	basic_machine=power-ibm
 		;;
 	ppc)	basic_machine=powerpc-unknown
 	        ;;
@@ -666,6 +730,10 @@ case $basic_machine in
 	ps2)
 		basic_machine=i386-ibm
 		;;
+	pw32)
+		basic_machine=i586-unknown
+		os=-pw32
+		;;
 	rom68k)
 		basic_machine=m68k-rom68k
 		os=-coff
@@ -757,6 +825,10 @@ case $basic_machine in
 		basic_machine=t3e-cray
 		os=-unicos
 		;;
+	tic54x | c54x*)
+		basic_machine=tic54x-unknown
+		os=-coff
+		;;
 	tx39)
 		basic_machine=mipstx39-unknown
 		;;
@@ -852,13 +924,20 @@ case $basic_machine in
 	vax)
 		basic_machine=vax-dec
 		;;
+	pdp10)
+		# there are many clones, so DEC is not a safe bet
+		basic_machine=pdp10-unknown
+		;;
 	pdp11)
 		basic_machine=pdp11-dec
 		;;
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sparc | sparcv9)
+	sh3 | sh4)
+		basic_machine=sh-unknown
+		;;
+	sparc | sparcv9 | sparcv9b)
 		basic_machine=sparc-sun
 		;;
         cydra)
@@ -880,6 +959,9 @@ case $basic_machine in
 		basic_machine=c4x-none
 		os=-coff
 		;;
+	*-unknown)
+		# Make sure to match an already-canonicalized machine name.
+		;;
 	*)
 		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
 		exit 1
@@ -939,12 +1021,13 @@ case $os in
 	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
 	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
 	      | -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
-	      | -openstep* | -oskit*)
+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* | -os2*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
 	-qnx*)
 		case $basic_machine in
-		    x86-* | i[34567]86-*)
+		    x86-* | i*86-*)
 			;;
 		    *)
 			os=-nto$os
@@ -1000,7 +1083,7 @@ case $os in
 	-ns2 )
 	        os=-nextstep2
 		;;
-	-nsk)
+	-nsk*)
 		os=-nsk
 		;;
 	# Preserve the version number of sinix5.
@@ -1037,7 +1120,7 @@ case $os in
 	-xenix)
 		os=-xenix
 		;;
-        -*mint | -*MiNT)
+        -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
 	        os=-mint
 		;;
 	-none)
@@ -1071,6 +1154,9 @@ case $basic_machine in
 	arm*-semi)
 		os=-aout
 		;;
+	pdp10-*)
+		os=-tops20
+		;;
         pdp11-*)
 		os=-none
 		;;
@@ -1179,7 +1265,7 @@ case $basic_machine in
 	*-masscomp)
 		os=-rtu
 		;;
-	f301-fujitsu)
+	f30[01]-fujitsu | f700-fujitsu)
 		os=-uxpv
 		;;
 	*-rom68k)
@@ -1257,7 +1343,7 @@ case $basic_machine in
 			-mpw* | -macos*)
 				vendor=apple
 				;;
-			-*mint | -*MiNT)
+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
 				vendor=atari
 				;;
 		esac
@@ -1266,3 +1352,11 @@ case $basic_machine in
 esac
 
 echo $basic_machine$os
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

configure.in

@@ -1,27 +1,45 @@
 dnl $Id$
 dnl Process this file with autoconf to produce a configure script.
-AC_INIT(lib/urldata.h)
+AC_INIT
+AC_CONFIG_SRCDIR([lib/urldata.h])
 AM_CONFIG_HEADER(config.h src/config.h)
 
 VERSION=`sed -ne 's/^#define LIBCURL_VERSION "\(.*\)"/\1/p' ${srcdir}/include/curl/curl.h`
 AM_INIT_AUTOMAKE(curl,$VERSION)
-AM_PROG_LIBTOOL
+
+dnl
+dnl we extract the numerical version for curl-config only
+VERSIONNUM=`sed -ne 's/^#define LIBCURL_VERSION_NUM 0x\(.*\)/\1/p' ${srcdir}/include/curl/curl.h`
+AC_SUBST(VERSIONNUM)
+
+dnl Solaris pkgadd support definitions
+PKGADD_PKG="HAXXcurl"
+PKGADD_NAME="cURL - a client that groks URLs"
+PKGADD_VENDOR="curl.haxx.se"
+AC_SUBST(PKGADD_PKG)
+AC_SUBST(PKGADD_NAME)
+AC_SUBST(PKGADD_VENDOR)
+
 
 dnl
 dnl Detect the canonical host and target build environment
 dnl
-AC_CANONICAL_HOST
-AC_CANONICAL_TARGET
 
-dnl Checks for programs.
-AC_PROG_CC
+AC_CANONICAL_HOST
+dnl Get system canonical name
+AC_DEFINE_UNQUOTED(OS, "${host}")
 
 dnl Check for AIX weirdos
 AC_AIX
 
+dnl Checks for programs.
+AC_PROG_CC
+
 dnl check for how to do large files
 AC_SYS_LARGEFILE
 
+AM_PROG_LIBTOOL
+
 dnl The install stuff has already been taken care of by the automake stuff
 dnl AC_PROG_INSTALL
 AC_PROG_MAKE_SET
@@ -82,6 +100,9 @@ void main(void) {
 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
 ])
 
@@ -506,6 +527,10 @@ then
       dnl add define KRB4
       AC_DEFINE(KRB4)
 
+      dnl substitute it too!
+      KRB4_ENABLED=1
+      AC_SUBST(KRB4_ENABLED)
+
       dnl the krb4 stuff needs a strlcpy()
       AC_CHECK_FUNCS(strlcpy)
 
@@ -515,6 +540,7 @@ else
   AC_MSG_RESULT(no)
 fi
 
+
 dnl **********************************************************************
 dnl Check for the presence of SSL libraries and headers
 dnl **********************************************************************
@@ -532,26 +558,36 @@ then
   AC_MSG_WARN(SSL/https support disabled)  
 else
 
-  dnl Check for & handle argument to --with-ssl.
+  dnl Check for and handle argument to --with-ssl.
+  EXTRA_SSL=
 
-  AC_MSG_CHECKING(where to look for SSL)
-  if test X"$OPT_SSL" = Xoff
-  then
-  	AC_MSG_RESULT([defaults (or given in environment)])
-  else
-	test X"$OPT_SSL" = Xyes && OPT_SSL=/usr/local/ssl
-        dnl	LIBS="$LIBS -L$OPT_SSL/lib"
-        LDFLAGS="$LDFLAGS -L$OPT_SSL/lib"
-	CPPFLAGS="$CPPFLAGS -I$OPT_SSL/include/openssl -I$OPT_SSL/include"
-	AC_MSG_RESULT([$OPT_SSL])
-  fi
+  case "$OPT_SSL" in
+  yes)
+    EXTRA_SSL=/usr/local/ssl ;;
+  *)
+    EXTRA_SSL=$OPT_SSL ;;
+  esac
 
-  dnl check for crypto libs (part of SSLeay)
-  AC_CHECK_LIB(crypto, CRYPTO_lock)
+  AC_CHECK_LIB(crypto, CRYPTO_lock,[
+     HAVECRYPTO="yes"
+     ],[
+     OLDLDFLAGS="$LDFLAGS"
+     OLDCPPFLAGS="$CPPFLAGS"
+     LDFLAGS="$LDFLAGS -L$EXTRA_SSL/lib"
+     CPPFLAGS="$CPPFLAGS -I$EXTRA_SSL/include/openssl -I$EXTRA_SSL/include"
+     AC_CHECK_LIB(crypto, CRYPTO_add_lock,[
+       HAVECRYPTO="yes" ], [
+       LDFLAGS="$OLDLDFLAGS"
+       CPPFLAGS="$OLDCPPFLAGS"
+       ])
+    ])
 
-  if test $ac_cv_lib_crypto_CRYPTO_lock = yes; then
+
+  if test "$HAVECRYPTO" = "yes"; then
     dnl This is only reasonable to do if crypto actually is there: check for
     dnl SSL libs NOTE: it is important to do this AFTER the crypto lib
+
+    AC_CHECK_LIB(crypto, CRYPTO_add_lock)
     AC_CHECK_LIB(ssl, SSL_connect)
 
     if test "$ac_cv_lib_ssl_SSL_connect" != yes; then
@@ -570,16 +606,26 @@ else
     fi
 
 
-
     dnl Check for SSLeay headers
-    AC_CHECK_HEADERS(openssl/x509.h openssl/rsa.h openssl/crypto.h openssl/pem.h openssl/ssl.h openssl/err.h)
+    AC_CHECK_HEADERS(openssl/x509.h openssl/rsa.h openssl/crypto.h \
+                     openssl/pem.h openssl/ssl.h openssl/err.h,
+      OPENSSL_ENABLED=1)
 
     if test $ac_cv_header_openssl_x509_h = no; then
-      AC_CHECK_HEADERS(x509.h rsa.h crypto.h pem.h ssl.h err.h)
+      AC_CHECK_HEADERS(x509.h rsa.h crypto.h pem.h ssl.h err.h,
+        OPENSSL_ENABLED=1)
     fi
 
+    AC_SUBST(OPENSSL_ENABLED)
+
   fi
 
+  if test X"$OPT_SSL" != Xoff &&
+     test "$OPENSSL_ENABLED" != "1"; then
+    AC_MSG_ERROR([OpenSSL libs and/or directories were not found where specified!])
+  fi
+
+
   dnl these can only exist if openssl exists
 
   AC_CHECK_FUNCS( RAND_status \
@@ -723,11 +769,6 @@ if test "$socklen_t" != "yes"; then
   AC_CHECK_TYPE(socklen_t, int)
 fi
 
-
-dnl Get system canonical name
-AC_CANONICAL_HOST
-AC_DEFINE_UNQUOTED(OS, "${host}")
-
 dnl Checks for library functions.
 dnl AC_PROG_GCC_TRADITIONAL
 AC_TYPE_SIGNAL
@@ -736,6 +777,7 @@ AC_CHECK_FUNCS( socket \
                 select \
                 strdup \
                 strstr \
+                strtok_r \
                 strftime \
                 uname \
                 strcasecmp \
@@ -783,7 +825,7 @@ dnl AC_PATH_PROG( RANLIB, ranlib, /usr/bin/ranlib,
 dnl   $PATH:/usr/bin/:/usr/local/bin )
 dnl AC_SUBST(RANLIB)
 
-AC_OUTPUT( Makefile \
+AC_CONFIG_FILES([Makefile \
 	   docs/Makefile \
            docs/examples/Makefile \
 	   include/Makefile \
@@ -798,9 +840,12 @@ AC_OUTPUT( Makefile \
 	   packages/Linux/RPM/Makefile \
 	   packages/Linux/RPM/curl.spec \
 	   packages/Linux/RPM/curl-ssl.spec \
+           packages/Solaris/Makefile \
            perl/Makefile \
            perl/Curl_easy/Makefile \
            php/Makefile \
-           php/examples/Makefile
-)
+           php/examples/Makefile \
+           curl-config
+])
+AC_OUTPUT
 

curl-config.in

@@ -0,0 +1,90 @@
+#! /bin/sh
+#
+# The idea to this kind of setup info script was stolen from numerous
+# other packages, such as neon, libxml and gnome.
+#
+# $Id$
+#
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+
+usage()
+{
+    cat <<EOF
+Usage: curl-config [OPTION]
+
+Available values for OPTION include:
+
+  --cflags    pre-processor and compiler flags
+  --feature   newline separated list of enabled features
+  --help      display this help and exit
+  --libs      library linking information
+  --prefix    curl install prefix
+  --version   output version information
+EOF
+
+    exit $1
+}
+
+if test $# -eq 0; then
+    usage 1
+fi
+
+while test $# -gt 0; do
+    case "$1" in
+    # this deals with options in the style
+    # --option=value and extracts the value part
+    # [not currently used]
+    -*=*) value=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+    *) value= ;;
+    esac
+
+    case "$1" in
+    --prefix)
+	echo $prefix
+	;;
+
+    --feature)
+	if test "@OPENSSL_ENABLED@" = "1"; then
+          echo "SSL"
+        fi
+	if test "@KRB4_ENABLED@" = "1"; then
+          echo "KRB4"
+        fi
+	if test "@IPV6_ENABLED@" = "1"; then
+          echo "IPv6"
+        fi
+	;;
+
+    --version)
+	echo libcurl @VERSION@
+	exit 0
+	;;
+
+    --vernum)
+	echo @VERSIONNUM@
+	exit 0
+	;;
+
+    --help)
+	usage 0
+	;;
+
+    --cflags)
+       	echo @CPPFLAGS@
+       	;;
+
+    --libs)
+       	echo @LDFLAGS@ @LIBS@
+       	;;
+
+    *)
+	usage
+	exit 1
+	;;
+    esac
+    shift
+done
+
+exit 0

docs/CONTRIBUTE

@@ -16,7 +16,7 @@ The License Issue
  the same license curl and libcurl is already using unless stated otherwise.
 
  If you add a larger piece of code, you can opt to make that file or set of
- files to use a different license as long as they don't enfore any changes to
+ files to use a different license as long as they don't enforce any changes to
  the rest of the package and they make sense. Such "separate parts" can not be
  GPL (as we don't want the GPL virus to attack users of libcurl) but they must
  use "GPL compatible" licenses.

docs/FAQ

@@ -1,4 +1,4 @@
-Updated: March 22, 2001 (http://curl.haxx.se/docs/faq.shtml)
+Updated: May 29, 2001 (http://curl.haxx.se/docs/faq.shtml)
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -12,6 +12,8 @@ FAQ
   1.2 What is libcurl?
   1.3 What is cURL not?
   1.4 When will you make curl do XXXX ?
+  1.5 Who makes cURL?
+  1.6 What do you get for making cURL?
 
  2. Install Related Problems
   2.1 configure doesn't find OpenSSL even when it is installed
@@ -30,8 +32,9 @@ FAQ
   3.6 Does curl support javascript, ASP, XML, XHTML or HTML version Y?
   3.7 Can I use curl to delete/rename a file through FTP?
   3.8 How do I tell curl to follow HTTP redirects?
-  3.9 How do I use curl in PHP?
+  3.9 How do I use curl in PHP, Perl, Tcl, Ruby or Java?
   3.10 What about SOAP, WebDAV, XML-RPC or similar protocols over HTTP?
+  3.11 How do I POST with a different Content-Type?
 
  4. Running Problems
   4.1 Problems connecting to SSL servers.
@@ -45,7 +48,7 @@ FAQ
    4.5.4 "404 Not Found"
    4.5.5 "405 Method Not Allowed"
   4.6 Can you tell me what error code 142 means?
-  4.7 How do I keep usernames and passwords secret in Curl command lines?
+  4.7 How do I keep user names and passwords secret in Curl command lines?
   4.8 I found a bug!
   4.9 Curl can't authenticate to the server that requires NTLM?
 
@@ -55,7 +58,7 @@ FAQ
   5.3 How do I fetch multiple files with libcurl?
   5.4 Does libcurl do Winsock initing on win32 systems?
   5.5 Does CURLOPT_FILE and CURLOPT_INFILE work on win32 ?
-  5.6 What about Keep-Alive or persistant connections?
+  5.6 What about Keep-Alive or persistent connections?
 
  6. License Issues
   6.1 I have a GPL program, can I use the libcurl library?
@@ -76,7 +79,7 @@ FAQ
   with URL spelled in uppercase to make it obvious it deals with URLs. The
   fact it can also be pronounced 'see URL' also helped.
 
-  Curl supports a range of common internet protocols, currently including
+  Curl supports a range of common Internet protocols, currently including
   HTTP, HTTPS, FTP, GOPHER, LDAP, DICT, TELNET and FILE.
 
   We spell it cURL or just curl. We pronounce it with an initial k sound:
@@ -84,10 +87,11 @@ FAQ
 
   1.2 What is libcurl?
 
-  libcurl is a reliable, higly portable multiprotocol file transfer library.
+  libcurl is a reliable and portable library which provides you with an easy
+  interface to a range of common Internet protocols.
 
-  Any application is free to use libcurl, even commercial or closed-source
-  ones.
+  You can use libcurl for free in your application even if it is commercial
+  or closed-source.
 
   1.3 What is cURL not?
   
@@ -100,8 +104,8 @@ FAQ
   something: fine, go ahead and write a script that wraps around curl to make
   it reality (like curlmirror.pl does).
 
-  Curl is not an ftp site mirroring program. Sure, get and send ftp with curl
-  but if you want systematic and sequential behaviour you should write a
+  Curl is not an FTP site mirroring program. Sure, get and send FTP with curl
+  but if you want systematic and sequential behavior you should write a
   script (or write a new program that interfaces libcurl) and do it.
 
   Curl is not a PHP tool, even though it works perfectly well when used from
@@ -141,6 +145,31 @@ FAQ
   * If you write the code, chances are bigger that it will get into curl
     faster.
 
+  1.5 Who makes cURL?
+
+  cURL and libcurl are not made by any single individual. Sure, Daniel
+  Stenberg writes the major parts, but various people's submissions are
+  important and crucial. Anyone can post their changes and improvements and
+  have them inserted in the main sources (of course on the condition that
+  developers agree on that the fixes are good).
+
+  The list of contributors in the bottom of the man page is only a small part
+  of all the people that every day provide us with bug reports, suggestions,
+  ideas and source code.
+
+  curl is developed by a community, with Daniel at the wheel.
+
+  1.6 What do you get for making cURL?
+
+  Project cURL is entirely free and open, without any commercial interests or
+  money involved. No person gets paid in any way for developing curl. We all
+  do this voluntarily on our spare time.
+
+  We get some help from companies. Contactor Data hosts the curl web site and
+  the main mailing list, Haxx owns the curl web site's domain and
+  sourceforge.net hosts several project tools we take advantage from like the
+  bug tracker, mailing lists and more.
+
 2. Install Related Problems
 
   2.1. configure doesn't find OpenSSL even when it is installed
@@ -176,7 +205,7 @@ FAQ
     a few functions are left out from the libssl.
 
     If the function names missing include RSA or RSAREF you can be certain
-    that this is because libssl requires the RSA and RSASEF libs to build.
+    that this is because libssl requires the RSA and RSAREF libs to build.
 
     See the INSTALL file section that explains how to add those libs to
     configure. Make sure that you remove the config.cache file before you
@@ -195,12 +224,12 @@ FAQ
 
   Curl uses OpenSSL to do the SSL stuff. The LIBEAY32.DLL is what curl needs
   on a windows machine to do https://. Check out the curl web site to find
-  accurate and up-to-date pointers to recent OpenSSL DDLs and other binary
+  accurate and up-to-date pointers to recent OpenSSL DLLs and other binary
   packages.
 
   2.4. Does cURL support Socks (RFC 1928) ?
 
-  No. Nobody has wanted it that badly yet. We appriciate patches that bring
+  No. Nobody has wanted it that badly yet. We appreciate patches that bring
   this functionality.
 
 
@@ -235,10 +264,11 @@ FAQ
   use the -F type. In all the most common cases, you should use -d which then
   causes a posting with the type 'application/x-www-form-urlencoded'.
 
-  This is described in some detail in the README.curl file, and if you don't
-  understand it the first time, read it again before you post questions about
-  this to the mailing list. Also, try reading through the mailing list
-  archives for old postings and questions regarding this.
+  This is described in some detail in the MANUAL and TheArtOfHttpScripting
+  documents, and if you don't understand it the first time, read it again
+  before you post questions about this to the mailing list. Also, try reading
+  through the mailing list archives for old postings and questions regarding
+  this.
 
   3.4. How do I tell curl to run custom FTP commands?
 
@@ -246,7 +276,7 @@ FAQ
   file transfer. Study the -Q/--quote option.
 
   Since curl is used for file transfers, you don't use curl to just perform
-  ftp commands without transfering anything. Therefore you must always specify
+  FTP commands without transferring anything. Therefore you must always specify
   a URL to transfer to/from even when doing custom FTP commands.
 
   3.5. How can I disable the Pragma: nocache header?
@@ -258,7 +288,7 @@ FAQ
   3.6. Does curl support javascript, ASP, XML, XHTML or HTML version Y?
 
   To curl, all contents are alike. It doesn't matter how the page was
-  generated. It may be ASP, PHP, perl, shell-script, SSI or plain
+  generated. It may be ASP, PHP, Perl, shell-script, SSI or plain
   HTML-files. There's no difference to curl and it doesn't even know what kind
   of language that generated the page.
 
@@ -268,7 +298,7 @@ FAQ
 
   3.7. Can I use curl to delete/rename a file through FTP?
 
-  Yes. You specify custom ftp commands with -Q/--quote.
+  Yes. You specify custom FTP commands with -Q/--quote.
 
   One example would be to delete a file after you have downloaded it:
 
@@ -282,8 +312,21 @@ FAQ
 
      curl -L http://redirector.com
 
-  3.9 How do I use curl in PHP?
+  3.9 How do I use curl in PHP, Perl, Tcl, Ruby or Java?
 
+  There exist many language-interfaces for curl that integrates it better with
+  various languages. If you are fluid in a script language, you may very well
+  opt to use such an interface instead of using the command line tool.
+
+  At the time of writing, there are bindings for the five language mentioned
+  above, but chances are there are even more by the time you read this. Or you
+  may be able you write your own wrapper for a not-yet supported language!
+
+  Find out more about which languages that support curl directly, and how to
+  install and use them, in the libcurl section of the curl web site:
+
+        http://curl.haxx.se/libcurl/
+  
   PHP4 has the ability to use libcurl as an internal module if built with that
   option enabled. You then get a set of extra functions that can be used
   within your PHP programs. You find all details about those functions in the
@@ -298,13 +341,20 @@ FAQ
   3.10 What about SOAP, WebDAV, XML-RPC or similar protocols over HTTP?
 
   Curl adheres to the HTTP spec, which basically means you can play with *any*
-  protocol that is built ontop of HTTP. Protocols such as SOAP, WEBDAV and
+  protocol that is built on top of HTTP. Protocols such as SOAP, WEBDAV and
   XML-RPC are all such ones. You can use -X to set custom requests and -H to
   set custom headers (or replace internally generated ones).
 
   Using libcurl or PHP's curl modules is just as fine and you'd just use the
   proper library options to do the same.
 
+  3.11 How do I POST with a different Content-Type?
+
+  You can always replace the internally generated headers with -H/--header.
+  To make a simple HTTP POST with text/xml as content-type, do something like:
+
+        curl -d "datatopost" -H "Content-Type: text/xml" [URL]
+
 4. Running Problems
 
   4.1. Problems connecting to SSL servers.
@@ -326,7 +376,7 @@ FAQ
 
   In general unix shells, the & letter is treated special and when used, it
   runs the specified command in the background. To safely send the & as a part
-  of a URL, you should qoute the entire URL by using single (') or double (")
+  of a URL, you should quote the entire URL by using single (') or double (")
   quotes around it.
 
   An example that would invoke a remote CGI that uses &-letters could be:
@@ -401,13 +451,13 @@ FAQ
   abort from such a condition and that's why it got this undocumented
   error. This should not occur in releases after 7.4.1.
 
-  4.7. How do I keep usernames and passwords secret in Curl command lines?
+  4.7. How do I keep user names and passwords secret in Curl command lines?
 
   This problem has two sides:
 
   The first part is to avoid having clear-text passwords in the command line
   so that they don't appear in 'ps' outputs and similar. That is easily
-  avoided by using the "-K" option tho tell curl to read parameters from a
+  avoided by using the "-K" option to tell curl to read parameters from a
   file or stdin to which you can pass the secret info.
 
   To keep the passwords in your account secret from the rest of the world is
@@ -417,11 +467,11 @@ FAQ
 
   Also note that regular HTTP and FTP passwords are sent in clear across the
   network. All it takes for anyone to fetch them is to listen on the network.
-  Evesdropping is very easy.
+  Eavesdropping is very easy.
 
   4.8 I found a bug!
 
-  It is not a bug if the behaviour is documented. Read the docs first.
+  It is not a bug if the behavior is documented. Read the docs first.
 
   If it is a problem with a binary you've downloaded or a package for your
   particular platform, try contacting the person who built the package/archive
@@ -450,14 +500,16 @@ FAQ
   programs. libcurl will use thread-safe functions instead of non-safe ones if
   your system has such.
 
-  We would appriciate some kind of report or README file from those who have
+  We would appreciate some kind of report or README file from those who have
   used libcurl in a threaded environment.
 
   5.2 How can I receive all data into a large memory chunk?
 
+  [ See also the examples/getinmemory.c source ]
+
   You are in full control of the callback function that gets called every time
   there is data received from the remote server. You can make that callback do
-  whatever you want. You do not have to write the receivied data to a file.
+  whatever you want. You do not have to write the received data to a file.
 
   One solution to this problem could be to have a pointer to a struct that you
   pass to the callback function. You set the pointer using the
@@ -493,13 +545,13 @@ FAQ
   curl_easy_setopt() and then transfer it with curl_easy_perform(). The handle
   you get from curl_easy_init() is not only reusable starting with libcurl
   7.7, but also you're encouraged to reuse it if you can, as that will enable
-  libcurl to use persistant connections.
+  libcurl to use persistent connections.
 
   For libcurl prior to 7.7, there was no multiple file support. The only
   available way to do multiple requests was to init/perform/cleanup for each
   transfer.
 
-  5.4 Does libcurl do Winsock initing on win32 systems?
+  5.4 Does libcurl do Winsock initialization on win32 systems?
 
   No.
 
@@ -519,15 +571,15 @@ FAQ
 
   (Provided by Joel DeYoung and Bob Schader)
 
-  5.6 What about Keep-Alive or persistant connections?
+  5.6 What about Keep-Alive or persistent connections?
 
   Starting with version 7.7, curl and libcurl will have excellent support for
-  persistant connections when transferring several files from the same server.
+  persistent connections when transferring several files from the same server.
   Curl will attempt to reuse connections for all URLs specified on the same
   command line/config file, and libcurl will reuse connections for all
   transfers that are made using the same libcurl handle.
 
-  Previous versions had no persistant connection support.
+  Previous versions had no persistent connection support.
 
 6. License Issues
 

docs/INSTALL

@@ -7,7 +7,7 @@
                                 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
+way to proceed is mainly divided in two different ways: the unix way or the 
 windows way.
 
 If you're using Windows (95/98/NT/ME/2000 or whatever) or OS/2, you should
@@ -183,9 +183,9 @@ Win32
         For VC++ 6, there's an included Makefile.vc6 that should be possible
         to use out-of-the-box.
 
-        Microsoft note: add /Zm200 to the compiler options, as the hugehelp.c
-        won't compile otherwise due to "too long puts string" or something
-        like that!
+        Microsoft note: add /Zm200 to the compiler options to increase the 
+		compiler's memory allocation limit, as the hugehelp.c won't compile
+		due to "too long puts string".
 
 
    With SSL:
@@ -237,7 +237,7 @@ IBM OS/2
    If you want to build with OpenSSL or OpenLDAP support, you'll need to
    download those libraries, too. Dirk Ohme has done some work to port SSL
    libraries under OS/2, but it looks like he doesn't care about emx.  You'll
-   find his patches on: http://come.to/Dirk.Ohme
+   find his patches on: http://come.to/Dirk_Ohme
 
    If during the linking you get an error about _errno being an undefined
    symbol referenced from the text segment, you need to add -D__ST_MT_ERRNO__
@@ -251,10 +251,10 @@ IBM OS/2
 
 PORTS
 =====
-   Just to show off, this is a probably incomplete list of known hardware and
+   This is a probably incomplete list of known hardware and
    operating systems that curl has been compiled for:
 
-        - Ultrix
+        - Ultrix 4.3a
         - SINIX-Z v5
         - Alpha DEC OSF 4
         - Alpha Digital UNIX v3.2

docs/INTERNALS

@@ -1,4 +1,4 @@
-                                       Updated for curl 7.7 on March 13, 2001
+                                       Updated for curl 7.8 on May 29, 2001
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -69,45 +69,96 @@ Library
  rather small and easy-to-follow. All the ones prefixed with 'curl_easy' are
  put in the lib/easy.c file.
 
+ Starting with libcurl 7.8, curl_global_init_() and curl_global_cleanup() were
+ introduced. They should be called by the application to initialize and clean
+ up global stuff in the library. As of today, they just do the global SSL
+ initing if SSL is enabled. libcurl itself has no "global" scope.
+
  All printf()-style functions use the supplied clones in lib/mprintf.c. This
  makes sure we stay absolutely platform independent.
 
  curl_easy_init() allocates an internal struct and makes some initializations.
- The returned handle does not revail internals.
+ The returned handle does not reveal internals. This is the 'UrlData' struct
+ which works as a global "anchor" struct. All connections performed will get
+ connect-specific data allocated that should be used for things related to
+ particular connections/requests.
 
- curl_easy_setopt() takes a three arguments, where the option stuff must be
- passed in pairs, the parameter-ID and the parameter-value. The list of
- options is documented in the man page.
+ curl_easy_setopt() takes three arguments, where the option stuff must be
+ passed in pairs: the parameter-ID and the parameter-value. The list of
+ options is documented in the man page. This function mainly sets things in
+ the 'UrlData' struct.
 
  curl_easy_perform() does a whole lot of things:
 
- It starts off in the lib/easy.c file by calling curl_transfer(), but the main
- work is lib/url.c. The function first analyzes the URL, it separates the
- different components and connects to the remote host. This may involve using
- a proxy and/or using SSL. The Curl_gethost() function in lib/hostip.c is used
- for looking up host names.
+ It starts off in the lib/easy.c file by calling Curl_perform() and the main
+ work then continues in lib/url.c. The flow continues with a call to
+ Curl_connect() to connect to the remote site.
 
- When connected, the proper protocol-specific function is called. The
- functions are named after the protocols they handle. Curl_ftp(), Curl_http(),
- Curl_dict(), etc. They all reside in their respective files (ftp.c, http.c
- and dict.c).
+ o Curl_connect()
 
- The protocol-specific functions of course deal with protocol-specific
- negotiations and setup. They have access to the Curl_sendf() (from
- lib/sendf.c) function to send printf-style formatted data to the remote host
- and when they're ready to make the actual file transfer they call the
- Curl_Transfer() function (in lib/transfer.c) to setup the transfer and
- returns. Curl_perform() then calls Transfer() in lib/transfer.c that performs
- the entire file transfer. Curl_perform() is what does the main "connect - do
- - transfer - done" loop. It loops if there's a Location: to follow.
+   ... analyzes the URL, it separates the different components and connects to
+   the remote host. This may involve using a proxy and/or using SSL. The
+   Curl_gethost() function in lib/hostip.c is used for looking up host names.
 
- During transfer, the progress functions in lib/progress.c are called at a
- frequent interval (or at the user's choice, a specified callback might get
- called). The speedcheck functions in lib/speedcheck.c are also used to verify
- that the transfer is as fast as required.
+   When Curl_connect is done, we are connected to the remote site. Then it is
+   time to tell the server to get a document/file. Curl_do() arranges this.
+
+   This function makes sure there's an allocated and initiated 'connectdata'
+   struct that is used for this particular connection only (although there may
+   be several requests performed on the same connect). A bunch of things are
+   inited/inherited from the UrlData struct.
+
+ o Curl_do()
+
+   Curl_do() makes sure the proper protocol-specific function is called. The
+   functions are named after the protocols they handle. Curl_ftp(),
+   Curl_http(), Curl_dict(), etc. They all reside in their respective files
+   (ftp.c, http.c and dict.c). HTTPS is handled by Curl_http() and FTPS by
+   Curl_ftp().
+
+   The protocol-specific functions of course deal with protocol-specific
+   negotiations and setup. They have access to the Curl_sendf() (from
+   lib/sendf.c) function to send printf-style formatted data to the remote
+   host and when they're ready to make the actual file transfer they call the
+   Curl_Transfer() function (in lib/transfer.c) to setup the transfer and
+   returns.
+
+ o Transfer()
+
+   Curl_perform() then calls Transfer() in lib/transfer.c that performs
+   the entire file transfer.
+
+   During transfer, the progress functions in lib/progress.c are called at a
+   frequent interval (or at the user's choice, a specified callback might get
+   called). The speedcheck functions in lib/speedcheck.c are also used to
+   verify that the transfer is as fast as required.
+
+ o Curl_done()
+
+   Called after a transfer is done. This function takes care of everything
+   that has to be done after a transfer. This function attempts to leave
+   matters in a state so that Curl_do() should be possible to call again on
+   the same connection (in a persistent connection case). It might also soon
+   be closed with Curl_disconnect().
+
+ o Curl_disconnect()
+
+   When doing normal connections and transfers, no one ever tries to close any
+   connection so this is not normally called when curl_easy_perform() is
+   used. This function is only used when we are certain that no more transfers
+   is going to be made on the connection. It can be also closed by force, or
+   it can be called to make sure that libcurl doesn't keep too many
+   connections alive at the same time (there's a default amount of 5 but that
+   can be changed with the CURLOPT_MAXCONNECTS option).
+
+   This function cleans up all resources that are associated with a single
+   connection.
+
+ Curl_perform() is the function that does the main "connect - do - transfer -
+ done" loop. It loops if there's a Location: to follow.
 
  When completed, the curl_easy_cleanup() should be called to free up used
- resources.
+ resources. It runs Curl_disconnect() on all open connectons.
 
  A quick roundup on internal function sequences (many of these call
  protocol-specific function-pointers):
@@ -201,42 +252,41 @@ Library
  exists in lib/getpass.c. libcurl offers a custom callback that can be used
  instead of this, but it doesn't change much to us.
 
-Persistant Connections
+Persistent Connections
 ======================
 
- With curl 7.7, we added persistant connection support to libcurl which has
- introduced a somewhat different treatmeant of things inside of libcurl.
+ The persistent connection support in libcurl requires some considerations on
+ how to do things inside of the library.
 
  o The 'UrlData' struct returned in the curl_easy_init() call must never
    hold connection-oriented data. It is meant to hold the root data as well
    as all the options etc that the library-user may choose.
- o The 'UrlData' struct holds the cache array of pointers to 'connectdata'
-   structs. There's one connectdata struct for each connection that libcurl
-   knows about.
+ o The 'UrlData' struct holds the "connection cache" (an array of pointers to
+   'connectdata' structs). There's one connectdata struct allocated for each
+   connection that libcurl knows about.
  o This also enables the 'curl handle' to be reused on subsequent transfers,
-   something that was illegal in pre-7.7 versions.
+   something that was illegal before libcurl 7.7.
  o When we are about to perform a transfer with curl_easy_perform(), we first
    check for an already existing connection in the cache that we can use,
    otherwise we create a new one and add to the cache. If the cache is full
    already when we add a new connection, we close one of the present ones. We
    select which one to close dependent on the close policy that may have been
    previously set.
- o When the tranfer operation is complete, we try to leave the connection open.
-   Particular options may tell us not to, and protocols may signal closure on
-   connections and then we don't keep it open of course.
+ o When the transfer operation is complete, we try to leave the connection
+   open. Particular options may tell us not to, and protocols may signal
+   closure on connections and then we don't keep it open of course.
  o When curl_easy_cleanup() is called, we close all still opened connections.
 
  You do realize that the curl handle must be re-used in order for the
- persistant connections to work.
+ persistent connections to work.
 
 Library Symbols
 ===============
  
  All symbols used internally in libcurl must use a 'Curl_' prefix if they're
- used in more than a single file. Single-file symbols must be made
- static. Public (exported) symbols must use a 'curl_' prefix. (There are
- exceptions, but they are destined to be changed to follow this pattern in the
- future.)
+ used in more than a single file. Single-file symbols must be made static.
+ Public ("exported") symbols must use a 'curl_' prefix. (There are exceptions,
+ but they are to be changed to follow this pattern in future versions.)
 
 Return Codes and Informationals
 ===============================
@@ -257,6 +307,7 @@ Client
 ======
 
  main() resides in src/main.c together with most of the client code.
+
  src/hugehelp.c is automatically generated by the mkhelp.pl perl script to
  display the complete "manual" and the src/urlglob.c file holds the functions
  used for the URL-"globbing" support. Globbing in the sense that the {} and []
@@ -272,25 +323,26 @@ Client
  curl_easy_getinfo() function to extract useful information from the curl
  session.
 
- Recent versions may loop and do all that several times if many URLs were
+ Recent versions may loop and do all this several times if many URLs were
  specified on the command line or config file.
 
 Memory Debugging
 ================
 
- The file named lib/memdebug.c contains debug-versions of a few
- functions. Functions such as malloc, free, fopen, fclose, etc that somehow
- deal with resources that might give us problems if we "leak" them. The
- functions in the memdebug system do nothing fancy, they do their normal
- function and then log information about what they just did. The logged data
- can then be analyzed after a complete session,
+ The file lib/memdebug.c contains debug-versions of a few functions. Functions
+ such as malloc, free, fopen, fclose, etc that somehow deal with resources
+ that might give us problems if we "leak" them. The functions in the memdebug
+ system do nothing fancy, they do their normal function and then log
+ information about what they just did. The logged data can then be analyzed
+ after a complete session,
 
- memanalyze.pl is a perl script present only present in CVS (not part of the
+ memanalyze.pl is the perl script present only present in CVS (not part of the
  release archives) that analyzes a log file generated by the memdebug
  system. It detects if resources are allocated but never freed and other kinds
  of errors related to resource management.
 
- Use -DMALLOCDEBUG when compiling to enable memory debugging.
+ Use -DMALLOCDEBUG when compiling to enable memory debugging, this is also
+ switched on by running configure with --enable-debug.
 
 Test Suite
 ==========

docs/LIBCURL

@@ -6,8 +6,8 @@
 
                    How To Use Libcurl In Your C/C++ Program
 
- [ libcurl can be used directly from within your PHP or Perl programs as well,
-   look elsewhere for documentation on this ]
+ [ libcurl can be used directly from within your Java, PHP, Perl, Ruby or Tcl
+   programs as well, look elsewhere for documentation on this ]
 
  The interface is meant to be very simple for applictions/programmers, hence
  the name "easy". We have therefore minimized the number of entries.
@@ -49,6 +49,29 @@ The Easy Interface
 
  For details on these, read the separate man pages.
 
+Linking with libcurl
+
+ Staring with 7.7.2 (on unix-like machines), there's a tool named curl-config
+ that gets installed with the rest of the curl stuff when 'make install' is
+ performed.
+
+ curl-config is added to make it easier for applications to link with
+ libcurl and developers to learn about libcurl and how to use it.
+
+ Run 'curl-config --libs' to get the (additional) linker options you need to
+ link with the particular version of libcurl you've installed.
+
+ For details, see the curl-config.1 man page.
+
+libcurl symbol names
+
+ All public functions in the libcurl interface are prefixed with 'curl_' (with
+ a lowercase c). You can find other functions in the library source code, but
+ other prefixes indicate the functions are private and may change without
+ further notice in the next release.
+
+ Only use documented functions and functionality!
+
 Portability
 
  libcurl works *exactly* the same, on any of the platforms it compiles and

docs/MANUAL

@@ -15,10 +15,6 @@ SIMPLE USAGE
 
         curl ftp://ftp.funet.fi/README
 
-  Get a gopher document from funet's gopher server:
-
-        curl gopher://gopher.funet.fi
-
   Get a web page from a server using port 8000:
 
         curl http://www.weirdserver.com:8000/
@@ -27,6 +23,10 @@ SIMPLE USAGE
 
         curl ftp://cool.haxx.se/
 
+  Get a gopher document from funet's gopher server:
+
+        curl gopher://gopher.funet.fi
+
   Get the definition of curl from a dictionary:
 
         curl dict://dict.org/m:curl
@@ -186,7 +186,7 @@ DETAILED INFORMATION
   -D/--dump-header option when getting files from both FTP and HTTP, and it
   will then store the headers in the specified file.
 
-  Store the HTTP headers in a separate file:
+  Store the HTTP headers in a separate file (headers.txt in the example):
 
         curl --dump-header headers.txt curl.haxx.se
 
@@ -245,32 +245,32 @@ POST (HTTP)
 
   -F accepts parameters like -F "name=contents". If you want the contents to
   be read from a file, use <@filename> as contents. When specifying a file,
-  you can also specify which content type the file is, by appending
-  ';type=<mime type>' to the file name. You can also post contents of several
-  files in one field. So that the field name 'coolfiles' can be sent three
-  files with different content types in a manner similar to:
+  you can also specify the file content type by appending ';type=<mime type>'
+  to the file name. You can also post the contents of several files in one field.
+  For example, the field name 'coolfiles' is used to send three  files, with
+  different content types using the following syntax:
 
         curl -F "coolfiles=@fil1.gif;type=image/gif,fil2.txt,fil3.html" \
         http://www.post.com/postit.cgi
 
-  If content-type is not specified, curl will try to guess from the extension
-  (it only knows a few), or use the previously specified type (from an earlier
-  file if several files are specified in a list) or finally using the default
-  type 'text/plain'.
+  If the content-type is not specified, curl will try to guess from the file
+  extension  (it only knows a few), or use the previously specified type
+  (from an earlier file if several files are specified in a list) or else it
+  will  using the default type 'text/plain'.
 
   Emulate a fill-in form with -F. Let's say you fill in three fields in a
   form. One field is a file name which to post, one field is your name and one
   field is a file description. We want to post the file we have written named
   "cooltext.txt". To let curl do the posting of this data instead of your
-  favourite browser, you have to check out the HTML of the form page to get to
-  know the names of the input fields. In our example, the input field names are
+  favourite browser, you have to read the HTML source of the form page and find
+  the names of the input fields. In our example, the input field names are
   'file', 'yourname' and 'filedescription'.
 
         curl -F "file=@cooltext.txt" -F "yourname=Daniel" \
              -F "filedescription=Cool text file with cool text inside" \
              http://www.post.com/postit.cgi
 
-  So, to send two files in one post you can do it in two ways:
+  To send two files in one post you can do it in two ways:
 
   1. Send multiple files in a single "field" with a single field name:
  
@@ -280,11 +280,11 @@ POST (HTTP)
 
         curl -F "docpicture=@dog.gif" -F "catpicture=@cat.gif" 
 
-REFERER
+REFERRER
 
   A HTTP request has the option to include information about which address
-  that referred to actual page, and curl allows the user to specify that
-  referrer to get specified on the command line. It is especially useful to
+  that referred to actual page.  Curl allows you to specify the
+  referrer to be used on the command line. It is especially useful to
   fool or trick stupid servers or CGI scripts that rely on that information
   being available or contain certain data.
 
@@ -353,13 +353,17 @@ COOKIES
   Note that by specifying -b you enable the "cookie awareness" and with -L
   you can make curl follow a location: (which often is used in combination
   with cookies). So that if a site sends cookies and a location, you can
-  use a non-existing file to trig the cookie awareness like:
+  use a non-existing file to trigger the cookie awareness like:
 
-        curl -L -b empty-file www.example.com
+        curl -L -b empty.txt www.example.com
 
   The file to read cookies from must be formatted using plain HTTP headers OR
   as netscape's cookie file. Curl will determine what kind it is based on the
-  file contents.
+  file contents.  In the above command, curl will parse the header and store
+  the cookies received from www.example.com.  curl will send to the server the
+  stored cookies which match the request as it follows the location.  The
+  file "empty.txt" may be a non-existant file.
+  
 
 PROGRESS METER
 
@@ -392,12 +396,12 @@ PROGRESS METER
 
 SPEED LIMIT
 
-  Curl offers the user to set conditions regarding transfer speed that must
-  be met to let the transfer keep going. By using the switch -y and -Y you
-  can make curl abort transfers if the transfer speed doesn't exceed your
-  given lowest limit for a specified time.
+  Curl allows the user to set the transfer speed conditions that must be met
+  to let the transfer keep going. By using the switch -y and -Y you
+  can make curl abort transfers if the transfer speed is below the specified
+  lowest limit for a specified time.
 
-  To let curl abandon downloading this page if its slower than 3000 bytes per
+  To have curl abort the download if the speed is slower than 3000 bytes per
   second for 1 minute, run:
 
         curl -y 3000 -Y 60 www.far-away-site.com
@@ -610,7 +614,7 @@ RESUMING FILE TRANSFERS
  (*1) = This requires that the ftp server supports the non-standard command
         SIZE. If it doesn't, curl will say so.
 
- (*2) = This requires that the wb server supports at least HTTP/1.1. If it
+ (*2) = This requires that the web server supports at least HTTP/1.1. If it
         doesn't, curl will say so.
 
 TIME CONDITIONS

docs/Makefile.am

@@ -6,6 +6,7 @@ AUTOMAKE_OPTIONS = foreign no-dependencies
 
 man_MANS = \
 	curl.1 \
+	curl-config.1 \
 	curl_easy_cleanup.3 \
 	curl_easy_getinfo.3 \
 	curl_easy_init.3 \
@@ -19,10 +20,16 @@ man_MANS = \
 	curl_slist_free_all.3 \
 	curl_version.3 \
 	curl_escape.3 \
-	curl_unescape.3
+	curl_unescape.3 \
+	curl_strequal.3 \
+	curl_strnequal.3 \
+	curl_mprintf.3 \
+	curl_global_init.3 \
+	curl_global_cleanup.3 \
+	libcurl.5
 
 EXTRA_DIST = $(man_MANS) \
 	MANUAL BUGS CONTRIBUTE FAQ FEATURES INTERNALS \
-	LIBCURL README.win32 RESOURCES TODO TheArtOfHttpScripting
+	LIBCURL README.win32 RESOURCES TODO TheArtOfHttpScripting THANKS
 
 SUBDIRS = examples

docs/README.win32

@@ -22,3 +22,8 @@ README.win32
   in order to extract a separate text file:
 
         curl -M >manual.txt
+
+  Download all the libcurl man pages in HTML format using the link on the
+  bottom of this page:
+
+        http://curl.haxx.se/libcurl/c/

docs/THANKS

@@ -0,0 +1,71 @@
+This project has been alive for several years. Countless people have provided
+feedback that have improved curl. Here follows a (incomplete) list of people
+that have contributed with non-trivial parts:
+
+ - Daniel Stenberg <daniel@haxx.se>
+ - Rafael Sagula <sagula@inf.ufrgs.br>
+ - Sampo Kellomaki <sampo@iki.fi>
+ - Linas Vepstas <linas@linas.org>
+ - Bjorn Reese <breese@mail1.stofanet.dk>
+ - Johan Anderson <johan@homemail.com>
+ - Kjell Ericson <Kjell.Ericson@haxx.se>
+ - Troy Engel <tengel@sonic.net>
+ - Ryan Nelson <ryan@inch.com>
+ - Bj<42>rn Stenberg <bjorn@haxx.se>
+ - Angus Mackay <amackay@gus.ml.org>
+ - Eric Young <eay@cryptsoft.com>
+ - Simon Dick <simond@totally.irrelevant.org>
+ - Oren Tirosh <oren@monty.hishome.net>
+ - Steven G. Johnson <stevenj@alum.mit.edu>
+ - Gilbert Ramirez Jr. <gram@verdict.uthscsa.edu>
+ - Andr<64>s Garc<72>a <ornalux@redestb.es>
+ - Douglas E. Wegscheid <wegscd@whirlpool.com>
+ - Mark Butler <butlerm@xmission.com>
+ - Eric Thelin <eric@generation-i.com>
+ - Marc Boucher <marc@mbsi.ca>
+ - Greg Onufer <Greg.Onufer@Eng.Sun.COM>
+ - Doug Kaufman <dkaufman@rahul.net>
+ - David Eriksson <david@2good.com>
+ - Ralph Beckmann <rabe@uni-paderborn.de>
+ - T. Yamada <tai@imasy.or.jp>
+ - Lars J. Aas <larsa@sim.no>
+ - J<>rn Hartroth <Joern.Hartroth@computer.org>
+ - Matthew Clarke <clamat@van.maves.ca>
+ - Linus Nielsen Feltzing <linus@haxx.se>
+ - Felix von Leitner <felix@convergence.de>
+ - Dan Zitter <dzitter@zitter.net>
+ - Jongki Suwandi <Jongki.Suwandi@eng.sun.com>
+ - Chris Maltby <chris@aurema.com>
+ - Ron Zapp <rzapper@yahoo.com>
+ - Paul Marquis <pmarquis@iname.com>
+ - Ellis Pritchard <ellis@citria.com>
+ - Damien Adant <dams@usa.net>
+ - Chris <cbayliss@csc.come>
+ - Marco G. Salvagno <mgs@whiz.cjb.net>
+ - Paul Marquis <pmarquis@iname.com>
+ - David LeBlanc <dleblanc@qnx.com>
+ - Rich Gray at Plus Technologies
+ - Luong Dinh Dung <u8luong@lhsystems.hu>
+ - Torsten Foertsch <torsten.foertsch@gmx.net>
+ - Kristian K<>hntopp <kris@koehntopp.de>
+ - Fred Noz <FNoz@siac.com>
+ - Caolan McNamara <caolan@csn.ul.ie>
+ - Albert Chin-A-Young <china@thewrittenword.com>
+ - Stephen Kick <skick@epicrealm.com>
+ - Martin Hedenfalk <mhe@stacken.kth.se>
+ - Richard Prescott
+ - Jason S. Priebe <priebe@wral-tv.com>
+ - T. Bharath <TBharath@responsenetworks.com>
+ - Alexander Kourakos <awk@users.sourceforge.net>
+ - James Griffiths <griffiths_james@yahoo.com>
+ - Loic Dachary <loic@senga.org>
+ - Robert Weaver <robert.weaver@sabre.com>
+ - Ingo Ralf Blum <ingoralfblum@ingoralfblum.com>
+ - Jun-ichiro itojun Hagino <itojun@iijlab.net>
+ - Frederic Lepied <flepied@mandrakesoft.com>
+ - Georg Horn <horn@koblenz-net.de>
+ - Cris Bailiff <c.bailiff@awayweb.com>
+ - Sterling Hughes <sterling@designmultimedia.com>
+ - S. Moonesamy
+ - Ingo Wilken <iw@WWW.Ecce-Terram.DE>
+ - Pawel A. Gajda <mis@k2.net.pl>

docs/TODO

@@ -9,17 +9,13 @@ TODO
  Things to do in project cURL. Please tell me what you think, contribute and
  send me patches that improve things!
 
-To do for the next release:
+To do in a future release (random order):
 
  * Make SSL session ids get used if multiple HTTPS documents from the same
-   host is requested.
+   host is requested. Note: is this really prioritized now with the persistent
+   connections?
 
- * Document the undocumented libcurl functions: the printf clones (like
-   curl_msprintf, curl_mfprintf, curl_msnprintf, curl_maprintf and
-   curl_mvfprintf) and the string compare functions (curl_strequal
-   and curl_strnequal).
-
-To do in a future release (random order):
+ * Suggested on the mailing list: CURLOPT_FTP_MKDIR...!
 
  * Rewrite parts of the test suite. Make a (XML?) format to store all
    test-data in a single for a single test case. The current system makes far
@@ -31,9 +27,8 @@ To do in a future release (random order):
    decrease footprint.  '--disable-[protocol]' where protocol is http, ftp,
    telnet, ldap, dict or file.
 
- * Extend the test suite to include telnet and https. The telnet could just do
-   ftp or http operations (for which we have test servers) and the https would
-   probably work against/with some of the openssl tools.
+ * Extend the test suite to include telnet. The telnet could just do ftp or
+   http operations (for which we have test servers).
 
  * Add a command line option that allows the output file to get the same time
    stamp as the remote file. libcurl already is capable of fetching the remote
@@ -47,14 +42,10 @@ To do in a future release (random order):
  * Add asynchronous name resolving, as this enables full timeout support for
    fork() systems.
 
- * Non-blocking connect(), also to make timeouts work on windows.
-
  * Move non-URL related functions that are used by both the lib and the curl
    application to a separate "portability lib".
 
- * Add support for other languages than C.  C++ (rumours have been heard about
-   something being worked on in this area) and perl (we have seen the first
-   versions of this!) comes to mind. Python anyone?
+ * Add libcurl support/interfaces for more languages. C++ wrapper perhaps?
 
  * "Content-Encoding: compress/gzip/zlib" HTTP 1.1 clearly defines how to get
    and decode compressed documents. There is the zlib that is pretty good at
@@ -86,10 +77,7 @@ To do in a future release (random order):
  * Other proxies
    Ftp-kind proxy, Socks5, whatever kind of proxies are there?
 
- * IPv6 Awareness and support. (This is partly done.)  RFC 2428 "FTP
+ * Full IPv6 Awareness and support. (This is partly done.)  RFC 2428 "FTP
    Extensions for IPv6 and NATs" is interesting. PORT should be replaced with
-   EPRT for IPv6 (done), and EPSV instead of PASV.  HTTP proxies are left to
-   add support for.
+   EPRT for IPv6 (done), and EPSV instead of PASV.
 
- * SSL for more protocols, like SSL-FTP...
-   (http://search.ietf.org/internet-drafts/draft-murray-auth-ftp-ssl-05.txt)

docs/curl-config.1

@@ -0,0 +1,59 @@
+.\" You can view this file with:
+.\" nroff -man curl-config.1
+.\" Written by Daniel Stenberg
+.\"
+.TH curl-config 1 "28 May 2001" "Curl 7.8" "curl-config manual"
+.SH NAME
+curl-config \- Get information about a libcurl installation
+.SH SYNOPSIS
+.B curl-config [options]
+.SH DESCRIPTION
+.B curl-config
+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.
+.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
+any particular order. The keywords will be separated by newlines. There may be
+none, one or several keywords in the list.
+.IP "--help"
+Displays the available options.
+.IP "--libs"
+Shows the complete set of libs and other linker options you will need in order
+to link your application with libcurl.
+.IP "--prefix"
+This is the prefix used when libcurl was installed. Libcurl is then installed
+in $prefix/lib and its header files are installed in $prefix/include and so
+on. The prefix is set with "configure --prefix".
+.IP "--version"
+Outputs version information about the installed libcurl.
+.IP "--vernum"
+Outputs version information about the installed libcurl, in numerical mode.
+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?
+
+  curl-config --libs
+
+How do I know if libcurl was built with SSL support?
+
+  curl-config --feature | grep SSL
+
+What's the installed libcurl version?
+
+  curl-config --version
+.SH "SEE ALSO"
+.BR curl (1)

docs/curl.1

@@ -2,7 +2,7 @@
 .\" nroff -man curl.1
 .\" Written by Daniel Stenberg
 .\"
-.TH curl 1 "15 March 2001" "Curl 7.7" "Curl Manual"
+.TH curl 1 "8 May 2001" "Curl 7.7.3" "Curl Manual"
 .SH NAME
 curl \- get a URL with FTP, TELNET, LDAP, GOPHER, DICT, FILE, HTTP or
 HTTPS syntax.
@@ -39,14 +39,14 @@ supported at the moment:
 
  http://www.any.org/archive[1996-1999]/volume[1-4]part{a,b,c,index}.html
 
-Starting with curl 7.6, you can specify any amount of URLs on the command
-line. They will be fetched in a sequential manner in the specified order.
+You can specify any amount of URLs on the command line. They will be fetched
+in a sequential manner in the specified order.
 
-Starting with curl 7.7, curl will attempt to re-use connections for multiple
-file transfers, so that getting many files from the same server will not do
-multiple connects/handshakes. This improves speed. Of course this is only done
-on files specified on a single command line and cannot be used between
-separate curl invokes.
+Curl will attempt to re-use connections for multiple file transfers, so that
+getting many files from the same server will not do multiple connects /
+handshakes. This improves speed. Of course this is only done on files
+specified on a single command line and cannot be used between separate curl
+invokes.
 .SH OPTIONS
 .IP "-a/--append"
 (FTP)
@@ -62,7 +62,7 @@ fail if its not set to "Mozilla/4.0".  To encode blanks in the string,
 surround the string with single quote marks.  This can also be set with the
 -H/--header flag of course.
 
-If this option is used more than once, the last one will be the one to be
+If this option is set more than once, the last one will be the one that's
 used.
 .IP "-b/--cookie <name=data>"
 (HTTP)
@@ -72,18 +72,18 @@ The data should be in the format "NAME1=VALUE1; NAME2=VALUE2".
 
 If no '=' letter is used in the line, it is treated as a filename to use to
 read previously stored cookie lines from, which should be used in this session
-if they match. Using this method also activates the "cookie parser" which
-will make curl record incoming cookies too, which may be handy if you're using
-this in combination with the -L/--location option. The file format of the file
-to read cookies from should be plain HTTP headers or the netscape cookie file
-format.
+if they match. Using this method also activates the "cookie parser" which will
+make curl record incoming cookies too, which may be handy if you're using this
+in combination with the -L/--location option. The file format of the file to
+read cookies from should be plain HTTP headers or the Netscape/Mozilla cookie
+file format.
 
 .B NOTE
 that the file specified with -b/--cookie is only used as input. No cookies
 will be stored in the file. To store cookies, save the HTTP headers to a file
 using -D/--dump-header!
 
-If this option is used more than once, the last one will be the one to be
+If this option is set more than once, the last one will be the one that's
 used.
 .IP "-B/--use-ascii"
 Use ASCII transfer when getting an FTP file or LDAP info. For FTP, this can
@@ -94,11 +94,12 @@ If this option is used twice, the second one will disable ASCII usage.
 .IP "--connect-timeout <seconds>"
 Maximum time in seconds that you allow the connection to the server to take.
 This only limits the connection phase, once curl has connected this option is
-of no more use. This option doesn't work in win32 systems.  See also the
+of no more use. This option didn't work in win32 systems until 7.7.2.  See
+also the
 .I "--max-time"
 option.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-c/--continue"
 .B Deprecated. Use '-C -' instead.
 Continue/Resume a previous file transfer. This instructs curl to
@@ -117,7 +118,7 @@ If used with uploads, the ftp server command SIZE will not be used by
 curl. Upload resume is for FTP only.
 HTTP resume is only possible with HTTP/1.1 or later servers.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-d/--data <data>"
 (HTTP) Sends the specified data in a POST request to the HTTP server, in a way
 that can emulate as if a user has filled in a HTML form and pressed the submit
@@ -128,7 +129,7 @@ content-type application/x-www-form-urlencoded. Compare to -F. If more than
 one -d/--data option is used on the same command line, the data pieces
 specified will be merged together with a separating &-letter. Thus, using '-d
 name=daniel -d skill=lousy' would generate a post chunk that looks like
-'name=daniel&skill=lousy'.
+\&'name=daniel&skill=lousy'.
 
 If you start the data with the letter @, the rest should be a file name to
 read the data from, or - if you want curl to read the data from stdin.  The
@@ -139,12 +140,12 @@ To post data purely binary, you should instead use the --data-binary option.
 
 -d/--data is the same as --data-ascii.
 
-If this option is used serveral times, the ones following the first will
+If this option is used several times, the ones following the first will
 append data.
 .IP "--data-ascii <data>"
 (HTTP) This is an alias for the -d/--data option.
 
-If this option is used serveral times, the ones following the first will
+If this option is used several times, the ones following the first will
 append data.
 .IP "--data-binary <data>"
 (HTTP) This posts data in a similar manner as --data-ascii does, although when
@@ -152,9 +153,9 @@ using this option the entire context of the posted data is kept as-is. If you
 want to post a binary file without the strip-newlines feature of the
 --data-ascii option, this is for you.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 
-If this option is used serveral times, the ones following the first will
+If this option is used several times, the ones following the first will
 append data.
 .IP "-D/--dump-header <file>"
 (HTTP/FTP)
@@ -165,7 +166,7 @@ This option is handy to use when you want to store the cookies that a HTTP
 site sends to you. The cookies could then be read in a second curl invoke by
 using the -b/--cookie option!
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-e/--referer <URL>"
 (HTTP) Sends the "Referer Page" information to the HTTP server. This can also
 be set with the -H/--header flag of course.  When used with
@@ -174,7 +175,7 @@ you can append ";auto" to the referer URL to make curl automatically set the
 previous URL when it follows a Location: header. The ";auto" string can be
 used alone, even if you don't set an initial referer.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "--egd-file <file>"
 (HTTPS) Specify the path name to the Entropy Gathering Daemon socket. The
 socket is used to seed the random engine for SSL connections. See also the
@@ -188,12 +189,12 @@ If the optional password isn't specified, it will be queried for on
 the terminal. Note that this certificate is the private key and the private
 certificate concatenated!
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "--cacert <CA certificate>"
 (HTTPS) Tells curl to use the specified certificate file to verify the
 peer. The certificate must be in PEM format.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-f/--fail"
 (HTTP)
 Fail silently (no output at all) on server errors. This is mostly done
@@ -215,7 +216,7 @@ get attached in the post as a file upload, while the < makes a text field and
 just get the contents for that text field from a file.
 
 Example, to send your password file to the server, where
-'password' is the name of the form-field to which /etc/passwd will be the
+\&'password' is the name of the form-field to which /etc/passwd will be the
 input:
 
 .B curl
@@ -256,7 +257,7 @@ name, IP address or host name. An example could look like:
 
 .B "curl --interface eth0:1 http://www.netscape.com/"
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-I/--head"
 (HTTP/FTP)
 Fetch the HTTP-header only! HTTP-servers feature the command HEAD
@@ -269,7 +270,7 @@ If this option is used twice, the second will again disable header only.
 should be one of 'clear', 'safe', 'confidential' or 'private'. Should you use
 a level that is not one of these, 'private' will instead be used.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-K/--config <config file>"
 Specify which config file to read curl arguments from. The config file is a
 text file in which command line arguments can be written which then will be
@@ -307,7 +308,7 @@ See also the
 .I "--connect-timeout"
 option.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-M/--manual"
 Manual. Display the huge help text.
 .IP "-n/--netrc"
@@ -325,7 +326,7 @@ directory.
 A quick and very simple example of how to setup a
 .I .netrc
 to allow curl to ftp to the machine host.domain.com with user name
-'myself' and password 'secret' should look similar to:
+\&'myself' and password 'secret' should look similar to:
 
 .B "machine host.domain.com login myself password secret"
 
@@ -385,7 +386,7 @@ i.e "my.host.domain" to specify machine
 (any single-letter string) to make it pick the machine's default
 .RE
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-q"
 If used as the first parameter on the command line, the
 .I $HOME/.curlrc
@@ -444,7 +445,7 @@ document.
 FTP range downloads only support the simple syntax 'start-stop' (optionally
 with one of the numbers omitted). It depends on the non-RFC command SIZE.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-s/--silent"
 Silent mode. Don't show progress meter or error messages.  Makes
 Curl mute.
@@ -471,18 +472,18 @@ think that your last directory name is the remote file name to
 use. That will most likely cause the upload operation to fail. If
 this is used on a http(s) server, the PUT command will be used.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-u/--user <user:password>"
 Specify user and password to use when fetching. See README.curl for detailed
 examples of how to use this. If no password is specified, curl will
 ask for it interactively.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-U/--proxy-user <user:password>"
 Specify user and password to use for Proxy authentication. If no
 password is specified, curl will ask for it interactively.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "--url <URL>"
 Specify a URL to fetch. This option is mostly handy when you wanna specify
 URL(s) in a config file.
@@ -565,12 +566,12 @@ The average download speed that curl measured for the complete download.
 The average upload speed that curl measured for the complete upload.
 .RE
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-x/--proxy <proxyhost[:port]>"
 Use specified proxy. If the port number is not specified, it is assumed at
 port 1080.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-X/--request <command>"
 (HTTP)
 Specifies a custom request to use when communicating with the HTTP server.
@@ -581,19 +582,19 @@ HTTP 1.1 specification for details and explanations.
 Specifies a custom FTP command to use instead of LIST when doing file lists
 with ftp.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-y/--speed-time <time>"
 If a download is slower than speed-limit bytes per second during a speed-time
 period, the download gets aborted. If speed-time is used, the default
 speed-limit will be 1 unless set with -y.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-Y/--speed-limit <speed>"
 If a download is slower than this given speed, in bytes per second, for
 speed-time seconds it gets aborted. speed-time is set with -Y and is 30 if
 not set.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-z/--time-cond <date expression>"
 (HTTP)
 Request to get a file that has been modified later than the given time and
@@ -609,7 +610,7 @@ Start the date expression with a dash (-) to make it request for a document
 that is older than the given date/time, default is a document that is newer
 than the specified date/time.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .IP "-3/--sslv3"
 (HTTPS)
 Forces curl to use SSL version 3 when negotiating with a remote SSL server.
@@ -630,7 +631,7 @@ Redirect all writes to stderr to the specified file instead. If the file name
 is a plain '-', it is instead written to stdout. This option has no point when
 you're using a shell with decent redirecting capabilities.
 
-If this option is used serveral times, the last one will be used.
+If this option is used several times, the last one will be used.
 .SH FILES
 .I ~/.curlrc
 .RS
@@ -755,73 +756,18 @@ Interface error. A specified outgoing interface could not be used.
 Bad password entered. An error was signalled when the password was entered.
 .IP 47
 Too many redirects. When following redirects, curl hit the maximum amount.
+.IP 48
+Unknown TELNET option specified.
+.IP 49
+Malformed telnet option.
 .IP XX
 There will appear more error codes here in future releases. The existing ones
 are meant to never change.
 .SH BUGS
 If you do find bugs, mail them to curl-bug@haxx.se.
 .SH AUTHORS / CONTRIBUTORS
- - Daniel Stenberg <Daniel.Stenberg@haxx.se>
- - Rafael Sagula <sagula@inf.ufrgs.br>
- - Sampo Kellomaki <sampo@iki.fi>
- - Linas Vepstas <linas@linas.org>
- - Bjorn Reese <breese@mail1.stofanet.dk>
- - Johan Anderson <johan@homemail.com>
- - Kjell Ericson <Kjell.Ericson@haxx.se>
- - Troy Engel <tengel@sonic.net>
- - Ryan Nelson <ryan@inch.com>
- - Bj<42>rn Stenberg <Bjorn.Stenberg@haxx.se>
- - Angus Mackay <amackay@gus.ml.org>
- - Eric Young <eay@cryptsoft.com>
- - Simon Dick <simond@totally.irrelevant.org>
- - Oren Tirosh <oren@monty.hishome.net>
- - Steven G. Johnson <stevenj@alum.mit.edu>
- - Gilbert Ramirez Jr. <gram@verdict.uthscsa.edu>
- - Andr<64>s Garc<72>a <ornalux@redestb.es>
- - Douglas E. Wegscheid <wegscd@whirlpool.com>
- - Mark Butler <butlerm@xmission.com>
- - Eric Thelin <eric@generation-i.com>
- - Marc Boucher <marc@mbsi.ca>
- - Greg Onufer <Greg.Onufer@Eng.Sun.COM>
- - Doug Kaufman <dkaufman@rahul.net>
- - David Eriksson <david@2good.com>
- - Ralph Beckmann <rabe@uni-paderborn.de>
- - T. Yamada <tai@imasy.or.jp>
- - Lars J. Aas <larsa@sim.no>
- - J<>rn Hartroth <Joern.Hartroth@computer.org>
- - Matthew Clarke <clamat@van.maves.ca>
- - Linus Nielsen Feltzing <linus@haxx.se>
- - Felix von Leitner <felix@convergence.de>
- - Dan Zitter <dzitter@zitter.net>
- - Jongki Suwandi <Jongki.Suwandi@eng.sun.com>
- - Chris Maltby <chris@aurema.com>
- - Ron Zapp <rzapper@yahoo.com>
- - Paul Marquis <pmarquis@iname.com>
- - Ellis Pritchard <ellis@citria.com>
- - Damien Adant <dams@usa.net>
- - Chris <cbayliss@csc.come>
- - Marco G. Salvagno <mgs@whiz.cjb.net>
- - Paul Marquis <pmarquis@iname.com>
- - David LeBlanc <dleblanc@qnx.com>
- - Rich Gray at Plus Technologies
- - Luong Dinh Dung <u8luong@lhsystems.hu>
- - Torsten Foertsch <torsten.foertsch@gmx.net>
- - Kristian K<>hntopp <kris@koehntopp.de>
- - Fred Noz <FNoz@siac.com>
- - Caolan McNamara <caolan@csn.ul.ie>
- - Albert Chin-A-Young <china@thewrittenword.com>
- - Stephen Kick <skick@epicrealm.com>
- - Martin Hedenfalk <mhe@stacken.kth.se>
- - Richard Prescott
- - Jason S. Priebe <priebe@wral-tv.com>
- - T. Bharath <TBharath@responsenetworks.com>
- - Alexander Kourakos <awk@users.sourceforge.net>
- - James Griffiths <griffiths_james@yahoo.com>
- - Loic Dachary <loic@senga.org>
- - Robert Weaver <robert.weaver@sabre.com>
- - Ingo Ralf Blum <ingoralfblum@ingoralfblum.com>
- - Jun-ichiro itojun Hagino <itojun@iijlab.net>
-
+Daniel Stenberg is the main author, but the whole list of contributors is
+found in the separate THANKS file.
 .SH WWW
 http://curl.haxx.se
 .SH FTP

docs/curl_easy_setopt.3

@@ -2,13 +2,13 @@
 .\" nroff -man [file]
 .\" Written by daniel@haxx.se
 .\"
-.TH curl_easy_setopt 3 "13 March 2001" "libcurl 7.7" "libcurl Manual"
+.TH curl_easy_setopt 3 "29 May 2001" "libcurl 7.8" "libcurl Manual"
 .SH NAME
 curl_easy_setopt - Set curl easy-session options
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
-.BI "CURLcode curl_easy_setopt(CURL *" handle ", CURLoption "option ", ...);
+.BI "CURLcode curl_easy_setopt(CURL *" handle ", CURLoption "option ", ...);"
 .ad
 .SH DESCRIPTION
 curl_easy_setopt() is called to tell libcurl how to behave in a number of
@@ -42,54 +42,43 @@ call.
 These options are in a bit of random order, but you'll figure it out!
 .TP 0.8i
 .B CURLOPT_FILE
-Data pointer to pass instead of FILE * to the file write function. Note that
-if you specify the
+Data pointer to pass to file write function. Note that if you specify the
 .I CURLOPT_WRITEFUNCTION
-, this is the pointer you'll get as input.
+, this is the pointer you'll get as input. If you don't use a callback, you
+must pass a 'FILE *' as libcurl passes it to fwrite() when writing data.
 
-NOTE: If you're using libcurl as a win32 .DLL, you MUST use a
-.I CURLOPT_WRITEFUNCTION
-if you set the
-.I CURLOPT_FILE
-option.
+NOTE: If you're using libcurl as a win32 DLL, you MUST use the
+\fICURLOPT_WRITEFUNCTION\fP if you set this option.
 .TP
 .B CURLOPT_WRITEFUNCTION
-Function pointer that should use match the following prototype:
-.BI "size_t function( void *ptr, size_t size, size_t nmemb, FILE *stream);"
+Function pointer that should match the following prototype:
+.BI "size_t function( void *ptr, size_t size, size_t nmemb, void *stream);"
 This function gets called by libcurl as soon as there is received data that
-needs to be written down. The size of the data pointed to by
-.I ptr 
-is
-.I size
-multiplied with
-.I nmemb.
-Return the number of bytes actually written or return -1 to signal error to the library (it will cause it to abort the transfer).
+needs to be written down. The size of the data pointed to by \fIptr\fP is
+\fIsize\fP multiplied with \fInmemb\fP.  Return the number of bytes actually
+written or return -1 to signal error to the library (it will cause it to abort
+the transfer with CURLE_WRITE_ERROR).
+
+Set the \fIstream\fP argument with the \fBCURLOPT_FILE\fP option.
 .TP
 .B CURLOPT_INFILE
-Data pointer to pass instead of FILE * to the file read function. Note that if
-you specify the
-.I CURLOPT_READFUNCTION
-, this is the pointer you'll get as input.
+Data pointer to pass to the file read function. Note that if you specify the
+\fICURLOPT_READFUNCTION\fP, this is the pointer you'll get as input. If you
+don't specify a read callback, this must be a valid FILE *.
 
-NOTE: If you're using libcurl as a win32 .DLL, you MUST use a
-.I CURLOPT_READFUNCTION
-if you set the
-.I CURLOPT_INFILE
-option.
+NOTE: If you're using libcurl as a win32 DLL, you MUST use a
+\fICURLOPT_READFUNCTION\fP if you set this option.
 .TP
 .B CURLOPT_READFUNCTION
-Function pointer that should use match the following prototype:
-.BI "size_t function( void *ptr, size_t size, size_t nmemb, FILE *stream);"
+Function pointer that should match the following prototype:
+.BI "size_t function( void *ptr, size_t size, size_t nmemb, void *stream);"
 This function gets called by libcurl as soon as it needs to read data in order
-to send it to the peer. The data area pointed at by the pointer
-.I ptr
-may be filled with at most
-.I size
-multiplied with
-.I nmemb
-number of bytes. Your function must return the actual number of bytes that you
-stored in that memory area. Returning -1 will signal an error to the library
-and cause it to abort the current transfer immediately.
+to send it to the peer. The data area pointed at by the pointer \fIptr\fP may
+be filled with at most \fIsize\fP multiplied with \fInmemb\fP number of
+bytes. Your function must return the actual number of bytes that you stored in
+that memory area. Returning -1 will signal an error to the library and cause
+it to abort the current transfer immediately (with a CURLE_READ_ERROR return
+code).
 .TP
 .B CURLOPT_INFILESIZE
 When uploading a file to a remote site, this option should be used to tell
@@ -120,7 +109,8 @@ this means, you probably don't want this tunnel option. (Added in libcurl 7.3)
 .TP
 .B CURLOPT_VERBOSE
 Set the parameter to non-zero to get the library to display a lot of verbose
-information about its operations.
+information about its operations. Very useful for libcurl and/or protocl
+debugging and understanding.
 .TP
 .B CURLOPT_HEADER
 A non-zero parameter tells the library to include the header in the
@@ -189,7 +179,10 @@ A non-zero parameter tells the library to use HTTP PUT a file. The file to put
 must be set with CURLOPT_INFILE and CURLOPT_INFILESIZE.
 .TP
 .B CURLOPT_MUTE
-A non-zero parameter tells the library to be completely quiet.
+A non-zero parameter tells the library to be completely quiet. This only
+affects error messages that occurs when there's no CURLOPT_ERRORBUFFER
+specified. If an error messaged is specifed, this option won't make any
+difference.
 .TP
 .B CURLOPT_USERPWD
 Pass a char * as parameter, which should be [username]:[password] to use for
@@ -274,7 +267,11 @@ curl_slist' structs properly filled in. Use
 .I curl_slist_append(3)
 to create the list and
 .I curl_slist_free_all(3)
-to clean up an entire list.
+to clean up an entire list. If you add a header that is otherwise generated
+and used by libcurl internally, your added one will be used instead. If you
+add a header with no contents as in 'Accept:', the internally used header will
+just get disabled. Thus, using this option you can add new headers, replace
+internal headers and remove internal headers.
 .TP
 .B CURLOPT_HTTPPOST
 Tells libcurl you want a multipart/formdata HTTP POST to be made and you
@@ -283,7 +280,8 @@ of HTTP post structs as parameter.  The linked list should be a fully valid
 list of 'struct HttpPost' structs properly filled in. The best and most
 elegant way to do this, is to use
 .I curl_formparse(3)
-as documented.
+as documented. The data in this list must remained intact until you close this
+curl handle again with curl_easy_cleanup().
 .TP
 .B CURLOPT_SSLCERT
 Pass a pointer to a zero terminated string as parameter. The string should be
@@ -313,12 +311,39 @@ struct curl_slist structs properly filled in as described for
 .I "CURLOPT_QUOTE"
 .TP
 .B CURLOPT_WRITEHEADER
-Pass a FILE * to be used to write the header part of the received data to.
+Pass a pointer to be used to write the header part of the received data to. If
+you don't use a callback to take care of the writing, this must be a FILE
+*. The headers are guaranteed to be written one-by-one and only complete lines
+are written. Parsing headers should be easy enough using this. See also the
+\fICURLOPT_HEADERFUNCTION\fP option.
+.TP
+.B CURLOPT_HEADERFUNCTION
+Function pointer that should match the following prototype:
+.BI "size_t function( void *ptr, size_t size, size_t nmemb, void *stream);"
+This function gets called by libcurl as soon as there is received header data
+that needs to be written down. The function will be called once for each
+header with a complete header line in each invoke. The size of the data
+pointed to by
+.I ptr 
+is
+.I size
+multiplied with
+.I nmemb.
+The pointer named
+.I stream
+will be the one you passed to libcurl with the
+.I CURLOPT_WRITEHEADER
+option.
+Return the number of bytes actually written or return -1 to signal error to
+the library (it will cause it to abort the transfer with a
+.I CURLE_WRITE_ERROR
+return code). (Added in libcurl 7.7.2)
 .TP
 .B CURLOPT_COOKIEFILE
 Pass a pointer to a zero terminated string as parameter. It should contain the
-name of your file holding cookie data. The cookie data may be in netscape
-cookie data format or just regular HTTP-style headers dumped to a file.
+name of your file holding cookie data. The cookie data may be in Netscape /
+Mozilla cookie data format or just regular HTTP-style headers dumped to a
+file.
 .TP
 .B CURLOPT_SSLVERSION
 Pass a long as parameter. Set what version of SSL to attempt to use, 2 or
@@ -353,7 +378,7 @@ name. (Added in libcurl 7.3)
 .B CURLOPT_KRB4LEVEL
 Pass a char * as parameter. Set the krb4 security level, this also enables
 krb4 awareness.  This is a string, 'clear', 'safe', 'confidential' or
-'private'.  If the string is set but doesn't match one of these, 'private'
+\&'private'.  If the string is set but doesn't match one of these, 'private'
 will be used. Set the string to NULL to disable kerberos4. The kerberos
 support only works for FTP. (Added in libcurl 7.3)
 .TP
@@ -467,7 +492,7 @@ Pass a char * to a zero terminated file name. The file will be used to read
 from to seed the random engine for SSL. The more random the specified file is,
 the more secure will the SSL connection become.
 .TP
-.B CURLOPT_FORBID_REUSE
+.B CURLOPT_EGDSOCKET
 Pass a char * to the zero terminated path name to the Entropy Gathering Daemon
 socket. It will be used to seed the random engine for SSL.
 .TP

docs/curl_escape.3

@@ -13,7 +13,10 @@ curl_escape - URL encodes the given string
 .SH DESCRIPTION
 This function will convert the given input string to an URL encoded string and
 return that as a new allocated string. All input characters that are not a-z,
-A-Z or 0-9 will be converted to their "URL escaped" version.
+A-Z or 0-9 will be converted to their "URL escaped" version. If a sequence of
+%NN (where NN is a two-digit hexadecimal number) is found in the string to
+encode, that 3-letter combination will be copied to the output unmodifed,
+assuming that it is an already encoded piece of data.
 
 If the 'length' argument is set to 0, curl_escape() will use strlen() on the
 input 'url' string to find out the size.

docs/curl_formfree.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" Written by daniel@haxx.se
 .\"
-.TH curl_formfree 3 "5 March 2001" "libcurl 7.5" "libcurl Manual"
+.TH curl_formfree 3 "6 April 2001" "libcurl 7.7.1" "libcurl Manual"
 .SH NAME
 curl_formfree - free a previously build multipart/formdata HTTP POST chain
 .SH SYNOPSIS
@@ -19,5 +19,7 @@ None
 .SH "SEE ALSO"
 .BR curl_formparse "(3) "
 .SH BUGS
-Surely there are some, you tell me!
+libcurl 7.7.1 and earlier versions does not allow a NULL pointer to be used as
+argument.
+
 

docs/curl_formparse.3

@@ -2,26 +2,36 @@
 .\" nroff -man [file]
 .\" Written by daniel@haxx.se
 .\"
-.TH curl_formparse 3 "5 March 2001" "libcurl 7.0" "libcurl Manual"
+.TH curl_formparse 3 "21 May 2001" "libcurl 7.7.4" "libcurl Manual"
 .SH NAME
 curl_formparse - add a section to a multipart/formdata HTTP POST
 .SH SYNOPSIS
 .B #include <curl/curl.h>
 .sp
-.BI "CURLcode curl_formparse(char *" string, "struct HttpPost **" firstitem,
-.BI "struct HttpPost ** "lastitem ");"
+.BI "CURLcode curl_formparse(char * " string, " struct HttpPost ** " firstitem,
+.BI "struct HttpPost ** " lastitem ");"
 .ad
 .SH DESCRIPTION
 curl_formparse() is used to append sections when building a multipart/formdata
-HTTP POST. Append one section at a time until you've added all the sections
-you want included and then you pass the
-.I firstitem
-pointer as parameter to CURLOPT_HTTPPOST.
-.I lastitem
-is set after each call and on repeated invokes it should be left as set to
-allow repeated invokes to find the end of the list in a faster way.
-.I string
-must be a zero terminated string following the following syntax.
+HTTP POST (sometimes refered to as rfc1867-style posts). Append one section at
+a time until you've added all the sections you want included and then you pass
+the \fIfirstitem\fP pointer as parameter to \fBCURLOPT_HTTPPOST\fP.
+\fIlastitem\fP is set after each call and on repeated invokes it should be
+left as set to allow repeated invokes to find the end of the list in a faster
+way.  \fIstring\fP must be a zero terminated string abiding to the syntax
+described in a section below
+
+The pointers \fI*firstitem\fP and \fI*lastitem\fP should both be pointing to
+NULL in the first call to this function. All list-data will be allocated by
+the function itself. You must call \fIcurl_formfree\fP after the form post has
+been done to free the resources again.
+
+This function will copy all input data and keep its own version of it
+allocated until you call \fIcurl_formfree\fP. When you've passed the pointer
+to \fIcurl_easy_setopt\fP, you must not free the list until after you've
+called \fIcurl_easy_cleanup\fP for the curl handle.
+
+See example below.
 .SH "FORM PARSE STRINGS"
 The
 .I string 
@@ -55,8 +65,21 @@ content-type for all of them in the same way as with a single file.
 .PP
 .SH RETURN VALUE
 Returns non-zero if an error occurs.
+.SH EXAMPLE
+
+ HttpPost* post = NULL;
+ HttpPost* last = NULL;
+
+ /* Add an image section */
+ curl_formparse("picture=@my-face.jpg", &post, &last);
+ /* Add a normal text section */
+ curl_formparse("name=FooBar", &post, &last);
+ /* Set the form info */
+ curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
+
 .SH "SEE ALSO"
-.BR curl_easy_setopt "(3) "
+.BR curl_easy_setopt "(3), "
+.BR curl_formfree "(3)
 .SH BUGS
 Surely there are some, you tell me!
 

docs/curl_global_cleanup.3

@@ -0,0 +1,27 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" Written by daniel@haxx.se
+.\"
+.TH curl_global_cleanup 3 "28 May 2001" "libcurl 7.8" "libcurl Manual"
+.SH NAME
+curl_global_cleanup - Global libcurl cleanup
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "void curl_global_cleanup(void);"
+.ad
+.SH DESCRIPTION
+curl_global_cleanup must be called once (no matter how many threads or libcurl
+sessions that'll be used) by every application that uses libcurl, after all
+uses of libcurl is complete.
+
+This is the opposite of \fIcurl_global_init\fP.
+
+Not calling this function may result in memory leaks.
+
+This function was added in libcurl 7.8.
+.SH "SEE ALSO"
+.BR curl_global_init "(3), "
+.SH BUGS
+None?
+

docs/curl_global_init.3

@@ -0,0 +1,34 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" Written by daniel@haxx.se
+.\"
+.TH curl_global_init 3 "29 May 2001" "libcurl 7.8" "libcurl Manual"
+.SH NAME
+curl_global_init - Global libcurl initialisation
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "CURLcode curl_global_init(long " flags ");"
+.ad
+.SH DESCRIPTION
+This function should be called once (no matter how many threads or libcurl
+sessions that'll be used) by every application that uses libcurl.
+
+If this function hasn't been invoked when \fIcurl_easy_init\fP is called, it
+will be done automatically by libcurl.
+
+The flags option should be set to zero. It will be used to tell libcurl what
+specific features it should \fBnot\fP init.
+
+You must however \fBalways\fP use the \fIcurl_global_cleanup\fP function, as
+that cannot be called automatically for you by libcurl.
+
+This function was added in libcurl 7.8.
+.SH RETURN VALUE
+If this function returns non-zero, something went wrong and you cannot use the
+other curl functions.
+.SH "SEE ALSO"
+.BR curl_global_cleanup "(3), "
+.SH BUGS
+None.
+

docs/curl_mprintf.3

@@ -0,0 +1,88 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" Written by daniel@haxx.se
+.\"
+.TH curl_printf 3 "20 April 2001" "libcurl 7.7.2" "libcurl Manual"
+.SH NAME
+curl_maprintf, curl_mfprintf, curl_mprintf, curl_msnprintf, curl_msprintf
+curl_mvaprintf, curl_mvfprintf, curl_mvprintf, curl_mvsnprintf,
+curl_mvsprintf - formatted output conversion
+.SH SYNOPSIS
+.B #include <curl/mprintf.h>
+.sp
+.BI "int curl_mprintf(const char *" format ", ...);"
+.br
+.BI "int curl_mfprintf(FILE *" fd ", const char *" format ", ...);"
+.br
+.BI "int curl_msprintf(char *" buffer ", const char *" format ", ...);"
+.br
+.BI "int curl_msnprintf(char *" buffer ", size_t " maxlength ", const char *" format ", ...);"
+.br
+.BI "int curl_mvprintf(const char *" format ", va_list " args ");"
+.br
+.BI "int curl_mvfprintf(FILE *" fd ", const char *" format ", va_list " args ");"
+.br
+.BI "int curl_mvsprintf(char *" buffer ", const char *" format ", va_list " args ");"
+.br
+.BI "int curl_mvsnprintf(char *" buffer ", size_t " maxlength ", const char *" format ", va_list " args ");"
+.br
+.BI "char *curl_maprintf(const char *" format ", ...);"
+.br
+.BI "char *curl_mvaprintf(const char *" format ", va_list " args ");"
+.SH DESCRIPTION
+These are all functions that produces output according to a format string and
+given arguments. These are mostly clones of the well-known C-style functions
+and there will be no detailed explanation of all available formatting rules
+and usage here.
+
+See this table for notable exceptions.
+.RS
+.TP
+.B curl_mprintf()
+Normal printf() clone.
+.TP
+.B curl_mfprintf()
+Normal fprinf() clone.
+.TP
+.B curl_msprintf()
+Normal sprintf() clone.
+.TP
+.B curl_msnprintf()
+snprintf() clone. Many systems don't have this. It is just like \fBsprintf\fP
+but with an extra argument after the buffer that specifies the length of the
+target buffer.
+.TP
+.B curl_mvprintf()
+Normal vprintf() clone.
+.TP
+.B curl_mvfprintf()
+Normal vfprintf() clone.
+.TP
+.B curl_mvsprintf()
+Normal vsprintf() clone.
+.TP
+.B curl_mvsnprintf()
+vsnprintf() clone.  Many systems don't have this. It is just like
+\fBvsprintf\fP but with an extra argument after the buffer that specifies the
+length of the target buffer.
+.TP
+.B curl_maprintf()
+Like printf() but returns the output string as a malloc()ed string. The
+returned string must be free()ed by the receiver.
+.TP
+.B curl_mvaprintf()
+Like curl_maprintf() but takes a va_list pointer argument instead of a
+variable amount of arguments.
+.RE
+
+To easily use all these cloned functions instead of the normal ones, #define
+_MPRINTF_REPLACE before you include the <curl/mprintf.h> file. Then all the
+normal names like printf, fprintf, sprintf etc will use the curl-functions
+instead.
+.SH RETURN VALUE
+The \fBcurl_maprintf\fP and \fBcurl_mvaprintf\fP functions return a pointer to
+a newly allocated string, or NULL it it failed.
+
+All other functions return the number of character they actually outputed.
+.SH "SEE ALSO"
+.BR printf "(3), " sprintf "(3), " fprintf "(3), " vprintf "(3) "

docs/curl_strequal.3

@@ -0,0 +1,30 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" Written by daniel@haxx.se
+.\"
+.TH curl_strequal 3 "20 April 2001" "libcurl 7.7.2" "libcurl Manual"
+.SH NAME
+curl_strequal, curl_strnequal - case insensitive string comparisons
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "int curl_strequal(char *" str1 ", char *" str2 ");"
+.sp
+.BI "int curl_strenqual(char *" str1 ", char *" str2 ", size_t " len ");"
+.SH DESCRIPTION
+The
+.B curl_strequal()
+function compares the two strings \fIstr1\fP and \fIstr2\fP, ignoring the case
+of the characters. It returns a non-zero (TRUE) integer if the strings are
+identical.
+.sp
+The \fBcurl_strnequal()\fP function is similar, except it only compares the
+first \fIlen\fP characters of \fIstr1\fP.
+.sp
+These functions are provided by libcurl to enable applications to compare
+strings in a truly portable manner. There are no standard portable case
+insensitive string comparison functions. These two works on all platforms.
+.SH RETURN VALUE
+A pointer to a zero terminated string.
+.SH "SEE ALSO"
+.BR strcmp "(3), " strcasecmp "(3)"

docs/curl_strnequal.3

@@ -0,0 +1 @@
+.so curl_strequal.3

docs/examples/Makefile.am

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

docs/examples/Makefile.example

@@ -0,0 +1,42 @@
+#############################################################################
+#                                  _   _ ____  _     
+#  Project                     ___| | | |  _ \| |    
+#                             / __| | | | |_) | |    
+#                            | (__| |_| |  _ <| |___ 
+#                             \___|\___/|_| \_\_____|
+#
+# $Id$
+#
+
+# What to call the final executable
+TARGET = example
+
+# Which object files that the executable consists of
+OBJS= ftpget.o
+
+# What compiler to use
+CC = gcc
+
+# Compiler flags, -g for debug, -c to make an object file
+CFLAGS = -c -g
+
+# This should point to a directory that holds libcurl, if it isn't
+# in the system's standard lib dir
+# We also set a -L to include the directory where we have the openssl
+# libraries
+LDFLAGS = -L/home/dast/lib -L/usr/local/ssl/lib
+
+# We need -lcurl for the curl stuff
+# We need -lsocket and -lnsl when on Solaris
+# We need -lssl and -lcrypto when using libcurl with SSL support
+# We need -ldl for dlopen() if that is in libdl
+# We need -lpthread for the pthread example
+LIBS = -lcurl -lsocket -lnsl -lssl -lcrypto -dl
+
+# Link the target with all objects and libraries
+$(TARGET) : $(OBJS)
+	$(CC) $(LDFLAGS) $(LIBS) -o $(TARGET) $(OBJS)
+
+# Compile the source files into object files
+ftpget.o : ftpget.c
+	$(CC) $(CFLAGS) $<

docs/examples/README

@@ -7,4 +7,12 @@ advantage of libcurl.
 If you end up with other small but still useful example sources, please mail
 them for submission in future packages and on the web site.
 
+The Makefile.example is an example makefile that could be used to build these
+examples. Just edit the file according to your system and requirements first.
+
 Try the php/examples/ directory for PHP programming snippets!
+
+  *PLEASE* do not use the curl.haxx.se site as a test target for your libcurl
+  applications/experiments. Even if the examples in this directory use that
+  site as an example URL at some places, it doesn't mean that the URLs work or
+  that we expect you to actually torture our web site with your tests! Thanks.

docs/examples/ftpget.c

@@ -0,0 +1,44 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ */
+
+#include <stdio.h>
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+/* to make this work under windows, use the win32-functions from the
+   win32socket.c file as well */
+
+int main(int argc, char **argv)
+{
+  CURL *curl;
+  CURLcode res;
+  FILE *ftpfile;
+  
+  /* local file name to store the file as */
+  ftpfile = fopen("curl.tar.gz", "wb"); /* b is binary for win */
+
+  curl = curl_easy_init();
+  if(curl) {
+    /* Get curl 7.7 from sunet.se's FTP site: */
+    curl_easy_setopt(curl, CURLOPT_URL,
+                     "ftp://ftp.sunet.se/pub/www/utilities/curl/curl-7.7.tar.gz");
+    curl_easy_setopt(curl, CURLOPT_FILE, ftpfile);
+    res = curl_easy_perform(curl);
+
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+
+  fclose(ftpfile); /* close the local file */
+
+  return 0;
+}

docs/examples/getinmemory.c

@@ -0,0 +1,80 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ *
+ * Example source code to show how the callback function can be used to
+ * download data into a chunk of memory instead of storing it in a file.
+ *
+ * This exact source code has not been verified to work.
+ */
+
+/* to make this work under windows, use the win32-functions from the
+   win32socket.c file as well */
+
+#include <stdio.h>
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+struct MemoryStruct {
+  char *memory;
+  size_t size;
+};
+
+size_t
+WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
+{
+  register int realsize = size * nmemb;
+  struct MemoryStruct *mem = (struct MemoryStruct *)data;
+  
+  mem->memory = (char *)realloc(mem->memory, mem->size + realsize + 1);
+  if (mem->memory) {
+    memcpy(&(mem->memory[mem->size]), ptr, realsize);
+    mem->size += realsize;
+    mem->memory[mem->size] = 0;
+  }
+  return realsize;
+}
+
+int main(int argc, char **argv)
+{
+  CURL *curl_handle;
+
+  struct MemoryStruct chunk;
+
+  chunk.memory=NULL; /* we expect realloc(NULL, size) to work */
+  chunk.size = 0;    /* no data at this point */
+
+  /* init the curl session */
+  curl_handle = curl_easy_init();
+
+  /* specify URL to get */
+  curl_easy_setopt(curl_handle, CURLOPT_URL, "http://cool.haxx.se/");
+
+  /* send all data to this function  */
+  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
+
+  /* we pass our 'chunk' struct to the callback function */
+  curl_easy_setopt(curl_handle, CURLOPT_FILE, (void *)&chunk);
+
+  /* get it! */
+  curl_easy_perform(curl_handle);
+
+  /* cleanup curl stuff */
+  curl_easy_cleanup(curl_handle);
+
+  /*
+   * Now, our chunk.memory points to a memory block that is chunk.size
+   * bytes big and contains the remote file.
+   *
+   * Do something nice with it!
+   */
+
+  return 0;
+}

docs/examples/multithread.c

@@ -0,0 +1,70 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ */
+
+/* A multi-threaded example that uses pthreads extensively to fetch
+ * X remote files at once */
+
+#include <stdio.h>
+#include <pthread.h>
+#include <curl/curl.h>
+
+/* silly list of test-URLs */
+char *urls[]= {
+  "http://curl.haxx.se/",
+  "ftp://cool.haxx.se/",
+  "http://www.contactor.se/",
+  "www.haxx.se"
+};
+
+void *pull_one_url(void *url)
+{
+  CURL *curl;
+
+  curl = curl_easy_init();
+
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_perform(curl);
+
+  curl_easy_cleanup(curl);
+
+  return NULL;
+}
+
+
+/* 
+   int pthread_create(pthread_t *new_thread_ID,
+   const pthread_attr_t *attr,
+   void * (*start_func)(void *), void *arg);
+*/
+
+int main(int argc, char **argv)
+{
+  pthread_t tid[4];
+  int i;
+  int error;
+  for(i=0; i< 4; i++) {
+    error = pthread_create(&tid[i],
+                           NULL, /* default attributes please */
+                           pull_one_url,
+                           urls[i]);
+    if(0 != error)
+      fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
+    else 
+      fprintf(stderr, "Thread %d, gets %s\n", i, urls[i]);
+  }
+
+  /* now wait for all threads to terminate */
+  for(i=0; i< 4; i++) {
+    error = pthread_join(tid[i], NULL);
+    fprintf(stderr, "Thread %d terminated\n", i);
+  }
+
+  return 0;
+}

docs/examples/sepheaders.c

@@ -19,9 +19,9 @@
 #include <curl/types.h>
 #include <curl/easy.h>
 
-size_t  write_data(void *ptr, size_t size, size_t nmemb, FILE *stream)
+size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  written = fwrite(ptr,size,nmemb,outfile);
+  written = fwrite(ptr, size, nmemb, (FILE *)stream);
   return written;
 }
 

docs/libcurl.5

@@ -0,0 +1,130 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" Written by Daniel Stenberg
+.\"
+.TH libcurl 5 "28 May 2001" "libcurl 7.8" "libcurl overview"
+.SH NAME
+libcurl \- client-side URL transfers
+.SH DESCRIPTION
+This is an overview on how to use libcurl in your c/c++ programs. There are
+specific man pages for each function mentioned in here.
+
+libcurl can also be used directly from within your Java, PHP, Perl, Ruby or
+Tcl programs as well, look elsewhere for documentation on this!
+
+All applications that use libcurl should call \fIcurl_global_init()\fP exactly
+once before any libcurl function can be used. After all usage of libcurl is
+complete, it \fBmust\fP call \fIcurl_global_cleanup()\fP. In between those two
+calls, you can use libcurl as described below.
+
+When using libcurl you init your session and get a handle, which you use as
+input to the following interface functions you use. Use \fIcurl_easy_init()\fP
+to get the handle.
+
+You continue by setting all the options you want in the upcoming transfer,
+most important among them is the URL itself (you can't transfer anything
+without a specified URL as you may have figured out yourself). You might want
+to set some callbacks as well that will be called from the library when data
+is available etc.  \fIcurl_easy_setopt()\fP is there for this.
+
+When all is setup, you tell libcurl to perform the transfer using
+\fIcurl_easy_perform()\fP.  It will then do the entire operation and won't
+return until it is done (successfully or not).
+
+After the transfer has been made, you can set new options and make another
+transfer, or if you're done, cleanup the session by calling
+\fIcurl_easy_cleanup()\fP.  If you want persistant connections, you don't
+cleanup immediately, but instead run ahead and perform other transfers using
+the same handle. See the chapter below for Persistant Connections.
+
+There is also a series of other helpful functions to use. They are:
+
+.RS
+.TP 10
+.B curl_version()
+displays the libcurl version
+.TP
+.B curl_getdate()
+converts a date string to time_t
+.TP
+.B curl_getenv()
+portable environment variable reader
+.TP
+.B curl_easy_getinfo()
+get information about a performed transfer
+.TP
+.B curl_formparse()
+helps building a HTTP form POST
+.TP
+.B curl_formfree()
+free a list built with curl_formparse()
+.TP
+.B curl_slist_append()
+builds a linked list
+.TP
+.B curl_slist_free_all()
+frees a whole curl_slist
+.TP
+.B curl_mprintf()
+portable printf() functions
+.TP
+.B curl_strequal()
+portable case insensitive string comparisons
+.RE
+
+.SH "LINKING WITH LIBCURL"
+Starting with 7.7.2 (on unix-like machines), there's a tool named curl-config
+that gets installed with the rest of the curl stuff when 'make install' is
+performed.
+
+curl-config is added to make it easier for applications to link with libcurl
+and developers to learn about libcurl and how to use it.
+
+Run 'curl-config --libs' to get the (additional) linker options you need to
+link with the particular version of libcurl you've installed.
+
+For details, see the curl-config.1 man page.
+.SH "LIBCURL SYMBOL NAMES"
+All public functions in the libcurl interface are prefixed with 'curl_' (with
+a lowercase c). You can find other functions in the library source code, but
+other prefixes indicate the functions are private and may change without
+further notice in the next release.
+
+Only use documented functions and functionality!
+.SH "PORTABILITY"
+libcurl works
+.B exactly
+the same, on any of the platforms it compiles and builds on.
+
+There's only one caution, and that is the win32 platform that may(*) require
+you to init the winsock stuff before you use the libcurl functions. Details on
+this are noted on the curl_easy_init() man page.
+
+(*) = it appears as if users of the cygwin environment get this done
+automatically.
+.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
+threads, but you must use separate curl handles if you want to use libcurl in
+more than one thread simultaneously.
+.SH "PERSISTANT CONNECTIONS"
+With libcurl 7.7, persistant connections were added. Persistant connections
+means that libcurl can re-use the same connection for several transfers, if
+the conditions are right.
+
+libcurl will *always* attempt to use persistant connections. Whenever you use
+curl_easy_perform(), libcurl will attempt to use an existing connection to do
+the transfer, and if none exists it'll open a new one that will be subject
+for re-use on a possible following call to curl_easy_perform().
+
+To allow libcurl to take full advantage of persistant connections, you should
+do as many of your file transfers as possible using the same curl
+handle. When you call curl_easy_cleanup(), all the possibly open connections
+held by libcurl will be closed and forgotten.
+
+Note that the options set with curl_easy_setopt() will be used in on every
+repeat curl_easy_perform() call
+.SH "COMPATIBILITY WITH OLDER LIBCURLS"
+Repeated curl_easy_perform() calls on the same handle were not supported in
+pre-7.7 versions, and caused confusion and undefined behaviour.
+

include/curl/curl.h

@@ -76,12 +76,12 @@ typedef int (*curl_progress_callback)(void *clientp,
 typedef size_t (*curl_write_callback)(char *buffer,
                                       size_t size,
                                       size_t nitems,
-                                      FILE *outstream);
+                                      void *outstream);
 
 typedef size_t (*curl_read_callback)(char *buffer,
                                      size_t size,
                                      size_t nitems,
-                                     FILE *instream);
+                                     void *instream);
 
 typedef int (*curl_passwd_callback)(void *clientp,
                                     char *prompt,
@@ -146,10 +146,17 @@ typedef enum {
   CURLE_TOO_MANY_REDIRECTS ,     /* 47 - catch endless re-direct loops */
   CURLE_UNKNOWN_TELNET_OPTION,   /* 48 - User specified an unknown option */
   CURLE_TELNET_OPTION_SYNTAX ,   /* 49 - Malformed telnet option */
-
+  CURLE_OBSOLETE,	         /* 50 - removed after 7.7.3 */
+  CURLE_SSL_PEER_CERTIFICATE,    /* 51 - peer's certificate wasn't ok */
+  
   CURL_LAST /* never use! */
 } CURLcode;
 
+/* this was the error code 50 in 7.7.3 and a few earlier versions, this
+   is no longer used by libcurl but is instead #defined here only to not
+   make programs break */
+#define CURLE_ALREADY_COMPLETE 99999
+
 /* This is just to make older programs not break: */
 #define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
 
@@ -172,7 +179,7 @@ typedef enum {
 typedef enum {
   CINIT(NOTHING, LONG, 0), /********* the first one is unused ************/
   
-  /* This is the FILE * the regular output should be written to. */
+  /* This is the FILE * or void * the regular output should be written to. */
   CINIT(FILE, OBJECTPOINT, 1),
 
   /* The full URL to get/put */
@@ -275,7 +282,8 @@ typedef enum {
   /* send linked-list of QUOTE commands */
   CINIT(QUOTE, OBJECTPOINT, 28),
 
-  /* send FILE * to store headers to */
+  /* send FILE * or void * to store headers to, if you use a callback it
+     is simply passed to the callback unmodified */
   CINIT(WRITEHEADER, OBJECTPOINT, 29),
 
 #ifdef MULTIDOC
@@ -430,6 +438,10 @@ typedef enum {
      phase. [Only works on unix-style/SIGALRM operating systems] */
   CINIT(CONNECTTIMEOUT, LONG, 78),
 
+  /* Function that will be called to store headers (instead of fwrite). The
+   * parameters will use fwrite() syntax, make sure to follow them. */
+  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
+
   CURLOPT_LASTENTRY /* the last unusued */
 } CURLoption;
 
@@ -480,9 +492,19 @@ char *curl_version(void);
 char *curl_escape(char *string, int length);
 char *curl_unescape(char *string, int length);
 
+/* curl_global_init() should be invoked exactly once for each application that
+   uses libcurl */
+CURLcode curl_global_init(long flags);
+
+/* curl_global_cleanup() should be invoked exactly once for each application
+   that uses libcurl */
+void curl_global_cleanup(void);
+
+
+
 /* This is the version number */
-#define LIBCURL_VERSION "7.7"
-#define LIBCURL_VERSION_NUM 0x070700
+#define LIBCURL_VERSION "7.8-pre2"
+#define LIBCURL_VERSION_NUM 0x070800
 
 /* linked-list structure for the CURLOPT_QUOTE option (and other) */
 struct curl_slist {
@@ -551,6 +573,9 @@ typedef enum {
   CURLCLOSEPOLICY_LAST /* last, never use this */
 } curl_closepolicy;
 
+#define CURL_GLOBAL_NOT_SSL (1<<0)
+#define CURL_GLOBAL_NOTHING CURL_GLOBAL_NOT_SSL
+#define CURL_GLOBAL_DEFAULT 0
 
 #ifdef  __cplusplus
 }

java/CurlGlue.java

@@ -0,0 +1,134 @@
+/**
+ * The curl class is a JNI wrapper for libcurl. Please bear with me, I'm no
+ * true java dude (yet). Improve what you think is bad and send me the
+ * updates!
+ * daniel@haxx.se
+ *
+ * This is meant as a raw, crude and low-level interface to libcurl. If you
+ * want fancy stuff, build upon this.
+ */
+
+public class CurlGlue
+{
+  // start of imported generated list, make a new list with
+  // define2java.pl on demand
+  public static final int CURLOPT_NOTHING  = 0;
+  public static final int CURLOPT_FILE  = 10001;
+  public static final int CURLOPT_URL  = 10002;
+  public static final int CURLOPT_PORT  = 3;
+  public static final int CURLOPT_PROXY  = 10004;
+  public static final int CURLOPT_USERPWD  = 10005;
+  public static final int CURLOPT_PROXYUSERPWD  = 10006;
+  public static final int CURLOPT_RANGE  = 10007;
+  public static final int CURLOPT_INFILE  = 10009;
+  public static final int CURLOPT_ERRORBUFFER  = 10010;
+  public static final int CURLOPT_WRITEFUNCTION  = 20011;
+  public static final int CURLOPT_READFUNCTION  = 20012;
+  public static final int CURLOPT_TIMEOUT  = 13;
+  public static final int CURLOPT_INFILESIZE  = 14;
+  public static final int CURLOPT_POSTFIELDS  = 10015;
+  public static final int CURLOPT_REFERER  = 10016;
+  public static final int CURLOPT_FTPPORT  = 10017;
+  public static final int CURLOPT_USERAGENT  = 10018;
+  public static final int CURLOPT_LOW_SPEED_LIMIT  = 19;
+  public static final int CURLOPT_LOW_SPEED_TIME  = 20;
+  public static final int CURLOPT_RESUME_FROM  = 21;
+  public static final int CURLOPT_COOKIE  = 10022;
+  public static final int CURLOPT_HTTPHEADER  = 10023;
+  public static final int CURLOPT_HTTPPOST  = 10024;
+  public static final int CURLOPT_SSLCERT  = 10025;
+  public static final int CURLOPT_SSLCERTPASSWD  = 10026;
+  public static final int CURLOPT_CRLF  = 27;
+  public static final int CURLOPT_QUOTE  = 10028;
+  public static final int CURLOPT_WRITEHEADER  = 10029;
+  public static final int CURLOPT_COOKIEFILE  = 10031;
+  public static final int CURLOPT_SSLVERSION  = 32;
+  public static final int CURLOPT_TIMECONDITION  = 33;
+  public static final int CURLOPT_TIMEVALUE  = 34;
+  public static final int CURLOPT_HTTPREQUEST  = 10035;
+  public static final int CURLOPT_CUSTOMREQUEST  = 10036;
+  public static final int CURLOPT_STDERR  = 10037;
+  public static final int CURLOPT_POSTQUOTE  = 10039;
+  public static final int CURLOPT_WRITEINFO  = 10040;
+  public static final int CURLOPT_VERBOSE  = 41;
+  public static final int CURLOPT_HEADER  = 42;
+  public static final int CURLOPT_NOPROGRESS  = 43;
+  public static final int CURLOPT_NOBODY  = 44;
+  public static final int CURLOPT_FAILONERROR  = 45;
+  public static final int CURLOPT_UPLOAD  = 46;
+  public static final int CURLOPT_POST  = 47;
+  public static final int CURLOPT_FTPLISTONLY  = 48;
+  public static final int CURLOPT_FTPAPPEND  = 50;
+  public static final int CURLOPT_NETRC  = 51;
+  public static final int CURLOPT_FOLLOWLOCATION  = 52;
+  public static final int CURLOPT_FTPASCII  = 53;
+  public static final int CURLOPT_TRANSFERTEXT  = 53;
+  public static final int CURLOPT_PUT  = 54;
+  public static final int CURLOPT_MUTE  = 55;
+  public static final int CURLOPT_PROGRESSFUNCTION  = 20056;
+  public static final int CURLOPT_PROGRESSDATA  = 10057;
+  public static final int CURLOPT_AUTOREFERER  = 58;
+  public static final int CURLOPT_PROXYPORT  = 59;
+  public static final int CURLOPT_POSTFIELDSIZE  = 60;
+  public static final int CURLOPT_HTTPPROXYTUNNEL  = 61;
+  public static final int CURLOPT_INTERFACE  = 10062;
+  public static final int CURLOPT_KRB4LEVEL  = 10063;
+  public static final int CURLOPT_SSL_VERIFYPEER  = 64;
+  public static final int CURLOPT_CAINFO  = 10065;
+  public static final int CURLOPT_PASSWDFUNCTION  = 20066;
+  public static final int CURLOPT_PASSWDDATA  = 10067;
+  public static final int CURLOPT_MAXREDIRS  = 68;
+  public static final int CURLOPT_FILETIME  = 10069;
+  public static final int CURLOPT_TELNETOPTIONS  = 10070;
+  public static final int CURLOPT_MAXCONNECTS  = 71;
+  public static final int CURLOPT_CLOSEPOLICY  = 72;
+  public static final int CURLOPT_CLOSEFUNCTION  = 20073;
+  public static final int CURLOPT_FRESH_CONNECT  = 74;
+  public static final int CURLOPT_FORBID_REUSE  = 75;
+  public static final int CURLOPT_RANDOM_FILE  = 10076;
+  public static final int CURLOPT_EGDSOCKET  = 10077;
+  public static final int CURLOPT_CONNECTTIMEOUT  = 78;
+  public static final int CURLOPT_HEADERFUNCTION  = 20079;
+  // end of generated list
+
+  public CurlGlue() {
+    javacurl_handle = jni_init();
+  }
+
+  public void finalize() {
+    jni_cleanup(javacurl_handle);
+  }
+
+  private int javacurl_handle;
+
+  /* constructor and destructor for the libcurl handle */
+  private native int jni_init();
+  private native void jni_cleanup(int javacurl_handle);
+  private native synchronized int jni_perform(int javacurl_handle);
+  
+    // Instead of varargs, we have different functions for each
+  // kind of type setopt() can take
+  private native int jni_setopt(int libcurl, int option, String value);
+  private native int jni_setopt(int libcurl, int option, int value);
+  private native int jni_setopt(int libcurl, int option, CurlWrite value);
+
+  public native int getinfo();
+  
+  public int perform() {
+    return jni_perform(javacurl_handle);
+  }
+  public int setopt(int option, int value) {
+    return jni_setopt(javacurl_handle, option, value);
+  }
+  public int setopt(int option, String value) {
+    return jni_setopt(javacurl_handle, option, value);
+  }
+  public int setopt(int option, CurlWrite value) {
+    return jni_setopt(javacurl_handle, option, value);
+  }
+
+  static {
+    System.loadLibrary("javacurl");
+  }
+  
+}

java/CurlWrite.java

@@ -0,0 +1,9 @@
+public interface CurlWrite
+{
+  /**
+   * handleString gets called by libcurl on each chunk of data
+   * we receive from the remote server
+   */
+  public int handleString(byte s[]);
+}
+

java/Makefile

@@ -0,0 +1,35 @@
+
+TARGET = libjavacurl.so
+
+OBJS = javacurl.o
+
+CC = gcc
+CFLAGS = -c
+CPPFLAGS = -I/usr/j2se/include -I/usr/local/include -I/usr/j2se/include/solaris
+
+# Linux might use -shared -Wl,-soname,libnative.so instead of -G
+LDFLAGS = -G -lcurl -ldl -L/usr/local/ssl/lib -lssl -lcrypto
+
+all: CurlGlue.h CurlGlue.class javacurl.o $(TARGET) test.class
+
+test:
+	java test
+
+javacurl.o: javacurl.c CurlGlue.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $<
+
+CurlGlue.h: CurlGlue.java CurlGlue.class
+	javah CurlGlue
+	touch CurlGlue.h
+
+test.class: CurlGlue.class javacurl.o
+	javac test.java
+
+CurlGlue.class: CurlGlue.java
+	javac $<
+
+$(TARGET): $(OBJS)
+	$(CC) -o $(TARGET) $(LDFLAGS) $(OBJS)
+
+clean:
+	rm -f javacurl.o CurlGlue.h CurlGlue.class

java/README

@@ -0,0 +1,15 @@
+                                  _   _ ____  _     
+                              ___| | | |  _ \| |    
+                             / __| | | | |_) | |    
+                            | (__| |_| |  _ <| |___ 
+                             \___|\___/|_| \_\_____|
+
+                                Java Interface
+
+ This is not a complete implementation of a libcurl interface. I've made the
+core work and it needs additional code to be added to get the rest of the
+stuff supported.
+
+ The interface is not set yet, bring your suggestions!
+
+ Feel free to grab the source files in here and help out!

java/define2java.pl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+
+open(GCC, "gcc -E ../include/curl/curl.h|");
+
+while(<GCC>) {
+    if($_ =~ /(CURLOPT_(.*)) += (.*)/) {
+        $var= $1;
+        $expr = $3;
+        $f=$3;
+        if($expr =~ / *(\d+) *\+ *(\d+)/) {
+            $expr = $1+$2;
+        }
+
+        # nah, keep the CURL prefix to make them look like other
+        # languages' defines
+        # $var =~ s/^CURL//g;
+
+        print "  public static final int $var = $expr;\n";
+    }
+}
+
+close(GCC);

java/javacurl.c

@@ -0,0 +1,196 @@
+
+#include <curl/curl.h> /* libcurl header */
+#include "CurlGlue.h"  /* the JNI-generated glue header file */
+
+/*
+ * This is a private struct allocated for every 'CurlGlue' object.
+ */
+struct javacurl {
+  void *libcurl;
+  void *whatever;
+  struct writecallback {
+    jmethodID mid;
+    JNIEnv *java;
+    jclass cls; /* global reference */
+    jobject object;
+  } write;
+};
+
+JNIEXPORT jint JNICALL Java_CurlGlue_jni_1init(JNIEnv *java,
+                                               jobject myself)
+{
+  void *libhandle;
+  struct javacurl *jcurl=NULL;
+
+  libhandle = curl_easy_init();
+
+  if(libhandle) {
+    jcurl=(struct javacurl *)malloc(sizeof(struct javacurl));
+    if(jcurl) {
+      memset(jcurl, 0, sizeof(struct javacurl));
+      jcurl->libcurl = libhandle;
+
+    }
+    else {
+      curl_easy_cleanup(libhandle);
+      return (jint)0;
+    }
+  }
+
+  return (jint) jcurl; /* nasty typecast */
+}
+
+JNIEXPORT void JNICALL Java_CurlGlue_jni_1cleanup(JNIEnv *java,
+                                                  jobject myself,
+                                                  jint jcurl)
+{
+
+  struct javacurl *curl = (struct javacurl*)jcurl;
+
+  if(curl->write.cls) {
+    /* a global reference we must delete */
+    (*java)->DeleteGlobalRef(java, curl->write.cls);
+    (*java)->DeleteGlobalRef(java, curl->write.object);
+  }
+
+  curl_easy_cleanup(curl->libcurl); /* cleanup libcurl stuff */
+
+  free((void *)curl); /* free the struct too */
+}
+
+/*
+ * setopt() int + string
+ */
+JNIEXPORT jint JNICALL Java_CurlGlue_jni_1setopt__IILjava_lang_String_2
+  (JNIEnv *java, jobject myself, jint jcurl, jint option, jstring value)
+{
+  /* get the actual string C-style */
+  const char *str = (*java)->GetStringUTFChars(java, value, 0);
+
+  void *handle = (void *)((struct javacurl*)jcurl)->libcurl;
+
+  puts("setopt int + string");
+  
+  return (jint)curl_easy_setopt(handle, (CURLoption)option, str);
+
+}
+
+/*
+ * setopt() int + int 
+ */
+JNIEXPORT jint JNICALL Java_CurlGlue_jni_1setopt__III
+  (JNIEnv *java, jobject myself, jint jcurl, jint option, jint value)
+{
+  void *handle = (void *)((struct javacurl*)jcurl)->libcurl;
+  CURLoption opt = (CURLoption)option;
+
+  puts("setopt int + int");
+
+  switch(opt) {
+  case CURLOPT_FILE:
+    /* silently ignored, we don't need user-specified callback data when
+       we have an object, and besides the CURLOPT_FILE is not exported
+       to the java interface */
+    return 0;
+  }
+
+  return (jint)curl_easy_setopt(handle, (CURLoption)option, value);
+}
+
+static int javacurl_write_callback(void *ptr,
+                                   size_t size,
+                                   size_t nmemb,
+                                   FILE  *stream)
+{
+  struct javacurl *curl = (struct javacurl *)stream;
+  size_t realsize = size * nmemb;
+  JNIEnv *java = curl->write.java;
+  jbyteArray jb=NULL;
+  int ret=0;
+
+  fprintf(stderr, "%d bytes data received in callback:\n"
+          "ptr=%p, java=%p cls=%p\n",
+          realsize, curl, java, curl->write.cls);
+
+  jb=(*java)->NewByteArray(java, realsize);
+  (*java)->SetByteArrayRegion(java, jb, 0, 
+                              realsize, (jbyte *)ptr);
+
+  fprintf(stderr, "created byte-array\n");
+
+  ret = (*java)->CallIntMethod(java,
+                               curl->write.object,
+                               curl->write.mid,
+                               jb);
+
+  fprintf(stderr, "java-method returned %d\n", ret);
+
+  return realsize;
+}
+
+/*
+ * setopt() int + object
+ */
+
+JNIEXPORT jint JNICALL Java_CurlGlue_jni_1setopt__IILCurlWrite_2
+  (JNIEnv *java, jobject myself, jint jcurl, jint option, jobject object)
+{
+  jclass cls_local = (*java)->GetObjectClass(java, object);
+  jmethodID mid;
+  struct javacurl *curl = (struct javacurl *)jcurl;
+  jclass cls;
+  jobject obj_global;
+
+  switch(option) {
+  case CURLOPT_WRITEFUNCTION:
+    /* this makes a reference that'll be alive until we kill it! */
+    cls = (*java)->NewGlobalRef(java, cls_local);
+
+    printf("setopt int + object, option = %d cls= %p\n",
+           option, cls);
+
+    if(!cls) {
+      puts("couldn't make local reference global");
+      return 0;
+    }
+
+    /* this is the write callback */
+    mid = (*java)->GetMethodID(java, cls, "handleString", "([B)I");
+    if(!mid) {
+      puts("no callback method found");
+      return 0;
+    }
+
+    obj_global = (*java)->NewGlobalRef(java, object);
+
+    curl->write.mid = mid;
+    curl->write.cls = cls;
+    curl->write.object = obj_global;
+    /*curl->write.java = java; stored on perform */
+
+    fprintf(stderr, "setopt write callback and write file pointer %p, java = %p\n",
+            curl, java);
+
+    curl_easy_setopt(curl->libcurl, CURLOPT_WRITEFUNCTION,
+                     javacurl_write_callback);
+    curl_easy_setopt(curl->libcurl, CURLOPT_FILE,
+                     curl);
+
+    break;
+  }
+  return 0;
+}
+
+JNIEXPORT jint JNICALL Java_CurlGlue_getinfo
+  (JNIEnv *java, jobject value)
+{
+    return 0;
+}
+
+JNIEXPORT jint JNICALL Java_CurlGlue_jni_1perform
+  (JNIEnv *java, jobject myself, jint jcurl)
+{
+  struct javacurl *curl=(struct javacurl*)jcurl;
+  curl->write.java = java;
+  return (jint)curl_easy_perform(curl->libcurl);
+}

java/test.java

@@ -0,0 +1,27 @@
+import CurlGlue;
+import CurlWrite;
+
+class test implements CurlWrite {
+    public int handleString(byte s[])
+    {
+        /* output everything */
+        System.out.println("IIIIIIIIIII -------------- OOOOOOOOOOOOOOOOOOO");
+        try {
+          System.out.write(s);
+        }
+        catch (java.io.IOException moo) {
+          // nothing
+        }
+        return 0;
+    }
+
+    public static void main(String[] args)
+    {
+        CurlGlue cg = new CurlGlue();
+        test cw = new test();
+        cg.setopt(CurlGlue.CURLOPT_URL, "http://www.contactor.se/");
+        cg.setopt(CurlGlue.CURLOPT_WRITEFUNCTION, cw);
+        cg.perform();
+    }
+}
+

lib/Makefile.am

@@ -16,7 +16,7 @@ lib_LTLIBRARIES = libcurl.la
 INCLUDES = -I$(top_srcdir)/include
 
 
-libcurl_la_LDFLAGS = -version-info 2:0:0
+libcurl_la_LDFLAGS = -version-info 2:0:1
 # This flag accepts an argument of the form current[:revision[:age]]. So,
 # passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
 # 1.
@@ -59,7 +59,7 @@ escape.c       mprintf.c      telnet.c       \
 escape.h       getpass.c      netrc.c        telnet.h       \
 getinfo.c 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
+http_chunks.c http_chunks.h strtok.c strtok.h
 
 noinst_HEADERS = setup.h transfer.h
 

lib/Makefile.b32

@@ -14,7 +14,7 @@ RM	   = del
 LIB	   = tlib
 TOPDIR	   = ..
 CURNTDIR   = .
-CXXFLAGS   = -5 -O2 -w-aus -w-ccc -w-csu -w-par -w-pia -w-rch -w-inl -w-ngu -w-pro
+CXXFLAGS   = -5 -O2 -w-aus -w-ccc -w-csu -w-par -w-pia -w-rch -w-inl -w-ngu -w-pro -tWM
 DEFINES    = -DLIBCURL_BIGENDIAN=0 -DNDEBUG -DWIN32 -DCONSOLE -DMBCS
 INCDIRS    = -I$(CURNTDIR);$(TOPDIR)/include/
 
@@ -34,6 +34,7 @@ SOURCES	   = \
 	formdata.c \
 	ftp.c \
 	http.c \
+        http_chunks.c \
 	ldap.c \
 	dict.c \
 	telnet.c \
@@ -64,11 +65,11 @@ OBJECTS = $(SOURCES:.c=.obj)
 all:	$(LIBCURLLIB)
 
 clean:
-	$(RM) $(LIBCURLLIB)
-        $(RM) *.obj
+	-$(RM) $(LIBCURLLIB)
+        -$(RM) *.obj
 
 $(LIBCURLLIB):  $(LINKLIB) $(OBJECTS) Makefile.b32.resp
-	$(RM) $(LIBCURLLIB)
+	-$(RM) $(LIBCURLLIB)
 	$(LIB) $(LIBCURLLIB) @Makefile.b32.resp
 
 

lib/Makefile.b32.resp

@@ -5,6 +5,7 @@
 +formdata.obj &
 +ftp.obj &
 +http.obj &
++http_chunks.obj &
 +ldap.obj &
 +dict.obj &
 +telnet.obj &

lib/Makefile.vc6

@@ -1,347 +1,358 @@
-#############################################################
-## Makefile for building libcurl.lib with MSVC6
-## Use: nmake -f makefile.vc6 [release | release-ssl | debug]
-##      (default is release)
-##
-## Comments to: Troy Engel <tengel@sonic.net>
-## Updated by: Craig Davison <cd@securityfocus.com>
-
-PROGRAM_NAME = libcurl.lib
-PROGRAM_NAME_DEBUG = libcurld.lib
-OPENSSL_PATH = ../../openssl-0.9.6
-
-########################################################
-## Nothing more to do below this line!
-
-## Release
-CCR = cl.exe /MD /O2 /D "NDEBUG"
-LINKR = link.exe -lib /out:$(PROGRAM_NAME)
-
-## Debug
-CCD = cl.exe /MDd /Gm /ZI /Od /D "_DEBUG" /GZ
-LINKD = link.exe -lib /out:$(PROGRAM_NAME_DEBUG)
-
-## SSL Release
-CCRS = cl.exe /MD /O2 /D "NDEBUG" /D "USE_SSLEAY" /I "$(OPENSSL_PATH)/include" /I "$(OPENSSL_PATH)/include/openssl"
-LINKRS = link.exe -lib /out:$(PROGRAM_NAME) /LIBPATH:$(OPENSSL_PATH)/out32dll
-
-CFLAGS = /I "../include" /nologo /W3 /GX /D "WIN32" /D "VC6" /D "_MBCS" /D "_LIB" /YX /FD /c /D "MSDOS"
-LFLAGS = /nologo
-LINKLIBS = wsock32.lib
-LINKSLIBS = libeay32.lib ssleay32.lib RSAglue.lib
-
-RELEASE_OBJS= \
-	base64r.obj \
-	cookier.obj \
-	transferr.obj \
-	escaper.obj \
-	formdatar.obj \
-	ftpr.obj \
-	httpr.obj \
-	ldapr.obj \
-	dictr.obj \
-	telnetr.obj \
-	getdater.obj \
-	getenvr.obj \
-	getpassr.obj \
-	hostipr.obj \
-	if2ipr.obj \
-	mprintfr.obj \
-	netrcr.obj \
-	progressr.obj \
-	sendfr.obj \
-	speedcheckr.obj \
-	ssluser.obj \
-	timevalr.obj \
-	urlr.obj \
-	filer.obj \
-	getinfor.obj \
-	versionr.obj \
-	easyr.obj \
-	strequalr.obj
-
-DEBUG_OBJS= \
-	base64d.obj \
-	cookied.obj \
-	transferd.obj \
-	escaped.obj \
-	formdatad.obj \
-	ftpd.obj \
-	httpd.obj \
-	ldapd.obj \
-	dictd.obj \
-	telnetd.obj \
-	getdated.obj \
-	getenvd.obj \
-	getpassd.obj \
-	hostipd.obj \
-	if2ipd.obj \
-	mprintfd.obj \
-	netrcd.obj \
-	progressd.obj \
-	sendfd.obj \
-	speedcheckd.obj \
-	sslused.obj \
-	timevald.obj \
-	urld.obj \
-	filed.obj \
-	getinfod.obj \
-	versiond.obj  \
-	easyd.obj \
-	strequald.obj
-
-RELEASE_SSL_OBJS= \
-	base64rs.obj \
-	cookiers.obj \
-	transferrs.obj \
-	escapers.obj \
-	formdatars.obj \
-	ftprs.obj \
-	httprs.obj \
-	ldaprs.obj \
-	dictrs.obj \
-	telnetrs.obj \
-	getdaters.obj \
-	getenvrs.obj \
-	getpassrs.obj \
-	hostiprs.obj \
-	if2iprs.obj \
-	mprintfrs.obj \
-	netrcrs.obj \
-	progressrs.obj \
-	sendfrs.obj \
-	speedcheckrs.obj \
-	sslusers.obj \
-	timevalrs.obj \
-	urlrs.obj \
-	filers.obj \
-	getinfors.obj \
-	versionrs.obj \
-	easyrs.obj \
-	strequalrs.obj
-
-LINK_OBJS= \
-	base64.obj \
-	cookie.obj \
-	transfer.obj \
-	escape.obj \
-	formdata.obj \
-	ftp.obj \
-	http.obj \
-	ldap.obj \
-	dict.obj \
-	telnet.obj \
-	getdate.obj \
-	getenv.obj \
-	getpass.obj \
-	hostip.obj \
-	if2ip.obj \
-	mprintf.obj \
-	netrc.obj \
-	progress.obj \
-	sendf.obj \
-	speedcheck.obj \
-	ssluse.obj \
-	timeval.obj \
-	url.obj \
-	file.obj \
-	getinfo.obj \
-	version.obj \
-	easy.obj \
-	strequal.obj
-
-all : release
-
-release: $(RELEASE_OBJS)
-	$(LINKR) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
-
-debug: $(DEBUG_OBJS)
-	$(LINKD) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
-
-release-ssl: $(RELEASE_SSL_OBJS)
-	$(LINKRS) $(LFLAGS) $(LINKLIBS) $(LINKSLIBS) $(LINK_OBJS)
-
-## Release
-base64r.obj: base64.c
-	$(CCR) $(CFLAGS) base64.c
-cookier.obj: cookie.c
-	$(CCR) $(CFLAGS) cookie.c
-transferr.obj: transfer.c
-	$(CCR) $(CFLAGS) transfer.c
-escaper.obj: escape.c
-	$(CCR) $(CFLAGS) escape.c
-formdatar.obj: formdata.c
-	$(CCR) $(CFLAGS) formdata.c
-ftpr.obj: ftp.c
-	$(CCR) $(CFLAGS) ftp.c
-httpr.obj: http.c
-	$(CCR) $(CFLAGS) http.c
-ldapr.obj: ldap.c
-	$(CCR) $(CFLAGS) ldap.c
-dictr.obj: dict.c
-	$(CCR) $(CFLAGS) dict.c
-telnetr.obj: telnet.c
-	$(CCR) $(CFLAGS) telnet.c
-getdater.obj: getdate.c
-	$(CCR) $(CFLAGS) getdate.c
-getenvr.obj: getenv.c
-	$(CCR) $(CFLAGS) getenv.c
-getpassr.obj: getpass.c
-	$(CCR) $(CFLAGS) getpass.c
-hostipr.obj: hostip.c
-	$(CCR) $(CFLAGS) hostip.c
-if2ipr.obj: if2ip.c
-	$(CCR) $(CFLAGS) if2ip.c
-mprintfr.obj: mprintf.c
-	$(CCR) $(CFLAGS) mprintf.c
-netrcr.obj: netrc.c
-	$(CCR) $(CFLAGS) netrc.c
-progressr.obj: progress.c
-	$(CCR) $(CFLAGS) progress.c
-sendfr.obj: sendf.c
-	$(CCR) $(CFLAGS) sendf.c
-speedcheckr.obj: speedcheck.c
-	$(CCR) $(CFLAGS) speedcheck.c
-ssluser.obj: ssluse.c
-	$(CCR) $(CFLAGS) ssluse.c
-timevalr.obj: timeval.c
-	$(CCR) $(CFLAGS) timeval.c
-urlr.obj: url.c
-	$(CCR) $(CFLAGS) url.c
-filer.obj: file.c
-	$(CCR) $(CFLAGS) file.c
-getinfor.obj: getinfo.c
-	$(CCR) $(CFLAGS) getinfo.c
-versionr.obj: version.c
-	$(CCR) $(CFLAGS) version.c
-easyr.obj: easy.c
-	$(CCR) $(CFLAGS) easy.c
-strequalr.obj: strequal.c
-	$(CCR) $(CFLAGS) strequal.c
-
-## Debug
-base64d.obj: base64.c
-	$(CCD) $(CFLAGS) base64.c
-cookied.obj: cookie.c
-	$(CCD) $(CFLAGS) cookie.c
-transferd.obj: transfer.c
-	$(CCD) $(CFLAGS) transfer.c
-escaped.obj: escape.c
-	$(CCD) $(CFLAGS) escape.c
-formdatad.obj: formdata.c
-	$(CCD) $(CFLAGS) formdata.c
-ftpd.obj: ftp.c
-	$(CCD) $(CFLAGS) ftp.c
-httpd.obj: http.c
-	$(CCD) $(CFLAGS) http.c
-ldapd.obj: ldap.c
-	$(CCD) $(CFLAGS) ldap.c
-dictd.obj: dict.c
-	$(CCD) $(CFLAGS) dict.c
-telnetd.obj: telnet.c
-	$(CCD) $(CFLAGS) telnet.c
-getdated.obj: getdate.c
-	$(CCD) $(CFLAGS) getdate.c
-getenvd.obj: getenv.c
-	$(CCD) $(CFLAGS) getenv.c
-getpassd.obj: getpass.c
-	$(CCD) $(CFLAGS) getpass.c
-hostipd.obj: hostip.c
-	$(CCD) $(CFLAGS) hostip.c
-if2ipd.obj: if2ip.c
-	$(CCD) $(CFLAGS) if2ip.c
-mprintfd.obj: mprintf.c
-	$(CCD) $(CFLAGS) mprintf.c
-netrcd.obj: netrc.c
-	$(CCD) $(CFLAGS) netrc.c
-progressd.obj: progress.c
-	$(CCD) $(CFLAGS) progress.c
-sendfd.obj: sendf.c
-	$(CCD) $(CFLAGS) sendf.c
-speedcheckd.obj: speedcheck.c
-	$(CCD) $(CFLAGS) speedcheck.c
-sslused.obj: ssluse.c
-	$(CCD) $(CFLAGS) ssluse.c
-timevald.obj: timeval.c
-	$(CCD) $(CFLAGS) timeval.c
-urld.obj: url.c
-	$(CCD) $(CFLAGS) url.c
-filed.obj: file.c
-	$(CCD) $(CFLAGS) file.c
-getinfod.obj: getinfo.c
-	$(CCD) $(CFLAGS) getinfo.c
-versiond.obj: version.c
-	$(CCD) $(CFLAGS) version.c
-easyd.obj: easy.c
-	$(CCD) $(CFLAGS) easy.c
-strequald.obj: strequal.c
-	$(CCD) $(CFLAGS) strequal.c
-
-
-## Release SSL
-base64rs.obj: base64.c
-	$(CCRS) $(CFLAGS) base64.c
-cookiers.obj: cookie.c
-	$(CCRS) $(CFLAGS) cookie.c
-transferrs.obj: transfer.c
-	$(CCRS) $(CFLAGS) transfer.c
-escapers.obj: escape.c
-	$(CCRS) $(CFLAGS) escape.c
-formdatars.obj: formdata.c
-	$(CCRS) $(CFLAGS) formdata.c
-ftprs.obj: ftp.c
-	$(CCRS) $(CFLAGS) ftp.c
-httprs.obj: http.c
-	$(CCRS) $(CFLAGS) http.c
-ldaprs.obj: ldap.c
-	$(CCRS) $(CFLAGS) ldap.c
-dictrs.obj: dict.c
-	$(CCRS) $(CFLAGS) dict.c
-telnetrs.obj: telnet.c
-	$(CCRS) $(CFLAGS) telnet.c
-getdaters.obj: getdate.c
-	$(CCRS) $(CFLAGS) getdate.c
-getenvrs.obj: getenv.c
-	$(CCRS) $(CFLAGS) getenv.c
-getpassrs.obj: getpass.c
-	$(CCRS) $(CFLAGS) getpass.c
-hostiprs.obj: hostip.c
-	$(CCRS) $(CFLAGS) hostip.c
-if2iprs.obj: if2ip.c
-	$(CCRS) $(CFLAGS) if2ip.c
-mprintfrs.obj: mprintf.c
-	$(CCRS) $(CFLAGS) mprintf.c
-netrcrs.obj: netrc.c
-	$(CCRS) $(CFLAGS) netrc.c
-progressrs.obj: progress.c
-	$(CCRS) $(CFLAGS) progress.c
-sendfrs.obj: sendf.c
-	$(CCRS) $(CFLAGS) sendf.c
-speedcheckrs.obj: speedcheck.c
-	$(CCRS) $(CFLAGS) speedcheck.c
-sslusers.obj: ssluse.c
-	$(CCRS) $(CFLAGS) ssluse.c
-timevalrs.obj: timeval.c
-	$(CCRS) $(CFLAGS) timeval.c
-urlrs.obj: url.c
-	$(CCRS) $(CFLAGS) url.c
-filers.obj: file.c
-	$(CCRS) $(CFLAGS) file.c
-getinfors.obj: getinfo.c
-	$(CCRS) $(CFLAGS) getinfo.c
-versionrs.obj: version.c
-	$(CCRS) $(CFLAGS) version.c
-easyrs.obj: easy.c
-	$(CCRS) $(CFLAGS) easy.c
-strequalrs.obj: strequal.c
-	$(CCRS) $(CFLAGS) strequal.c
-
-
-clean:
-	-@erase *.obj
-	-@erase vc60.idb
-	-@erase vc60.pch
-
-distrib: clean
-	-@erase $(PROGRAM_NAME)
-
+#############################################################
+## Makefile for building libcurl.lib with MSVC6
+## Use: nmake -f makefile.vc6 [release | release-ssl | debug]
+##      (default is release)
+##
+## Comments to: Troy Engel <tengel@sonic.net>
+## Updated by: Craig Davison <cd@securityfocus.com>
+## Updated by: SM <sm@technologist.com>
+
+PROGRAM_NAME = libcurl.lib
+PROGRAM_NAME_DEBUG = libcurld.lib
+#OPENSSL_PATH = ../../openssl-0.9.6a
+
+########################################################
+## Nothing more to do below this line!
+
+## Release
+CCR = cl.exe /MD /O2 /D "NDEBUG"
+LINKR = link.exe -lib /out:$(PROGRAM_NAME)
+
+## Debug
+CCD = cl.exe /MDd /Gm /ZI /Od /D "_DEBUG" /GZ
+LINKD = link.exe -lib /out:$(PROGRAM_NAME_DEBUG)
+
+## SSL Release
+CCRS = cl.exe /MD /O2 /D "NDEBUG" /D "USE_SSLEAY" /I "$(OPENSSL_PATH)/inc32" /I "$(OPENSSL_PATH)/inc32/openssl"
+LINKRS = link.exe -lib /out:$(PROGRAM_NAME) /LIBPATH:$(OPENSSL_PATH)/out32dll
+
+CFLAGS = /I "../include" /nologo /W3 /GX /D "WIN32" /D "VC6" /D "_MBCS" /D "_LIB" /YX /FD /c /D "MSDOS"
+LFLAGS = /nologo
+LINKLIBS = wsock32.lib
+LINKSLIBS = libeay32.lib ssleay32.lib RSAglue.lib
+
+RELEASE_OBJS= \
+	base64r.obj \
+	cookier.obj \
+	transferr.obj \
+	escaper.obj \
+	formdatar.obj \
+	ftpr.obj \
+	httpr.obj \
+	http_chunksr.obj \
+	ldapr.obj \
+	dictr.obj \
+	telnetr.obj \
+	getdater.obj \
+	getenvr.obj \
+	getpassr.obj \
+	hostipr.obj \
+	if2ipr.obj \
+	mprintfr.obj \
+	netrcr.obj \
+	progressr.obj \
+	sendfr.obj \
+	speedcheckr.obj \
+	ssluser.obj \
+	timevalr.obj \
+	urlr.obj \
+	filer.obj \
+	getinfor.obj \
+	versionr.obj \
+	easyr.obj \
+	strequalr.obj
+
+DEBUG_OBJS= \
+	base64d.obj \
+	cookied.obj \
+	transferd.obj \
+	escaped.obj \
+	formdatad.obj \
+	ftpd.obj \
+	httpd.obj \
+	http_chunksd.obj \
+	ldapd.obj \
+	dictd.obj \
+	telnetd.obj \
+	getdated.obj \
+	getenvd.obj \
+	getpassd.obj \
+	hostipd.obj \
+	if2ipd.obj \
+	mprintfd.obj \
+	netrcd.obj \
+	progressd.obj \
+	sendfd.obj \
+	speedcheckd.obj \
+	sslused.obj \
+	timevald.obj \
+	urld.obj \
+	filed.obj \
+	getinfod.obj \
+	versiond.obj  \
+	easyd.obj \
+	strequald.obj
+
+RELEASE_SSL_OBJS= \
+	base64rs.obj \
+	cookiers.obj \
+	transferrs.obj \
+	escapers.obj \
+	formdatars.obj \
+	ftprs.obj \
+	httprs.obj \
+	http_chunksrs.obj \
+	ldaprs.obj \
+	dictrs.obj \
+	telnetrs.obj \
+	getdaters.obj \
+	getenvrs.obj \
+	getpassrs.obj \
+	hostiprs.obj \
+	if2iprs.obj \
+	mprintfrs.obj \
+	netrcrs.obj \
+	progressrs.obj \
+	sendfrs.obj \
+	speedcheckrs.obj \
+	sslusers.obj \
+	timevalrs.obj \
+	urlrs.obj \
+	filers.obj \
+	getinfors.obj \
+	versionrs.obj \
+	easyrs.obj \
+	strequalrs.obj
+
+LINK_OBJS= \
+	base64.obj \
+	cookie.obj \
+	transfer.obj \
+	escape.obj \
+	formdata.obj \
+	ftp.obj \
+	http.obj \
+	http_chunks.obj \
+	ldap.obj \
+	dict.obj \
+	telnet.obj \
+	getdate.obj \
+	getenv.obj \
+	getpass.obj \
+	hostip.obj \
+	if2ip.obj \
+	mprintf.obj \
+	netrc.obj \
+	progress.obj \
+	sendf.obj \
+	speedcheck.obj \
+	ssluse.obj \
+	timeval.obj \
+	url.obj \
+	file.obj \
+	getinfo.obj \
+	version.obj \
+	easy.obj \
+	strequal.obj
+
+all : release
+
+release: $(RELEASE_OBJS)
+	$(LINKR) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
+
+debug: $(DEBUG_OBJS)
+	$(LINKD) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
+
+release-ssl: $(RELEASE_SSL_OBJS)
+	$(LINKRS) $(LFLAGS) $(LINKLIBS) $(LINKSLIBS) $(LINK_OBJS)
+
+## Release
+base64r.obj: base64.c
+	$(CCR) $(CFLAGS) base64.c
+cookier.obj: cookie.c
+	$(CCR) $(CFLAGS) cookie.c
+transferr.obj: transfer.c
+	$(CCR) $(CFLAGS) transfer.c
+escaper.obj: escape.c
+	$(CCR) $(CFLAGS) escape.c
+formdatar.obj: formdata.c
+	$(CCR) $(CFLAGS) formdata.c
+ftpr.obj: ftp.c
+	$(CCR) $(CFLAGS) ftp.c
+httpr.obj: http.c
+	$(CCR) $(CFLAGS) http.c
+http_chunksr.obj: http_chunks.c
+	$(CCR) $(CFLAGS) http_chunks.c
+ldapr.obj: ldap.c
+	$(CCR) $(CFLAGS) ldap.c
+dictr.obj: dict.c
+	$(CCR) $(CFLAGS) dict.c
+telnetr.obj: telnet.c
+	$(CCR) $(CFLAGS) telnet.c
+getdater.obj: getdate.c
+	$(CCR) $(CFLAGS) getdate.c
+getenvr.obj: getenv.c
+	$(CCR) $(CFLAGS) getenv.c
+getpassr.obj: getpass.c
+	$(CCR) $(CFLAGS) getpass.c
+hostipr.obj: hostip.c
+	$(CCR) $(CFLAGS) hostip.c
+if2ipr.obj: if2ip.c
+	$(CCR) $(CFLAGS) if2ip.c
+mprintfr.obj: mprintf.c
+	$(CCR) $(CFLAGS) mprintf.c
+netrcr.obj: netrc.c
+	$(CCR) $(CFLAGS) netrc.c
+progressr.obj: progress.c
+	$(CCR) $(CFLAGS) progress.c
+sendfr.obj: sendf.c
+	$(CCR) $(CFLAGS) sendf.c
+speedcheckr.obj: speedcheck.c
+	$(CCR) $(CFLAGS) speedcheck.c
+ssluser.obj: ssluse.c
+	$(CCR) $(CFLAGS) ssluse.c
+timevalr.obj: timeval.c
+	$(CCR) $(CFLAGS) timeval.c
+urlr.obj: url.c
+	$(CCR) $(CFLAGS) url.c
+filer.obj: file.c
+	$(CCR) $(CFLAGS) file.c
+getinfor.obj: getinfo.c
+	$(CCR) $(CFLAGS) getinfo.c
+versionr.obj: version.c
+	$(CCR) $(CFLAGS) version.c
+easyr.obj: easy.c
+	$(CCR) $(CFLAGS) easy.c
+strequalr.obj: strequal.c
+	$(CCR) $(CFLAGS) strequal.c
+
+## Debug
+base64d.obj: base64.c
+	$(CCD) $(CFLAGS) base64.c
+cookied.obj: cookie.c
+	$(CCD) $(CFLAGS) cookie.c
+transferd.obj: transfer.c
+	$(CCD) $(CFLAGS) transfer.c
+escaped.obj: escape.c
+	$(CCD) $(CFLAGS) escape.c
+formdatad.obj: formdata.c
+	$(CCD) $(CFLAGS) formdata.c
+ftpd.obj: ftp.c
+	$(CCD) $(CFLAGS) ftp.c
+httpd.obj: http.c
+	$(CCD) $(CFLAGS) http.c
+http_chunksd.obj: http_chunks.c
+	$(CCD) $(CFLAGS) http_chunks.c
+ldapd.obj: ldap.c
+	$(CCD) $(CFLAGS) ldap.c
+dictd.obj: dict.c
+	$(CCD) $(CFLAGS) dict.c
+telnetd.obj: telnet.c
+	$(CCD) $(CFLAGS) telnet.c
+getdated.obj: getdate.c
+	$(CCD) $(CFLAGS) getdate.c
+getenvd.obj: getenv.c
+	$(CCD) $(CFLAGS) getenv.c
+getpassd.obj: getpass.c
+	$(CCD) $(CFLAGS) getpass.c
+hostipd.obj: hostip.c
+	$(CCD) $(CFLAGS) hostip.c
+if2ipd.obj: if2ip.c
+	$(CCD) $(CFLAGS) if2ip.c
+mprintfd.obj: mprintf.c
+	$(CCD) $(CFLAGS) mprintf.c
+netrcd.obj: netrc.c
+	$(CCD) $(CFLAGS) netrc.c
+progressd.obj: progress.c
+	$(CCD) $(CFLAGS) progress.c
+sendfd.obj: sendf.c
+	$(CCD) $(CFLAGS) sendf.c
+speedcheckd.obj: speedcheck.c
+	$(CCD) $(CFLAGS) speedcheck.c
+sslused.obj: ssluse.c
+	$(CCD) $(CFLAGS) ssluse.c
+timevald.obj: timeval.c
+	$(CCD) $(CFLAGS) timeval.c
+urld.obj: url.c
+	$(CCD) $(CFLAGS) url.c
+filed.obj: file.c
+	$(CCD) $(CFLAGS) file.c
+getinfod.obj: getinfo.c
+	$(CCD) $(CFLAGS) getinfo.c
+versiond.obj: version.c
+	$(CCD) $(CFLAGS) version.c
+easyd.obj: easy.c
+	$(CCD) $(CFLAGS) easy.c
+strequald.obj: strequal.c
+	$(CCD) $(CFLAGS) strequal.c
+
+
+## Release SSL
+base64rs.obj: base64.c
+	$(CCRS) $(CFLAGS) base64.c
+cookiers.obj: cookie.c
+	$(CCRS) $(CFLAGS) cookie.c
+transferrs.obj: transfer.c
+	$(CCRS) $(CFLAGS) transfer.c
+escapers.obj: escape.c
+	$(CCRS) $(CFLAGS) escape.c
+formdatars.obj: formdata.c
+	$(CCRS) $(CFLAGS) formdata.c
+ftprs.obj: ftp.c
+	$(CCRS) $(CFLAGS) ftp.c
+httprs.obj: http.c
+	$(CCR) $(CFLAGS) http.c
+http_chunksrs.obj: http_chunks.c
+	$(CCRS) $(CFLAGS) http_chunks.c
+ldaprs.obj: ldap.c
+	$(CCRS) $(CFLAGS) ldap.c
+dictrs.obj: dict.c
+	$(CCRS) $(CFLAGS) dict.c
+telnetrs.obj: telnet.c
+	$(CCRS) $(CFLAGS) telnet.c
+getdaters.obj: getdate.c
+	$(CCRS) $(CFLAGS) getdate.c
+getenvrs.obj: getenv.c
+	$(CCRS) $(CFLAGS) getenv.c
+getpassrs.obj: getpass.c
+	$(CCRS) $(CFLAGS) getpass.c
+hostiprs.obj: hostip.c
+	$(CCRS) $(CFLAGS) hostip.c
+if2iprs.obj: if2ip.c
+	$(CCRS) $(CFLAGS) if2ip.c
+mprintfrs.obj: mprintf.c
+	$(CCRS) $(CFLAGS) mprintf.c
+netrcrs.obj: netrc.c
+	$(CCRS) $(CFLAGS) netrc.c
+progressrs.obj: progress.c
+	$(CCRS) $(CFLAGS) progress.c
+sendfrs.obj: sendf.c
+	$(CCRS) $(CFLAGS) sendf.c
+speedcheckrs.obj: speedcheck.c
+	$(CCRS) $(CFLAGS) speedcheck.c
+sslusers.obj: ssluse.c
+	$(CCRS) $(CFLAGS) ssluse.c
+timevalrs.obj: timeval.c
+	$(CCRS) $(CFLAGS) timeval.c
+urlrs.obj: url.c
+	$(CCRS) $(CFLAGS) url.c
+filers.obj: file.c
+	$(CCRS) $(CFLAGS) file.c
+getinfors.obj: getinfo.c
+	$(CCRS) $(CFLAGS) getinfo.c
+versionrs.obj: version.c
+	$(CCRS) $(CFLAGS) version.c
+easyrs.obj: easy.c
+	$(CCRS) $(CFLAGS) easy.c
+strequalrs.obj: strequal.c
+	$(CCRS) $(CFLAGS) strequal.c
+
+
+clean:
+	-@erase *.obj
+	-@erase vc60.idb
+	-@erase vc60.pch
+
+distrib: clean
+	-@erase $(PROGRAM_NAME)
+

lib/cookie.c

@@ -86,6 +86,7 @@ Example set of cookies:
 #include "cookie.h"
 #include "getdate.h"
 #include "strequal.h"
+#include "strtok.h"
 
 /* The last #include file should be: */
 #ifdef MALLOCDEBUG
@@ -199,6 +200,7 @@ Curl_cookie_add(struct CookieInfo *c,
     /* This line is NOT a HTTP header style line, we do offer support for
        reading the odd netscape cookies-file format here */
     char *firstptr;
+    char *tok_buf;
     int fields;
 
     if(lineptr[0]=='#') {
@@ -214,7 +216,7 @@ Curl_cookie_add(struct CookieInfo *c,
     if(ptr)
       *ptr=0; /* clear it */
 
-    firstptr=strtok(lineptr, "\t"); /* first tokenize it on the TAB */
+    firstptr=strtok_r(lineptr, "\t", &tok_buf); /* first tokenize it on the TAB */
 
     /* Here's a quick check to eliminate normal HTTP-headers from this */
     if(!firstptr || strchr(firstptr, ':')) {
@@ -224,17 +226,38 @@ Curl_cookie_add(struct CookieInfo *c,
 
     /* Now loop through the fields and init the struct we already have
        allocated */
-    for(ptr=firstptr, fields=0; ptr; ptr=strtok(NULL, "\t"), fields++) {
+    for(ptr=firstptr, fields=0; ptr; ptr=strtok_r(NULL, "\t", &tok_buf), fields++) {
       switch(fields) {
       case 0:
         co->domain = strdup(ptr);
         break;
       case 1:
-        /* what _is_ this field for? */
+        /* This field got its explanation on the 23rd of May 2001 by
+           Andr<64>s Garc<72>a:
+
+           flag: A TRUE/FALSE value indicating if all machines within a given
+           domain can access the variable. This value is set automatically by
+           the browser, depending on the value you set for the domain.
+
+           As far as I can see, it is set to true when the cookie says
+           .domain.com and to false when the domain is complete www.domain.com
+
+           We don't currently take advantage of this knowledge.
+        */
         break;
       case 2:
-        co->path = strdup(ptr);
-        break;
+        /* It turns out, that sometimes the file format allows the path
+           field to remain not filled in, we try to detect this and work
+           around it! Andr<64>s Garc<72>a made us aware of this... */
+        if (strcmp("TRUE", ptr) && strcmp("FALSE", ptr)) {
+          /* only if the path doesn't look like a boolean option! */
+          co->path = strdup(ptr);
+          break;
+        }
+        /* this doesn't look like a path, make one up! */
+        co->path = strdup("/");
+        fields++; /* add a field and fall down to secure */
+        /* FALLTHROUGH */
       case 3:
         co->secure = strequal(ptr, "TRUE");
         break;

lib/curllib.dsp

@@ -43,7 +43,7 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MT /W3 /GX /O2 /I "C:\jdk1.3.0_01\include" /I "C:\jdk1.3.0_01\include\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /c
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
@@ -53,7 +53,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /dll /machine:I386 /out:"Release/curl.dll"
+# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /machine:I386 /out:"Release/curl.dll"
 
 !ELSEIF  "$(CFG)" == "curllib - Win32 Debug"
 
@@ -69,7 +69,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "C:\jdk1.3.0_01\include" /I "C:\jdk1.3.0_01\include\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CURLLIB_EXPORTS" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -79,7 +79,8 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /dll /debug /machine:I386 /out:"Debug/curl.dll" /pdbtype:sept
+# ADD LINK32 kernel32.lib wsock32.lib /nologo /dll /debug /machine:I386 /out:"Debug/curl.dll" /pdbtype:sept
+# SUBTRACT LINK32 /nodefaultlib
 
 !ENDIF 
 
@@ -112,14 +113,6 @@ SOURCE=.\easy.c
 # End Source File
 # Begin Source File
 
-SOURCE=.\easyswig.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\easyswig_wrap.c
-# End Source File
-# Begin Source File
-
 SOURCE=.\escape.c
 # End Source File
 # Begin Source File
@@ -160,6 +153,10 @@ SOURCE=.\http.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\http_chunks.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\if2ip.c
 # End Source File
 # Begin Source File
@@ -288,6 +285,10 @@ SOURCE=.\http.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\http_chunks.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\if2ip.h
 # End Source File
 # Begin Source File

lib/easy.c

@@ -73,16 +73,32 @@
 #include "urldata.h"
 #include <curl/curl.h>
 #include "transfer.h"
-#include <curl/types.h>
+#include "ssluse.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
 
+CURLcode curl_global_init(long flags)
+{
+  if(!(flags & CURL_GLOBAL_NOT_SSL))
+    Curl_SSL_init();
+
+  return CURLE_OK;
+}
+
+void curl_global_cleanup(void)
+{
+  Curl_SSL_cleanup();
+}
+
 CURL *curl_easy_init(void)
 {
   CURLcode res;
   struct UrlData *data;
 
+  /* Make sure we inited the global SSL stuff */
+  Curl_SSL_init();
+
   /* We use curl_open() with undefined URL so far */
   res = Curl_open((CURL **)&data, NULL);
   if(res != CURLE_OK)

lib/escape.c

@@ -25,6 +25,7 @@
  * allocated string or NULL if an error occurred.  */
 
 #include "setup.h"
+#include <ctype.h>
 #include <curl/curl.h>
 
 #include <stdio.h>
@@ -44,6 +45,7 @@ char *curl_escape(char *string, int length)
   int newlen = alloc;
   int index=0;
 
+  length = alloc-1;
   while(length--) {
     in = *string;
     if(' ' == in)
@@ -52,14 +54,28 @@ char *curl_escape(char *string, int length)
             !(in >= 'A' && in <= 'Z') &&
             !(in >= '0' && in <= '9')) {
       /* encode it */
-      newlen += 2; /* the size grows with two, since this'll become a %XX */
-      if(newlen > alloc) {
-        alloc *= 2;
-        ns = realloc(ns, alloc);
-        if(!ns)
-          return NULL;
+      if(('%' == in) &&
+         (length>=2) &&
+         isxdigit((int)string[1]) &&
+         isxdigit((int)string[2]) ) {
+        /*
+         * This is an already encoded letter, leave it!
+         */
+        memcpy(&ns[index], string, 3);
+        string+=2;
+      }
+      else {
+        /* encode this now */
+
+        newlen += 2; /* the size grows with two, since this'll become a %XX */
+        if(newlen > alloc) {
+          alloc *= 2;
+          ns = realloc(ns, alloc);
+          if(!ns)
+            return NULL;
+        }
+        sprintf(&ns[index], "%%%02X", in);
       }
-      sprintf(&ns[index], "%%%02X", in);
       index+=3;
     }
     else {

lib/file.c

@@ -183,11 +183,11 @@ CURLcode Curl_file(struct connectdata *conn)
       return res;
 
     now = Curl_tvnow();
-    if(Curl_pgrsUpdate(data))
+    if(Curl_pgrsUpdate(conn))
       res = CURLE_ABORTED_BY_CALLBACK;
   }
   now = Curl_tvnow();
-  if(Curl_pgrsUpdate(data))
+  if(Curl_pgrsUpdate(conn))
     res = CURLE_ABORTED_BY_CALLBACK;
 
   close(fd);

lib/formdata.c

@@ -371,6 +371,7 @@ char *Curl_FormBoundary(void)
 void Curl_FormFree(struct FormData *form)
 {
   struct FormData *next;
+
   do {
     next=form->next;  /* the following form line */
     free(form->line); /* free the line */
@@ -383,6 +384,11 @@ void Curl_FormFree(struct FormData *form)
 void curl_formfree(struct HttpPost *form)
 {
   struct HttpPost *next;
+
+  if(!form)
+    /* no form to free, just get out of this */
+    return;
+
   do {
     next=form->next;  /* the following form line */
 

lib/ftp.c

@@ -78,6 +78,7 @@
 #endif
 
 #include "strequal.h"
+#include "ssluse.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
@@ -146,6 +147,165 @@ static CURLcode AllowServerConnect(struct UrlData *data,
 #define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
 			isdigit((int)line[2]) && (' ' == line[3]))
 
+
+int Curl_GetFTPResponse(int sockfd,
+                        char *buf,
+                        struct connectdata *conn,
+                        int *ftpcode)
+{
+  /* Brand new implementation.
+   * We cannot read just one byte per read() and then go back to select()
+   * as it seems that the OpenSSL read() stuff doesn't grok that properly.
+   *
+   * Alas, read as much as possible, split up into lines, use the ending
+   * line in a response or continue reading.
+   */
+
+  int nread;   /* total size read */
+  int perline; /* count bytes per line */
+  bool keepon=TRUE;
+  ssize_t gotbytes;
+  char *ptr;
+  int timeout = 3600; /* default timeout in seconds */
+  struct timeval interval;
+  fd_set rkeepfd;
+  fd_set readfd;
+  struct UrlData *data = conn->data;
+  char *line_start;
+  int code;
+
+#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;
+
+  ptr=buf;
+  line_start = buf;
+
+  nread=0;
+  perline=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, BUFSIZE-nread, &gotbytes))
+        keepon = FALSE;
+      else if(gotbytes <= 0) {
+        keepon = FALSE;
+        error = SELECT_ERROR;
+        failf(data, "Connection aborted");
+      }
+      else {
+        /* we got a whole chunk of data, which can be anything from one
+         * byte to a set of lines and possible just a piece of the last
+         * line */
+        int i;
+
+        nread += gotbytes;
+        for(i=0; i< gotbytes; ptr++, i++) {
+          perline++;
+          if(*ptr=='\n') {
+            /* a newline is CRLF in ftp-talk, so the CR is ignored as
+               the line isn't really terminated until the LF comes */
+
+            /* output debug output if that is requested */
+            if(data->bits.verbose) {
+              fputs("< ", data->err);
+              fwrite(line_start, 1, perline, data->err);
+              /* no need to output LF here, it is part of the data */
+            }
+
+            if(perline>3 && lastline(line_start)) {
+              /* This is the end of the last line, copy the last
+               * line to the start of the buffer and zero terminate,
+               * for old times sake (and krb4)! */
+              char *moo;
+              int i;
+              for(moo=line_start, i=0; moo<ptr; moo++, i++)
+                buf[i] = *moo;
+              moo[i]=0; /* zero terminate */
+              keepon=FALSE;
+              break;
+            }
+            perline=0; /* line starts over here */
+            line_start = ptr+1;
+          }
+        }
+      }
+      break;
+    } /* switch */
+  } /* while there's buffer left and loop is requested */
+
+  if(!error)
+    code = atoi(buf);
+
+#if KRB4
+  /* handle the security-oriented responses 6xx ***/
+  /* FIXME: some errorchecking perhaps... ***/
+  switch(code) {
+  case 631:
+    sec_read_msg(conn, buf, prot_safe);
+    break;
+  case 632:
+    sec_read_msg(conn, buf, prot_private);
+    break;
+  case 633:
+    sec_read_msg(conn, buf, prot_confidential);
+    break;
+  default:
+    /* normal ftp stuff we pass through! */
+    break;
+  }
+#endif
+
+  if(error)
+    return -error;
+
+  if(ftpcode)
+    *ftpcode=code; /* return the initial number like this */
+
+  return nread; /* total amount of bytes read */
+}
+
+#if 0
 /*
  * We allow the ftpcode pointer to be NULL if no reply integer is wanted
  */
@@ -156,6 +316,7 @@ int Curl_GetFTPResponse(int sockfd, char *buf,
 {
   int nread;
   ssize_t keepon=TRUE;
+  size_t got;
   char *ptr;
   int timeout = 3600; /* in seconds */
   struct timeval interval;
@@ -259,6 +420,7 @@ int Curl_GetFTPResponse(int sockfd, char *buf,
 
   return nread;
 }
+#endif
 
 /* -- who are we? -- */
 char *Curl_getmyhost(char *buf, int buf_size)
@@ -316,6 +478,15 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
       return result;
   }
 
+  if(conn->protocol & PROT_FTPS) {
+    /* FTPS is simply ftp with SSL for the control channel */
+    /* now, perform the SSL initialization for this socket */
+    result = Curl_SSLConnect(conn);
+    if(result)
+      return result;
+  }
+
+
   /* The first thing we do is wait for the "220*" line: */
   nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
   if(nread < 0)
@@ -337,8 +508,6 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
        set a valid level */
     sec_request_prot(conn, data->krb4_level);
 
-    data->cmdchannel = fdopen(conn->firstsocket, "w");
-
     if(sec_login(conn) != 0)
       infof(data, "Logging in with password in cleartext!\n");
     else
@@ -487,11 +656,14 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
       failf(data, "Received only partial file");
       return CURLE_PARTIAL_FILE;
     }
-    else if(!data->bits.no_body && (0 == *ftp->bytecountp)) {
+    else if(!conn->bits.resume_done &&
+            !data->bits.no_body &&
+            (0 == *ftp->bytecountp)) {
       failf(data, "No data was received!");
       return CURLE_FTP_COULDNT_RETR_FILE;
     }
   }
+
 #ifdef KRB4
   sec_fflush_fd(conn, conn->secondarysocket);
 #endif
@@ -499,7 +671,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
   sclose(conn->secondarysocket);
   conn->secondarysocket = -1;
 
-  if(!data->bits.no_body) {  
+  if(!data->bits.no_body && !conn->bits.resume_done) {  
     /* now let's see what the server says about the transfer we
        just performed: */
     nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
@@ -513,6 +685,8 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
     }
   }
 
+  conn->bits.resume_done = FALSE; /* clean this for next connection */
+
   /* Send any post-transfer QUOTE strings? */
   if(data->postquote) {
     qitem = data->postquote;
@@ -680,35 +854,34 @@ CURLcode _ftp(struct connectdata *conn)
     if(nread < 0)
       return CURLE_OPERATION_TIMEOUTED;
 
-    if(ftpcode != 213) {
-      failf(data, "Couldn't get file size: %s", buf+4);
-      return CURLE_FTP_COULDNT_GET_SIZE;
-    }
-    /* get the size from the ascii string: */
-    filesize = atoi(buf+4);
+    if(ftpcode == 213) {
 
-    sprintf(buf, "Content-Length: %d\r\n", filesize);
-    result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
-    if(result)
-      return result;
+      /* get the size from the ascii string: */
+      filesize = atoi(buf+4);
 
-#ifdef HAVE_STRFTIME
-    if(data->bits.get_filetime && data->progress.filetime) {
-      struct tm *tm;
-#ifdef HAVE_LOCALTIME_R
-      struct tm buffer;
-      tm = (struct tm *)localtime_r(&data->progress.filetime, &buffer);
-#else
-      tm = localtime(&data->progress.filetime);
-#endif
-      /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
-      strftime(buf, BUFSIZE-1, "Last-Modified: %a, %d %b %Y %H:%M:%S %Z\r\n",
-               tm);
+      sprintf(buf, "Content-Length: %d\r\n", filesize);
       result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
       if(result)
         return result;
-    }
+
+#ifdef HAVE_STRFTIME
+      if(data->bits.get_filetime && data->progress.filetime) {
+        struct tm *tm;
+#ifdef HAVE_LOCALTIME_R
+        struct tm buffer;
+        tm = (struct tm *)localtime_r(&data->progress.filetime, &buffer);
+#else
+        tm = localtime(&data->progress.filetime);
 #endif
+        /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
+        strftime(buf, BUFSIZE-1, "Last-Modified: %a, %d %b %Y %H:%M:%S %Z\r\n",
+                 tm);
+        result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
+        if(result)
+          return result;
+      }
+#endif
+    }
 
     return CURLE_OK;
   }
@@ -727,8 +900,8 @@ CURLcode _ftp(struct connectdata *conn)
 #else
     const int niflags = NI_NUMERICHOST | NI_NUMERICSERV;
 #endif
-    char *ap;
-    char *pp;
+    unsigned char *ap;
+    unsigned char *pp;
     int alen, plen;
     char portmsgbuf[4096], tmp[4096];
 
@@ -795,17 +968,17 @@ CURLcode _ftp(struct connectdata *conn)
 
       switch (sa->sa_family) {
       case AF_INET:
-	ap = (char *)&((struct sockaddr_in *)&ss)->sin_addr;
+	ap = (unsigned char *)&((struct sockaddr_in *)&ss)->sin_addr;
 	alen = sizeof(((struct sockaddr_in *)&ss)->sin_addr);
-	pp = (char *)&((struct sockaddr_in *)&ss)->sin_port;
+	pp = (unsigned char *)&((struct sockaddr_in *)&ss)->sin_port;
 	plen = sizeof(((struct sockaddr_in *)&ss)->sin_port);
 	lprtaf = 4;
 	eprtaf = 1;
 	break;
       case AF_INET6:
-	ap = (char *)&((struct sockaddr_in6 *)&ss)->sin6_addr;
+	ap = (unsigned char *)&((struct sockaddr_in6 *)&ss)->sin6_addr;
 	alen = sizeof(((struct sockaddr_in6 *)&ss)->sin6_addr);
-	pp = (char *)&((struct sockaddr_in6 *)&ss)->sin6_port;
+	pp = (unsigned char *)&((struct sockaddr_in6 *)&ss)->sin6_port;
 	plen = sizeof(((struct sockaddr_in6 *)&ss)->sin6_port);
 	lprtaf = 6;
 	eprtaf = 2;
@@ -830,7 +1003,8 @@ CURLcode _ftp(struct connectdata *conn)
 	}
 	ftpsendf(conn->firstsocket, conn, "%s |%d|%s|%s|", *modep, eprtaf,
 	    portmsgbuf, tmp);
-      } else if (strcmp(*modep, "LPRT") == 0 || strcmp(*modep, "PORT") == 0) {
+      } else if (strcmp(*modep, "LPRT") == 0 ||
+                 strcmp(*modep, "PORT") == 0) {
 	int i;
 
         if (strcmp(*modep, "LPRT") == 0 && lprtaf < 0)
@@ -842,7 +1016,7 @@ CURLcode _ftp(struct connectdata *conn)
         if (strcmp(*modep, "LPRT") == 0) {
 	  snprintf(tmp, sizeof(tmp), "%d,%d", lprtaf, alen);
 	  if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >= sizeof(portmsgbuf)) {
-	    goto again;
+	    continue;
 	  }
 	}
 	for (i = 0; i < alen; i++) {
@@ -851,18 +1025,18 @@ CURLcode _ftp(struct connectdata *conn)
 	  else
 	    snprintf(tmp, sizeof(tmp), "%u", ap[i]);
 	  if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >= sizeof(portmsgbuf)) {
-	    goto again;
+	    continue;
 	  }
 	}
         if (strcmp(*modep, "LPRT") == 0) {
 	  snprintf(tmp, sizeof(tmp), ",%d", plen);
 	  if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >= sizeof(portmsgbuf))
-	    goto again;
+	    continue;
 	}
 	for (i = 0; i < plen; i++) {
 	  snprintf(tmp, sizeof(tmp), ",%u", pp[i]);
 	  if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >= sizeof(portmsgbuf)) {
-	    goto again;
+            continue;
 	  }
 	}
 	ftpsendf(conn->firstsocket, conn, "%s %s", *modep, portmsgbuf);
@@ -998,6 +1172,7 @@ again:;
   }
   else { /* we use the PASV command */
 #if 0
+    /* no support for IPv6 passive mode yet */
     char *mode[] = { "EPSV", "LPSV", "PASV", NULL };
     int results[] = { 229, 228, 227, 0 };
 #else
@@ -1265,7 +1440,7 @@ again:;
         CURLE_FTP_COULDNT_SET_BINARY;
     }
 
-    if(data->resume_from) {
+    if(conn->resume_from) {
       /* we're about to continue the uploading of a file */
       /* 1. get already existing file's size. We use the SIZE
          command for this which may not exist in the server!
@@ -1279,7 +1454,7 @@ again:;
       /* 4. lower the infilesize counter */
       /* => transfer as usual */
 
-      if(data->resume_from < 0 ) {
+      if(conn->resume_from < 0 ) {
         /* we could've got a specified offset from the command line,
            but now we know we didn't */
 
@@ -1295,10 +1470,10 @@ again:;
         }
 
         /* get the size from the ascii string: */
-        data->resume_from = atoi(buf+4);
+        conn->resume_from = atoi(buf+4);
       }
 
-      if(data->resume_from) {
+      if(conn->resume_from) {
         /* do we still game? */
         int passed=0;
         /* enable append instead */
@@ -1308,7 +1483,7 @@ again:;
            input. If we knew it was a proper file we could've just
            fseek()ed but we only have a stream here */
         do {
-          int readthisamountnow = (data->resume_from - passed);
+          int readthisamountnow = (conn->resume_from - passed);
           int actuallyread;
 
           if(readthisamountnow > BUFSIZE)
@@ -1324,15 +1499,24 @@ again:;
             return CURLE_FTP_COULDNT_USE_REST;
           }
         }
-        while(passed != data->resume_from);
+        while(passed != conn->resume_from);
 
         /* now, decrease the size of the read */
         if(data->infilesize>0) {
-          data->infilesize -= data->resume_from;
+          data->infilesize -= conn->resume_from;
 
           if(data->infilesize <= 0) {
-            failf(data, "File already completely uploaded\n");
-            return CURLE_FTP_COULDNT_STOR_FILE;
+            infof(data, "File already completely uploaded\n");
+
+            /* no data to transfer */
+            result=Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
+            
+            /* Set resume done so that we won't get any error in
+             * Curl_ftp_done() because we didn't transfer the amount of bytes
+             * that the local file file obviously is */
+            conn->bits.resume_done = TRUE; 
+
+            return CURLE_OK;
           }
         }
         /* we've passed, proceed as normal */
@@ -1380,13 +1564,13 @@ again:;
     bool dirlist=FALSE;
     long downloadsize=-1;
 
-    if(data->bits.set_range && data->range) {
+    if(conn->bits.use_range && conn->range) {
       long from, to;
       int totalsize=-1;
       char *ptr;
       char *ptr2;
 
-      from=strtol(data->range, &ptr, 0);
+      from=strtol(conn->range, &ptr, 0);
       while(ptr && *ptr && (isspace((int)*ptr) || (*ptr=='-')))
         ptr++;
       to=strtol(ptr, &ptr2, 0);
@@ -1396,22 +1580,23 @@ again:;
       }
       if((-1 == to) && (from>=0)) {
         /* X - */
-        data->resume_from = from;
+        conn->resume_from = from;
         infof(data, "FTP RANGE %d to end of file\n", from);
       }
       else if(from < 0) {
         /* -Y */
         totalsize = -from;
         conn->maxdownload = -from;
-        data->resume_from = from;
+        conn->resume_from = from;
         infof(data, "FTP RANGE the last %d bytes\n", totalsize);
       }
       else {
         /* X-Y */
         totalsize = to-from;
         conn->maxdownload = totalsize+1; /* include the last mentioned byte */
-        data->resume_from = from;
-        infof(data, "FTP RANGE from %d getting %d bytes\n", from, conn->maxdownload);
+        conn->resume_from = from;
+        infof(data, "FTP RANGE from %d getting %d bytes\n", from,
+              conn->maxdownload);
       }
       infof(data, "range-download from %d to %d, totally %d bytes\n",
             from, to, totalsize);
@@ -1459,7 +1644,7 @@ again:;
           CURLE_FTP_COULDNT_SET_BINARY;
       }
 
-      if(data->resume_from) {
+      if(conn->resume_from) {
 
         /* Daniel: (August 4, 1999)
          *
@@ -1484,34 +1669,47 @@ again:;
           int foundsize=atoi(buf+4);
           /* We got a file size report, so we check that there actually is a
              part of the file left to get, or else we go home.  */
-          if(data->resume_from< 0) {
+          if(conn->resume_from< 0) {
             /* We're supposed to download the last abs(from) bytes */
-            if(foundsize < -data->resume_from) {
+            if(foundsize < -conn->resume_from) {
               failf(data, "Offset (%d) was beyond file size (%d)",
-                    data->resume_from, foundsize);
+                    conn->resume_from, foundsize);
               return CURLE_FTP_BAD_DOWNLOAD_RESUME;
             }
             /* convert to size to download */
-            downloadsize = -data->resume_from;
+            downloadsize = -conn->resume_from;
             /* download from where? */
-            data->resume_from = foundsize - downloadsize;
+            conn->resume_from = foundsize - downloadsize;
           }
           else {
-            if(foundsize <= data->resume_from) {
+            if(foundsize < conn->resume_from) {
               failf(data, "Offset (%d) was beyond file size (%d)",
-                    data->resume_from, foundsize);
+                    conn->resume_from, foundsize);
               return CURLE_FTP_BAD_DOWNLOAD_RESUME;
             }
             /* Now store the number of bytes we are expected to download */
-            downloadsize = foundsize-data->resume_from;
+            downloadsize = foundsize-conn->resume_from;
           }
         }
 
+	if (downloadsize == 0) {
+          /* no data to transfer */
+          result=Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
+	  infof(data, "File already completely downloaded\n");
+
+          /* Set resume done so that we won't get any error in Curl_ftp_done()
+           * because we didn't transfer the amount of bytes that the remote
+           * file obviously is */
+          conn->bits.resume_done = TRUE; 
+
+	  return CURLE_OK;
+	}
+	
         /* Set resume file transfer offset */
         infof(data, "Instructs server to resume from offset %d\n",
-              data->resume_from);
+              conn->resume_from);
 
-        ftpsendf(conn->firstsocket, conn, "REST %d", data->resume_from);
+        ftpsendf(conn->firstsocket, conn, "REST %d", conn->resume_from);
 
         nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode);
         if(nread < 0)
@@ -1702,16 +1900,9 @@ size_t Curl_ftpsendf(int fd, struct connectdata *conn, char *fmt, ...)
 
   strcat(s, "\r\n"); /* append a trailing CRLF */
 
-#ifdef KRB4
-  if(conn->sec_complete && conn->data->cmdchannel) {
-    bytes_written = sec_fprintf(conn, conn->data->cmdchannel, s);
-    fflush(conn->data->cmdchannel);
-  }
-  else
-#endif /* KRB4 */
-    {
-      bytes_written = swrite(fd, s, strlen(s));
-    }
+  bytes_written=0;
+  Curl_write(conn, fd, s, strlen(s), &bytes_written);
+
   return(bytes_written);
 }
 
@@ -1720,12 +1911,14 @@ CURLcode Curl_ftp_disconnect(struct connectdata *conn)
 {
   struct FTP *ftp= conn->proto.ftp;
 
-  if(ftp->user)
-    free(ftp->user);
-  if(ftp->passwd)
-    free(ftp->passwd);
-  if(ftp->entrypath)
-    free(ftp->entrypath);
-
+  /* The FTP session may or may not have been allocated/setup at this point! */
+  if(ftp) {
+    if(ftp->user)
+      free(ftp->user);
+    if(ftp->passwd)
+      free(ftp->passwd);
+    if(ftp->entrypath)
+      free(ftp->entrypath);
+  }
   return CURLE_OK;
 }

lib/getdate.c

@@ -132,44 +132,44 @@
    then those parser generators need to be fixed instead of adding those
    names to this list. */
 
-#define yymaxdepth gd_maxdepth
-#define yyparse gd_parse
-#define yylex   gd_lex
-#define yyerror gd_error
-#define yylval  gd_lval
-#define yychar  gd_char
-#define yydebug gd_debug
-#define yypact  gd_pact
-#define yyr1    gd_r1
-#define yyr2    gd_r2
-#define yydef   gd_def
-#define yychk   gd_chk
-#define yypgo   gd_pgo
-#define yyact   gd_act
-#define yyexca  gd_exca
-#define yyerrflag gd_errflag
-#define yynerrs gd_nerrs
-#define yyps    gd_ps
-#define yypv    gd_pv
-#define yys     gd_s
-#define yy_yys  gd_yys
-#define yystate gd_state
-#define yytmp   gd_tmp
-#define yyv     gd_v
-#define yy_yyv  gd_yyv
-#define yyval   gd_val
-#define yylloc  gd_lloc
-#define yyreds  gd_reds          /* With YYDEBUG defined */
-#define yytoks  gd_toks          /* With YYDEBUG defined */
-#define yylhs   gd_yylhs
-#define yylen   gd_yylen
-#define yydefred gd_yydefred
-#define yydgoto gd_yydgoto
-#define yysindex gd_yysindex
-#define yyrindex gd_yyrindex
-#define yygindex gd_yygindex
-#define yytable  gd_yytable
-#define yycheck  gd_yycheck
+#define yymaxdepth Curl_gd_maxdepth
+#define yyparse Curl_gd_parse
+#define yylex   Curl_gd_lex
+#define yyerror Curl_gd_error
+#define yylval  Curl_gd_lval
+#define yychar  Curl_gd_char
+#define yydebug Curl_gd_debug
+#define yypact  Curl_gd_pact
+#define yyr1    Curl_gd_r1
+#define yyr2    Curl_gd_r2
+#define yydef   Curl_gd_def
+#define yychk   Curl_gd_chk
+#define yypgo   Curl_gd_pgo
+#define yyact   Curl_gd_act
+#define yyexca  Curl_gd_exca
+#define yyerrflag Curl_gd_errflag
+#define yynerrs Curl_gd_nerrs
+#define yyps    Curl_gd_ps
+#define yypv    Curl_gd_pv
+#define yys     Curl_gd_s
+#define yy_yys  Curl_gd_yys
+#define yystate Curl_gd_state
+#define yytmp   Curl_gd_tmp
+#define yyv     Curl_gd_v
+#define yy_yyv  Curl_gd_yyv
+#define yyval   Curl_gd_val
+#define yylloc  Curl_gd_lloc
+#define yyreds  Curl_gd_reds          /* With YYDEBUG defined */
+#define yytoks  Curl_gd_toks          /* With YYDEBUG defined */
+#define yylhs   Curl_gd_yylhs
+#define yylen   Curl_gd_yylen
+#define yydefred Curl_gd_yydefred
+#define yydgoto Curl_gd_yydgoto
+#define yysindex Curl_gd_yysindex
+#define yyrindex Curl_gd_yyrindex
+#define yygindex Curl_gd_yygindex
+#define yytable  Curl_gd_yytable
+#define yycheck  Curl_gd_yycheck
 
 static int yylex ();
 static int yyerror ();

lib/getdate.y

@@ -108,44 +108,44 @@
    then those parser generators need to be fixed instead of adding those
    names to this list. */
 
-#define yymaxdepth gd_maxdepth
-#define yyparse gd_parse
-#define yylex   gd_lex
-#define yyerror gd_error
-#define yylval  gd_lval
-#define yychar  gd_char
-#define yydebug gd_debug
-#define yypact  gd_pact
-#define yyr1    gd_r1
-#define yyr2    gd_r2
-#define yydef   gd_def
-#define yychk   gd_chk
-#define yypgo   gd_pgo
-#define yyact   gd_act
-#define yyexca  gd_exca
-#define yyerrflag gd_errflag
-#define yynerrs gd_nerrs
-#define yyps    gd_ps
-#define yypv    gd_pv
-#define yys     gd_s
-#define yy_yys  gd_yys
-#define yystate gd_state
-#define yytmp   gd_tmp
-#define yyv     gd_v
-#define yy_yyv  gd_yyv
-#define yyval   gd_val
-#define yylloc  gd_lloc
-#define yyreds  gd_reds          /* With YYDEBUG defined */
-#define yytoks  gd_toks          /* With YYDEBUG defined */
-#define yylhs   gd_yylhs
-#define yylen   gd_yylen
-#define yydefred gd_yydefred
-#define yydgoto gd_yydgoto
-#define yysindex gd_yysindex
-#define yyrindex gd_yyrindex
-#define yygindex gd_yygindex
-#define yytable  gd_yytable
-#define yycheck  gd_yycheck
+#define yymaxdepth Curl_gd_maxdepth
+#define yyparse Curl_gd_parse
+#define yylex   Curl_gd_lex
+#define yyerror Curl_gd_error
+#define yylval  Curl_gd_lval
+#define yychar  Curl_gd_char
+#define yydebug Curl_gd_debug
+#define yypact  Curl_gd_pact
+#define yyr1    Curl_gd_r1
+#define yyr2    Curl_gd_r2
+#define yydef   Curl_gd_def
+#define yychk   Curl_gd_chk
+#define yypgo   Curl_gd_pgo
+#define yyact   Curl_gd_act
+#define yyexca  Curl_gd_exca
+#define yyerrflag Curl_gd_errflag
+#define yynerrs Curl_gd_nerrs
+#define yyps    Curl_gd_ps
+#define yypv    Curl_gd_pv
+#define yys     Curl_gd_s
+#define yy_yys  Curl_gd_yys
+#define yystate Curl_gd_state
+#define yytmp   Curl_gd_tmp
+#define yyv     Curl_gd_v
+#define yy_yyv  Curl_gd_yyv
+#define yyval   Curl_gd_val
+#define yylloc  Curl_gd_lloc
+#define yyreds  Curl_gd_reds          /* With YYDEBUG defined */
+#define yytoks  Curl_gd_toks          /* With YYDEBUG defined */
+#define yylhs   Curl_gd_yylhs
+#define yylen   Curl_gd_yylen
+#define yydefred Curl_gd_yydefred
+#define yydgoto Curl_gd_yydgoto
+#define yysindex Curl_gd_yysindex
+#define yyrindex Curl_gd_yyrindex
+#define yygindex Curl_gd_yygindex
+#define yytable  Curl_gd_yytable
+#define yycheck  Curl_gd_yycheck
 
 static int yylex ();
 static int yyerror ();

lib/hostip.c

@@ -123,7 +123,6 @@ struct hostent *Curl_gethost(struct UrlData *data,
   int ret; /* this variable is unused on several platforms but used on some */
 
 #define CURL_NAMELOOKUP_SIZE 9000
-
   /* Allocate enough memory to hold the full name information structs and
    * everything. OSF1 is known to require at least 8872 bytes. The buffer
    * required for storing all possible aliases and IP numbers is according to
@@ -133,6 +132,8 @@ struct hostent *Curl_gethost(struct UrlData *data,
     return NULL; /* major failure */
   *bufp = buf;
 
+  ret = 0; /* to prevent the compiler warning */
+
   if ( (in=inet_addr(hostname)) != INADDR_NONE ) {
     struct in_addr *addrentry;
 

lib/http.c

@@ -336,8 +336,9 @@ CURLcode Curl_http_connect(struct connectdata *conn)
     }
 
     /* now, perform the SSL initialization for this socket */
-    if(Curl_SSLConnect(conn))
-      return CURLE_SSL_CONNECT_ERROR;
+    result = Curl_SSLConnect(conn);
+    if(result)
+      return result;
   }
 
   if(conn->bits.user_passwd && !data->bits.this_is_a_follow) {
@@ -497,7 +498,7 @@ CURLcode Curl_http(struct connectdata *conn)
   if((data->bits.http_post ||
       data->bits.http_formpost ||
       data->bits.http_put) &&
-     data->resume_from) {
+     conn->resume_from) {
     /**********************************************************************
      * Resuming upload in HTTP means that we PUT or POST and that we have
      * got a resume_from value set. The resume value has already created
@@ -506,15 +507,15 @@ CURLcode Curl_http(struct connectdata *conn)
      * file size before we continue this venture in the dark lands of HTTP.
      *********************************************************************/
    
-    if(data->resume_from < 0 ) {
+    if(conn->resume_from < 0 ) {
       /*
        * This is meant to get the size of the present remote-file by itself.
        * We don't support this now. Bail out!
        */
-       data->resume_from = 0;
+       conn->resume_from = 0;
     }
 
-    if(data->resume_from) {
+    if(conn->resume_from) {
       /* do we still game? */
       int passed=0;
 
@@ -522,7 +523,7 @@ CURLcode Curl_http(struct connectdata *conn)
          input. If we knew it was a proper file we could've just
          fseek()ed but we only have a stream here */
       do {
-        int readthisamountnow = (data->resume_from - passed);
+        int readthisamountnow = (conn->resume_from - passed);
         int actuallyread;
 
         if(readthisamountnow > BUFSIZE)
@@ -537,11 +538,11 @@ CURLcode Curl_http(struct connectdata *conn)
                 passed);
           return CURLE_READ_ERROR;
         }
-      } while(passed != data->resume_from); /* loop until done */
+      } while(passed != conn->resume_from); /* loop until done */
 
       /* now, decrease the size of the read */
       if(data->infilesize>0) {
-        data->infilesize -= data->resume_from;
+        data->infilesize -= conn->resume_from;
 
         if(data->infilesize <= 0) {
           failf(data, "File already completely uploaded\n");
@@ -551,7 +552,7 @@ CURLcode Curl_http(struct connectdata *conn)
       /* we've passed, proceed as normal */
     }
   }
-  if(data->bits.set_range) {
+  if(conn->bits.use_range) {
     /*
      * A range is selected. We use different headers whether we're downloading
      * or uploading and we always let customized headers override our internal
@@ -559,23 +560,23 @@ CURLcode Curl_http(struct connectdata *conn)
      */
     if((data->httpreq == HTTPREQ_GET) &&
        !checkheaders(data, "Range:")) {
-      conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n", data->range);
+      conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n", conn->range);
     }
     else if((data->httpreq != HTTPREQ_GET) &&
             !checkheaders(data, "Content-Range:")) {
 
-      if(data->resume_from) {
+      if(conn->resume_from) {
         /* This is because "resume" was selected */
-        long total_expected_size= data->resume_from + data->infilesize;
+        long total_expected_size= conn->resume_from + data->infilesize;
         conn->allocptr.rangeline = aprintf("Content-Range: bytes %s%ld/%ld\r\n",
-                                      data->range, total_expected_size-1,
+                                      conn->range, total_expected_size-1,
                                       total_expected_size);
       }
       else {
         /* Range was selected and then we just pass the incoming range and 
            append total size */
         conn->allocptr.rangeline = aprintf("Content-Range: bytes %s/%d\r\n",
-                                      data->range, data->infilesize);
+                                      conn->range, data->infilesize);
       }
     }
   }
@@ -610,7 +611,7 @@ CURLcode Curl_http(struct connectdata *conn)
                  conn->allocptr.proxyuserpwd)?conn->allocptr.proxyuserpwd:"",
                 (conn->bits.user_passwd && conn->allocptr.userpwd)?
                 conn->allocptr.userpwd:"",
-                (data->bits.set_range && conn->allocptr.rangeline)?
+                (conn->bits.use_range && conn->allocptr.rangeline)?
                 conn->allocptr.rangeline:"",
                 (data->useragent && *data->useragent && conn->allocptr.uagent)?
                 conn->allocptr.uagent:"",
@@ -646,12 +647,21 @@ CURLcode Curl_http(struct connectdata *conn)
     if(data->timecondition) {
       struct tm *thistime;
 
+      /* Phil Karn (Fri, 13 Apr 2001) pointed out that the If-Modified-Since
+       * header family should have their times set in GMT as RFC2616 defines:
+       * "All HTTP date/time stamps MUST be represented in Greenwich Mean Time
+       * (GMT), without exception. For the purposes of HTTP, GMT is exactly
+       * equal to UTC (Coordinated Universal Time)." (see page 20 of RFC2616).
+       */
+
 #ifdef HAVE_LOCALTIME_R
       /* thread-safe version */
+      /* We assume that the presense of localtime_r() proves the presense
+         of gmtime_r() which is a bit ugly but might work */
       struct tm keeptime;
-      thistime = (struct tm *)localtime_r(&data->timevalue, &keeptime);
+      thistime = (struct tm *)gmtime_r(&data->timevalue, &keeptime);
 #else
-      thistime = localtime(&data->timevalue);
+      thistime = gmtime(&data->timevalue);
 #endif
       if(NULL == thistime) {
         failf(data, "localtime() failed!");
@@ -709,8 +719,7 @@ CURLcode Curl_http(struct connectdata *conn)
       http->storefread = data->fread; /* backup */
       http->in = data->in; /* backup */
           
-      data->fread =
-        (size_t (*)(char *, size_t, size_t, FILE *))
+      data->fread = (curl_read_callback)
         Curl_FormReader; /* set the read function to read from the
                             generated form data */
       data->in = (FILE *)&http->form;

lib/krb4.c

@@ -81,8 +81,8 @@ struct krb4_data {
 };
 
 #ifndef HAVE_STRLCPY
-
-size_t
+/* if it ever goes non-static, make it Curl_ prefixed! */
+size_t static 
 strlcpy (char *dst, const char *src, size_t dst_sz)
 {
     size_t n;

lib/netrc.c

@@ -41,6 +41,7 @@
 #include <curl/curl.h>
 
 #include "strequal.h"
+#include "strtok.h"
 
 /* The last #include file should be: */
 #ifdef MALLOCDEBUG
@@ -111,8 +112,9 @@ int Curl_parsenetrc(char *host,
   file = fopen(netrcbuffer, "r");
   if(file) {
     char *tok;
+	char *tok_buf;
     while(fgets(netrcbuffer, sizeof(netrcbuffer), file)) {
-      tok=strtok(netrcbuffer, " \t\n");
+      tok=strtok_r(netrcbuffer, " \t\n", &tok_buf);
       while(tok) {
 	switch(state) {
 	case NOTHING:
@@ -163,7 +165,7 @@ int Curl_parsenetrc(char *host,
 	  }
 	  break;
 	} /* switch (state) */
-	tok = strtok(NULL, " \t\n");
+	tok = strtok_r(NULL, " \t\n", &tok_buf);
       } /* while (tok) */
     } /* while fgets() */
 

lib/progress.c

@@ -91,11 +91,12 @@ static char *max5data(double bytes, char *max5)
 
 */
 
-void Curl_pgrsDone(struct UrlData *data)
+void Curl_pgrsDone(struct connectdata *conn)
 {
+  struct UrlData *data = conn->data;
   if(!(data->progress.flags & PGRS_HIDE)) {
     data->progress.lastshow=0;
-    Curl_pgrsUpdate(data); /* the final (forced) update */
+    Curl_pgrsUpdate(conn); /* the final (forced) update */
     fprintf(data->err, "\n");
   }
 }
@@ -134,6 +135,7 @@ void Curl_pgrsTime(struct UrlData *data, timerid timer)
 
 void Curl_pgrsStartNow(struct UrlData *data)
 {
+  data->progress.speeder_c = 0; /* reset the progress meter display */
   data->progress.start = Curl_tvnow();
 }
 
@@ -171,7 +173,7 @@ void Curl_pgrsSetUploadSize(struct UrlData *data, double size)
 
  */
 
-int Curl_pgrsUpdate(struct UrlData *data)
+int Curl_pgrsUpdate(struct connectdata *conn)
 {
   struct timeval now;
   int result;
@@ -184,6 +186,8 @@ int Curl_pgrsUpdate(struct UrlData *data)
   double total_transfer;
   double total_expected_transfer;
 
+  struct UrlData *data = conn->data;
+
   int nowindex = data->progress.speeder_c% CURR_TIME;
   int checkindex;
   int count;
@@ -197,15 +201,16 @@ int Curl_pgrsUpdate(struct UrlData *data)
   
   double total_estimate;
 
+
   if(data->progress.flags & PGRS_HIDE)
     ; /* We do enter this function even if we don't wanna see anything, since
          this is were lots of the calculations are being made that will be used
          even when not displayed! */
   else if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
     if (!data->progress.callback) {
-      if(data->resume_from)
+      if(conn->resume_from)
         fprintf(data->err, "** Resuming transfer from byte position %d\n",
-                data->resume_from);
+                conn->resume_from);
       fprintf(data->err,
               "  %% Total    %% Received %% Xferd  Average Speed          Time             Curr.\n"
               "                                 Dload  Upload Total    Current  Left    Speed\n");

lib/progress.h

@@ -36,13 +36,13 @@ typedef enum {
   TIMER_LAST /* must be last */
 } timerid;
   
-void Curl_pgrsDone(struct UrlData *data);
+void Curl_pgrsDone(struct connectdata *);
 void Curl_pgrsStartNow(struct UrlData *data);
 void Curl_pgrsSetDownloadSize(struct UrlData *data, double size);
 void Curl_pgrsSetUploadSize(struct UrlData *data, double size);
 void Curl_pgrsSetDownloadCounter(struct UrlData *data, double size);
 void Curl_pgrsSetUploadCounter(struct UrlData *data, double size);
-int Curl_pgrsUpdate(struct UrlData *data);
+int Curl_pgrsUpdate(struct connectdata *);
 void Curl_pgrsTime(struct UrlData *data, timerid timer);
 
 

lib/sendf.c

@@ -236,7 +236,14 @@ CURLcode Curl_client_write(struct UrlData *data,
     }
   }
   if((type & CLIENTWRITE_HEADER) && data->writeheader) {
-    wrote = data->fwrite(ptr, 1, len, data->writeheader);
+    /*
+     * Write headers to the same callback or to the especially setup
+     * header callback function (added after version 7.7.1).
+     */
+    curl_write_callback writeit=
+      data->fwrite_header?data->fwrite_header:data->fwrite;
+
+    wrote = writeit(ptr, 1, len, data->writeheader);
     if(wrote != len) {
       failf (data, "Failed writing header");
       return CURLE_WRITE_ERROR;

lib/ssluse.c

@@ -37,6 +37,11 @@
 #ifdef USE_SSLEAY
 #include <openssl/rand.h>
 
+/* The last #include file should be: */
+#ifdef MALLOCDEBUG
+#include "memdebug.h"
+#endif
+
 static char global_passwd[64];
 
 static int passwd_callback(char *buf, int num, int verify
@@ -230,10 +235,54 @@ int cert_verify_callback(int ok, X509_STORE_CTX *ctx)
 
 #endif
 
+#ifdef USE_SSLEAY
+/* "global" init done? */
+static int init_ssl=0;
+#endif
+
+/* Global init */
+void Curl_SSL_init(void)
+{
+#ifdef USE_SSLEAY
+
+  /* make sure this is only done once */
+  if(0 != init_ssl)
+    return;
+
+  init_ssl++; /* never again */
+
+  /* Lets get nice error messages */
+  SSL_load_error_strings();
+
+  /* Setup all the global SSL stuff */
+  SSLeay_add_ssl_algorithms();
+#endif
+}
+
+/* Global cleanup */
+void Curl_SSL_cleanup(void)
+{
+#ifdef USE_SSLEAY
+  if(init_ssl) {
+    /* only cleanup if we did a previous init */
+
+    /* Free the SSL error strings */
+    ERR_free_strings();
+  
+    /* EVP_cleanup() removes all ciphers and digests from the
+       table. */
+    EVP_cleanup();
+  }
+#endif  
+}
+
+
 /* ====================================================== */
-int
+CURLcode
 Curl_SSLConnect(struct connectdata *conn)
 {
+  CURLcode retcode = CURLE_OK;
+
 #ifdef USE_SSLEAY
   struct UrlData *data = conn->data;
   int err;
@@ -243,15 +292,9 @@ Curl_SSLConnect(struct connectdata *conn)
   /* mark this is being ssl enabled from here on out. */
   conn->ssl.use = TRUE;
 
-  /* Lets get nice error messages */
-  SSL_load_error_strings();
-
   /* Make funny stuff to get random input */
   random_the_seed(conn);
     
-  /* Setup all the global SSL stuff */
-  SSLeay_add_ssl_algorithms();
-
   switch(data->ssl.version) {
   default:
     req_method = SSLv23_client_method();
@@ -268,13 +311,13 @@ Curl_SSLConnect(struct connectdata *conn)
 
   if(!conn->ssl.ctx) {
     failf(data, "SSL: couldn't create a context!");
-    return 1;
+    return CURLE_OUT_OF_MEMORY;
   }
     
   if(data->cert) {
     if (!cert_stuff(conn, data->cert, data->cert)) {
       failf(data, "couldn't use certificate!\n");
-      return 2;
+      return CURLE_SSL_CONNECT_ERROR;
     }
   }
 
@@ -287,7 +330,7 @@ Curl_SSLConnect(struct connectdata *conn)
                                        data->ssl.CAfile,
                                        data->ssl.CApath)) {
       failf(data,"error setting cerficate verify locations\n");
-      return 2;
+      return CURLE_SSL_CONNECT_ERROR;
     }
   }
   else
@@ -307,7 +350,7 @@ Curl_SSLConnect(struct connectdata *conn)
   if (-1 == err) {
     err = ERR_get_error(); 
     failf(data, "SSL: %s", ERR_error_string(err, NULL));
-    return 10;
+    return CURLE_SSL_CONNECT_ERROR;
   }
 
   /* Informational message */
@@ -323,7 +366,7 @@ Curl_SSLConnect(struct connectdata *conn)
   conn->ssl.server_cert = SSL_get_peer_certificate (conn->ssl.handle);
   if(!conn->ssl.server_cert) {
     failf(data, "SSL: couldn't get peer certificate!");
-    return 3;
+    return CURLE_SSL_PEER_CERTIFICATE;
   }
   infof (data, "Server certificate:\n");
   
@@ -331,7 +374,7 @@ Curl_SSLConnect(struct connectdata *conn)
                            NULL, 0);
   if(!str) {
     failf(data, "SSL: couldn't get X509-subject!");
-    return 4;
+    return CURLE_SSL_CONNECT_ERROR;
   }
   infof(data, "\t subject: %s\n", str);
   CRYPTO_free(str);
@@ -340,7 +383,7 @@ Curl_SSLConnect(struct connectdata *conn)
                            NULL, 0);
   if(!str) {
     failf(data, "SSL: couldn't get X509-issuer name!");
-    return 5;
+    return CURLE_SSL_CONNECT_ERROR;
   }
   infof(data, "\t issuer: %s\n", str);
   CRYPTO_free(str);
@@ -350,7 +393,9 @@ Curl_SSLConnect(struct connectdata *conn)
 
   if(data->ssl.verifypeer) {
     data->ssl.certverifyresult=SSL_get_verify_result(conn->ssl.handle);
-    infof(data, "Verify result: %d\n", data->ssl.certverifyresult);
+    failf(data, "SSL certificate verify result: %d\n",
+          data->ssl.certverifyresult);
+    retcode = CURLE_SSL_PEER_CERTIFICATE;
   }
   else
     data->ssl.certverifyresult=0;
@@ -360,5 +405,5 @@ Curl_SSLConnect(struct connectdata *conn)
   /* this is for "-ansi -Wall -pedantic" to stop complaining!   (rabe) */
   (void) conn;
 #endif
-  return 0;
+  return retcode;
 }

lib/ssluse.h

@@ -23,5 +23,9 @@
  * $Id$
  *****************************************************************************/
 #include "urldata.h"
-int Curl_SSLConnect(struct connectdata *conn);
+CURLcode Curl_SSLConnect(struct connectdata *conn);
+/* Global SSL init */
+void Curl_SSL_init(void);
+/* Global SSL cleanup */
+void Curl_SSL_cleanup(void);
 #endif

lib/strequal.c

@@ -80,7 +80,7 @@ int curl_strnequal(const char *first, const char *second, size_t max)
  *
  * 
  */
-size_t strlcat(char *dst, const char *src, size_t siz)
+size_t Curl_strlcat(char *dst, const char *src, size_t siz)
 {
   char *d = dst;
   const char *s = src;

lib/strequal.h

@@ -32,4 +32,9 @@ int curl_strnequal(const char *first, const char *second, size_t max);
 #define strequal(a,b) curl_strequal(a,b)
 #define strnequal(a,b,c) curl_strnequal(a,b,c)
 
+#ifndef HAVE_STRLCAT
+#define strlcat(x,y,z) Curl_strlcat(x,y,z)
+size_t Curl_strlcat(char *dst, const char *src, size_t siz);
+#endif
+
 #endif

lib/strtok.c

@@ -0,0 +1,128 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+
+#include "setup.h"
+
+#ifndef HAVE_STRTOK_R
+
+/*
+ * Copyright (c) 1998 Softweyr LLC.  All rights reserved.
+ *
+ * strtok_r, from Berkeley strtok
+ * Oct 13, 1998 by Wes Peters <wes@softweyr.com>
+ *
+ * Copyright (c) 1988, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notices, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notices, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *
+ *	This product includes software developed by Softweyr LLC, the
+ *      University of California, Berkeley, and its contributors.
+ *
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY SOFTWEYR LLC, THE REGENTS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL SOFTWEYR LLC, THE
+ * REGENTS, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stddef.h>
+
+char *
+Curl_strtok_r(char *s, const char *delim, char **last)
+{
+  char *spanp;
+  int c, sc;
+  char *tok;
+
+  if (s == NULL && (s = *last) == NULL) {
+    return NULL;
+  }
+
+  /*
+   * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
+   */
+ cont:
+  c = *s++;
+  for (spanp = (char *)delim; (sc = *spanp++) != 0; ) {
+    if (c == sc) {
+      goto cont;
+    }
+  }
+
+  if (c == 0) {		/* no non-delimiter characters */
+    *last = NULL;
+    return NULL;
+  }
+  tok = s - 1;
+  
+  /*
+   * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
+   * Note that delim must have one NUL; we stop if we see that, too.
+   */
+  for (;;) {
+    c = *s++;
+    spanp = (char *)delim;
+    do {
+      if ((sc = *spanp++) == c) {
+        if (c == 0) {
+          s = NULL;
+        }
+        else {
+          char *w = s - 1;
+          *w = '\0';
+        }
+        *last = s;
+        return tok;
+      }
+    }
+    while (sc != 0);
+  }
+  /* NOTREACHED */
+}
+
+#endif
+

lib/strtok.h

@@ -0,0 +1,38 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#ifndef _CURL_STRTOK_R_H
+#define _CURL_STRTOK_R_H
+
+#include <stddef.h>
+#include "setup.h"
+
+#ifndef HAVE_STRTOK_R
+char *Curl_strtok_r(char *s, const char *delim, char **last);
+#define strtok_r Curl_strtok_r
+#else
+extern char *strtok_r(char *s1, const char *s2, char **lasts);
+#endif
+
+#endif
+

lib/transfer.c

@@ -103,8 +103,74 @@
 #define min(a, b)   ((a) < (b) ? (a) : (b))
 #endif
 
-/* Parts of this function was written by the friendly Mark Butler
-   <butlerm@xmission.com>. */
+/*
+ * compareheader()
+ *
+ * Returns TRUE if 'headerline' contains the 'header' with given 'content'.
+ * Pass headers WITH the colon.
+ */
+static bool
+compareheader(char *headerline, /* line to check */
+              char *header,     /* header keyword _with_ colon */
+              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.
+   * The field value MAY be preceded by any amount of LWS, though a single SP
+   * is preferred." */
+
+  size_t hlen = strlen(header);
+  size_t clen;
+  size_t len;
+  char *start;
+  char *end;
+
+  if(!strnequal(headerline, header, hlen))
+    return FALSE; /* doesn't start with header */
+
+  /* pass the header */
+  start = &headerline[hlen];
+
+  /* pass all white spaces */
+  while(*start && isspace((int)*start))
+    start++;
+
+  /* find the end of the header line */
+  end = strchr(start, '\r'); /* lines end with CRLF */
+  if(!end) {
+    /* in case there's a non-standard compliant line here */
+    end = strchr(start, '\n');
+
+    if(!end)
+      /* hm, there's no line ending here, return false and bail out! */
+      return FALSE;
+  }
+
+  len = end-start; /* length of the content part of the input line */
+  clen = strlen(content); /* length of the word to find */
+
+  /* find the content string in the rest of the line */
+  for(;len>=clen;len--, start++) {
+    if(strnequal(start, content, clen))
+      return TRUE; /* match! */
+  }
+
+  return FALSE; /* no match */
+}
+
+/*
+ * Transfer()
+ *
+ * This function is what performs the actual transfer. It is capable of
+ * doing both ways simultaneously.
+ * The transfer must already have been setup by a call to Curl_Transfer().
+ *
+ * Note that headers are created in a preallocated buffer of a default size.
+ * That buffer can be enlarged on demand, but it is never shrinken again.
+ *
+ * Parts of this function was once written by the friendly Mark Butler
+ * <butlerm@xmission.com>.
+ */
 
 CURLcode static
 Transfer(struct connectdata *c_conn)
@@ -261,7 +327,11 @@ Transfer(struct connectdata *c_conn)
                 /* no more complete header lines within buffer */
                 /* copy what is remaining into headerbuff */
                 int str_length = (int)strlen(str);
-                
+
+                /*
+                 * We enlarge the header buffer if it seems to be too
+                 * smallish
+                 */
                 if (hbuflen + (int)str_length >= data->headersize) {
                   char *newbuff;
                   long newsize=MAX((hbuflen+str_length)*3/2,
@@ -284,6 +354,12 @@ Transfer(struct connectdata *c_conn)
 
               str = end_ptr + 1;	/* move just past new line */
 
+              /*
+               * We're about to copy a chunk of data to the end of the
+               * already received header. We make sure that the full string
+               * fit in the allocated header buffer, or else we enlarge 
+               * it.
+               */
               if (hbuflen + (str - str_start) >= data->headersize) {
                 char *newbuff;
                 long newsize=MAX((hbuflen+(str-str_start))*3/2,
@@ -307,23 +383,17 @@ Transfer(struct connectdata *c_conn)
               
               p = data->headerbuff;
               
-              /* we now have a full line that p points to */
-              if (('\n' == *p) || ('\r' == *p)) {
-                /* Zero-length line means end of header! */
-#if 0
-                if (-1 != conn->size)	/* if known */
-                  conn->size += bytecount; /* we append the already read
-                                              size */
-#endif
+              /****
+               * We now have a FULL header line that p points to
+               *****/
 
+              if (('\n' == *p) || ('\r' == *p)) {
+                /* Zero-length header line means end of headers! */
 
                 if ('\r' == *p)
                   p++;		/* pass the \r byte */
                 if ('\n' == *p)
                   p++;		/* pass the \n byte */
-#if 0 /* headers are not included in the size */
-                Curl_pgrsSetDownloadSize(data, conn->size);
-#endif
 
                 if(100 == httpcode) {
                   /*
@@ -354,14 +424,29 @@ Transfer(struct connectdata *c_conn)
 
                 if(!header) {
                   /*
-                   * end-of-headers.
+                   * really end-of-headers.
                    *
-                   * If we requested a "no body" and this isn't a "close"
-                   * connection, this is a good time to get out and return
-                   * home.
+                   * If we requested a "no body", this is a good time to get
+                   * out and return home.
                    */
-                  if(!conn->bits.close && data->bits.no_body)
+                  if(data->bits.no_body)
                     return CURLE_OK;
+
+                  if(!conn->bits.close) {
+                    /* If this is not the last request before a close, we must
+                       set the maximum download size to the size of the
+                       expected document or else, we won't know when to stop
+                       reading! */
+                    if(-1 != conn->size)
+                      conn->maxdownload = conn->size;
+
+                    /* If max download size is *zero* (nothing) we already
+                       have nothing and can safely return ok now! */
+                    if(0 == conn->maxdownload)
+                      return CURLE_OK;
+                    
+                    /* What to do if the size is *not* known? */
+                  }
                   break;		/* exit header line loop */
                 }
 
@@ -371,12 +456,19 @@ Transfer(struct connectdata *c_conn)
                 hbuflen = 0;
                 continue;
               }
+
+              /*
+               * Checks for special headers coming up.
+               */
               
               if (!headerline++) {
                 /* This is the first header, it MUST be the error code line
                    or else we consiser this to be the body right away! */
                 if (2 == sscanf (p, " HTTP/1.%d %3d", &httpversion,
                                  &httpcode)) {
+                  data->progress.httpcode = httpcode;
+                  data->progress.httpversion = httpversion;
+
                   /* 404 -> URL not found! */
                   if (
                       ( ((data->bits.http_follow_location) &&
@@ -391,13 +483,21 @@ Transfer(struct connectdata *c_conn)
                     failf (data, "The requested file was not found");
                     return CURLE_HTTP_NOT_FOUND;
                   }
-                  data->progress.httpcode = httpcode;
-                  data->progress.httpversion = httpversion;
+
                   if(httpversion == 0)
                     /* Default action for HTTP/1.0 must be to close, unless
                        we get one of those fancy headers that tell us the
                        server keeps it open for us! */
                     conn->bits.close = TRUE;
+
+                  if (httpcode == 304)
+                    /* (quote from RFC2616, section 10.3.5):
+                     *  The 304 response MUST NOT contain a
+                     * message-body, and thus is always
+                     * terminated by the first empty line
+                     * after the header fields.
+                     */
+                    conn->size=0;
                 }
                 else {
                   header = FALSE;	/* this is not a header line */
@@ -405,15 +505,14 @@ Transfer(struct connectdata *c_conn)
                 }
               }
               /* check for Content-Length: header lines to get size */
-              if (strnequal("Content-Length", p, 14) &&
-                  sscanf (p+14, ": %ld", &contentlength)) {
+              if (strnequal("Content-Length:", p, 15) &&
+                  sscanf (p+15, " %ld", &contentlength)) {
                 conn->size = contentlength;
                 Curl_pgrsSetDownloadSize(data, contentlength);
               }
               else if((httpversion == 0) &&
                       conn->bits.httpproxy &&
-                      strnequal("Proxy-Connection: keep-alive", p,
-                                strlen("Proxy-Connection: keep-alive"))) {
+                      compareheader(p, "Proxy-Connection:", "keep-alive")) {
                 /*
                  * When a HTTP/1.0 reply comes when using a proxy, the
                  * 'Proxy-Connection: keep-alive' line tells us the
@@ -423,8 +522,18 @@ 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 (strnequal("Connection: close", p,
-                                 strlen("Connection: close"))) {
+              else if((httpversion == 0) &&
+                      compareheader(p, "Connection:", "keep-alive")) {
+                /*
+                 * A HTTP/1.0 reply with the 'Connection: keep-alive' line
+                 * tells us the connection will be kept alive for our
+                 * pleasure.  Default action for 1.0 is to close.
+                 *
+                 * [RFC2068, section 19.7.1] */
+                conn->bits.close = FALSE; /* don't close when done */
+                infof(data, "HTTP/1.0 connection set to keep alive!\n");
+              }
+              else if (compareheader(p, "Connection:", "close")) {
                 /*
                  * [RFC 2616, section 8.1.2.1]
                  * "Connection: close" is HTTP/1.1 language and means that
@@ -433,8 +542,7 @@ Transfer(struct connectdata *c_conn)
                  */
                 conn->bits.close = TRUE; /* close when done */
               }
-              else if (strnequal("Transfer-Encoding: chunked", p,
-                                 strlen("Transfer-Encoding: chunked"))) {
+              else if (compareheader(p, "Transfer-Encoding:", "chunked")) {
                 /*
                  * [RFC 2616, section 3.6.1] A 'chunked' transfer encoding
                  * means that the server will send a series of "chunks". Each
@@ -448,20 +556,20 @@ Transfer(struct connectdata *c_conn)
                 /* init our chunky engine */
                 Curl_httpchunk_init(conn);
               }
-              else if (strnequal("Content-Range", p, 13)) {
-                if (sscanf (p+13, ": bytes %d-", &offset) ||
-                    sscanf (p+13, ": bytes: %d-", &offset)) {
+              else if (strnequal("Content-Range:", p, 14)) {
+                if (sscanf (p+14, " bytes %d-", &offset) ||
+                    sscanf (p+14, " bytes: %d-", &offset)) {
                   /* This second format was added August 1st 2000 by Igor
                      Khristophorov since Sun's webserver JavaWebServer/1.1.1
                      obviously sends the header this way! :-( */
-                  if (data->resume_from == offset) {
+                  if (conn->resume_from == offset) {
                     /* we asked for a resume and we got it */
                     content_range = TRUE;
                   }
                 }
               }
               else if(data->cookies &&
-                      strnequal("Set-Cookie: ", p, 11)) {
+                      strnequal("Set-Cookie:", p, 11)) {
                 Curl_cookie_add(data->cookies, TRUE, &p[12]);
               }
               else if(strnequal("Last-Modified:", p,
@@ -474,14 +582,20 @@ Transfer(struct connectdata *c_conn)
               }
               else if ((httpcode >= 300 && httpcode < 400) &&
                        (data->bits.http_follow_location) &&
-                       strnequal("Location: ", p, 10)) {
+                       strnequal("Location:", p, 9)) {
                 /* this is the URL that the server advices us to get instead */
                 char *ptr;
                 char *start=p;
                 char backup;
 
-                start += 10; /* pass "Location: " */
+                start += 9; /* pass "Location:" */
+
+                /* Skip spaces and tabs. We do this to support multiple
+                   white spaces after the "Location:" keyword. */
+                while(*start && isspace((int)*start ))
+                  start++;
                 ptr = start; /* start scanning here */
+
                 /* scan through the string to find the end */
                 while(*ptr && !isspace((int)*ptr))
                   ptr++;
@@ -491,6 +605,10 @@ Transfer(struct connectdata *c_conn)
                 *ptr = backup; /* restore ending letter */
               }
 
+              /*
+               * End of header-checks. Write them to the client.
+               */
+
               writetype = CLIENTWRITE_HEADER;
               if (data->bits.http_include_header)
                 writetype |= CLIENTWRITE_BODY;
@@ -536,7 +654,7 @@ Transfer(struct connectdata *c_conn)
                   infof (data, "Follow to new URL: %s\n", conn->newurl);
                   return CURLE_OK;
                 }
-                else if (data->resume_from &&
+                else if (conn->resume_from &&
                          !content_range &&
                          (data->httpreq==HTTPREQ_GET)) {
                   /* we wanted to resume a download, although the server
@@ -546,7 +664,7 @@ Transfer(struct connectdata *c_conn)
                          "byte ranges. Cannot resume.");
                   return CURLE_HTTP_RANGE_ERROR;
                 }
-                else if(data->timecondition && !data->range) {
+                else if(data->timecondition && !conn->range) {
                   /* A time condition has been set AND no ranges have been
                      requested. This seems to be what chapter 13.3.4 of
                      RFC 2616 defines to be the correct action for a
@@ -572,16 +690,6 @@ Transfer(struct connectdata *c_conn)
                   } /* two valid time strings */
                 } /* we have a time condition */
 
-                if(!conn->bits.close) {
-                  /* If this is not the last request before a close, we must
-                     set the maximum download size to the size of the expected
-                     document or else, we won't know when to stop reading! */
-                  if(-1 != conn->size)
-                    conn->maxdownload = conn->size;
-
-                  /* What to do if the size is *not* known? */
-                }
-
               } /* this is HTTP */
             } /* this is the first time we write a body part */
             bodywrites++;
@@ -611,7 +719,7 @@ Transfer(struct connectdata *c_conn)
               /* If it returned OK, we just keep going */
             }
 
-            if(conn->maxdownload &&
+            if((-1 != conn->maxdownload) &&
                (bytecount + nread >= conn->maxdownload)) {
               nread = conn->maxdownload - bytecount;
               if((signed int)nread < 0 ) /* this should be unusual */
@@ -623,7 +731,7 @@ Transfer(struct connectdata *c_conn)
 
             Curl_pgrsSetDownloadCounter(data, (double)bytecount);
             
-            if(! conn->bits.chunk) {
+            if(!conn->bits.chunk && nread) {
               /* If this is chunky transfer, it was already written */
               urg = Curl_client_write(data, CLIENTWRITE_BODY, str, nread);
               if(urg)
@@ -685,7 +793,7 @@ Transfer(struct connectdata *c_conn)
       }
 
       now = Curl_tvnow();
-      if(Curl_pgrsUpdate(data))
+      if(Curl_pgrsUpdate(conn))
         urg = CURLE_ABORTED_BY_CALLBACK;
       else
         urg = Curl_speedcheck (data, now);
@@ -708,6 +816,12 @@ Transfer(struct connectdata *c_conn)
       }
     }
   }
+
+  /*
+   * The tranfer has been performed. Just make some general checks before
+   * returning.
+   */
+
   if(!(data->bits.no_body) && contentlength &&
      (bytecount != contentlength)) {
     failf(data, "transfer closed with %d bytes remaining to read",
@@ -719,7 +833,7 @@ Transfer(struct connectdata *c_conn)
           conn->proto.http->chunk.datasize);
     return CURLE_PARTIAL_FILE;
   }
-  if(Curl_pgrsUpdate(data))
+  if(Curl_pgrsUpdate(conn))
     return CURLE_ABORTED_BY_CALLBACK;
 
   if(conn->bytecountp)
@@ -736,6 +850,14 @@ CURLcode Curl_perform(CURL *curl)
   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! */
+
+  if(!data->url)
+    /* we can't do anything wihout URL */
+    return CURLE_URL_MALFORMAT;
+
+  data->followlocation=0; /* reset the location-follow counter */
+  data->bits.this_is_a_follow = FALSE; /* reset this */
 
   Curl_pgrsStartNow(data);
 
@@ -745,12 +867,31 @@ CURLcode Curl_perform(CURL *curl)
     if(res == CURLE_OK) {
       res = Curl_do(conn);
       if(res == CURLE_OK) {
+        if(conn->protocol&PROT_FTPS)
+          /* FTPS, disable ssl while transfering data */
+          conn->ssl.use = FALSE;
         res = Transfer(conn); /* now fetch that URL please */
-        if(res == CURLE_OK)
+        if(conn->protocol&PROT_FTPS)
+          /* FTPS, enable ssl again after havving transferred data */
+          conn->ssl.use = TRUE;
+
+        if(res == CURLE_OK) {
+          /*
+           * We must duplicate the new URL here as the connection data
+           * may be free()ed in the Curl_done() function.
+           */
+          newurl = conn->newurl?strdup(conn->newurl):NULL;
+
           res = Curl_done(conn);
+        }
       }
 
-      if((res == CURLE_OK) && conn->newurl) {
+      /*
+       * Important: 'conn' cannot be used here, since it may have been closed
+       * in 'Curl_done' or other functions.
+       */
+
+      if((res == CURLE_OK) && newurl) {
         /* Location: redirect
  
            This is assumed to happen for HTTP(S) only!
@@ -763,9 +904,6 @@ CURLcode Curl_perform(CURL *curl)
 
 	if (data->maxredirs && (data->followlocation >= data->maxredirs)) {
 	  failf(data,"Maximum (%d) redirects followed", data->maxredirs);
-#ifdef USE_OLD_DISCONNECT
-          curl_disconnect(c_connect);
-#endif
           res=CURLE_TOO_MANY_REDIRECTS;
 	  break;
 	}
@@ -790,7 +928,7 @@ CURLcode Curl_perform(CURL *curl)
           data->bits.http_set_referer = TRUE; /* might have been false */
         }
 
-        if(2 != sscanf(conn->newurl, "%15[^:]://%c", prot, &letter)) {
+        if(2 != sscanf(newurl, "%15[^:]://%c", prot, &letter)) {
           /***
            *DANG* this is an RFC 2068 violation. The URL is supposed
            to be absolute and this doesn't seem to be that!
@@ -803,19 +941,21 @@ CURLcode Curl_perform(CURL *curl)
           char *pathsep;
           char *newest;
 
+          /* we must make our own copy of the URL to play with, as it may
+             point to read-only data */
+          char *url_clone=strdup(data->url);
+
+          if(!url_clone)
+            return CURLE_OUT_OF_MEMORY;
+
           /* protsep points to the start of the host name */
-          protsep=strstr(data->url, "//");
+          protsep=strstr(url_clone, "//");
           if(!protsep)
-            protsep=data->url;
-          else {
-            port=FALSE; /* we got a full URL and thus we should not obey the
-                           port number that might have been set by the user
-                           in data->use_port */
-
+            protsep=url_clone;
+          else
             protsep+=2; /* pass the slashes */
-          }
 
-          if('/' != conn->newurl[0]) {
+          if('/' != newurl[0]) {
             /* First we need to find out if there's a ?-letter in the URL,
                and cut it and the right-side of that off */
             pathsep = strrchr(protsep, '?');
@@ -836,16 +976,17 @@ CURLcode Curl_perform(CURL *curl)
               *pathsep=0;
           }
 
-          newest=(char *)malloc( strlen(data->url) +
+          newest=(char *)malloc( strlen(url_clone) +
                                  1 + /* possible slash */
-                                 strlen(conn->newurl) + 1/* zero byte */);
+                                 strlen(newurl) + 1/* zero byte */);
 
           if(!newest)
             return CURLE_OUT_OF_MEMORY;
-          sprintf(newest, "%s%s%s", data->url, ('/' == conn->newurl[0])?"":"/",
-                  conn->newurl);
-          free(conn->newurl);
-          conn->newurl = newest;
+          sprintf(newest, "%s%s%s", url_clone, ('/' == newurl[0])?"":"/",
+                  newurl);
+          free(newurl);
+          free(url_clone);
+          newurl = newest;
         }
         else {
           /* This is an absolute URL, don't use the custom port number */
@@ -856,8 +997,9 @@ CURLcode Curl_perform(CURL *curl)
           free(data->url);
       
         /* TBD: set the URL with curl_setopt() */
-        data->url = conn->newurl;
-        conn->newurl = NULL; /* don't show! */
+        data->url = newurl;
+        newurl = NULL; /* don't free! */
+
         data->bits.urlstringalloc = TRUE; /* the URL is allocated */
 
         infof(data, "Follows Location: to new URL: '%s'\n", data->url);
@@ -871,7 +1013,6 @@ CURLcode Curl_perform(CURL *curl)
         switch(data->progress.httpcode) {
         case 300: /* Multiple Choices */
         case 301: /* Moved Permanently */
-        case 302: /* Found */
         case 306: /* Not used */
         case 307: /* Temporary Redirect */
         default:  /* for all unknown ones */
@@ -879,6 +1020,24 @@ CURLcode Curl_perform(CURL *curl)
            * seem to be OK to POST to.
            */
           break;
+        case 302: /* Found */
+          /* (From 10.3.3)
+
+            Note: RFC 1945 and RFC 2068 specify that the client is not allowed
+            to change the method on the redirected request.  However, most
+            existing user agent implementations treat 302 as if it were a 303
+            response, performing a GET on the Location field-value regardless
+            of the original request method. The status codes 303 and 307 have
+            been added for servers that wish to make unambiguously clear which
+            kind of reaction is expected of the client.
+
+            (From 10.3.4)
+
+            Note: Many pre-HTTP/1.1 user agents do not understand the 303
+            status. When interoperability with such clients is a concern, the
+            302 status code may be used instead, since most user agents react
+            to a 302 response as described here for 303.             
+          */
         case 303: /* See Other */
           /* Disable both types of POSTs, since doing a second POST when
            * following isn't what anyone would want! */
@@ -902,29 +1061,23 @@ CURLcode Curl_perform(CURL *curl)
            */
           break;
         }
-#ifdef USE_OLD_DISCONNECT
-        curl_disconnect(c_connect);
-#endif
         continue;
       }
-
-#ifdef USE_OLD_DISCONNECT
-      curl_disconnect(c_connect);
-#endif
     }
     break; /* it only reaches here when this shouldn't loop */
 
   } while(1); /* loop if Location: */
 
-  if(conn->newurl) {
-    free(conn->newurl);
-    conn->newurl = NULL;
-  }
+  if(newurl)
+    free(newurl);
+
+  /* make sure the alarm is switched off! */
+  if(data->timeout || data->connecttimeout)
+    myalarm(0);
 
   return res;
 }
 
-
 CURLcode 
 Curl_Transfer(struct connectdata *c_conn, /* connection data */
               int sockfd,	/* socket to read from or -1 */

lib/transfer.h

@@ -35,11 +35,4 @@ Curl_Transfer (struct connectdata *data,
                                         the same we read from. -1 disables */
                long *writebytecountp /* return number of bytes written */
 );
-
-#ifdef _OLDCURL
-/* "hackish" define to make sources compile without too much human editing.
-   Don't use "Tranfer()" anymore! */
-#define Transfer(a,b,c,d,e,f,g) Curl_Transfer(a,b,c,d,e,f,g)
-#endif
-
 #endif

lib/url.c

@@ -91,6 +91,7 @@
 #include "cookie.h"
 #include "strequal.h"
 #include "escape.h"
+#include "strtok.h"
 
 /* And now for the protocols */
 #include "ftp.h"
@@ -153,13 +154,6 @@ CURLcode Curl_close(CURL *curl)
     data->bits.httpproxy=FALSE;
   }
 
-
-  if(data->bits.rangestringalloc) {
-    free(data->range);
-    data->range=NULL;
-    data->bits.rangestringalloc=0; /* free now */
-  }
-
   /* check for allocated [URL] memory to free: */
   if(data->freethis)
     free(data->freethis);
@@ -223,10 +217,10 @@ CURLcode Curl_open(CURL **curl, char *url)
     data->err  = stderr;  /* default stderr to stderr */
 
     /* use fwrite as default function to store output */
-    data->fwrite = (size_t (*)(char *, size_t, size_t, FILE *))fwrite;
+    data->fwrite = (curl_write_callback)fwrite;
 
     /* use fread as default function to read input */
-    data->fread = (size_t (*)(char *, size_t, size_t, FILE *))fread;
+    data->fread = (curl_read_callback)fread;
 
     /* set the default passwd function */
     data->fpasswd = my_getpass;
@@ -703,14 +697,14 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
     /*
      * What range of the file you want to transfer
      */
-    data->range = va_arg(param, char *);
-    data->bits.set_range = data->range?1:0;
+    data->set_range = va_arg(param, char *);
+    data->bits.set_range = data->set_range?1:0;
     break;
   case CURLOPT_RESUME_FROM:
     /*
      * Resume transfer at the give file position
      */
-    data->resume_from = va_arg(param, long);
+    data->set_resume_from = va_arg(param, long);
     break;
   case CURLOPT_STDERR:
     /*
@@ -719,6 +713,12 @@ CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
      */
     data->err = va_arg(param, FILE *);
     break;
+  case CURLOPT_HEADERFUNCTION:
+    /*
+     * Set header write callback
+     */
+    data->fwrite_header = va_arg(param, curl_write_callback);
+    break;
   case CURLOPT_WRITEFUNCTION:
     /*
      * Set data write callback
@@ -795,6 +795,16 @@ CURLcode Curl_disconnect(struct connectdata *conn)
   if(!conn)
     return CURLE_OK; /* this is closed and fine already */
 
+  /*
+   * The range string is usually freed in curl_done(), but we might
+   * get here *instead* if we fail prematurely. Thus we need to be able
+   * to free this resource here as well.
+   */
+  if(conn->bits.rangestringalloc) {
+    free(conn->range);
+    conn->bits.rangestringalloc = FALSE;
+  }
+
   if(-1 != conn->connectindex) {
     /* unlink ourselves! */
     infof(conn->data, "Closing live connection (#%d)\n", conn->connectindex);
@@ -816,11 +826,25 @@ CURLcode Curl_disconnect(struct connectdata *conn)
     free(conn->hostent_buf);
 #endif
 
+  if(conn->newurl)
+    free(conn->newurl);
+
   if(conn->path) /* the URL path part */
     free(conn->path);
 
 #ifdef USE_SSLEAY
   if (conn->ssl.use) {
+    /*
+      ERR_remove_state() frees the error queue associated with
+      thread pid.  If pid == 0, the current thread will have its
+      error queue removed.
+
+      Since error queue data structures are allocated
+      automatically for new threads, they must be freed when
+      threads are terminated in oder to avoid memory leaks.
+    */
+    ERR_remove_state(0);
+
     if(conn->ssl.handle) {
       (void)SSL_shutdown(conn->ssl.handle);
       SSL_set_connect_state(conn->ssl.handle);
@@ -918,7 +942,7 @@ ConnectionExists(struct UrlData *data,
 
       if(strequal(needle->protostr, check->protostr) &&
          strequal(needle->name, check->name) &&
-         (needle->port == check->port) ) {
+         (needle->remote_port == check->remote_port) ) {
         bool dead;
         if(strequal(needle->protostr, "FTP")) {
           /* This is FTP, verify that we're using the same name and
@@ -936,9 +960,11 @@ ConnectionExists(struct UrlData *data,
           data->connects[i]=NULL; /* nothing here */
           continue; /* try another one now */
         }
+
+        *usethis = check;
+        return TRUE; /* yes, we found one to use! */
+        
       }
-      *usethis = check;
-      return TRUE; /* yes, we found one to use! */
     }
     else { /* The requested needle connection is using a proxy,
               is the checked one using the same? */
@@ -1049,6 +1075,11 @@ ConnectionStore(struct UrlData *data,
 static CURLcode ConnectPlease(struct UrlData *data,
                               struct connectdata *conn)
 {
+#if defined(WIN32)
+  unsigned long nonblock = 0;
+  fd_set connectfd;
+  struct timeval conntimeout;
+#endif
 
 #ifndef ENABLE_IPV6
   conn->firstsocket = socket(AF_INET, SOCK_STREAM, 0);
@@ -1211,10 +1242,33 @@ static CURLcode ConnectPlease(struct UrlData *data,
     return CURLE_COULDNT_CONNECT;
   }
 #else
+  /* non-zero nonblock value sets socket as nonblocking under Win32 */
+#if defined(WIN32)
+  FD_ZERO (&connectfd);
+  FD_SET(conn->firstsocket, &connectfd);
+  if (conn->data->connecttimeout > 0) {
+    nonblock = 1;
+  }
+  ioctlsocket(conn->firstsocket, FIONBIO, &nonblock);
+#endif
   if (connect(conn->firstsocket,
               (struct sockaddr *) &(conn->serv_addr),
               sizeof(conn->serv_addr)
               ) < 0) {
+#if defined(WIN32)
+    conntimeout.tv_sec = conn->data->connecttimeout;
+    conntimeout.tv_usec = 0;	
+    if(-1 != select (conn->firstsocket + 1, NULL, &connectfd, NULL, &conntimeout)) {
+      if (FD_ISSET(conn->firstsocket, &connectfd)) {
+        /* shut off non-blocking again */
+        nonblock = 0;
+        ioctlsocket(conn->firstsocket, FIONBIO, &nonblock);
+        return CURLE_OK;
+      }
+      else
+        errno = EINTR;
+    }
+#endif
     switch(errno) {
 #ifdef ECONNREFUSED
       /* this should be made nicer */
@@ -1309,6 +1363,9 @@ static CURLcode Connect(struct UrlData *data,
   conn->secondarysocket = -1; /* no file descriptor */
   conn->connectindex = -1;    /* no index */
   conn->bits.httpproxy = data->bits.httpproxy; /* proxy-or-not status */
+  conn->bits.use_range = data->bits.set_range; /* range status */
+  conn->range = data->set_range;               /* clone the range setting */
+  conn->resume_from = data->set_resume_from;   /* inherite resume_from */
 
   /* Default protocol-independent behavior doesn't support persistant
      connections, so we set this to force-close. Protocols that support
@@ -1319,6 +1376,9 @@ static CURLcode Connect(struct UrlData *data,
   conn->bits.user_passwd = data->userpwd?1:0;
   conn->bits.proxy_user_passwd = data->proxyuserpwd?1:0;
 
+  /* maxdownload must be -1 on init, as 0 is a valid value! */
+  conn->maxdownload = -1;  /* might have been used previously! */
+
   /* Store creation time to help future close decision making */
   conn->created = Curl_tvnow();
 
@@ -1397,6 +1457,8 @@ static CURLcode Connect(struct UrlData *data,
 #ifdef USE_SSLEAY
       else if(strnequal(conn->gname, "HTTPS", 5))
         strcpy(conn->protostr, "https");
+      else if(strnequal(conn->gname, "FTPS", 4))
+        strcpy(conn->protostr, "ftps");
 #endif /* USE_SSLEAY */
       else if(strnequal(conn->gname, "TELNET", 6))
         strcpy(conn->protostr, "telnet");
@@ -1499,6 +1561,7 @@ static CURLcode Connect(struct UrlData *data,
      * checked if the lowercase versions don't exist.
      */
     char *no_proxy=NULL;
+    char *no_proxy_tok_buf;
     char *proxy=NULL;
     char proxy_env[128];
 
@@ -1510,7 +1573,7 @@ static CURLcode Connect(struct UrlData *data,
       /* NO_PROXY wasn't specified or it wasn't just an asterisk */
       char *nope;
 
-      nope=no_proxy?strtok(no_proxy, ", "):NULL;
+      nope=no_proxy?strtok_r(no_proxy, ", ", &no_proxy_tok_buf):NULL;
       while(nope) {
         if(strlen(nope) <= strlen(conn->name)) {
           char *checkn=
@@ -1520,7 +1583,7 @@ static CURLcode Connect(struct UrlData *data,
             break;
           }
         }
-	nope=strtok(NULL, ", ");
+	nope=strtok_r(NULL, ", ", &no_proxy_tok_buf);
       }
       if(!nope) {
 	/* It was not listed as without proxy */
@@ -1538,7 +1601,19 @@ static CURLcode Connect(struct UrlData *data,
 	/* read the protocol proxy: */
 	prox=curl_getenv(proxy_env);
 
-	if(!prox) {
+        /*
+         * We don't try the uppercase version of HTTP_PROXY because of
+         * security reasons:
+         *
+         * When curl is used in a webserver application
+         * environment (cgi or php), this environment variable can
+         * be controlled by the web server user by setting the
+         * http header 'Proxy:' to some value.
+         * 
+         * This can cause 'internal' http/ftp requests to be
+         * arbitrarily redirected by any external attacker.
+         */
+	if(!prox && !strequal("http_proxy", proxy_env)) {
           /* There was no lowercase variable, try the uppercase version: */
 	  for(envp = proxy_env; *envp; envp++)
 	    *envp = toupper(*envp);
@@ -1597,13 +1672,13 @@ static CURLcode Connect(struct UrlData *data,
    * server, we just fail since we can't rewind the file writing from within
    * this function.
    ***********************************************************/
-  if(data->resume_from) {
-    if(!data->bits.set_range) {
+  if(conn->resume_from) {
+    if(!conn->bits.use_range) {
       /* if it already was in use, we just skip this */
-      snprintf(resumerange, sizeof(resumerange), "%d-", data->resume_from);
-      data->range=strdup(resumerange); /* tell ourselves to fetch this range */
-      data->bits.rangestringalloc = TRUE; /* mark as allocated */
-      data->bits.set_range = 1; /* switch on range usage */
+      snprintf(resumerange, sizeof(resumerange), "%d-", conn->resume_from);
+      conn->range=strdup(resumerange); /* tell ourselves to fetch this range */
+      conn->bits.rangestringalloc = TRUE; /* mark as allocated */
+      conn->bits.use_range = 1; /* switch on range usage */
     }
   }
 
@@ -1666,8 +1741,19 @@ static CURLcode Connect(struct UrlData *data,
     conn->curl_done = Curl_http_done;
     conn->curl_close = Curl_http_close;
   }
-  else if(strequal(conn->protostr, "FTP")) {
+  else if(strequal(conn->protostr, "FTP") ||
+          strequal(conn->protostr, "FTPS")) {
     char *type;
+
+    if(strequal(conn->protostr, "FTPS")) {
+#ifdef USE_SSLEAY
+      conn->protocol |= PROT_FTPS;
+#else
+      failf(data, "libcurl was built with SSL disabled, ftps: not supported!");
+      return CURLE_UNSUPPORTED_PROTOCOL;
+#endif /* !USE_SSLEAY */
+    }
+
     conn->port = (data->use_port && allow_port)?data->use_port:PORT_FTP;
     conn->remote_port = PORT_FTP;
     conn->protocol |= PROT_FTP;
@@ -1676,6 +1762,12 @@ static CURLcode Connect(struct UrlData *data,
        !data->bits.tunnel_thru_httpproxy) {
       /* Unless we have asked to tunnel ftp operations through the proxy, we
          switch and use HTTP operations only */
+      if(conn->protocol & PROT_FTPS) {
+        /* FTPS is a hacked protocol and does not work through your
+           ordinary http proxy! */
+        failf(data, "ftps does not work through http proxy!");
+        return CURLE_UNSUPPORTED_PROTOCOL;
+      }
       conn->curl_do = Curl_http;
       conn->curl_done = Curl_http_done;
       conn->curl_close = Curl_http_close;
@@ -1940,24 +2032,45 @@ static CURLcode Connect(struct UrlData *data,
      */
     struct connectdata *old_conn = conn;
     char *path = old_conn->path; /* setup the current path pointer properly */
+    char *ppath = old_conn->ppath; /* this is the modified path pointer */
     if(old_conn->proxyhost)
       free(old_conn->proxyhost);
     conn = conn_temp;        /* use this connection from now on */
-    free(conn->path);        /* free the previous path pointer */
 
     /* we need these pointers if we speak over a proxy */
-    conn->name = old_conn->name;
-    conn->hostname = old_conn->hostname;
+    conn->name = conn->gname;
+    conn->hostname = old_conn->gname;
 
-    conn->path = path;       /* use this one */
-    conn->ppath = path;      /* set this too */
+    free(conn->path);    /* free the previously allocated path pointer */
+
+    /* 'path' points to the allocated data, 'ppath' may have been advanced
+       to point somewhere within the 'path' area. */
+    conn->path = path; 
+    conn->ppath = ppath;
 
     /* re-use init */
-    conn->maxdownload = 0;   /* might have been used previously! */
     conn->bits.reuse = TRUE; /* yes, we're re-using here */
+    conn->bits.chunk = FALSE; /* always assume not chunked unless told
+                                 otherwise */
+    conn->maxdownload = -1;  /* might have been used previously! */
 
     free(old_conn);          /* we don't need this anymore */
 
+    /*
+     * If we're doing a resumed transfer, we need to setup our stuff
+     * properly.
+     */
+    conn->resume_from = data->set_resume_from;
+    if (conn->resume_from) {
+        snprintf(resumerange, sizeof(resumerange), "%d-", conn->resume_from);
+        if (conn->bits.rangestringalloc == TRUE) 
+            free(conn->range);
+        
+        /* tell ourselves to fetch this range */
+        conn->range = strdup(resumerange);
+        conn->bits.rangestringalloc = TRUE; /* mark range string allocated */
+    }
+    
     *in_connect = conn;      /* return this instead! */
 
     infof(data, "Re-using existing connection! (#%d)\n", conn->connectindex);
@@ -2126,8 +2239,10 @@ CURLcode Curl_connect(struct UrlData *data,
     /* We're not allowed to return failure with memory left allocated
        in the connectdata struct, free those here */
     conn = (struct connectdata *)*in_connect;
-    if(conn)
+    if(conn) {
       Curl_disconnect(conn);      /* close the connection */
+      *in_connect = NULL;         /* return a NULL */
+    }
   }
   return code;
 }
@@ -2138,13 +2253,26 @@ CURLcode Curl_done(struct connectdata *conn)
   struct UrlData *data=conn->data;
   CURLcode result;
 
+  /* cleanups done even if the connection is re-used */
+
+  if(conn->bits.rangestringalloc) {
+    free(conn->range);
+    conn->bits.rangestringalloc = FALSE;
+  }
+
+  /* Cleanup possible redirect junk */
+  if(conn->newurl) {
+    free(conn->newurl);
+    conn->newurl = NULL;
+  }
+ 
   /* this calls the protocol-specific function pointer previously set */
   if(conn->curl_done)
     result = conn->curl_done(conn);
   else
     result = CURLE_OK;
 
-  Curl_pgrsDone(data); /* done with the operation */
+  Curl_pgrsDone(conn); /* done with the operation */
 
   /* if data->bits.reuse_forbid is TRUE, it means the libcurl client has
      forced us to close this no matter what we think.

lib/urldata.h

@@ -148,7 +148,7 @@ struct HTTP {
 
   /* For FORM posting */
   struct Form form;
-  size_t (*storefread)(char *, size_t , size_t , FILE *);
+  curl_read_callback storefread;
   FILE *in;
 
   struct Curl_chunker chunk;
@@ -185,6 +185,12 @@ struct ConnectBits {
   bool httpproxy; /* if set, this transfer is done through a http proxy */
   bool user_passwd;       /* do we use user+password for this connection? */
   bool proxy_user_passwd; /* user+password for the proxy? */
+
+  bool use_range;
+  bool rangestringalloc; /* the range string is malloc()'ed */
+
+  bool resume_done; /* nothing was transfered, resumed transfer already
+                       complete */
 };
 
 /*
@@ -207,6 +213,7 @@ struct connectdata {
 #define PROT_DICT    (1<<6)
 #define PROT_LDAP    (1<<7)
 #define PROT_FILE    (1<<8)
+#define PROT_FTPS    (1<<9)
 
 #ifdef ENABLE_IPV6
   struct addrinfo *hp; /* host info pointer list */
@@ -227,6 +234,10 @@ struct connectdata {
   char *ppath;
   long bytecount;
 
+  char *range; /* range, if used. See README for detailed specification on
+                  this syntax. */
+  int resume_from; /* continue [ftp] transfer from here */
+
   char *proxyhost; /* name of the http proxy host */
 
   struct timeval now;     /* "current" time */
@@ -293,7 +304,6 @@ struct connectdata {
 		   document headers */
 
 #ifdef KRB4
-
   enum protection_level command_prot;
   enum protection_level data_prot;
   enum protection_level request_data_prot;
@@ -401,7 +411,6 @@ struct Configbits {
   bool this_is_a_follow; /* this is a followed Location: request */
   bool krb4; /* kerberos4 connection requested */
   bool proxystringalloc; /* the http proxy string is malloc()'ed */
-  bool rangestringalloc; /* the range string is malloc()'ed */
   bool urlstringalloc;   /* the URL string is malloc()'ed */
   bool reuse_forbid;     /* if this is forbidden to be reused, close 
                             after use */
@@ -450,9 +459,10 @@ struct UrlData {
   long header_size;  /* size of read header(s) in bytes */
   long request_size; /* the amount of bytes sent in the request(s) */
 
-  FILE *out;    /* the fetched file goes here */
-  FILE *in;     /* the uploaded file is read from here */
-  FILE *writeheader; /* write the header to this is non-NULL */
+  void *out;         /* the fetched file goes here */
+  void *in;          /* the uploaded file is read from here */
+  void *writeheader; /* write the header to this is non-NULL */
+
   char *url;   /* what to get */
   char *freethis; /* if non-NULL, an allocated string for the URL */
   long use_port;  /* which port to use (when not using default) */
@@ -460,8 +470,8 @@ struct UrlData {
   struct ssl_config_data ssl; /* this is for ssl-stuff */
 
   char *userpwd;  /* <user:password>, if used */
-  char *range; /* range, if used. See README for detailed specification on
-                  this syntax. */
+  char *set_range; /* range, if used. See README for detailed specification on
+                      this syntax. */
 
   /* stuff related to HTTP */
 
@@ -485,6 +495,9 @@ struct UrlData {
   /* function that stores the output:*/
   curl_write_callback fwrite;
 
+  /* optional function that stores the header output:*/
+  curl_write_callback fwrite_header;
+
   /* function that reads the input:*/
   curl_read_callback fread;
 
@@ -507,7 +520,7 @@ struct UrlData {
   long low_speed_limit; /* bytes/second */
   long low_speed_time;  /* number of seconds */
 
-  int resume_from;    /* continue [ftp] transfer from here */
+  int set_resume_from;    /* continue [ftp] transfer from here */
 
   char *cookie;       /* HTTP cookie string to send */
 
@@ -553,10 +566,6 @@ struct UrlData {
   char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
 
   char *krb4_level; /* what security level */
-#ifdef KRB4
-  FILE *cmdchannel;
-#endif
-
   struct timeval keeps_speed; /* this should be request-specific */
 
   /* 'connects' will be an allocated array with pointers. If the pointer is

lib/version.c

@@ -38,6 +38,24 @@ char *curl_version(void)
 
 #ifdef USE_SSLEAY
 
+#if (SSLEAY_VERSION_NUMBER >= 0x906000)
+  {
+    char sub[2];
+    sub[1]='\0';
+    if(SSLEAY_VERSION_NUMBER&0xff0) {
+      sub[0]=((SSLEAY_VERSION_NUMBER>>4)&0xff) + 'a' -1;
+    }
+    else
+      sub[0]='\0';
+
+    sprintf(ptr, " (OpenSSL %lx.%lx.%lx%s)",
+            (SSLEAY_VERSION_NUMBER>>28)&0xf,
+            (SSLEAY_VERSION_NUMBER>>20)&0xff,
+            (SSLEAY_VERSION_NUMBER>>12)&0xff,
+            sub);
+  }
+
+#else
 #if (SSLEAY_VERSION_NUMBER >= 0x900000)
   sprintf(ptr, " (SSL %lx.%lx.%lx)",
           (SSLEAY_VERSION_NUMBER>>28)&0xff,
@@ -46,17 +64,19 @@ char *curl_version(void)
 #else
   {
     char sub[2];
+    sub[1]='\0';
     if(SSLEAY_VERSION_NUMBER&0x0f) {
       sub[0]=(SSLEAY_VERSION_NUMBER&0x0f) + 'a' -1;
     }
     else
-      sub[0]=0;
+      sub[0]='\0';
 
     sprintf(ptr, " (SSL %x.%x.%x%s)",
             (SSLEAY_VERSION_NUMBER>>12)&0xff,
             (SSLEAY_VERSION_NUMBER>>8)&0xf,
             (SSLEAY_VERSION_NUMBER>>4)&0xf, sub);
   }
+#endif
 #endif
   ptr=strchr(ptr, '\0');
 #endif

maketgz

@@ -73,7 +73,7 @@ if { findprog automake >/dev/null 2>/dev/null; } then
   echo "- Could not find or run automake, I hope you know what you're doing!"
 else
   echo "Runs automake --include-deps"
-  automake --include-deps
+  automake --include-deps Makefile
 fi
 
 ############################################################################

memanalyze.pl

@@ -12,12 +12,21 @@ do {
     }
 } while (shift @ARGV);
 
+my $maxmem;
+
+sub newtotal {
+    my ($newtot)=@_;
+    # count a max here
+
+    if($newtot > $maxmem) {
+        $maxmem= $newtot;
+    }
+}
+
 while(<STDIN>) {
     chomp $_;
     $line = $_;
-    if($verbose) {
-        print "IN: $line\n";
-    }
+
     if($line =~ /^MEM ([^:]*):(\d*) (.*)/) {
         # generic match for the filename+linenumber
         $source = $1;
@@ -34,17 +43,39 @@ while(<STDIN>) {
                 print "FREE ERROR: Previously freed at: ".$getmem{$addr}."\n";
             }
             else {
+                if(0 && $verbose) {
+                    print "malloc at ".$getmem{$addr}." is freed again at $source:$linenum\n";
+                }
+
                 $totalmem -= $sizeataddr{$addr};
+
+                newtotal($totalmem);
+                $frees++;
+
                 $sizeataddr{$addr}=-1; # set -1 to mark as freed
                 $getmem{$addr}="$source:$linenum";
+
             }
         }
         elsif($function =~ /malloc\((\d*)\) = 0x([0-9a-f]*)/) {
             $size = $1;
             $addr = $2;
+
+            if($sizeataddr{$addr}>0) {
+                # this means weeeeeirdo
+                print "Fucked up debug compile, rebuild curl now\n";
+            }
+
             $sizeataddr{$addr}=$size;
             $totalmem += $size;
 
+            if(0 && $verbose) {
+                print "malloc($size) at $source:$linenum\n";
+            }
+
+            newtotal($totalmem);
+            $mallocs++;
+
             $getmem{$addr}="$source:$linenum";
         }
         elsif($function =~ /realloc\(0x([0-9a-f]*), (\d*)\) = 0x([0-9a-f]*)/) {
@@ -58,6 +89,9 @@ while(<STDIN>) {
             $totalmem += $newsize;
             $sizeataddr{$newaddr}=$newsize;
 
+            newtotal($totalmem);
+            $reallocs++;
+            
             $getmem{$oldaddr}="";
             $getmem{$newaddr}="$source:$linenum";
         }
@@ -71,6 +105,9 @@ while(<STDIN>) {
             $sizeataddr{$addr}=$size;
 
             $totalmem += $size;
+
+            newtotal($totalmem);
+            $strdups++;
         }
         else {
             print "Not recognized input line: $function\n";
@@ -134,9 +171,6 @@ while(<STDIN>) {
     else {
         print "Not recognized prefix line: $line\n";
     }
-    if($verbose) {
-        print "TOTAL: $totalmem\n";
-    }
 }
 
 if($totalmem) {
@@ -168,3 +202,12 @@ if($fopens) {
         }
     }
 }
+
+if($verbose) {
+    print "Mallocs: $mallocs\n",
+    "Reallocs: $reallocs\n",
+    "Strdups:  $strdups\n",
+    "Frees: $frees\n";
+
+    print "Maximum allocated: $maxmem\n";
+}

packages/Makefile.am

@@ -1,3 +1,3 @@
-SUBDIRS = Win32 Linux
+SUBDIRS = Win32 Linux Solaris
 
 EXTRA_DIST = README

packages/Solaris/Makefile.am

@@ -0,0 +1,39 @@
+#
+# $Id$
+#
+
+PKGADD_PKG="@PKGADD_PKG@"
+PKGADD_NAME="@PACKAGE@-@VERSION@ - @PKGADD_NAME@"
+PKGADD_VENDOR="@PKGADD_VENDOR@"
+PKGADD_ARCH="@host_cpu@"
+PKGADD_DESC="@PACKAGE@-@VERSION@ - @PKGADD_NAME@"
+PKGADD_CLASSES=none
+PKGADD_BASEDIR=/
+
+PKGADD_FILE=${PKGADD_PKG}-@PACKAGE@-@VERSION@-@host@.pkg
+
+package:
+	if [ ! -f release ]; then echo 0 > release; fi
+	if [ `find root -newer release -print|wc -l` -gt 0 ]; then expr `cat release` + 1 > release; fi
+	echo PKG=${PKGADD_PKG} > pkginfo
+	echo NAME=${PKGADD_NAME} >> pkginfo
+	echo VENDOR=${PKGADD_VENDOR} >> pkginfo
+	echo ARCH=${PKGADD_ARCH} >> pkginfo
+	echo DESC=${PKGADD_DESC} >> pkginfo
+	echo CLASSES=${PKGADD_CLASSES} >> pkginfo
+	echo BASEDIR=${PKGADD_BASEDIR} >> pkginfo
+	echo CATEGORY=application >> pkginfo
+	echo VERSION=`cat ./release` >> pkginfo
+	echo > prototype
+	for subdir in opt var etc usr; \
+	do if [ -d root/$$subdir ]; then \
+		pkgproto root/$$subdir=$$subdir >> prototype;\
+	fi; done
+	for file in pkginfo preinstall postinstall copyright; \
+	do if [ -f $$file ]; then \
+		echo "i $$file=$$file" >> prototype; \
+	fi; done
+	rm -rf ./tmp
+	mkdir ./tmp
+	pkgmk -o -d ./tmp
+	pkgtrans -so ./tmp ${top_srcdir}/../${PKGADD_FILE} ${PKGADD_PKG}

packages/Win32/README

@@ -2,6 +2,9 @@ Author: J
 
 DESCRIPTION
 
+(If you're only looking for precompiled win32 binaries, go visit
+http://curl.haxx.se/download.html)
+
 Packaging of the curl binaries for Win32 should at this point in time be based
 on the InfoZip (zip/unzip) archiver family as the de-facto standard for
 Windows archives. A package should contain the main binary curl.exe along with

perl/Curl_easy/Changes

@@ -1,6 +1,47 @@
 Revision history for Perl extension Curl::easy.
 Check out the file README for more info.
 
+1.1.5  Fri Apr 20 2001: - Cris Bailiff <c.bailiff@devsecure.com>
+    - Add latest CURLOPT_ and CURLINFO_ constants to the constants list
+
+1.1.4  Fri Apr 20 2001: - Cris Bailiff <c.bailiff@devsecure.com>
+    - Fix case where curl_slists such as 'HTTPHEADERS' need to
+      be re-set over persistant requests
+
+1.1.3  Wed Apr 18 2001: - Cris Bailiff <c.bailiff@devsecure.com>
+    - Change/shorten module function names: Curl::easy::curl_easy_setopt
+      becomes Curl::easy::setopt etc. This requires minor changes to existing
+      scripts....
+    - Added callback function support to pass arbitrary SV * (including
+	  FILE globs) from perl through libcurl to the perl callback.
+	- Make callbacks still work with existing scripts which use STDIO
+	- Initial support for libcurl 7.7.2 HEADERFUNCTION callback feature
+	- Minor API cleanups/changes in the callback function signatures
+	- Added Curl::easy::version function to return curl version string
+	- Callback documentation added in easy.pm
+    - More tests in test.pl
+
+1.1.2  Mon Apr 16 2001: - Georg Horn <horn@koblenz-net.de>
+    - Added support for callback functions. This is for the curl_easy_setopt()
+      options WRITEFUNCTION, READFUNCTION, PROGRESSFUNCTION and PASSWDFUNCTION.
+      Still missing, but not really neccessary: Passing a FILE * pointer,
+      that is passed in from libcurl, on to the perl callback function.
+    - Various cleanups, fixes and enhancements to easy.xs and test.pl.
+
+1.1.1  Thu Apr 12 2001:
+    - Made more options of curl_easy_setopt() work: Options that require
+      a list of curl_slist structs to be passed in, like CURLOPT_HTTPHEADER,
+      are now working by passing a perl array containing the list elements.
+      As always, look at the test script test.pl for an example.
+
+1.1.0  Wed Apr 11 2001:
+    - tested against libcurl 7.7
+    - Added new function Curl::easy::internal_setopt(). By calling
+      Curl::easy::internal_setopt(Curl::easy::USE_INTERNAL_VARS, 1);
+      the headers and content of the fetched page are no longer stored
+      into files (or written to stdout) but are stored into internal
+      Variables $Curl::easy::headers and $Curl::easy::content.
+
 1.0.2  Tue Oct 10 2000:
     - runs with libcurl 7.4
     - modified curl_easy_getinfo(). It now calls curl_getinfo() that has

perl/Curl_easy/MANIFEST

@@ -1,6 +1,7 @@
 Changes
 MANIFEST
 Makefile.PL
+README
 easy.pm
 easy.xs
 test.pl

perl/Curl_easy/README

@@ -12,16 +12,16 @@ installed. You then may install this module via the usual way:
     make install
 
 The module provides the same functionality as libcurl provides to C programs,
-please refer to the documentation of libcurl.
+please refer to the documentation of libcurl. Some examples may be found in
+test.pl.
 
-A short example how to use the module may be found in test.pl.
+This software is distributed AS IS, WITHOUT WARRANTY OF ANY KIND, either
+express or implied. Send praise, patches, money, beer and pizza to the author.
+Send complaints to /dev/null. ;-)
 
-This Software is distributed AS IS, WITHOUT WARRANTY OF ANY KIND,
-either express or implied. Send praise, patches, money, beer and
-pizza to the author. Send complaints to /dev/null. ;-)
+The author of this software is Georg Horn <horn@koblenz-net.de>
+Parts of the callback support have been added by Cris Bailiff
+<c.bailiff@awayweb.com> and Forrest Cahoon <forrest.cahoon@merrillcorp.com>
 
-The author of this module is Georg Horn <horn@koblenz-net.de>
-
-The latest version of this module can be dowloaded from
-http://koblenz-net.de/~horn/export/
+The latest version can be downloaded from http://koblenz-net.de/~horn/export/
 

perl/Curl_easy/easy.pm

@@ -29,6 +29,7 @@ CURLOPT_FTPASCII
 CURLOPT_FTPLISTONLY
 CURLOPT_FTPPORT
 CURLOPT_HEADER
+CURLOPT_HEADERFUNCTION
 CURLOPT_HTTPHEADER
 CURLOPT_HTTPPOST
 CURLOPT_HTTPPROXYTUNNEL
@@ -44,6 +45,8 @@ CURLOPT_NETRC
 CURLOPT_NOBODY
 CURLOPT_NOPROGRESS
 CURLOPT_NOTHING
+CURLOPT_PASSWDDATA
+CURLOPT_PASSWDFUNCTION
 CURLOPT_PORT
 CURLOPT_POST
 CURLOPT_POSTFIELDS
@@ -75,6 +78,17 @@ CURLOPT_USERPWD
 CURLOPT_VERBOSE
 CURLOPT_WRITEFUNCTION
 CURLOPT_WRITEHEADER
+CURLOPT_MAXREDIRS
+CURLOPT_FILETIME
+CURLOPT_TELNETOPTIONS
+CURLOPT_MAXCONNECTS
+CURLOPT_CLOSEPOLICY
+CURLOPT_CLOSEFUNCTION
+CURLOPT_FRESH_CONNECT
+CURLOPT_FORBID_REUSE
+CURLOPT_RANDOM_FILE
+CURLOPT_EGD_SOCKET
+CURLOPT_CONNECTTIMEOUT
 
 CURLINFO_EFFECTIVE_URL
 CURLINFO_HTTP_CODE
@@ -88,8 +102,18 @@ CURLINFO_SPEED_DOWNLOAD
 CURLINFO_SPEED_UPLOAD
 CURLINFO_HEADER_SIZE
 CURLINFO_REQUEST_SIZE
+CURLINFO_SSL_VERIFYRESULT
+CURLINFO_FILETIME
+CURLINFO_CONTENT_LENGTH_DOWNLOAD
+CURLINFO_CONTENT_LENGTH_UPLOAD
+
+USE_INTERNAL_VARS
 );
-$VERSION = '1.0.1';
+
+$VERSION = '1.1.5';
+
+$Curl::easy::headers = "";
+$Curl::easy::content = "";
 
 sub AUTOLOAD {
     # This AUTOLOAD is used to 'autoload' constants from the constant()
@@ -116,21 +140,122 @@ Curl::easy - Perl extension for libcurl
 =head1 SYNOPSIS
 
   use Curl::easy;
-  
-  $CURL = curl_easy_init();
-  $CURLcode = curl_easy_setopt($CURL, CURLoption, Value);
-  $CURLcode = curl_easy_perform($CURL);
-  curl_easy_cleanup($CURL);
-  
-
+ 
+  $curl = Curl::easy::init();
+  $CURLcode = Curl::easy::setopt($curl, CURLoption, Value);
+  $CURLcode = Curl::easy::perform($curl);
+  Curl::easy::cleanup($curl);
+ 
 =head1 DESCRIPTION
-
+ 
 This perl module provides an interface to the libcurl C library. See
 http://curl.haxx.se/ for more information on cURL and libcurl.
+ 
+=head1 FILES and CALLBACKS
+
+Curl::easy supports the various options of curl_easy_setopt which require either a FILE * or
+a callback function.
+
+The perl callback functions are handled through a C wrapper which takes care of converting
+from C to perl variables and back again. This wrapper simplifies some C arguments to make
+them behave in a more 'perl' like manner. In particular, the read and write callbacks do not
+look just like the 'fread' and 'fwrite' C functions - perl variables do not need separate length
+parameters, and perl functions can return a list of variables, instead of needing a pointer
+to modify. The details are described below.
+
+=head2 FILE handles (GLOBS)
+ 
+Curl options which take a FILE, such as CURLOPT_FILE, CURLOPT_WRITEHEADER, CURLOPT_INFILE
+can be passed a perl file handle:
+ 
+  open BODY,">body.out";
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_FILE, BODY);
+
+=head2 WRITE callback
+
+The CUROPT_WRITEFUNCTION option may be set which will cause libcurl to callback to
+the given subroutine:
+
+  sub chunk { my ($data,$pointer)=@_; ...; return length($data) }
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_WRITEFUNCTION, \&chunk );
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_FILE, );
+
+In this case, the subroutine will be passed whatever is defined by CURLOPT_FILE. This can be
+a ref to a scalar, or a GLOB or anything else you like.
+
+The callback function must return the number of bytes 'handled' ( length($data) ) or the transfer
+will abort. A transfer can be aborted by returning a 'length' of '-1'.
+
+The option CURLOPT_WRITEHEADER can be set to pass a different '$pointer' into the CURLOPT_WRITEFUNCTION 
+for header values. This lets you collect the headers and body separately:
+
+  my $headers="";
+  my $body="";
+  sub chunk { my ($data,$pointer)=@_; ${$pointer}.=$data; return length($data) }
+
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_WRITEFUNCTION, \&chunk );
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_WRITEHEADER, \$header );
+  $CURLcode = Curl::easy::setopt($curl, CURLOPT_FILE, \$body );
+
+If you have libcurl > 7.7.1, then you could instead set CURLOPT_HEADERFUNCTION to a different callback,
+and have the header collected that way.
+
+=head2 READ callback
+
+Curl::easy supports CURLOPT_READFUNCTION. This function should look something like this:
+
+    sub read_callback {
+        my ($maxlength,$pointer)=@_;
+
+		....
+
+        return $data;
+    }
+
+The subroutine must return an empty string "" at the end of the data. Note that this function
+isn't told how much data to provide - $maxlength is just the maximum size of the buffer
+provided by libcurl. If you are doing an HTTP POST or PUT for example, it is important that this
+function only returns as much data as the 'Content-Length' header specifies, followed by a
+an empty (0 length) buffer.
+
+=head2 PROGRESS callback
+
+Curl::easy supports CURLOPT_PROGRESSFUNCTION. This function should look something like this:
+
+    sub prog_callb
+    {
+        my ($clientp,$dltotal,$dlnow,$ultotal,$ulnow)=@_;
+		....
+        return 0;
+    }                        
+
+The function should return 0 normally, or -1 which will abort/cancel the transfer. $clientp is whatever
+value/scalar is set using the CURLOPT_PROGRESSDATA option.
+
+=head2 PASSWD callback
+
+Curl::easy supports CURLOPT_PASSWDFUNCTION. This function should look something like this:
+ 
+    sub passwd_callb
+    {
+		my ($clientp,$prompt,$buflen)=@_;
+		...
+    	return (0,$data);
+    }                    
+
+$clientp is whatever scalar is set using the CURLOPT_PASSWDDATA option.
+$prompt is a text string which can be used to prompt for a password.
+$buflen is the maximum accepted password reply.
+
+The function must return 0 (for 'OK') and the password data as a list. Return (-1,"") to
+indicate an error.
 
 =head1 AUTHOR
-
+ 
 Georg Horn <horn@koblenz-net.de>
+ 
+Additional callback,pod and tes work by Cris Bailiff <c.bailiff@devsecure.com>
+and Forrest Cahoon <forrest.cahoon@merrillcorp.com>
 
 =head1 SEE ALSO
 

perl/Curl_easy/easy.xs

@@ -7,6 +7,17 @@
 #include <curl/curl.h>
 #include <curl/easy.h>
 
+#if (LIBCURL_VERSION_NUM<0x070702)
+#define CURLOPT_HEADERFUNCTION 20079
+#define header_callback_func write_callback_func
+#else
+#define header_callback_func writeheader_callback_func
+#endif
+
+/* Lists that can be set via curl_easy_setopt() */
+
+static struct curl_slist *httpheader = NULL, *quote = NULL, *postquote = NULL;
+
 
 /* Buffer and varname for option CURLOPT_ERRORBUFFER */
 
@@ -14,6 +25,339 @@ static char errbuf[CURL_ERROR_SIZE];
 static char *errbufvarname = NULL;
 
 
+/* Callback functions */
+
+static SV *read_callback = NULL, *write_callback = NULL,
+          *progress_callback = NULL, *passwd_callback = NULL,
+	  *header_callback = NULL; 
+	  /* *closepolicy_callback = NULL; */
+
+
+/* For storing the content */
+
+static char *contbuf = NULL, *bufptr = NULL;
+static int bufsize = 32768, contlen = 0;
+
+
+/* Internal options for this perl module */
+
+#define USE_INTERNAL_VARS 0x01
+
+static int internal_options = 0;
+
+
+/* Setup these global vars */
+
+static void init_globals(void)
+{
+    if (httpheader) curl_slist_free_all(httpheader);
+    if (quote) curl_slist_free_all(quote);
+    if (postquote) curl_slist_free_all(postquote);
+    httpheader = quote = postquote = NULL;
+    if (errbufvarname) free(errbufvarname);
+    errbufvarname = NULL;
+    if (contbuf == NULL) {
+	contbuf = malloc(bufsize + 1);
+    }
+    bufptr = contbuf;
+    *bufptr = '\0';
+    contlen = 0;
+    internal_options = 0;
+}
+
+
+/* Register a callback function */
+
+static void register_callback(SV **callback, SV *function)
+{
+    if (*callback == NULL) {
+	/* First time, create new SV */
+	*callback = newSVsv(function);
+    } else {
+	/* Been there, done that. Just overwrite the SV */
+	SvSetSV(*callback, function);
+    }
+}
+
+/* generic fwrite callback, which decides which callback to call */
+static size_t
+fwrite_wrapper (const void *ptr,
+		size_t size,
+		size_t nmemb,
+		void *stream,
+		void *call_function)
+{
+    dSP;
+    int count, status;
+    SV *sv;
+
+    if (call_function) {
+	/* then we are doing a callback to perl */
+
+	ENTER;
+	SAVETMPS;
+
+	PUSHMARK(SP);
+
+	if (stream == stdout) {
+	    sv = newSViv(0);	/* FIXME: should cast stdout to GLOB somehow? */
+	} else {		/* its already an SV */
+	    sv = stream;
+	}
+
+	if (ptr != NULL) {
+	    XPUSHs(sv_2mortal(newSVpvn(ptr, size * nmemb)));
+	} else {
+	    XPUSHs(sv_2mortal(newSVpv("", 0)));
+	}
+	XPUSHs(sv_2mortal(newSVsv(sv)));	/* CURLOPT_FILE SV* */
+	PUTBACK;
+
+	count = perl_call_sv((SV *) call_function, G_SCALAR);
+
+	SPAGAIN;
+	if (count != 1)
+	    croak("Big trouble, perl_call_sv(write_callback) didn't return status\n");
+
+	status = POPi;
+
+	PUTBACK;
+
+	FREETMPS;
+	LEAVE;
+	return status;
+
+    } else {
+	/* default to a normal 'fwrite' */
+	/* stream could be a FILE * or an SV * */
+	FILE *f;
+
+	if (stream == stdout) {	/* the only possible FILE ? Think so */
+	    f = stream;
+	} else {		/* its a GLOB */
+	    f = IoIFP(sv_2io(stream));	/* may barf if not a GLOB */
+	}
+
+	return fwrite(ptr, size, nmemb, f);
+    }
+}
+
+/* Write callback for calling a perl callback */
+size_t
+write_callback_func( const void *ptr, size_t size,
+                                size_t nmemb, void *stream)
+{
+    return fwrite_wrapper(ptr,size,nmemb,stream,
+        write_callback);
+}
+
+/* header callback for calling a perl callback */
+size_t
+writeheader_callback_func( const void *ptr, size_t size,
+                              size_t nmemb, void *stream)
+{
+    return fwrite_wrapper(ptr,size,nmemb,stream,
+        header_callback);
+}
+
+size_t
+read_callback_func( void *ptr, size_t size,
+                    size_t nmemb, void *stream)
+{
+    dSP ;
+
+    int count;
+    SV *sv;
+    STRLEN len;
+    size_t maxlen,mylen;
+    char *p;
+
+    maxlen = size*nmemb;
+
+    if (read_callback) {
+        /* we are doing a callback to perl */
+
+        ENTER ;
+        SAVETMPS ;
+ 
+        PUSHMARK(SP) ;
+	
+        if (stream == stdin) {
+            sv = newSViv(0); /* should cast stdin to GLOB somehow? */
+        } else { /* its an SV */
+            sv = stream;
+        }
+	
+        XPUSHs(sv_2mortal(newSViv(maxlen))); /* send how many bytes please */
+        XPUSHs(sv_2mortal(newSVsv(sv))); /* CURLOPT_INFILE SV*  */
+        PUTBACK ;
+
+        count = perl_call_sv(read_callback, G_SCALAR);
+	 
+        SPAGAIN;
+        if (count != 1)
+            croak("Big trouble, perl_call_sv(read_callback) didn't return data\n");
+
+        sv = POPs;
+        p = SvPV(sv,len);
+
+        /* only allowed to return the number of bytes asked for */
+        mylen = len<maxlen ? len : maxlen;
+        memcpy(ptr,p,(size_t)mylen);
+        PUTBACK ;
+ 
+        FREETMPS ;
+        LEAVE ;
+        return (size_t) (mylen/size);
+    } else {
+       /* default to a normal 'fread' */
+       /* stream could be a FILE * or an SV * */
+       FILE *f;
+
+       if (stream == stdin) { /* the only possible FILE ? Think so*/
+           f = stream;
+       } else { /* its a GLOB */
+           f = IoIFP(sv_2io(stream)); /* may barf if not a GLOB */
+       }
+
+       return fread(ptr,size,nmemb,f);
+    }
+}
+
+/* Porgress callback for calling a perl callback */
+
+static int progress_callback_func(void *clientp, size_t dltotal, size_t dlnow,
+    size_t ultotal, size_t ulnow)
+{
+    dSP;
+    int count;
+
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(sp);
+    if (clientp != NULL) {
+	XPUSHs(sv_2mortal(newSVpv(clientp, 0)));
+    } else {
+	XPUSHs(sv_2mortal(newSVpv("", 0)));
+    }
+    XPUSHs(sv_2mortal(newSViv(dltotal)));
+    XPUSHs(sv_2mortal(newSViv(dlnow)));
+    XPUSHs(sv_2mortal(newSViv(ultotal)));
+    XPUSHs(sv_2mortal(newSViv(ulnow)));
+    PUTBACK;
+    count = perl_call_sv(progress_callback, G_SCALAR);
+    SPAGAIN;
+    if (count != 1)
+	croak("Big trouble, perl_call_sv(progress_callback) didn't return 1\n");
+    count = POPi;
+    PUTBACK;
+    FREETMPS;
+    LEAVE;
+    return count;
+}
+
+
+/* Password callback for calling a perl callback */
+
+static int passwd_callback_func(void *clientp, char *prompt, char *buffer,
+    int buflen)
+{
+    dSP;
+    int count;
+    SV *sv;
+    STRLEN len;
+    size_t mylen;
+    char *p;            
+
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(sp);
+    if (clientp != NULL) {
+        XPUSHs(sv_2mortal(newSVsv(clientp)));
+    } else {
+        XPUSHs(sv_2mortal(newSVpv("", 0)));
+    }
+    XPUSHs(sv_2mortal(newSVpv(prompt, 0)));
+    XPUSHs(sv_2mortal(newSViv(buflen)));
+    PUTBACK;
+    count = perl_call_sv(passwd_callback, G_ARRAY);
+    SPAGAIN;
+    if (count != 2)
+	croak("Big trouble, perl_call_sv(passwd_callback) didn't return status + data\n");
+
+    sv = POPs;
+    count = POPi;
+
+    p = SvPV(sv,len);
+ 
+    /* only allowed to return the number of bytes asked for */
+    mylen = len<(buflen-1) ? len : (buflen-1);
+    memcpy(buffer,p,mylen);
+    buffer[buflen]=0; /* ensure C string terminates */
+
+    PUTBACK;
+    FREETMPS;
+    LEAVE;
+    return count;
+}
+
+
+#if 0
+/* awaiting closepolicy prototype */
+int 
+closepolicy_callback_func(void *clientp)
+{
+   dSP;
+   int argc, status;
+   SV *pl_status;
+
+   ENTER;
+   SAVETMPS;
+
+   PUSHMARK(SP);
+   PUTBACK;
+
+   argc = perl_call_sv(closepolicy_callback, G_SCALAR);
+   SPAGAIN;
+
+   if (argc != 1) {
+      croak("Unexpected number of arguments returned from closefunction callback\n");
+   }
+   pl_status = POPs;
+   status = SvTRUE(pl_status) ? 0 : 1;
+
+   PUTBACK;
+   FREETMPS;
+   LEAVE;
+
+   return status;
+}
+#endif
+
+
+
+/* Internal write callback. Only used if USE_INTERNAL_VARS was specified */
+
+static size_t internal_write_callback(char *data, size_t size, size_t num,
+    FILE *fp)
+{
+    int i;
+
+    size *= num;
+    if ((contlen + size) >= bufsize) {
+	bufsize *= 2;
+	contbuf = realloc(contbuf, bufsize + 1);
+	bufptr = contbuf + contlen;
+    }
+    contlen += size;
+    for (i = 0; i < size; i++) {
+	*bufptr++ = *data++;
+    }
+    *bufptr = '\0';
+    return size;
+}
+
+
 static int
 constant(char *name, int arg)
 {
@@ -24,13 +368,17 @@ constant(char *name, int arg)
 	case 'A':
 	case 'B':
 	case 'C':
-	case 'D':
 	    if (strEQ(name, "CONNECT_TIME")) return CURLINFO_CONNECT_TIME;
+	    if (strEQ(name, "CONTENT_LENGTH_DOWNLOAD")) return CURLINFO_CONTENT_LENGTH_DOWNLOAD;
+	    if (strEQ(name, "CONTENT_LENGTH_UPLOAD")) return CURLINFO_CONTENT_LENGTH_UPLOAD;
 	    break;
+	case 'D':
 	case 'E':
-	case 'F':
 	    if (strEQ(name, "EFFECTIVE_URL")) return CURLINFO_EFFECTIVE_URL;
 	    break;
+	case 'F':
+	    if (strEQ(name, "FILETIME")) return CURLINFO_FILETIME;
+	    break;
 	case 'G':
 	case 'H':
 	    if (strEQ(name, "HEADER_SIZE")) return CURLINFO_HEADER_SIZE;
@@ -53,6 +401,8 @@ constant(char *name, int arg)
 	    if (strEQ(name, "REQUEST_SIZE")) return CURLINFO_REQUEST_SIZE;
 	    break;
 	case 'S':
+	    if (strEQ(name, "SSL_VERIFYRESULT")) return CURLINFO_SSL_VERIFYRESULT;
+	    break;
 	case 'T':
 	    if (strEQ(name, "SIZE_DOWNLOAD")) return CURLINFO_SIZE_DOWNLOAD;
 	    if (strEQ(name, "SIZE_UPLOAD")) return CURLINFO_SIZE_UPLOAD;
@@ -77,26 +427,35 @@ constant(char *name, int arg)
 	    if (strEQ(name, "AUTOREFERER")) return CURLOPT_AUTOREFERER;
 	    break;
 	case 'C':
-	case 'D':
+	    if (strEQ(name, "CONNECTTIMEOUT")) return CURLOPT_CONNECTTIMEOUT;
 	    if (strEQ(name, "COOKIE")) return CURLOPT_COOKIE;
 	    if (strEQ(name, "COOKIEFILE")) return CURLOPT_COOKIEFILE;
+	    if (strEQ(name, "CLOSEFUNCTION")) return CURLOPT_CLOSEFUNCTION;
+	    if (strEQ(name, "CLOSEPOLICY")) return CURLOPT_CLOSEPOLICY;
 	    if (strEQ(name, "CRLF")) return CURLOPT_CRLF;
 	    if (strEQ(name, "CUSTOMREQUEST")) return CURLOPT_CUSTOMREQUEST;
 	    break;
+	case 'D':
 	case 'E':
-	case 'F':
+	    if (strEQ(name, "EGDSOCKET")) return CURLOPT_EGDSOCKET;
 	    if (strEQ(name, "ERRORBUFFER")) return CURLOPT_ERRORBUFFER;
+            break;
+	case 'F':
 	    if (strEQ(name, "FAILONERROR")) return CURLOPT_FAILONERROR;
 	    if (strEQ(name, "FILE")) return CURLOPT_FILE;
+	    if (strEQ(name, "FILETIME")) return CURLOPT_FILETIME;
 	    if (strEQ(name, "FOLLOWLOCATION")) return CURLOPT_FOLLOWLOCATION;
+	    if (strEQ(name, "FORBID_REUSE")) return CURLOPT_FORBID_REUSE;
 	    if (strEQ(name, "FTPAPPEND")) return CURLOPT_FTPAPPEND;
 	    if (strEQ(name, "FTPASCII")) return CURLOPT_FTPASCII;
 	    if (strEQ(name, "FTPLISTONLY")) return CURLOPT_FTPLISTONLY;
 	    if (strEQ(name, "FTPPORT")) return CURLOPT_FTPPORT;
+	    if (strEQ(name, "FRESH_CONNECT")) return CURLOPT_FRESH_CONNECT;
 	    break;
 	case 'G':
 	case 'H':
 	    if (strEQ(name, "HEADER")) return CURLOPT_HEADER;
+            if (strEQ(name, "HEADERFUNCTION")) return CURLOPT_HEADERFUNCTION;
 	    if (strEQ(name, "HTTPHEADER")) return CURLOPT_HTTPHEADER;
 	    if (strEQ(name, "HTTPPOST")) return CURLOPT_HTTPPOST;
 	    if (strEQ(name, "HTTPPROXYTUNNEL")) return CURLOPT_HTTPPROXYTUNNEL;
@@ -115,6 +474,9 @@ constant(char *name, int arg)
 	    if (strEQ(name, "LOW_SPEED_TIME")) return CURLOPT_LOW_SPEED_TIME;
 	    break;
 	case 'M':
+	    if (strEQ(name, "MAXCONNECTS")) return CURLOPT_MAXCONNECTS;
+	    if (strEQ(name, "MAXREDIRS")) return CURLOPT_MAXREDIRS;
+	    break;
 	case 'N':
 	    if (strEQ(name, "MUTE")) return CURLOPT_MUTE;
 	    if (strEQ(name, "NETRC")) return CURLOPT_NETRC;
@@ -124,6 +486,8 @@ constant(char *name, int arg)
 	    break;
 	case 'O':
 	case 'P':
+	    if (strEQ(name, "PASSWDDATA")) return CURLOPT_PASSWDDATA;
+	    if (strEQ(name, "PASSWDFUNCTION")) return CURLOPT_PASSWDFUNCTION;
 	    if (strEQ(name, "PORT")) return CURLOPT_PORT;
 	    if (strEQ(name, "POST")) return CURLOPT_POST;
 	    if (strEQ(name, "POSTFIELDS")) return CURLOPT_POSTFIELDS;
@@ -137,19 +501,23 @@ constant(char *name, int arg)
 	    if (strEQ(name, "PUT")) return CURLOPT_PUT;
 	    break;
 	case 'Q':
-	case 'R':
 	    if (strEQ(name, "QUOTE")) return CURLOPT_QUOTE;
+            break;
+ 	case 'R':
+	    if (strEQ(name, "RANDOM_FILE")) return CURLOPT_RANDOM_FILE;
 	    if (strEQ(name, "RANGE")) return CURLOPT_RANGE;
 	    if (strEQ(name, "READFUNCTION")) return CURLOPT_READFUNCTION;
 	    if (strEQ(name, "REFERER")) return CURLOPT_REFERER;
 	    if (strEQ(name, "RESUME_FROM")) return CURLOPT_RESUME_FROM;
 	    break;
 	case 'S':
-	case 'T':
 	    if (strEQ(name, "SSLCERT")) return CURLOPT_SSLCERT;
 	    if (strEQ(name, "SSLCERTPASSWD")) return CURLOPT_SSLCERTPASSWD;
 	    if (strEQ(name, "SSLVERSION")) return CURLOPT_SSLVERSION;
 	    if (strEQ(name, "STDERR")) return CURLOPT_STDERR;
+            break;
+	case 'T':
+	    if (strEQ(name, "TELNETOPTIONS")) return CURLOPT_TELNETOPTIONS;
 	    if (strEQ(name, "TIMECONDITION")) return CURLOPT_TIMECONDITION;
 	    if (strEQ(name, "TIMEOUT")) return CURLOPT_TIMEOUT;
 	    if (strEQ(name, "TIMEVALUE")) return CURLOPT_TIMEVALUE;
@@ -173,12 +541,13 @@ constant(char *name, int arg)
 	    break;
 	}
     }
+    if (strEQ(name, "USE_INTERNAL_VARS")) return USE_INTERNAL_VARS;
     errno = EINVAL;
     return 0;
 }
 
 
-MODULE = Curl::easy		PACKAGE = Curl::easy		
+MODULE = Curl::easy		PACKAGE = Curl::easy		PREFIX = curl_easy_
 
 int
 constant(name,arg)
@@ -189,56 +558,167 @@ constant(name,arg)
 void *
 curl_easy_init()
 CODE:
-    if (errbufvarname) free(errbufvarname);
-    errbufvarname = NULL;
+    init_globals();
     RETVAL = curl_easy_init();
+    curl_easy_setopt(RETVAL, CURLOPT_HEADERFUNCTION, header_callback_func);
+    curl_easy_setopt(RETVAL, CURLOPT_WRITEFUNCTION, write_callback_func);
 OUTPUT:
     RETVAL
 
+char *
+curl_easy_version()
+CODE:
+	RETVAL=curl_version();
+OUTPUT:
+	RETVAL
 
 int
 curl_easy_setopt(curl, option, value)
 void * curl
 int option
-char * value
+SV * value
 CODE:
     if (option < CURLOPTTYPE_OBJECTPOINT) {
 	/* This is an option specifying an integer value: */
-	long value = (long)SvIV(ST(2));
-	RETVAL = curl_setopt(curl, option, value);
+	RETVAL = curl_easy_setopt(curl, option, (long)SvIV(value));
     } else if (option == CURLOPT_FILE || option == CURLOPT_INFILE ||
-	    option == CURLOPT_WRITEHEADER) {
-	/* This is an option specifying a FILE * value: */
-	FILE * value = IoIFP(sv_2io(ST(2)));
-	RETVAL = curl_setopt(curl, option, value);
+	    option == CURLOPT_WRITEHEADER || option == CURLOPT_PROGRESSDATA ||
+	    option == CURLOPT_PASSWDDATA) {
+	/* This is an option specifying an SV * value: */
+	RETVAL = curl_easy_setopt(curl, option, newSVsv(ST(2)));
     } else if (option == CURLOPT_ERRORBUFFER) {
-	SV *sv;
-	RETVAL = curl_setopt(curl, option, errbuf);
+	/* Pass in variable name for storing error messages... */
+	RETVAL = curl_easy_setopt(curl, option, errbuf);
 	if (errbufvarname) free(errbufvarname);
-	errbufvarname = strdup(value);
-	sv = perl_get_sv(errbufvarname, TRUE | GV_ADDMULTI);
+	errbufvarname = strdup((char *)SvPV(value, PL_na));
     } else if (option == CURLOPT_WRITEFUNCTION || option ==
-	    CURLOPT_READFUNCTION || option == CURLOPT_PROGRESSFUNCTION) {
+	    CURLOPT_READFUNCTION || option == CURLOPT_PROGRESSFUNCTION ||
+	    option == CURLOPT_PASSWDFUNCTION || option == CURLOPT_HEADERFUNCTION) {
 	/* This is an option specifying a callback function */
-	/* not yet implemented */
+	switch (option) {
+	case CURLOPT_WRITEFUNCTION:
+	    register_callback(&write_callback, value);
+	    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback_func);
+	    break;
+	case CURLOPT_READFUNCTION:
+	    register_callback(&read_callback, value);
+	    curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback_func);
+	    break;
+        case CURLOPT_HEADERFUNCTION:
+            register_callback(&header_callback, value);
+	    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback_func);	
+	case CURLOPT_PROGRESSFUNCTION:
+	    register_callback(&progress_callback, value);
+	    curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback_func);
+	    break;
+	case CURLOPT_PASSWDFUNCTION:
+	    register_callback(&passwd_callback, value);
+	    curl_easy_setopt(curl, CURLOPT_PASSWDFUNCTION, passwd_callback_func);
+	    break;
+        /* awaiting a prototype for the closepolicy function callback 
+        case CURLOPT_CLOSEFUNCTION:
+            register_callback(&closepolicy_callback, value);
+            curl_easy_setopt(curl, CURLOPT_CLOSEFUNCTION, closepolicy_callback_func);
+            break;
+        */
+	}
 	RETVAL = -1;
+    } else if (option == CURLOPT_HTTPHEADER || option == CURLOPT_QUOTE ||
+	    option == CURLOPT_POSTQUOTE) {
+	/* This is an option specifying a list of curl_slist structs: */
+	AV *array = (AV *)SvRV(value);
+	struct curl_slist **slist = NULL;
+	/* We have to find out which list to use... */
+	switch (option) {
+	case CURLOPT_HTTPHEADER:
+	    slist = &httpheader; break;
+	case CURLOPT_QUOTE:
+	    slist = &quote; break;
+	case CURLOPT_POSTQUOTE:
+	    slist = &postquote; break;
+	}
+        /* free any previous list */
+        if (*slist) {
+            curl_slist_free_all(*slist);
+            *slist=NULL;
+        }                                                                       
+	/* ...store the values into it... */
+	for (;;) {
+	    SV *sv = av_shift(array);
+	    int len = 0;
+	    char *str = SvPV(sv, len);
+	    if (len == 0) break;
+	    *slist = curl_slist_append(*slist, str);
+	}
+	/* ...and pass the list into curl_easy_setopt() */
+	RETVAL = curl_easy_setopt(curl, option, *slist);
     } else {
-	/* default, option specifying a char * value: */
-	RETVAL = curl_setopt(curl, option, value);
+	/* This is an option specifying a char * value: */
+	RETVAL = curl_easy_setopt(curl, option, SvPV(value, PL_na));
     }
 OUTPUT:
     RETVAL
 
 
+int
+internal_setopt(option, value)
+int option
+int value
+CODE:
+    if (value == 1) {
+	internal_options |= option;
+    } else {
+	internal_options &= !option;
+    }
+    RETVAL = 0;
+OUTPUT:
+    RETVAL
+
+
 int
 curl_easy_perform(curl)
 void * curl 
 CODE:
+    if (internal_options & USE_INTERNAL_VARS) {
+	/* Use internal callback which just stores the content into a buffer. */
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, internal_write_callback);
+	curl_easy_setopt(curl, CURLOPT_HEADER, 1);
+    }
     RETVAL = curl_easy_perform(curl);
     if (RETVAL && errbufvarname) {
+	/* If an error occurred and a varname for error messages has been
+	   specified, store the error message. */
 	SV *sv = perl_get_sv(errbufvarname, TRUE | GV_ADDMULTI);
 	sv_setpv(sv, errbuf);
     }
+    if (!RETVAL && (internal_options & USE_INTERNAL_VARS)) {
+	/* No error and internal variable for the content are to be used:
+	   Split the data into headers and content and store them into
+	   perl variables. */
+	SV *head_sv = perl_get_sv("Curl::easy::headers", TRUE | GV_ADDMULTI);
+	SV *cont_sv = perl_get_sv("Curl::easy::content", TRUE | GV_ADDMULTI);
+	char *p = contbuf;
+	int nl = 0, found = 0;
+	while (p < bufptr) {
+	    if (nl && (*p == '\n' || *p == '\r')) {
+		/* found empty line, end of headers */
+		*p++ = '\0';
+		sv_setpv(head_sv, contbuf);
+		while (*p == '\n' || *p == '\r') {
+		    p++;
+		}
+		sv_setpv(cont_sv, p);
+		found = 1;
+		break;
+	    }
+	    nl = (*p == '\n');
+	    p++;
+	}
+	if (!found) {
+	    sv_setpv(head_sv, "");
+	    sv_setpv(cont_sv, contbuf);
+	}
+    }
 OUTPUT:
     RETVAL
 
@@ -249,22 +729,26 @@ void * curl
 int option
 double value
 CODE:
+#ifdef __GNUC__
+    /* a(void) warnig about unnused variable */
+    (void) value;
+#endif
     switch (option & CURLINFO_TYPEMASK) {
 	case CURLINFO_STRING: {
 	    char * value = (char *)SvPV(ST(2), PL_na);
-	    RETVAL = curl_getinfo(curl, option, &value);
+	    RETVAL = curl_easy_getinfo(curl, option, &value);
 	    sv_setpv(ST(2), value);
 	    break;
 	}
 	case CURLINFO_LONG: {
 	    long value = (long)SvIV(ST(2));
-	    RETVAL = curl_getinfo(curl, option, &value);
+	    RETVAL = curl_easy_getinfo(curl, option, &value);
 	    sv_setiv(ST(2), value);
 	    break;
 	}
 	case CURLINFO_DOUBLE: {
 	    double value = (double)SvNV(ST(2));
-	    RETVAL = curl_getinfo(curl, option, &value);
+	    RETVAL = curl_easy_getinfo(curl, option, &value);
 	    sv_setnv(ST(2), value);
 	    break;
 	}
@@ -282,8 +766,7 @@ curl_easy_cleanup(curl)
 void * curl 
 CODE:
     curl_easy_cleanup(curl);
-    if (errbufvarname) free(errbufvarname);
-    errbufvarname = NULL;
+    init_globals();
     RETVAL = 0;
 OUTPUT:
     RETVAL

perl/Curl_easy/test.pl

@@ -8,11 +8,14 @@
 
 # Change 1..1 below to 1..last_test_to_print .
 # (It may become useful if the test is moved to ./t subdirectory.)
+use Benchmark;
+use strict;
 
-BEGIN { $| = 1; print "1..5\n"; }
-END {print "not ok 1\n" unless $loaded;}
+BEGIN { $| = 1; print "1..13\n"; }
+END {print "not ok 1\n" unless $::loaded;}
 use Curl::easy;
-$loaded = 1;
+
+$::loaded = 1;
 print "ok 1\n";
 
 ######################### End of black magic.
@@ -21,81 +24,292 @@ print "ok 1\n";
 # (correspondingly "not ok 13") depending on the success of chunk 13
 # of the test code):
 
+print "Testing curl version ",&Curl::easy::version(),"\n";
+
 # Read URL to get
-$defurl = "http://www/";
-$url = "";
+my $defurl = "http://localhost/cgi-bin/printenv";
+my $url = "";
 print "Please enter an URL to fetch [$defurl]: ";
 $url = <STDIN>;
 if ($url =~ /^\s*\n/) {
     $url = $defurl;
 }
 
-# Use this for simple benchmarking
-#for ($i=0; $i<1000; $i++) {
-
 # Init the curl session
-if (($curl = Curl::easy::curl_easy_init()) != 0) {
+my $curl;
+if (($curl = Curl::easy::init()) != 0) {
     print "ok 2\n";
 } else {
     print "ko 2\n";
 }
 
-# Set URL to get
-if (Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_URL, $url) == 0) {
-    print "ok 3\n";
-} else {
-    print "ko 3\n";
-}
 
 # No progress meter please
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_NOPROGRESS, 1);
+# !! Need this on for all tests, as once disabled, can't re-enable it...
+#Curl::easy::setopt($curl, CURLOPT_NOPROGRESS, 1);
 
 # Shut up completely
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_MUTE, 1);
+Curl::easy::setopt($curl, CURLOPT_MUTE, 1);
 
 # Follow location headers
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_FOLLOWLOCATION, 1);
+Curl::easy::setopt($curl, CURLOPT_FOLLOWLOCATION, 1);
 
 # Set timeout
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_TIMEOUT, 30);
+Curl::easy::setopt($curl, CURLOPT_TIMEOUT, 30);
 
 # Set file where to read cookies from
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_COOKIEFILE, "cookies");
+Curl::easy::setopt($curl, CURLOPT_COOKIEFILE, "cookies");
 
 # Set file where to store the header
 open HEAD, ">head.out";
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_WRITEHEADER, HEAD);
+Curl::easy::setopt($curl, CURLOPT_WRITEHEADER, *HEAD);
+print "ok 3\n";
 
 # Set file where to store the body
-open BODY, ">body.out";
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_FILE, BODY);
+# Send body to stdout - test difference between FILE * and SV *
+#open BODY, ">body.out";
+#Curl::easy::setopt($curl, CURLOPT_FILE,*BODY);
+print "ok 4\n";
 
+# Add some additional headers to the http-request:
+my @myheaders;
+$myheaders[0] = "Server: www";
+$myheaders[1] = "User-Agent: Perl interface for libcURL";
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_HTTPHEADER, \@myheaders);
+                                                                        
 # Store error messages in variable $errbuf
 # NOTE: The name of the variable is passed as a string!
-# curl_easy_setopt() creates a perl variable with that name, and
-# curl_easy_perform() stores the errormessage into it if an error occurs.
-Curl::easy::curl_easy_setopt($curl, Curl::easy::CURLOPT_ERRORBUFFER, "errbuf");
+# setopt() creates a perl variable with that name, and
+# perform() stores the errormessage into it if an error occurs.
+ 
+Curl::easy::setopt($curl, CURLOPT_ERRORBUFFER, "errbuf");
+Curl::easy::setopt($curl, CURLOPT_URL, $url);
+print "ok 5\n";
+
+my $bytes;
+my $realurl;
+my $httpcode;
+my $errbuf;
 
 # Go get it
-if (Curl::easy::curl_easy_perform($curl) == 0) {
-    Curl::easy::curl_easy_getinfo($curl, Curl::easy::CURLINFO_SIZE_DOWNLOAD, $bytes);
-    print "ok 4: $bytes bytes read\n";
-    print "check out the files head.out and body.out\n";
-    print "for the headers and content of the URL you just fetched...\n";
-    Curl::easy::curl_easy_getinfo($curl, Curl::easy::CURLINFO_EFFECTIVE_URL, $realurl);
-    Curl::easy::curl_easy_getinfo($curl, Curl::easy::CURLINFO_HTTP_CODE, $httpcode);
+if (Curl::easy::perform($curl) == 0) {
+    Curl::easy::getinfo($curl, CURLINFO_SIZE_DOWNLOAD, $bytes);
+    print "ok 6: $bytes bytes read\n";
+    Curl::easy::getinfo($curl, CURLINFO_EFFECTIVE_URL, $realurl);
+    Curl::easy::getinfo($curl, CURLINFO_HTTP_CODE, $httpcode);
     print "effective fetched url (http code: $httpcode) was: $url\n";
+} else {
+   # We can acces the error message in $errbuf here
+    print "not ok 6: '$errbuf'\n";
+	die "basic url access failed";
+}
+
+# cleanup
+#close HEAD;
+# test here - BODY is still expected to be the output
+# Curl-easy-1.0.2.pm core dumps if we 'perform' with a closed output FD...
+#close BODY;
+#exit;
+#
+# The header callback will only be called if your libcurl has the
+# CURLOPT_HEADERFUNCTION supported, otherwise your headers
+# go to CURLOPT_WRITEFUNCTION instead...
+#
+
+my $header_called=0;
+sub header_callback { print "header callback called\n"; $header_called=1; return length($_[0])};
+
+# test for sub reference and head callback
+Curl::easy::setopt($curl, CURLOPT_HEADERFUNCTION, \&header_callback);
+print "ok 7\n"; # so far so good
+
+if (Curl::easy::perform($curl) != 0) {
+	print "not ";
+};
+print "ok 8\n";
+
+print "next test will fail on libcurl < 7.7.2\n";
+print "not " if (!$header_called); # ok if you have a libcurl <7.7.2
+print "ok 9\n";
+
+my $body_called=0;
+sub body_callback {
+	my ($chunk,$handle)=@_;
+	print "body callback called with ",length($chunk)," bytes\n";
+	print "data=$chunk\n";
+	$body_called++;
+	return length($chunk); # OK
+}
+
+# test for ref to sub and body callback
+my $body_ref=\&body_callback;
+Curl::easy::setopt($curl, CURLOPT_WRITEFUNCTION, $body_ref);
+
+if (Curl::easy::perform($curl) != 0) {
+	print "not ";
+};
+print "ok 10\n";
+
+print "not " if (!$body_called);
+print "ok 11\n";
+
+my $body_abort_called=0;
+sub body_abort_callback {
+	my ($chunk,$sv)=@_;
+	print "body abort callback called with ",length($chunk)," bytes\n";
+	$body_abort_called++;
+	return  -1; # signal a failure
+}
+
+# test we can abort a request mid-way
+my $body_abort_ref=\&body_abort_callback;
+Curl::easy::setopt($curl, CURLOPT_WRITEFUNCTION, $body_abort_ref);
+
+if (Curl::easy::perform($curl) == 0) { # reverse test - this should have failed
+	print "not ";
+};
+print "ok 12\n";
+
+print "not " if (!$body_abort_called); # should have been called
+print "ok 13\n";
+
+# reset to a working 'write' function for next tests
+Curl::easy::setopt($curl,CURLOPT_WRITEFUNCTION, sub { return length($_[0])} );
+
+# inline progress function
+# tests for inline subs and progress callback
+# - progress callback must return 'true' on each call.
+ 
+my $progress_called=0;
+sub prog_callb
+{
+    my ($clientp,$dltotal,$dlnow,$ultotal,$ulnow)=@_;
+    print "\nperl progress_callback has been called!\n";
+    print "clientp: $clientp, dltotal: $dltotal, dlnow: $dlnow, ultotal: $ultotal, ";
+    print "ulnow: $ulnow\n";
+	$progress_called++;
+    return 0;
+}                        
+
+Curl::easy::setopt($curl, CURLOPT_PROGRESSFUNCTION, \&prog_callb);
+
+# Turn progress meter back on - this doesn't work - once its off, its off.
+Curl::easy::setopt($curl, CURLOPT_NOPROGRESS, 0);
+
+if (Curl::easy::perform($curl) != 0) {
+	print "not ";
+};
+print "ok 14\n";
+
+print "not " if (!$progress_called);
+print "ok 15\n";
+
+my $read_max=10;
+
+sub read_callb
+{
+    my ($maxlen,$sv)=@_;
+    print "\nperl read_callback has been called!\n";
+    print "max data size: $maxlen\n";
+	print "(upload needs $read_max bytes)\n";
+    print "context: ".$sv."\n";
+	if ($read_max > 0) {
+		print "\nEnter max ", $read_max, " characters to be uploaded.\n";
+		my $data = <STDIN>;
+		chomp $data;
+		$read_max=$read_max-length($data);
+		return $data;
+	} else {
+		return "";
+	}
+}  
+
+#
+# test post/read callback functions - requires a url which accepts posts, or it fails!
+#
+
+Curl::easy::setopt($curl,CURLOPT_READFUNCTION,\&read_callb);
+Curl::easy::setopt($curl,CURLOPT_INFILESIZE,$read_max );
+Curl::easy::setopt($curl,CURLOPT_UPLOAD,1 );
+Curl::easy::setopt($curl,CURLOPT_CUSTOMREQUEST,"POST" );
+                                                       
+if (Curl::easy::perform($curl) != 0) {
+	print "not ";
+};
+print "ok 16\n";
+
+sub passwd_callb
+{
+    my ($clientp,$prompt,$buflen)=@_;
+    print "\nperl passwd_callback has been called!\n";
+    print "clientp: $clientp, prompt: $prompt, buflen: $buflen\n";
+    print "\nEnter max $buflen characters for $prompt ";
+    my $data = <STDIN>;
+    chomp($data);
+    return (0,$data);
+}                                                         
+
+Curl::easy::cleanup($curl);
+
+# Now do an ftp upload:
+
+$defurl = "ftp://horn\@localhost//tmp/bla";
+print "\n\nPlease enter an URL for ftp upload [$defurl]: ";
+$url = <STDIN>;
+if ($url =~ /^\s*\n/) {
+    $url = $defurl;
+}
+
+# Init the curl session
+if (($curl = Curl::easy::init()) != 0) {
+    print "ok 17\n";
+} else {
+    print "not ok 17\n";
+}
+
+# Set URL to get
+if (Curl::easy::setopt($curl, Curl::easy::CURLOPT_URL, $url) == 0) {
+    print "ok 18\n";
+} else {
+    print "not ok 18\n";
+
+}
+
+# Tell libcurl to to an upload
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_UPLOAD, 1);
+
+# No progress meter please
+#Curl::easy::setopt($curl, Curl::easy::CURLOPT_NOPROGRESS, 1);
+
+# Use our own progress callback
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_PROGRESSFUNCTION, \&prog_callb);
+
+# Shut up completely
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_MUTE, 1);
+
+# Store error messages in $errbuf
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_ERRORBUFFER, "errbuf");
+
+$read_max=10;
+# Use perl read callback to read data to be uploaded
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_READFUNCTION,
+    \&read_callb);
+
+# Use perl passwd callback to read password for login to ftp server
+Curl::easy::setopt($curl, Curl::easy::CURLOPT_PASSWDFUNCTION, \&passwd_callb);
+
+print "ok 19\n";
+
+# Go get it
+if (Curl::easy::perform($curl) == 0) {
+    Curl::easy::getinfo($curl, Curl::easy::CURLINFO_SIZE_UPLOAD, $bytes);
+    print "ok 20: $bytes bytes transferred\n\n";
 } else {
     # We can acces the error message in $errbuf here
-    print "ko 4: '$errbuf'\n";
+    print "not ok 20: '$errbuf'\n";
 }
 
 # Cleanup
-close HEAD;
-close BODY;
-Curl::easy::curl_easy_cleanup($curl);
-print "ok 5\n";
-
-# Use this for simple benchmarking
-#}
+Curl::easy::cleanup($curl);
+print "ok 21\n";
 

perl/README

@@ -11,7 +11,8 @@ elegantly used from within it. You can either invoke external curl command
 line or use the curl interface.
 
  Georg Horn's Perl interface to curl is available in the Curl_easy/
-subdirectory.
+subdirectory. Using the Curl::easy module is just straightforward and
+works much like using libcurl in a C programm, so please refer to the
+documentation of libcurl. Have a look at test.pl to get an idea of how
+to start.
 
- Unfortunately, we don't have any examples nor any documentation for it at
-this point.

reconf

@@ -9,7 +9,7 @@ die(){
 	echo "$@" ; exit
 }
 
-aclocal -I .	|| die "ahhhhh"
-autoheader	|| die "ahhhhh"
-automake	|| die "ahhhhh"
-autoconf	|| die "ahhhhh"
+aclocal -I . || die "The command 'aclocal -I .' failed"
+autoheader   || die "The command 'autoheader' failed"
+automake     || die "The command 'automake' failed"
+autoconf     || die "The command 'autoconf' failed"

src/Makefile.am

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

src/Makefile.vc6

@@ -1,84 +1,84 @@
-########################################################
-## Makefile for building curl.exe with MSVC6
-## Use: nmake -f makefile.vc6 [release | debug]
-##      (default is release)
-##
-## Comments to: Troy Engel <tengel@sonic.net>
-## Updated by: Craig Davison <cd@securityfocus.com>
-
-PROGRAM_NAME = curl.exe
-
-########################################################
-## Nothing more to do below this line!
-
-## Release
-CCR = cl.exe /MD /O2 /D "NDEBUG"
-LINKR = link.exe /incremental:no /libpath:"../lib"
-
-## Debug
-CCD = cl.exe /MDd /Gm /ZI /Od /D "_DEBUG" /GZ
-LINKD = link.exe /incremental:yes /debug /libpath:"../lib"
-
-CFLAGS = /I "../include" /nologo /W3 /GX /D "WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-LFLAGS = /nologo /out:$(PROGRAM_NAME) /subsystem:console /machine:I386
-LINKLIBS = wsock32.lib libcurl.lib
-LINKLIBS_DEBUG = wsock32.lib libcurld.lib
-
-RELEASE_OBJS= \
-	hugehelpr.obj \
-	writeoutr.obj \
-	urlglobr.obj \
-	mainr.obj
-
-DEBUG_OBJS= \
-	hugehelpd.obj \
-	writeoutd.obj \
-	urlglobd.obj \
-	maind.obj
-	
-LINK_OBJS= \
-	hugehelp.obj \
-	writeout.obj \
-	urlglob.obj \
-	main.obj
-
-all : release
-
-release: $(RELEASE_OBJS)
-	$(LINKR) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
-
-debug: $(DEBUG_OBJS)
-	$(LINKD) $(LFLAGS) $(LINKLIBS_DEBUG) $(LINK_OBJS)
-
-## Release
-hugehelpr.obj: hugehelp.c
-	$(CCR) $(CFLAGS) /Zm200 hugehelp.c
-writeoutr.obj: writeout.c
-	$(CCR) $(CFLAGS) writeout.c
-urlglobr.obj: urlglob.c
-	$(CCR) $(CFLAGS) urlglob.c
-mainr.obj: main.c
-	$(CCR) $(CFLAGS) main.c
-
-## Debug
-hugehelpd.obj: hugehelp.c
-	$(CCD) $(CFLAGS) /Zm200 hugehelp.c
-writeoutd.obj: writeout.c
-	$(CCD) $(CFLAGS) writeout.c
-urlglobd.obj: urlglob.c
-	$(CCD) $(CFLAGS) urlglob.c
-maind.obj: main.c
-	$(CCD) $(CFLAGS) main.c
-
-clean:
-	-@erase hugehelp.obj
-	-@erase main.obj
-	-@erase vc60.idb
-	-@erase vc60.pdb
-	-@erase vc60.pch
-	-@erase curl.ilk
-	-@erase curl.pdb
-
-distrib: clean
-	-@erase $(PROGRAM_NAME)
-
+########################################################
+## Makefile for building curl.exe with MSVC6
+## Use: nmake -f makefile.vc6 [release | debug]
+##      (default is release)
+##
+## Comments to: Troy Engel <tengel@sonic.net>
+## Updated by: Craig Davison <cd@securityfocus.com>
+
+PROGRAM_NAME = curl.exe
+
+########################################################
+## Nothing more to do below this line!
+
+## Release
+CCR = cl.exe /MD /O2 /D "NDEBUG"
+LINKR = link.exe /incremental:no /libpath:"../lib"
+
+## Debug
+CCD = cl.exe /MDd /Gm /ZI /Od /D "_DEBUG" /GZ
+LINKD = link.exe /incremental:yes /debug /libpath:"../lib"
+
+CFLAGS = /I "../include" /nologo /W3 /GX /D "WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+LFLAGS = /nologo /out:$(PROGRAM_NAME) /subsystem:console /machine:I386
+LINKLIBS = wsock32.lib libcurl.lib
+LINKLIBS_DEBUG = wsock32.lib libcurld.lib
+
+RELEASE_OBJS= \
+	hugehelpr.obj \
+	writeoutr.obj \
+	urlglobr.obj \
+	mainr.obj
+
+DEBUG_OBJS= \
+	hugehelpd.obj \
+	writeoutd.obj \
+	urlglobd.obj \
+	maind.obj
+	
+LINK_OBJS= \
+	hugehelp.obj \
+	writeout.obj \
+	urlglob.obj \
+	main.obj
+
+all : release
+
+release: $(RELEASE_OBJS)
+	$(LINKR) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
+
+debug: $(DEBUG_OBJS)
+	$(LINKD) $(LFLAGS) $(LINKLIBS_DEBUG) $(LINK_OBJS)
+
+## Release
+hugehelpr.obj: hugehelp.c
+	$(CCR) $(CFLAGS) /Zm200 hugehelp.c
+writeoutr.obj: writeout.c
+	$(CCR) $(CFLAGS) writeout.c
+urlglobr.obj: urlglob.c
+	$(CCR) $(CFLAGS) urlglob.c
+mainr.obj: main.c
+	$(CCR) $(CFLAGS) main.c
+
+## Debug
+hugehelpd.obj: hugehelp.c
+	$(CCD) $(CFLAGS) /Zm200 hugehelp.c
+writeoutd.obj: writeout.c
+	$(CCD) $(CFLAGS) writeout.c
+urlglobd.obj: urlglob.c
+	$(CCD) $(CFLAGS) urlglob.c
+maind.obj: main.c
+	$(CCD) $(CFLAGS) main.c
+
+clean:
+	-@erase hugehelp.obj
+	-@erase main.obj
+	-@erase vc60.idb
+	-@erase vc60.pdb
+	-@erase vc60.pch
+	-@erase curl.ilk
+	-@erase curl.pdb
+
+distrib: clean
+	-@erase $(PROGRAM_NAME)
+

src/config-win32.h

@@ -1,7 +1,4 @@
-/* src/config.h.  Generated automatically by configure.  */
-/* Define if you have the strcasecmp function.  */
-/*#define HAVE_STRCASECMP 1*/
-
+/* src/config-win32.h.  manually created to look like a config.h.  */
 /* Define if you have the stricmp function.  */
 #define HAVE_STRICMP 1
 

src/config.h.in

@@ -1,7 +1,4 @@
 /* src/config.h.  Generated automatically by configure.  */
-/* Define if you have the strcasecmp function.  */
-#undef HAVE_STRCASECMP
-
 /* Define cpu-machine-OS */
 #undef OS
 

src/main.c

@@ -21,10 +21,14 @@
  * $Id$
  *****************************************************************************/
 
+/* This is now designed to have its own local setup.h */
+#include "setup.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <sys/types.h>
 #include <sys/stat.h>
 #include <ctype.h>
 
@@ -38,9 +42,6 @@
 
 #define CURLseparator	"--_curl_--"
 
-/* This is now designed to have its own local setup.h */
-#include "setup.h"
-
 #if defined(WIN32)&&!defined(__CYGWIN32__)
 #include <winsock.h>
 #endif
@@ -178,6 +179,7 @@ static CURLcode win32_init(void) { return CURLE_OK; }
  */
 CURLcode main_init(void)
 {
+  curl_global_init(CURL_GLOBAL_DEFAULT);
   return win32_init();
 }
 
@@ -188,6 +190,7 @@ CURLcode main_init(void)
 void main_free(void)
 {
   win32_cleanup();
+  curl_global_cleanup();
 }
 
 int SetHTTPrequest(HttpReq req, HttpReq *store)
@@ -1267,7 +1270,7 @@ struct OutStruct {
   struct Configurable *config;
 };
 
-int my_fwrite(void *buffer, size_t size, size_t nmemb, FILE *stream)
+int my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)
 {
   struct OutStruct *out=(struct OutStruct *)stream;
   if(out && !out->stream) {
@@ -1290,6 +1293,7 @@ struct ProgressData {
   size_t prev;
   size_t point;
   int width;
+  FILE *out; /* where to write everything to */
 };
 
 int myprogress (void *clientp,
@@ -1319,7 +1323,7 @@ int myprogress (void *clientp,
     int prevblock = bar->prev / 1024;
     int thisblock = bar->point / 1024;
     while ( thisblock > prevblock ) {
-      fprintf( stderr, "#" );
+      fprintf( bar->out, "#" );
       prevblock++;
     }
   }
@@ -1335,14 +1339,16 @@ int myprogress (void *clientp,
     line[i] = '\0';
     sprintf( format, "%%-%ds %%5.1f%%%%", barwidth );
     sprintf( outline, format, line, percent );
-    fprintf( stderr, "\r%s", outline );
+    fprintf( bar->out, "\r%s", outline );
   }
   bar->prev = bar->point;
 
   return 0;
 }
 
-void progressbarinit(struct ProgressData *bar)
+static
+void progressbarinit(struct ProgressData *bar,
+                     struct Configurable *config)
 {
 #ifdef __EMX__
   /* 20000318 mgs */
@@ -1376,6 +1382,7 @@ void progressbarinit(struct ProgressData *bar)
   bar->width = scr_size[0] - 1;
 #endif
 
+  bar->out = config->errors;
 }
 
 void free_config_fields(struct Configurable *config)
@@ -1457,7 +1464,7 @@ operate(struct Configurable *config, int argc, char *argv[])
   curl_memdebug("memdump");
 #endif
 
-  main_init(); /* inits winsock crap for windows */
+  main_init(); /* inits */
 
   config->showerror=TRUE;
   config->conf=CONF_DEFAULT;
@@ -1829,7 +1836,7 @@ operate(struct Configurable *config, int argc, char *argv[])
          !(config->conf&(CONF_NOPROGRESS|CONF_MUTE))) {
         /* we want the alternative style, then we have to implement it
            ourselves! */
-        progressbarinit(&progressbar);
+        progressbarinit(&progressbar, config);
         curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, myprogress);
         curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, &progressbar);
       }
@@ -1900,7 +1907,7 @@ operate(struct Configurable *config, int argc, char *argv[])
   /* cleanup the curl handle! */
   curl_easy_cleanup(curl);
 
-  main_free(); /* cleanup the winsock stuff for windows */
+  main_free(); /* cleanup */
 
   return res;
 }

src/version.h

@@ -1,3 +1,3 @@
 #define CURL_NAME "curl"
-#define CURL_VERSION "7.7"
+#define CURL_VERSION "7.8-pre2"
 #define CURL_ID CURL_NAME " " CURL_VERSION " (" OS ") "

src/writeout.c

@@ -141,12 +141,12 @@ void ourWriteOut(CURL *curl, char *writeinfo)
               case VAR_SIZE_UPLOAD:
                 if(CURLE_OK ==
                    curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD, &doubleinfo))
-                  fprintf(stream, "%.3f", doubleinfo);
+                  fprintf(stream, "%.0f", doubleinfo);
                 break;
               case VAR_SIZE_DOWNLOAD:
                 if(CURLE_OK ==
                    curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &doubleinfo))
-                  fprintf(stream, "%.3f", doubleinfo);
+                  fprintf(stream, "%.0f", doubleinfo);
                 break;
               case VAR_SPEED_DOWNLOAD:
                 if(CURLE_OK ==