7.9.2 commit

set.upload to FALSE or else we might still get an upload if the previous
operation was an upload!

CHANGES

@@ -6,6 +6,706 @@
 
                                History of Changes
 
+Version 7.9.2
+
+Daniel (5 December 2001)
+- Jon Travis found out that if you used libcurl and CURLOPT_UPLOAD and then
+  on the same handle used CURLOPT_HTTPGET it would still attempt to upload.
+  His suggested fix was perfect.
+
+Daniel (4 December 2001)
+- Incorporated more macos fixes and added four specific files in a new
+  subdirectory below src.
+
+Daniel (3 December 2001)
+- Eric Lavigne reported two problems:
+
+  First one in the curl_strnequal() function. I think this problem is rather
+  macos 9 specific, as most platform provides a function to use instead of the
+  one provided by libcurl.
+
+  A second, more important, was in the way we take care of FTP responses. The
+  code would read a large chunk of data and search for the end-of-response
+  line within that chunk. When found, it would just skip the rest of the
+  data. However, when the network connections are special, or perhaps the
+  server is, we could actually get more than one response in that chunk of
+  data so that when the next invoke to this function was done, the response
+  had already been read and thrown away. Now, we cache the data not used in
+  one call, as it could be useful in the subsequent call. Test case 126 was
+  added and the test ftp server modified, to exercise this particular case.
+
+Version 7.9.2-pre8
+
+Daniel (2 December 2001)
+- Bug report #487825 correctly identified a problem when using a proxy and
+  following a redirection from HTTP to HTTPS. libcurl then re-used the same
+  proxy connection but without doing a proper HTTPS request.
+
+- Fixed win32 compiling quirks.
+
+Version 7.9.2-pre7
+
+Daniel (30 November 2001)
+- Documented --disable-epsv and CURLOPT_FTP_USE_EPSV.
+
+Daniel (29 November 2001)
+- Added --disable-epsv as an option. When used, curl won't attempt to use the
+  EPSV command when doing passive FTP downloads. Wrote a test case for it.
+
+- Eric provided a few more fixes for building on Macs. He also pointed out
+  a flaw in the signal handler restoration code.
+
+Daniel (28 November 2001)
+- Fiddled with some Tru64 problems reported by Dimitris Sarris. They appeared
+  only when using VERBOSE ftp transfers. Do we use a too small buffer for
+  gethostbyaddr_r(), was the lack of using in_addr_t wrong or is it that the
+  hostent struct must be blanked before use? With Dimitris help and these
+  patches, the problems seem to be history.
+
+- CURLOPT_FTP_USE_EPSV was added and can be set to FALSE to prevent libcurl
+  from using the EPSV command before trying the normal PASV. Heikki Korpela
+  pointed out that some firewalls and similar don't like the EPSV so we must
+  be able to shut if off to work everywhere.
+
+- I added a configure check for 'in_addr_t' and made the ftp code use that to
+  receive the inet_addr() return code in. Works on Solaris and Linux at
+  least. The Linux man page for inet_addr() doesn't even mention in_addr_t...
+
+- Adjusted (almost) all FTP tests to the new command sequence.
+
+- FTP command sequence changes:
+
+  EPSV is now always attempted before PASV. It is the final touch to make IPv6
+  passive FTP downloads to work, but EPSV is not restricted to IPv6 but works
+  fine with IPv4 too on the servers that support it.
+
+  SIZE is now always issued before RETR. It makes curl know the actual
+  download size before the download takes place, as it makes it less important
+  to find the size sent in RETR responses. Many sites don't include the size
+  in there.
+
+  Both these changes made it necessary to change the test suite's ftp server
+  code, and all FTP test cases need to be checked and adjusted!
+
+Daniel (27 November 2001)
+- Hans Steegers pointed out that the telnet code read from stdout, not stdin
+  as it is supposed to do!
+
+Version 7.9.2-pre6
+
+Daniel (27 November 2001)
+- Eric Lavigne's minor changes to build on MacOS before OS X were applied.
+
+- greep at mindspring.com provided a main index.html page for our release
+  archive docs directory. It just links to all the existing HTML files, but
+  I think it may come useful to people.
+
+- There's now some initial code to support the EPSV FTP command. That should
+  be used to do passive transfers IPv6-style. The code is still #if 0'ed in
+  lib/ftp.c as I have no IPv6 ftp server to test this with.
+
+Daniel (26 November 2001)
+- Robert Schlabbach had problems to understand how to do resumed transfers,
+  and I clarified the man page -C section somewhat.
+
+Version 7.9.2-pre5
+
+Daniel (22 November 2001)
+- Andr<64>s Garc<72>a helped me out to track down the roots of bug report #479537,
+  which was concerning curl returning the wrong error code when failing to
+  connect. This didn't happen on all systems, and more specificly I've so far
+  only seen this happen on IPv4-only Linux hosts.
+
+- I applied the fixes for the two bugs Eric Lavigne found when doing his MacOS
+  port. A missing comma in arpa_telnet.h and a pretty wild write in the FTP
+  response reader function. The latter write is however likely to occur in our
+  own buffer unless very big FTP server replies (>25K) are read. I've never
+  seen such a reply ever, so I think this is a relatively minor risk.
+
+Daniel (21 November 2001)
+- Moonesamy provided code to prevent junk from being output when libcurl
+  returns an error code but no error description and that corrects how make is
+  run in the Makefile.dist file (that appears as root Makefile in release
+  archives).
+
+- Eric Lavigne mailed me bugfixes and patches for building libcurl on MacOS
+  (non-X).
+
+- Kevin Roth modified the cygwin files once again, now to build against the
+  shared OpenSSL DLLs.
+
+Version 7.9.2-pre4
+
+Daniel (20 November 2001)
+- Georg Horn brought a patch that introduced CURLINFO_STARTTRANSFER_TIME,
+  complete with man page updates!
+
+Daniel (19 November 2001)
+- Miklos Nemeth provided details enough to update the Borland makefile
+  properly.
+
+- Lars M Gustafsson found a case with a bad free(). In fact, it was so bad I'm
+  amazed we never saw this before!
+
+- Kevin Roth patched the cygwin Makfile.
+
+Daniel (16 November 2001)
+- Klevtsov Vadim fixed a bug in how time-conditionals were sent when doing
+  HTTP.
+
+Version 7.9.2-pre3
+
+Daniel (14 November 2001)
+- Samuel Listopad patched away the problem with SSL we got when someone call
+  curl_global_init() => curl_global_cleanup() => curl_global_init(). The
+  second init would not "take" and SSL would be unusable with curl from that
+  point. This doesn't change the fact that calling the functions that way is
+  wrong. curl_global_init() should be called exactly once and not more.
+
+Daniel (13 November 2001)
+- Fixed some minor variable type mixups in ftp.c that caused compiler warnings
+  on HP-UX 11.00.
+
+- The FTP fix I did yesterday used an uninitialized variable that caused
+  spurious errors when doing FTP.
+
+Version 7.9.2-pre2
+
+Daniel (12 November 2001)
+- Ricardo Cadime fell over a multiple-requests problem when first a FTP
+  directory fetch failed and then a second request is made after that. The
+  second request happened to get the FTP server response back from the
+  previous request, when it did its initial CWD command.
+
+- Bjorn Reese pointed out that we could improve the time diff function to
+  prevent truncation a bit.
+
+- Kai-Uwe Rommel made me aware that -p (http proxy tunnel) silly enough didn't
+  work for plain HTTP requests! So I made that work.
+
+Version 7.9.2-pre1
+
+Daniel (12 November 2001)
+- Rewrote the Curl_ConnectHTTPProxyTunnel(). It should now not only work a lot
+  faster, it should also support such ("broken") proxies that John Lask
+  previously have reported problems with. His proxy sends a trailing zero byte
+  after the end of the (proxy-) headers. I've tested this myself and it seems
+  to work on a proxy the previous version also worked with...! This rewrite is
+  due to the problems John Lask previously experienced.
+
+- Andr<64>s Garc<72>a found out why the "current speed" meter sometimes showed 2048K
+  for very quick transfers. It turned out the "time diff"-function returned a
+  zero millisecond diff. We now always say it is at least one millisecond! In
+  reality, these timers very rarely have that good resolution so even though
+  the time diff was longer than 1 millisecond, it was reported as no diff.
+
+- I also modified the getinfo() again when returning times, as Paul Harrington
+  reports that 7.9.1 only returns times with 1 second accuracy, which indeed
+  is wrong.
+
+Daniel (8 November 2001)
+- Marcus Webster found out that curl_formadd() could read one byte outside a
+  buffer boundary, which then of course could lead to a crash. Marcus also
+  gracefully provided a patch for this this.
+
+- Glen Scott ran configure on his Cobalt Qube and it didn't figure out the
+  correct way of calling gethostbyname_r() and thus failed to resolve hosts.
+  This is two errors: it shouldn't continue the configure script if it finds
+  gethostbyname_r() but can't figure out how to use it, and it should really
+  figure out how to use it as it was running Linux and we know how that
+  works...
+ 
+Daniel (7 November 2001)
+- docs/VERSIONS is a new file in the archive that explains the version number
+  system we use in the curl project.
+
+- Did some more fixes that now makes libcurl only ignore signals as long as
+  it needs to, and then restore (if any) previous signal handler again.
+
+Daniel (6 November 2001)
+- Enrik Berkhan posted bug report #478780, in which he very correctly pointed
+  out two bad timeout matters in libcurl: we didn't restore the sigaction
+  struct (the alarm handler for SIGALRM) nor did we restore the previous
+  alarm() timeout that could've been set by a "parent" process or similar.
+
+- Kevin Roth made the cygwin binary get stripped before install.
+
+Daniel (5 November 2001)
+- Detlef Schmier reported that curl didn't compile using Solaris 8 with the
+  native cc compiler. It was due to a bad function prototype. Fixed now.
+  Unfortunately, I can't enable the -Wstrict-prototypes in my debug builds
+  though, as gcc then complains like crazy on OpenSSL include files... :-(
+
+- John Lask provided SSL over HTTP proxy fixes. They'll need some tweaking
+  to work on all platforms.
+
+- John Lask added the -1/--TLSv1 options that forces SSL into using TLS
+  version 1 when speaking HTTPS.
+
+- John Lask brought a brand new VC++ makefile for the lib directory, that
+  works a lot better than the previous!
+
+- Ramana Mokkapati brought some clever insights on the LDAP failures (bug
+  report #475407), and his suggested changes are now applied.
+
+Version 7.9.1
+
+Daniel (4 November 2001)
+- I've added a number of new test cases the last few days. A few of them since
+  I got reports that hinted on problems on timeouts, so I added four tests
+  with timeouts for all sorts of protocols and stuff. I also came to think of
+  a few other error scenarios that we currently didn't test properly, so I
+  wrote up tests for a few of those too.
+
+Daniel (2 November 2001)
+- Replaced read() and write() with recv() and send() for socket operations
+  even under normal unixes.
+
+Daniel (1 November 2001)
+- When an FTP transfer was aborted due to a timeout, it wasn't really aware of
+  how many bytes that had been transferred and the error text always said 0
+  bytes. I modified this to output the actually transferred amount! :-)
+
+- The FTP fixes in pre7 didn't compile on IPv6 enabled hosts. Does now. I also
+  added more comments in the lib/ftp.c source file.
+
+- Minor updates to the FAQ, added a brand new section to the web site about
+  the name issue (who owns "curl"? will someone sue us? etc etc):
+  http://curl.haxx.se/legal/thename.html
+
+Version 7.9.1-pre7
+
+Daniel (31 October 2001)
+- The curl_easy_getinfo() timers accidentally lost their subsecond accuracy as
+  the calculations used longs instead of doubles! Paul Harrington reported.
+
+- The SSL SocketIsDead() checks weren't good enough (as expected really), so I
+  had to add a generic internal try-it-out system. If the request on a re-used
+  connection seems to fail, then we go back and get a new (fresh) connection
+  and re-tries the request on that instead. It kind of makes the
+  SocketIsDead() check obsolete, but I think it is a quicker way for those
+  cases where it actually discovers that the connection is dead.
+
+- When fixing the above, I noticed that we did quite a few writes to sockets
+  in libcurl where we didn't check the return code (that it actually worked to
+  send the data). With the new "attempted request" system we must detect those
+  situations so I went over a bunch of functions, changed return types and
+  added checks for what they actually return.
+
+Version 7.9.1-pre6
+
+Daniel (31 October 2001)
+- Paul Harrington detected a problem with persistant SSL connections. Or to be
+  more exact, we didn't properly detect that the connection was dead and then
+  a second connection would try to re-use it wrongly. The solution to this
+  problem is still not very clear and I'm working on it. One OpenSSL insider
+  said there is no way to know if the SSL connection is alive or not without
+  actually trying an operation.
+
+Daniel (30 October 2001)
+- If a cookie was read from a file, it could accidentally strdup() a NULL
+  pointer. Paul Harrington reported. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/cookie.c.diff?r1=1.25&r2=1.26]
+
+- The MANUAL file now documents -t correctly. I also fixed the -T description
+  in the curl.1 man page.
+
+Daniel (29 October 2001)
+- John Janssen found out that curl_formadd was missing in the libcurl.def file
+  and that the docs stated the wrong return type for the function.
+
+- Andr<64>s Garc<72>a found a bug with multiple files in the curl_formadd() function,
+  that I removed with this patch [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/formdata.c.diff?r1=1.25&r2=1.26].
+
+- Kevin Roth brought another patch that moved the cygwin package files to the
+  packages/Win32/cygwin directory.
+
+- A bug in the connection re-use logic made repeated requests to the same FTP
+  server (when using name+pasword in the URL) sometimes use more than one
+  connection. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/url.c.diff?r1=1.166&r2=1.167]
+
+- Moonesamy tracked down and fixed a problem with the new 7.9.1 connect
+  code. This corrected the error Kevin Roth reported on the 7.9.1-pre5 release
+  (test 19)...
+  [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/connect.c.diff?r1=1.13&r2=1.14]
+
+Daniel (26 October 2001)
+- Added test28 which verifies that "Location:"-following works even if the
+  contents is separated with more than one space.
+
+Daniel (25 October 2001)
+- Ramana Mokkapati pointed out that LDAP transfers would 'hang' after the
+  correct data has been output.
+
+Version 7.9.1-pre5
+
+Daniel (24 October 2001)
+- T. Bharath found a memory leak in the cookie engine. When we update a cookie
+  that we already knew about, we lost a chunk of memory in the progress... The
+  brand new test case 27 now tests for this occurrence. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/cookie.c.diff?r1=1.24&r2=1.25]
+
+Daniel (23 October 2001)
+- pack_hostent() didn't properly align some pointers, so at least SPARC CPUs
+  would core. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/hostip.c.diff?r1=1.34&r2=1.35]
+
+Daniel (22 October 2001)
+- Tom Benoist reported that this SGI IRIX compiler didn't handle indented
+  preprocessor instructions, so they're no longer in the source code!
+
+- Applied Kevin Roth's patches to make it easier to build cygwin packages from
+  the out-of-the-box curl release archives.
+
+- I forgot to mention it below, but libcurl now closes connections that report
+  transfer failures. Unconditionally. This could be made more nicely in the
+  future if we set a flag or something that the connection is still good to be
+  used for the errors that know that for a fact. We have to close the
+  connection for the cases where we abort for example a HTTP transfer in the
+  middle, or otherwise we might re-use that connection later with lots of data
+  still being sent to us on it. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/transfer.c.diff?r1=1.63&r2=1.64]
+
+Daniel (19 October 2001)
+- CURLE_GOT_NOTHING is now returned when a HTTP server doesn't return
+  anything, not even a header. test case 37 was added to test for this.
+
+- T. Bharath made curl_easy_duphandle() properly clone the cookie status as
+  well.
+
+Version 7.9.1-pre4
+
+Daniel (18 October 2001)
+- CURLOPT_FAILONERROR, set with "curl --fail" no longer returns an error if
+  the HTTP return code is below 400.
+
+Daniel (17 October 2001)
+- The test suite now kills any running test http server when you re-start the
+  tests.
+
+- We had to remove 'use strict' from two perl scripts, as the cygwin
+  adjustments didn't play nicely otherwise for some reason. Any perl wizard
+  out there who can put the scrict back and still make it run good on unix and
+  cygwin?
+
+- A potential memory leak pointed out to us by Yanick Pelletier was removed.
+  It would occur when a http file transfer fails. [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/curl/curl/lib/transfer.c.diff?r1=1.60&r2=1.61]
+
+- The memory debugging system should no longer display anything to stderr
+  if the curl_memdebug() hasn't been used to explicitly say so. This makes it
+  easier to use the memory debug system and switch the logging on/off.
+
+Daniel (16 October 2001)
+- Kevin Roth provided fixes for building curl nicer in cygwin environments.
+
+Daniel (12 October 2001)
+- Cleaning up the progress meter/info code. The "current speed" is now more
+  accurate than before as we now use the true time spent between the measures,
+  and not just "assuming" every-second-update like before. The output should
+  now also be of the same width at all times, never to show "extra" zeroes on
+  the right edge.
+
+- After talking about possible Location: bugs on the mailing list, I modified
+  the "absolute URL" checker in lib/transfer.c to be more strict when checking
+  if the redirected URL is absolute.
+
+Daniel (11 October 2001)
+- Kevin Roth provided patches that make the test suite run fine on Windows
+  2000 running cygwin.
+
+Daniel (10 October 2001)
+- Setting the -c or the CURLOPT_COOKIEJAR option now enables the cookie parser.
+  Previously -b or CURLOPT_COOKIEFILE was also required for the jar to work.
+
+Version 7.9.1-pre3
+
+Daniel (9 October 2001)
+- Added a new option to the command line client: -0/--http1.0. It uses the new
+  libcurl option CURLOPT_HTTP_VERSION to request that libcurl uses HTTP 1.0
+  requests instead of the default version (1.1). It should only be used if you
+  really MUST do that because of a silly remote server.
+
+- Renamed the 'TimeCond' typedef in curl/curl.h to use a 'curl_' prefix as
+  all public curl-symbols should.
+
+- libcurl now explicitly ignores the SIGPIPE signal.
+
+Daniel (8 October 2001)
+- Kevin Roth's change to the cookie-jar comment (in the stored file) was
+  applied.
+
+- Lucas Adamski's minor bug in the bind error code failf() was fixed.
+
+Daniel (5 October 2001)
+- Moonesamy fixed the Curl_connecthost() function to not give compiler errors
+  on a bunch of compilers, due to the argument named 'socket'.
+
+- Moonesamy also provided updated VC++ makefiles and project files.
+
+Version 7.9.1-pre2
+
+Daniel (4 October 2001)
+- Albert Chin provided a configure patch that makes the script detect proper
+  gethostbyname_r() method without actually running any code, only compiling
+  is necessary. This also removes the need of having a resolving 'localhost'
+  name.
+
+- Found and removed memory leakage (name resolve data) in libcurl on
+  IPv6-enabled hosts. These could sneak through because we didn't have any
+  resource tracing on the IPv6-related functions. We do now.
+
+Daniel (3 October 2001)
+- Keith McGuigan patched away a (mainly Windows-) problem with the name
+  resolver data being kept in the static memory area, which is removed when a
+  thread is killed. The curl handle itself though perfectly handles being
+  passed between threads.
+
+- Dirk Eddelbuettel reported an odd bug that turned out to be his proxy that
+  required an Authorization: header. Now, proxies are not supposed to require
+  that header, that is for true servers...
+
+- I accidentally ruined Georg's curl_formadd(). Uh, bad me. Corrected now.
+
+Version 7.9.1-pre1
+
+Daniel (3 October 2001)
+- Georg Huettenegger once again made an effort beyond the call of duty and not
+  only improved the curl_formadd() function, but also took care of adjusting
+  the curl command line client to use this new function instead of the
+  obsoleted curl_formparse.
+
+Daniel (2 October 2001)
+- Major fix in how libcurl does TCP connects. It now does non-blocking
+  connects to enable good timeouts without signals, and it now tries all IP
+  addresses for any given host (if it resolves more than one and the first
+  one(s) don't connect). Added a new source file 'connect.c' to deal with all
+  the TCP connect stuff.
+
+- We now support IPv4-style IP-addresses in rfc2732-format, to better support
+  people writing scripts without knowing what address there is.
+
+Daniel (28 September 2001)
+- Cleanups in the FTP source code. Divided the code into even more smaller
+  functions and generally tried to make the differences between IPv4 and IPv6
+  get less noticable in the sources.
+
+- If the remote file time is not readable/accessable/understood by libcurl,
+  libcurl now returns -1 in the CURLINFO_FILETIME data, not 0 as it previously
+  did. This should make curl not touch the file data unless there was a known
+  remote date when -R is used.
+
+Daniel (27 September 2001)
+- Working on getting non-blocking connects working platform independent. We
+  will also make curl try all IPs for a given host if the first one should
+  fail.
+
+Daniel (26 September 2001)
+- Kevin Roth provided a cookie example that proved the cookie jar
+  functionality wasn't working properly. I added test case 46 and made it
+  work.
+
+Daniel (25 September 2001)
+- J<>rn Hartroth updated the mingw32 makefiles.
+
+Version 7.9
+
+Daniel (23 September 2001)
+- Found and removed a 'socket leak' that would occur on IPv6 enabled hosts
+  when FTP RETR failed.
+
+- Made the FTP upload tests run fine on machines with IPv6 enabled.
+
+Version 7.9-pre8
+
+Daniel (19 September 2001)
+- Vojtech Minarik set up a special-purpose test server and provided me with
+  test certificates in order for me to repeat the bug reports #440068 and
+  #440373. It turned out we didn't check all the error codes properly. We do
+  now, and connecting with a unacceptable certificate will make libcurl fail
+  to connect with an error code returned.
+
+- Ramana Mokkapati found a case when the Location: following code did wrong.
+  I wrote a test case for this (45).
+
+Version 7.9-pre7
+
+Daniel (17 September 2001)
+- Linus Nielsen Feltzing fixed telnet for win32. It makes libcurl require
+  winsock 2.0.
+
+Version 7.9-pre6
+
+- libtool 1.4.2 is now in use!
+
+Version 7.9-pre5
+
+Daniel (14 September 2001)
+- Added another 14 ftp tests.
+
+Daniel (13 September 2001)
+- Added curl_easy_duphandle() to the easy.h header file. It has now been
+  tested and proved to work in a real-world tests by T Bharath. We still need
+  to write up some docs for this function.
+
+- Added four more ftp tests to the test suite.
+
+Daniel (12 September 2001)
+- CURLOPT_SSL_CIPHER_LIST was added, and the curl tool option is named
+  --ciphers. Use them to specify a list of ciphers to use in the SSL
+  connection.
+
+- T. Bharath found a memory leak in libcurl's windows version. It turned out
+  to be the new duphandle() that didn't quite work yet.
+
+Version 7.9-pre4
+
+Daniel (11 September 2001)
+- Added verbose output for SSL connections that output the server
+  certificate's start and expire dates. As suggested by Paul Harrington.
+
+- Heikki Korpela found problems in the perl ftp server used for the test
+  suite, when he runs on on OpenBSD with perl 5.6. Some changes have been
+  made, but nothing really certain.
+
+- T. Bharath has experienced problems with libcurl's stack usage on windows
+  and works on reducing it.
+
+Daniel (10 September 2001)
+- Cris Bailiff fixed the perl interface. It stopped working since the changed
+  behavior with WRITEHEADER and NULL pointers.
+
+- The "output cookies" function could dump core if no cookies were enabled.
+
+Daniel (7 September 2001)
+- SM pointed out that the SSL code didn't compile any longer if SSL was
+  disabled... Also, we needed to correct the #include for the utime stuff on
+  windows.
+
+Daniel (6 September 2001)
+- T. Bharath pointed out a flaw in the SSL session cache code that made it
+  sometimes read from a NULL pointer.
+
+Version 7.9-pre3
+
+Daniel (3 September 2001)
+- Added the -R/--remote-time option, that uses the remote file's datestamp to
+  set the local file's datestamp. Thus, when you get a remote file your local
+  file will get the same time and date. Note that this only works when you use
+  -o or -O.
+
+- Installed libtool 1.4.1, libtoolized and everything.
+
+Daniel (1 September 2001)
+- Heikki Korpela pointed out that I did not ship the proper libtool stuff in 
+  the pre-releases, even though that was my intention. libtoolize has now
+  been re-run.
+
+- Heikki also patched away the bad use of 'make -C' in the test suite
+  makefile. make -C is not very portable and is now banned from here.
+
+Version 7.9-pre2
+
+Daniel (31 August 2001)
+- I just made a huge internal struct rehaul, and all the big internally used
+  structs have been renamed, redesigned and stuff have been moved around a bit
+  to make the source easier to follow, more logically grouped and to hopefully
+  decrease future bugs. I also hope that this will make new functions to get
+  easier to add, and make it less likely that we have bugs left like the URL-
+  free bug from August 23.
+
+Version 7.9-pre1
+
+Daniel (29 August 2001)
+- The new cookie code have enabled the brand new '-c/--cookie-jar' option. Use
+  that to specify the file name in which you want to have all cookies curl
+  knows of, dumped to. It'll be written using the netscape cookie format.
+
+  This is internally done with the new CURLOPT_COOKIEJAR option to libcurl,
+  which in turn dumps this information when curl_easy_cleanup() is invoked.
+  There might be reasons to re-consider my choice of putting it there. Perhaps
+  it is better placed to get done just before *_perform() is done. It is all
+  of course depending on how you guys want to use this feature...
+
+- Added ftpupload.c in the source examples section, based on source code posted
+  by Erick Nuwendam.
+
+Daniel (28 August 2001)
+- Now running libtool CVS branch-1-4 to generate stuff. Should fix problems
+  on OpenBSD and hopefully on FreeBSD as well!
+
+- Georg Huettenegger modified the curl_formadd() functionality slightly, and
+  added support for error code 417 when doing form post and using the Expect:
+  header. Great work!
+
+- Made some tests with cached SSL session IDs, and they seem to work. There
+  should be a significant speed improvement in the SSL connection phase, but
+  in my tiny tests it just isn't possible to notice any difference. Like other
+  caching in libcurl, you must reuse the same handle for the caching to take
+  effect. SSL session ID caching is done on a per host-name and destination
+  port number basis.
+
+  Set verbose, and you'll get informational tests when libcurl detects and
+  uses a previous SSL session ID.
+
+- Upgraded to automake 1.5 on my development/release machine.
+
+Daniel (27 August 2001)
+- Slowly started writing SSL session ID caching code
+
+Daniel (24 August 2001)
+- T. Bharath removed compiler warnings on windows and updated the MS project
+  files.
+
+- Kevin Roth reported two kinds of command line constructs with the new -G that
+  curl didn't really deal with the way one would like.
+
+- Tim Costello patched away a use of strcasecmp() in the SSL code. We have our
+  own portable version named strequal() that should be used!
+
+- Tim also pointed out a problem in the lib/Makefile.vc6 file that made it mix
+  debug object modules causing confusions.
+
+Daniel (23 August 2001)
+- T. Bharath accurately found a libcurl bug that would happen when doing a
+  second invoke of curl_easy_perform() with a new URL when the previous invoke
+  followed a Location: header.
+
+- Started the improvement work on the cookie engine:
+  - Now keeps cookies in the same order as the cookie file
+  - A write to the possibly static string was removed
+  - Added a function that can output all cookies
+  - Now supports reading multiple cookie files
+
+- Steve Lhomme corrected a DLL naming issue in the MSVC++ project file.
+
+- Split up the monster function in lib/ftp.c to use more smallish functions to
+  increase readability and maintainability.
+
+Daniel (21 August 2001)
+- Georg Huettenegger's big patch was applied. Now we have:
+  o "Expect: 100-continue" support. We will from now on send that header in
+    all rfc1867-posts, as that makes us abort much faster when the server
+    rejects our POST. Posting without the Expect: header is still possible in
+    the standard replace-internal-header style.
+  o curl_formadd() is a new formpost building function that is introduced to
+    replace the now deprecated curl_formparse() function. The latter function
+    will still hang around for a while, but the curl_formadd() is the new way
+    and correct way to build form posts.
+  o Documentation has been updated to reflect these changes
+
+  These changes are reason enough to name the next curl release 7.9...
+
+- We now convert man pages to HTML pages and include them in the release
+  archive. For the pleasure of everyone without nroff within reach.
+
+- Andr<64>s Garc<72>a's suggested flushing of the progress meter output stream was
+  added. It should make the progress meter look better on Windows.
+
+- Troy Engel pointed out a mistake in the configure script that made it fail
+  on many Red Hat boxes!
+
+Daniel (20 August 2001)
+- We need an updated libtool to make a better build environment for OpenBSD
+  as well as FreeBSD
+
+Version 7.8.1
+
 Daniel (20 August 2001)
 - Brad pointed out that we ship two extra libtool files in the tarballs that
   we really don't need to! Removing them makes the gz-archive about 60K
@@ -993,7 +1693,7 @@ Version 7.6.1-pre2
 Daniel (31 January 2001)
 - Curl_read() and curl_read() now return a ssize_t for the size, as it had to
   be able to return -1. The telnet support crashed due to this and there was a
-  possibility to weird behaviour all over. Linus Nielsen Feltzing helped me
+  possibility to weird behavior all over. Linus Nielsen Feltzing helped me
   find this.
 
 - Added a configure.in check for a working getaddrinfo() if IPv6 is requested.

CVS-INFO

@@ -10,8 +10,8 @@ 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.
 
-Use autoconf 2.50 and no earlier. Also, try having automake 1.4 and libtool
-1.4 at least.
+Use autoconf 2.50 and no earlier. Also, try having automake 1.5 and libtool
+1.4.1 at least.
 
 You will need perl to generate the src/hugehelp.c file. The file
 src/hugehelp.c.cvs is a one-shot file that you can rename to src/hugehelp.c if

LEGAL

@@ -1,4 +1,4 @@
- Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ Copyright (C) 1998-2001, Daniel Stenberg, <daniel@haxx.se>, et al.
 
  Everyone is permitted to copy and distribute verbatim copies of this license
  document, but changing it is not allowed.

MITX.txt

@@ -10,8 +10,7 @@ in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, and/or sell copies of the
 Software, and to permit persons to whom the Software is furnished to do so,
 provided that the above copyright notice(s) and this permission notice appear
-in all copies of the Software and that both the above copyright notice(s) and
-this permission notice appear in supporting documentation.
+in all copies of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

Makefile.am

@@ -6,18 +6,20 @@ AUTOMAKE_OPTIONS = foreign no-dependencies
 
 EXTRA_DIST =						\
 	CHANGES LEGAL maketgz MITX.txt MPL-1.1.txt	\
-	config-win32.h reconf Makefile.dist		\
-	curl-config.in build_vms.com config-riscos.h	\
-	config-vms.h
+	reconf Makefile.dist curl-config.in build_vms.com curl-mode.el \
+	config-vms.h config-win32.h config-riscos.h config-mac.h
 
 bin_SCRIPTS = curl-config
 
-SUBDIRS = docs lib src include tests packages perl php
+SUBDIRS = docs lib src include tests packages
 
 # create a root makefile in the distribution:
 dist-hook:
 	cp $(srcdir)/Makefile.dist $(distdir)/Makefile
 
+html:
+	cd docs; make html
+
 check: test
 
 test:
@@ -64,3 +66,9 @@ pkgadd:
 	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
+
+#
+# Build a cygwin binary tarball installation file
+# resulting .tar.bz2 file will end up at packages/Win32/cygwin
+cygwinbin:
+	$(MAKE) -C packages/Win32/cygwin cygwinbin

Makefile.dist

@@ -5,7 +5,7 @@
 #                            | (__| |_| |  _ <| |___ 
 #                             \___|\___/|_| \_\_____|
 #
-# Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+# Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
 #
 # In order to be useful for every potential user, curl and libcurl are
 # dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -43,13 +43,13 @@ mingw32-ssl:
 
 vc:
 	cd lib
-	nmake -f Makefile.vc6
+	nmake -f Makefile.vc6 cfg=release
 	cd ..\src
 	nmake -f Makefile.vc6
 
 vc-ssl:
 	cd lib
-	nmake -f Makefile.vc6 release-ssl
+	nmake -f Makefile.vc6 cfg=release-ssl
 	cd ..\src
 	nmake -f Makefile.vc6
 

README

@@ -12,7 +12,7 @@ README
   document.
 
   libcurl is a library that Curl is using to do its job. It is readily
-  available to be used by your software. Read the libcurl.5 man page to
+  available to be used by your software. Read the libcurl.3 man page to
   find out how!
 
   You find answers to the most frequent questions we get in the FAQ document.
@@ -26,6 +26,7 @@ README
   The official download mirror sites are:
 
         Sweden    -- ftp://ftp.sunet.se/pub/www/utilities/curl/
+        Sweden    -- http://cool.haxx.se/curl/
         Germany   -- ftp://ftp.fu-berlin.de/pub/unix/network/curl/
 
   To download the very latest source off the CVS server do this:

acconfig.h

@@ -54,3 +54,13 @@
 
 /* Define if you have a working OpenSSL installation */
 #undef OPENSSL_ENABLED
+
+/* Define the one correct non-blocking socket method below */
+#undef HAVE_FIONBIO
+#undef HAVE_IOCTLSOCKET
+#undef HAVE_IOCTLSOCKET_CASE
+#undef HAVE_O_NONBLOCK
+#undef HAVE_DISABLED_NONBLOCKING
+
+/* Define this to 'int' if in_addr_t is not an available typedefed type */
+#undef in_addr_t

acinclude.m4

@@ -1,3 +1,107 @@
+dnl Check for how to set a socket to non-blocking state. There seems to exist
+dnl four known different ways, with the one used almost everywhere being POSIX
+dnl and XPG3, while the other different ways for different systems (old BSD,
+dnl Windows and Amiga).
+dnl
+dnl There are two known platforms (AIX 3.x and SunOS 4.1.x) where the
+dnl O_NONBLOCK define is found but does not work. This condition is attempted
+dnl to get caught in this script by using an excessive number of #ifdefs...
+dnl
+AC_DEFUN(CURL_CHECK_NONBLOCKING_SOCKET,
+[
+  AC_MSG_CHECKING([non-blocking sockets style])
+
+  AC_TRY_COMPILE([
+/* headers for O_NONBLOCK test */
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+],[
+/* try to compile O_NONBLOCK */
+
+#if defined(sun) || defined(__sun__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# if defined(__SVR4) || defined(__srv4__)
+#  define PLATFORM_SOLARIS
+# else
+#  define PLATFORM_SUNOS4
+# endif
+#endif
+#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX4)
+# define PLATFORM_AIX_V3
+#endif
+
+#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3)
+#error "O_NONBLOCK does not work on this platform"
+#endif
+  int socket;
+  int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
+],[
+dnl the O_NONBLOCK test was fine
+nonblock="O_NONBLOCK"
+AC_DEFINE(HAVE_O_NONBLOCK)
+],[
+dnl the code was bad, try a different program now, test 2
+
+  AC_TRY_COMPILE([
+/* headers for FIONBIO test */
+#include <unistd.h>
+#include <stropts.h>
+],[
+/* FIONBIO source test */
+ int flags = ioctl(socket, FIONBIO, &flags);
+],[
+dnl FIONBIO test was good
+nonblock="FIONBIO"
+AC_DEFINE(HAVE_FIONBIO)
+],[
+dnl FIONBIO test was also bad
+dnl the code was bad, try a different program now, test 3
+
+  AC_TRY_COMPILE([
+/* headers for ioctlsocket test (cygwin?) */
+#include <windows.h>
+],[
+/* ioctlsocket source code */
+ int flags = ioctlsocket(socket, FIONBIO, &flags);
+],[
+dnl ioctlsocket test was good
+nonblock="ioctlsocket"
+AC_DEFINE(HAVE_IOCTLSOCKET)
+],[
+dnl ioctlsocket didnt compile!
+
+  AC_TRY_COMPILE([
+/* headers for IoctlSocket test (Amiga?) */
+#include <sys/ioctl.h>
+],[
+/* IoctlSocket source code */
+ int flags = IoctlSocket(socket, FIONBIO, (long)1);
+],[
+dnl ioctlsocket test was good
+nonblock="IoctlSocket"
+AC_DEFINE(HAVE_IOCTLSOCKET_CASE)
+],[
+dnl ioctlsocket didnt compile!
+nonblock="nada"
+AC_DEFINE(HAVE_DISABLED_NONBLOCKING)
+])
+dnl end of forth test
+
+])
+dnl end of third test
+
+])
+dnl end of second test
+
+])
+dnl end of non-blocking try-compile test
+  AC_MSG_RESULT($nonblock)
+
+  if test "$nonblock" = "nada"; then
+    AC_MSG_WARN([non-block sockets disabled])
+  fi
+])
+
 dnl Check for socklen_t: historically on BSD it is an int, and in
 dnl POSIX 1g it is a type of its own, but some platforms use different
 dnl types for the argument to getsockopt, getpeername, etc.  So we
@@ -39,6 +143,43 @@ AC_DEFUN([TYPE_SOCKLEN_T],
 #include <sys/socket.h>])
 ])
 
+dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
+dnl and a few other things. If not found, we set it to unsigned int, as even
+dnl 64-bit implementations use to set it to a 32-bit type.
+AC_DEFUN([TYPE_IN_ADDR_T],
+[
+   AC_CHECK_TYPE([in_addr_t], ,[
+      AC_MSG_CHECKING([for in_addr_t equivalent])
+      AC_CACHE_VAL([curl_cv_in_addr_t_equiv],
+      [
+         # Systems have either "struct sockaddr *" or
+         # "void *" as the second argument to getpeername
+         curl_cv_in_addr_t_equiv=
+         for t in int size_t unsigned long "unsigned long"; do
+            AC_TRY_COMPILE([
+               #include <sys/types.h>
+               #include <sys/socket.h>
+               #include <arpa/inet.h>
+            ],[
+               $t data = inet_addr ("1.2.3.4");
+            ],[
+               curl_cv_in_addr_t_equiv="$t"
+               break
+            ])
+         done
+
+         if test "x$curl_cv_in_addr_t_equiv" = x; then
+            AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
+         fi
+      ])
+      AC_MSG_RESULT($curl_cv_in_addr_t_equiv)
+      AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
+			[type to use in place of in_addr_t if not defined])],
+      [#include <sys/types.h>
+#include <sys/socket.h>,
+#include <arpa/inet.h>])
+])
+
 dnl ************************************************************
 dnl check for "localhost", if it doesn't exist, we can't do the
 dnl gethostbyname_r tests!
@@ -142,7 +283,6 @@ AC_DEFUN(CURL_CHECK_INET_NTOA_R,
 	AC_DEFINE(NEED_REENTRANT)
 	AC_MSG_RESULT(yes)],
 	AC_MSG_RESULT(no))])])
-
 ])
 
 AC_DEFUN(CURL_CHECK_GETHOSTBYADDR_R,
@@ -220,8 +360,6 @@ rc = gethostbyaddr_r(address, length, type, &h,
 	    ac_cv_gethostbyaddr_args=8],[
 	    AC_MSG_RESULT(no)
 	    have_missing_r_funcs="$have_missing_r_funcs gethostbyaddr_r"])])])])])
-
-
 ])
 
 AC_DEFUN(CURL_CHECK_GETHOSTBYNAME_R,
@@ -229,82 +367,64 @@ AC_DEFUN(CURL_CHECK_GETHOSTBYNAME_R,
   dnl check for number of arguments to gethostbyname_r. it might take
   dnl either 3, 5, or 6 arguments.
   AC_CHECK_FUNCS(gethostbyname_r,[
-    AC_MSG_CHECKING(if gethostbyname_r takes 3 arguments)
-    AC_TRY_RUN([
+    AC_MSG_CHECKING([if gethostbyname_r takes 3 arguments])
+    AC_TRY_COMPILE([
 #include <string.h>
 #include <sys/types.h>
 #include <netdb.h>
+#undef NULL
+#define NULL (void *)0
 
 int
-main () {
-struct hostent h;
-struct hostent_data hdata;
-char *name = "localhost";
-int rc;
-memset(&h, 0, sizeof(struct hostent));
-memset(&hdata, 0, sizeof(struct hostent_data));
-rc = gethostbyname_r(name, &h, &hdata);
-exit (rc != 0 ? 1 : 0); }],[
+gethostbyname_r(const char *, struct hostent *, struct hostent_data *);],[
+gethostbyname_r(NULL, NULL, NULL);],[
       AC_MSG_RESULT(yes)
       AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
       ac_cv_gethostbyname_args=3],[
       AC_MSG_RESULT(no)
-      AC_MSG_CHECKING(if gethostbyname_r with -D_REENTRANT takes 3 arguments)
-      AC_TRY_RUN([
+      AC_MSG_CHECKING([if gethostbyname_r with -D_REENTRANT takes 3 arguments])
+      AC_TRY_COMPILE([
 #define _REENTRANT
 
 #include <string.h>
 #include <sys/types.h>
 #include <netdb.h>
+#undef NULL
+#define NULL (void *)0
 
 int
-main () {
-struct hostent h;
-struct hostent_data hdata;
-char *name = "localhost";
-int rc;
-memset(&h, 0, sizeof(struct hostent));
-memset(&hdata, 0, sizeof(struct hostent_data));
-rc = gethostbyname_r(name, &h, &hdata);
-exit (rc != 0 ? 1 : 0); }],[
+gethostbyname_r(const char *,struct hostent *, struct hostent_data *);],[
+gethostbyname_r(NULL, NULL, NULL);],[
 	AC_MSG_RESULT(yes)
 	AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
 	AC_DEFINE(NEED_REENTRANT)
 	ac_cv_gethostbyname_args=3],[
 	AC_MSG_RESULT(no)
-	AC_MSG_CHECKING(if gethostbyname_r takes 5 arguments)
-	AC_TRY_RUN([
+	AC_MSG_CHECKING([if gethostbyname_r takes 5 arguments])
+	AC_TRY_COMPILE([
 #include <sys/types.h>
 #include <netdb.h>
+#undef NULL
+#define NULL (void *)0
 
-int
-main () {
-struct hostent *hp;
-struct hostent h;
-char *name = "localhost";
-char buffer[8192];
-int h_errno;
-hp = gethostbyname_r(name, &h, buffer, 8192, &h_errno);
-exit (hp == NULL ? 1 : 0); }],[
+struct hostent *
+gethostbyname_r(const char *, struct hostent *, char *, int, int *);],[
+gethostbyname_r(NULL, NULL, NULL, 0, NULL);],[
 	  AC_MSG_RESULT(yes)
 	  AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
           ac_cv_gethostbyname_args=5],[
 	  AC_MSG_RESULT(no)
-	  AC_MSG_CHECKING(if gethostbyname_r takes 6 arguments)
-	  AC_TRY_RUN([
+	  AC_MSG_CHECKING([if gethostbyname_r takes 6 arguments])
+	  AC_TRY_COMPILE([
 #include <sys/types.h>
 #include <netdb.h>
+#undef NULL
+#define NULL (void *)0
 
 int
-main () {
-struct hostent h;
-struct hostent *hp;
-char *name = "localhost";
-char buf[8192];
-int rc;
-int h_errno;
-rc = gethostbyname_r(name, &h, buf, 8192, &hp, &h_errno);
-exit (rc != 0 ? 1 : 0); }],[
+gethostbyname_r(const char *, struct hostent *, char *, size_t,
+struct hostent **, int *);],[
+gethostbyname_r(NULL, NULL, NULL, 0, NULL, NULL);],[
 	    AC_MSG_RESULT(yes)
 	    AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
             ac_cv_gethostbyname_args=6],[

build_vms.com

@@ -1,5 +1,10 @@
 $!
-$	def = "sys_users:[nbaggus.curl]"
+$
+$	on control_y then goto Common_Exit!
+$	orig = f$environment("DEFAULT")
+$	loc  = f$environment("PROCEDURE")
+$	def = f$parse("X.X;1",loc) - "X.X;1"
+$
 $	set def 'def'
 $	cc_qual = "/define=HAVE_CONFIG_H=1/include=(""../include/"",""../"")"
 $	if p1 .eqs. "LISTING" then cc_qual = cc_qual + "/LIST/MACHINE"
@@ -11,11 +16,17 @@ $	call build "[.src]" "*.msg"
 $	link /exe=curl.exe [.src]curl/lib/include=main,[.lib]curl/lib
 $
 $
-$	goto Exit
+$	goto Common_Exit
 $build:	subroutine
 $	set noon
 $	set default 'p1'
 $	search = p2
+$	reset = f$search("reset")
+$	if f$search("CURL.OLB") .eqs. ""
+$	then
+$		LIB/CREATE/OBJECT CURL.OLB
+$	endif
+$	reset = f$search("reset",1)
 $Loop:
 $	file = f$search(search,1)
 $	if file .eqs. "" then goto EndLoop
@@ -51,5 +62,6 @@ $	x = cmd_'typ'
 $	'x' 'file'
 $	ENDSUBROUTINE	! Compile
 $
-$Exit:
+$Common_Exit:
+$	set default 'orig'
 $	exit

buildconf

@@ -5,9 +5,7 @@ die(){
 	exit
 }
 
-MAKEFILES=`find . -name Makefile.am | sed 's/\.am$//'`
-
-automake $MAKEFILES || die "The command 'automake $MAKEFILES' failed"
+automake          || 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-mac.h

@@ -0,0 +1,45 @@
+#define OS "mac"
+
+#define HAVE_NETINET_IN_H	1
+#define HAVE_SYS_SOCKET_H	1
+#define HAVE_SYS_SELECT_H	1
+#define HAVE_NETDB_H		1
+#define HAVE_ARPA_INET_H	1
+#define HAVE_UNISTD_H		1
+#define HAVE_NET_IF_H		1
+#define HAVE_SYS_TYPES_H	1
+#define HAVE_GETTIMEOFDAY	1
+#define HAVE_FCNTL_H		1
+#define HAVE_SYS_STAT_H		1
+#define HAVE_ALLOCA_H		1
+#define HAVE_TIME_H			1
+#define HAVE_STDLIB_H		1
+#define HAVE_UTIME_H		1
+
+#define TIME_WITH_SYS_TIME	1
+
+#define HAVE_STRDUP			1
+#define HAVE_UTIME			1
+#define HAVE_INET_NTOA		1
+#define HAVE_SETVBUF		1
+#define HAVE_STRFTIME		1
+#define HAVE_INET_ADDR		1
+#define HAVE_MEMCPY			1
+#define HAVE_SELECT			1
+#define HAVE_SOCKET			1
+
+//#define HAVE_STRICMP		1
+#define HAVE_SIGACTION		1
+
+#ifdef MACOS_SSL_SUPPORT
+#	define USE_SSLEAY			1
+#	define USE_OPENSSL			1
+#endif
+
+#define HAVE_RAND_STATUS	1
+#define HAVE_RAND_EGD		1
+
+#define HAVE_FIONBIO        1
+
+#include <extra/stricmp.h>
+#include <extra/strdup.h>

config-win32.h

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

config.guess

@@ -3,7 +3,7 @@
 #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
 #   Free Software Foundation, Inc.
 
-timestamp='2001-04-20'
+timestamp='2001-09-04'
 
 # 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
@@ -52,7 +52,7 @@ version="\
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 2000
+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
@@ -95,25 +95,25 @@ trap 'rm -f $dummy.c $dummy.o $dummy.rel $dummy; exit 1' 1 2 15
 # 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
+set_cc_for_build='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
+	  ($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
+	     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
+	  CC_FOR_BUILD=no_compiler_found ;
 	fi
 	;;
  ,,*)   CC_FOR_BUILD=$CC ;;
  ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac
+esac'
 
 # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 8/24/94.)
+# (ghazi@noc.rutgers.edu 1994-08-24)
 if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
 	PATH=$PATH:/.attbin ; export PATH
 fi
@@ -150,6 +150,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# 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)
+		eval $set_cc_for_build
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 			| grep __ELF__ >/dev/null
 		then
@@ -204,6 +205,7 @@ main:
 	jsr \$26,exit
 	.end main
 EOF
+	eval $set_cc_for_build
 	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
 	if test "$?" = 0 ; then
 		case `./$dummy` in
@@ -225,6 +227,9 @@ EOF
 			2-307)
 				UNAME_MACHINE="alphaev67"
 				;;
+			2-1307)
+				UNAME_MACHINE="alphaev68"
+				;;
 		esac
 	fi
 	rm -f $dummy.s $dummy
@@ -328,6 +333,9 @@ EOF
     aushp:SunOS:*:*)
 	echo sparc-auspex-sunos${UNAME_RELEASE}
 	exit 0 ;;
+    sparc*:NetBSD:*)
+	echo `uname -p`-unknown-netbsd${UNAME_RELEASE}
+	exit 0 ;;
     atari*:OpenBSD:*:*)
 	echo m68k-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
@@ -385,6 +393,7 @@ EOF
 	echo clipper-intergraph-clix${UNAME_RELEASE}
 	exit 0 ;;
     mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval $set_cc_for_build
 	sed 's/^	//' << EOF >$dummy.c
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
@@ -475,6 +484,7 @@ EOF
 	exit 0 ;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval $set_cc_for_build
 		sed 's/^		//' << EOF >$dummy.c
 		#include <sys/systemcfg.h>
 
@@ -553,6 +563,7 @@ EOF
                   fi ;;
               esac
               if [ "${HP_ARCH}" = "" ]; then
+	      eval $set_cc_for_build
               sed 's/^              //' << EOF >$dummy.c
 
               #define _HPUX_SOURCE
@@ -598,6 +609,7 @@ EOF
 	echo ia64-hp-hpux${HPUX_REV}
 	exit 0 ;;
     3050*:HI-UX:*:*)
+	eval $set_cc_for_build
 	sed 's/^	//' << EOF >$dummy.c
 	#include <unistd.h>
 	int
@@ -633,7 +645,7 @@ EOF
     9000/8??:4.3bsd:*:*)
 	echo hppa1.0-hp-bsd
 	exit 0 ;;
-    *9??*:MPE/iX:*:*)
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
 	echo hppa1.0-hp-mpeix
 	exit 0 ;;
     hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
@@ -677,12 +689,13 @@ EOF
 	echo xmp-cray-unicos
         exit 0 ;;
     CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos${UNAME_RELEASE}
+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
     CRAY*[A-Z]90:*:*:*)
 	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
     CRAY*TS:*:*:*)
 	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
@@ -763,97 +776,29 @@ EOF
 	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
+	case `sed -n '/^byte/s/^.*: \(.*\) endian/\1/p' < /proc/cpuinfo` in
+	  big)    echo mips-unknown-linux-gnu && exit 0 ;;
+	  little) echo mipsel-unknown-linux-gnu && exit 0 ;;
+	esac
 	;;
     ppc:Linux:*:*)
-	# Determine Lib Version
-	cat >$dummy.c <<EOF
-#include <features.h>
-#if defined(__GLIBC__)
-extern char __libc_version[];
-extern char __libc_release[];
-#endif
-main(argc, argv)
-     int argc;
-     char *argv[];
-{
-#if defined(__GLIBC__)
-  printf("%s %s\n", __libc_version, __libc_release);
-#else
-  printf("unknown\n");
-#endif
-  return 0;
-}
-EOF
-	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}
+	echo powerpc-unknown-linux-gnu
+	exit 0 ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-gnu
 	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" ;;
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
         esac
-		objdump --private-headers $dummy | \
-		  grep ld.so.1 > /dev/null
-		if test "$?" = 0 ; then
-			LIBC="libc1"
-		fi
-	fi
-	rm -f $dummy.s $dummy
+	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
 	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
 	exit 0 ;;
     parisc:Linux:*:* | hppa:Linux:*:*)
@@ -883,40 +828,30 @@ EOF
 	# 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
+	ld_supported_targets=`cd /; ld --help 2>&1 \
+			 | sed -ne '/supported targets:/!d
 				    s/[ 	][ 	]*/ /g
-				    s/.*supported emulations: *//
+				    s/.*supported targets: *//
 				    s/ .*//
 				    p'`
-        case "$ld_supported_emulations" in
-	  i*86linux)
-		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
-		exit 0
-		;;
-	  elf_i*86)
+        case "$ld_supported_targets" in
+	  elf32-i386)
 		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
 		;;
-	  i*86coff)
+	  a.out-i386-linux)
+		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+		exit 0 ;;		
+	  coff-i386)
 		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
-		exit 0
-		;;
-	esac
-	# 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;
-	  ;;
+		exit 0 ;;
+	  "")
+		# Either a pre-BFD a.out linker (linux-gnuoldld) or
+		# one that does not give us useful --help.
+		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
+		exit 0 ;;
 	esac
 	# Determine whether the default compiler is a.out or elf
+	eval $set_cc_for_build
 	cat >$dummy.c <<EOF
 #include <features.h>
 #ifdef __cplusplus
@@ -928,15 +863,15 @@ EOF
 #ifdef __ELF__
 # ifdef __GLIBC__
 #  if __GLIBC__ >= 2
-    printf ("%s-${VENDOR}-linux-gnu\n", argv[1]);
+    printf ("%s-pc-linux-gnu\n", argv[1]);
 #  else
-    printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+    printf ("%s-pc-linux-gnulibc1\n", argv[1]);
 #  endif
 # else
-   printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+   printf ("%s-pc-linux-gnulibc1\n", argv[1]);
 # endif
 #else
-  printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]);
+  printf ("%s-pc-linux-gnuaout\n", argv[1]);
 #endif
   return 0;
 }
@@ -945,9 +880,10 @@ EOF
 	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*:*)
+	# 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.
 	echo i386-sequent-sysv4
 	exit 0 ;;
     i*86:UNIX_SV:4.2MP:2.*)
@@ -966,14 +902,13 @@ EOF
 		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
 	fi
 	exit 0 ;;
-    i*86:*:5:7*)
-        # Fixed at (any) Pentium or better
-        UNAME_MACHINE=i586
-        if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
-	    echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
-	else
-	    echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
-	fi
+    i*86:*:5:[78]*)
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
 	exit 0 ;;
     i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
@@ -1067,7 +1002,7 @@ EOF
 		echo ns32k-sni-sysv
 	fi
 	exit 0 ;;
-    PENTIUM:CPunix:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
                       # says <Richard.M.Bartel@ccMail.Census.GOV>
         echo i586-unisys-sysv4
         exit 0 ;;
@@ -1080,6 +1015,10 @@ EOF
 	# From seanf@swdc.stratus.com.
 	echo i860-stratus-sysv4
 	exit 0 ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit 0 ;;
     mc68*:A/UX:*:*)
 	echo m68k-apple-aux${UNAME_RELEASE}
 	exit 0 ;;
@@ -1172,11 +1111,18 @@ EOF
     *:ITS:*:*)
 	echo pdp10-unknown-its
 	exit 0 ;;
+    i*86:XTS-300:*:STOP)
+	echo ${UNAME_MACHINE}-unknown-stop
+	exit 0 ;;
+    i*86:atheos:*:*)
+	echo ${UNAME_MACHINE}-unknown-atheos
+	exit 0 ;;
 esac
 
 #echo '(No uname command or uname output not recognized.)' 1>&2
 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
 
+eval $set_cc_for_build
 cat >$dummy.c <<EOF
 #ifdef _SEQUENT_
 # include <sys/types.h>

config.sub

@@ -3,7 +3,7 @@
 #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
 #   Free Software Foundation, Inc.
 
-timestamp='2001-04-20'
+timestamp='2001-09-07'
 
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
@@ -117,7 +117,7 @@ esac
 # 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* | storm-chaos* | os2-emx*)
+  nto-qnx* | linux-gnu* | storm-chaos* | os2-emx* | windows32-*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
@@ -157,6 +157,14 @@ case $os in
 		os=-vxworks
 		basic_machine=$1
 		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+ 	-chorusrdb)
+ 		os=-chorusrdb
+		basic_machine=$1
+ 		;;
 	-hiux*)
 		os=-hiuxwe2
 		;;
@@ -215,26 +223,36 @@ 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] | arm[bl]e | armv[2345] | armv[345][lb] | strongarm | xscale \
-		| pyramid | mn10200 | mn10300 | tron | a29k \
-		| 580 | i960 | h8300 \
-		| 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 | sh[34] \
-		| powerpc | powerpcle \
-		| 1750a | dsp16xx | pdp10 | pdp11 \
-		| mips16 | mips64 | mipsel | mips64el \
-		| mips64orion | mips64orionel | mipstx39 | mipstx39el \
-		| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
-		| mips64vr5000 | miprs64vr5000el | mcore | s390 | s390x \
-		| sparc | sparclet | sparclite | sparc64 | sparcv9 | sparcv9b \
-		| v850 | c4x \
-		| thumb | d10v | d30v | fr30 | avr | openrisc | tic80 \
-		| pj | pjl | h8500)
+	1750a | 580 \
+	| a29k \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+	| c4x | clipper \
+	| d10v | d30v | dsp16xx \
+	| fr30 \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| i370 | i860 | i960 | ia64 \
+	| m32r | m68000 | m68k | m88k | mcore \
+	| mips16 | mips64 | mips64el | mips64orion | mips64orionel \
+	| mips64vr4100 | mips64vr4100el | mips64vr4300 \
+	| mips64vr4300el | mips64vr5000 | mips64vr5000el \
+	| mipsbe | mipseb | mipsel | mipsle | mipstx39 | mipstx39el \
+	| mipsisa32 \
+	| mn10200 | mn10300 \
+	| ns16k | ns32k \
+	| openrisc \
+	| pdp10 | pdp11 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+	| pyramid \
+	| s390 | s390x \
+	| sh | sh[34] | sh[34]eb | shbe | shle \
+	| sparc | sparc64 | sparclet | sparclite | sparcv9 | sparcv9b \
+	| stormy16 | strongarm \
+	| tahoe | thumb | tic80 | tron \
+	| v850 \
+	| we32k \
+	| x86 | xscale \
+	| z8k)
 		basic_machine=$basic_machine-unknown
 		;;
 	m6811 | m68hc11 | m6812 | m68hc12)
@@ -242,7 +260,7 @@ case $basic_machine in
 		basic_machine=$basic_machine-unknown
 		os=-none
 		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | w65)
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
 		;;
 
 	# We use `pc' rather than `unknown'
@@ -257,31 +275,43 @@ case $basic_machine in
 		exit 1
 		;;
 	# Recognize the basic CPU types with company name.
-	# FIXME: clean up the formatting here.
-	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-* \
-	      | 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-* | pdp10-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
-	      | sparc64-* | sparcv9-* | sparcv9b-* | sparc86x-* \
-	      | mips16-* | mips64-* | mipsel-* \
-	      | mips64el-* | mips64orion-* | mips64orionel-* \
-	      | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
-	      | mipstx39-* | mipstx39el-* | mcore-* \
-	      | f30[01]-* | f700-* | s390-* | s390x-* | sv1-* | t3e-* \
-	      | [cjt]90-* \
-	      | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
-	      | thumb-* | v850-* | d30v-* | tic30-* | tic80-* | c30-* | fr30-* \
-	      | bs2000-* | tic54x-* | c54x-* | x86_64-* | pj-* | pjl-*)
+	580-* \
+	| a29k-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alphapca5[67]-* | arc-* \
+	| arm-*  | armbe-* | armle-* | armv*-* \
+	| bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c54x-* \
+	| clipper-* | cray2-* | cydra-* \
+	| d10v-* | d30v-* \
+	| elxsi-* \
+	| f30[01]-* | f700-* | fr30-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| i*86-* | i860-* | i960-* | ia64-* \
+	| m32r-* \
+	| m68000-* | m680[01234]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | mcore-* \
+	| mips-* | mips16-* | mips64-* | mips64el-* | mips64orion-* \
+	| mips64orionel-* | mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* | mipsbe-* | mipseb-* \
+	| mipsle-* | mipsel-* | mipstx39-* | mipstx39el-* \
+	| none-* | np1-* | ns16k-* | ns32k-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+	| pyramid-* \
+	| romp-* | rs6000-* \
+	| s390-* | s390x-* \
+	| sh-* | sh[34]-* | sh[34]eb-* | shbe-* | shle-* \
+	| sparc-* | sparc64-* | sparc86x-* | sparclite-* \
+	| sparcv9-* | sparcv9b-* | stormy16-* | strongarm-* | sv1-* \
+	| t3e-* | tahoe-* | thumb-* | tic30-* | tic54x-* | tic80-* | tron-* \
+	| v850-* | vax-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xmp-* | xps100-* | xscale-* \
+	| ymp-* \
+	| z8k-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -727,6 +757,16 @@ case $basic_machine in
 	ppcle-* | powerpclittle-*)
 		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
+	ppc64)	basic_machine=powerpc64-unknown
+	        ;;
+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+		basic_machine=powerpc64le-unknown
+	        ;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
 	ps2)
 		basic_machine=i386-ibm
 		;;
@@ -881,6 +921,10 @@ case $basic_machine in
 		basic_machine=hppa1.1-winbond
 		os=-proelf
 		;;
+	windows32)
+		basic_machine=i386-pc
+		os=-windows32-msvcrt
+		;;
 	xmp)
 		basic_machine=xmp-cray
 		os=-unicos
@@ -934,7 +978,7 @@ case $basic_machine in
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sh3 | sh4)
+	sh3 | sh4 | sh3eb | sh4eb)
 		basic_machine=sh-unknown
 		;;
 	sparc | sparcv9 | sparcv9b)
@@ -1018,11 +1062,13 @@ case $os in
 	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
 	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -chorusos* | -chorusrdb* \
 	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
 	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
 	      | -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
 	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* | -os2*)
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
 	-qnx*)
@@ -1346,6 +1392,9 @@ case $basic_machine in
 			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
 				vendor=atari
 				;;
+			-vos*)
+				vendor=stratus
+				;;
 		esac
 		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
 		;;

configure.in

@@ -1,9 +1,16 @@
 dnl $Id$
 dnl Process this file with autoconf to produce a configure script.
+
+dnl Ensure that this file is processed with autoconf 2.50 or newer
+dnl Don't even think about removing this check!
+AC_PREREQ(2.50)
+
+dnl First some basic init macros
 AC_INIT
 AC_CONFIG_SRCDIR([lib/urldata.h])
 AM_CONFIG_HEADER(config.h src/config.h)
 
+dnl figure out the libcurl version
 VERSION=`sed -ne 's/^#define LIBCURL_VERSION "\(.*\)"/\1/p' ${srcdir}/include/curl/curl.h`
 AM_INIT_AUTOMAKE(curl,$VERSION)
 
@@ -38,6 +45,10 @@ AC_PROG_CC
 dnl check for how to do large files
 AC_SYS_LARGEFILE
 
+dnl check for cygwin stuff
+AC_LIBTOOL_WIN32_DLL
+
+dnl libtool setup
 AM_PROG_LIBTOOL
 
 dnl The install stuff has already been taken care of by the automake stuff
@@ -158,6 +169,24 @@ AC_CHECK_FUNC(gethostname, , AC_CHECK_LIB(ucb, gethostname))
 dnl dl lib?
 AC_CHECK_FUNC(dlclose, , AC_CHECK_LIB(dl, dlopen))
 
+dnl **********************************************************************
+dnl Check how non-blocking sockets are set
+dnl **********************************************************************
+AC_ARG_ENABLE(nonblocking,
+[  --enable-nonblocking  Makes the script detect how to do it
+  --disable-nonblocking Makes the script disable non-blocking sockets],
+[
+  if test "$enableval" = "no" ; then
+    AC_MSG_WARN([non-blocking sockets disabled])
+    AC_DEFINE(HAVE_DISABLED_NONBLOCKING)
+  else
+    CURL_CHECK_NONBLOCKING_SOCKET
+  fi
+],
+[
+  CURL_CHECK_NONBLOCKING_SOCKET
+])
+
 dnl **********************************************************************
 dnl Check for the random seed preferences 
 dnl **********************************************************************
@@ -305,6 +334,8 @@ else
   case "$OPT_SSL" in
   yes)
     EXTRA_SSL=/usr/local/ssl ;;
+  off)
+    EXTRA_SSL= ;;
   *)
     dnl check the given spot right away!
     EXTRA_SSL=$OPT_SSL
@@ -426,9 +457,6 @@ then
 Set to explicitly specify we don't want to use thread-safe functions)
 else
 
-  dnl check that 'localhost' resolves first
-  CURL_CHECK_WORKING_RESOLVER
-
   dnl dig around for gethostbyname_r()
   CURL_CHECK_GETHOSTBYNAME_R()
 
@@ -464,7 +492,6 @@ AC_CHECK_HEADERS( \
         sys/stat.h \
         sys/types.h \
         sys/time.h \
-        getopt.h \
         sys/param.h \
         termios.h \
         termio.h \
@@ -475,7 +502,9 @@ AC_CHECK_HEADERS( \
         winsock.h \
         time.h \
         io.h \
-        pwd.h
+        pwd.h \
+        utime.h \
+        sys/utime.h
 )
 
 dnl Check for libz header
@@ -497,6 +526,7 @@ AC_CHECK_SIZEOF(long long, 4)
 AC_CHECK_TYPE(ssize_t, int)
 
 TYPE_SOCKLEN_T
+TYPE_IN_ADDR_T
 
 dnl Checks for library functions.
 dnl AC_PROG_GCC_TRADITIONAL
@@ -514,7 +544,6 @@ AC_CHECK_FUNCS( socket \
                 strcmpi \
                 gethostname \
                 gethostbyaddr \
-                getservbyname \
                 gettimeofday \
                 inet_addr \
                 inet_ntoa \
@@ -529,7 +558,8 @@ AC_CHECK_FUNCS( socket \
                 strlcat \
                 getpwuid \
                 geteuid \
-                dlopen
+                dlopen \
+                utime
 )
 
 dnl removed 'getpass' check on October 26, 2000
@@ -566,15 +596,12 @@ AC_CONFIG_FILES([Makefile \
            tests/data/Makefile \
 	   packages/Makefile \
 	   packages/Win32/Makefile \
+	   packages/Win32/cygwin/Makefile \
 	   packages/Linux/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 \
            curl-config
 ])
 AC_OUTPUT

curl-mode.el

@@ -0,0 +1,21 @@
+;;;; Emacs Lisp help for writing curl code. ;;;;
+
+;;; In C files, put something like this to load this file automatically:
+;;
+;;   /* -----------------------------------------------------------------
+;;    * local variables:
+;;    * eval: (load-file "../curl-mode.el")
+;;    * end:
+;;    */
+;;
+;; (note: make sure to get the path right in the argument to load-file).
+
+
+;;; The curl hacker's C conventions
+
+;;; we use intent-level 2
+(setq c-basic-offset 2)
+;;; never ever use tabs to indent!
+(setq indent-tabs-mode nil)
+;;; I like this, stolen from Subversion! ;-)
+(setq angry-mob-with-torches-and-pitchforks t)

docs/BUGS

@@ -1,3 +1,4 @@
+$Id$
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -35,23 +36,24 @@ BUGS
   The address and how to subscribe to the mailing list is detailed in the
   MANUAL file.
 
-  HOW TO GET A STACK TRACE with a common unix debugger
-  ====================================================
+  How To Get A Stack Trace
+  ========================
 
   First, you must make sure that you compile all sources with -g and that you
-  don't 'strip' the final executable.
+  don't 'strip' the final executable. Try to avoid optimizing the code as
+  well, remove -O, -O2 etc from the compiler options.
 
-  Run the program until it bangs.
+  Run the program until it dumps core.
 
   Run your debugger on the core file, like '<debugger> curl core'. <debugger>
   should be replaced with the name of your debugger, in most cases that will
   be 'gdb', but 'dbx' and others also occur.
 
   When the debugger has finished loading the core file and presents you a
-  prompt, you can give the compiler instructions. Enter 'where' (without the
-  quotes) and press return.
+  prompt, enter 'where' (without the quotes) and press return.
 
   The list that is presented is the stack trace. If everything worked, it is
   supposed to contain the chain of functions that were called when curl
-  crashed.
+  crashed. Include the stack trace with your detailed bug report. It'll help a
+  lot.
 

docs/CONTRIBUTE

@@ -10,6 +10,12 @@ To Think About When Contributing Source Code
  in mind when you decide to write a contribution to the project. This concerns
  new features as well as corrections to existing flaws or bugs.
 
+Join the Community
+
+ Skip over to http://curl.haxx.se/mail/ and join the appropriate mailing
+ list(s).  Read up on details before you post questions. Read this file before
+ you start sending patches!
+
 The License Issue
 
  When contributing with code, you agree to put your changes and new code under
@@ -21,6 +27,12 @@ The License Issue
  GPL (as we don't want the GPL virus to attack users of libcurl) but they must
  use "GPL compatible" licenses.
 
+What To Read
+
+ Source code, the man pages, the INTERALS document, the TODO, the most recent
+ CHANGES. Just lurking on the libcurl mailing list is gonna give you a lot of
+ insights on what's going on right now.
+
 Naming
 
  Try using a non-confusing naming scheme for your new functions and variable
@@ -87,7 +99,9 @@ Write Access to CVS Repository
  If you are a frequent contributor, or have another good reason, you can of
  course get write access to the CVS repository and then you'll be able to
  check-in all your changes straight into the CVS tree instead of sending all
- changes by mail as patches. Just ask if this is what you'd want.
+ changes by mail as patches. Just ask if this is what you'd want. You will be
+ required to have posted a few quality patches first, before you can be
+ granted write access.
 
 Test Cases
 

docs/FAQ

@@ -1,4 +1,4 @@
-Updated: August 7, 2001 (http://curl.haxx.se/docs/faq.shtml)
+Updated: November 27, 2001 (http://curl.haxx.se/docs/faq.shtml)
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -36,6 +36,7 @@ FAQ
   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?
+  3.12 Why do FTP specific features over HTTP proxy fail?
 
  4. Running Problems
   4.1 Problems connecting to SSL servers.
@@ -81,7 +82,7 @@ FAQ
   fact it can also be pronounced 'see URL' also helped.
 
   Curl supports a range of common Internet protocols, currently including
-  HTTP, HTTPS, FTP, GOPHER, LDAP, DICT, TELNET and FILE.
+  HTTP, HTTPS, FTP, FTPS, GOPHER, LDAP, DICT, TELNET and FILE.
 
   We spell it cURL or just curl. We pronounce it with an initial k sound:
   [kurl].
@@ -96,10 +97,9 @@ FAQ
 
   1.3 What is cURL not?
   
-  Curl is *not*, I repeat, *not* a wget clone even though that is a very
-  common misconception. Never, during curl's development, have I intended curl
-  to replace wget or compete on its market. Curl is targeted at single-shot
-  file transfers.
+  Curl is *not* a wget clone even though that is a very common misconception.
+  Never, during curl's development, have we intended curl to replace wget or
+  compete on its market. Curl is targeted at single-shot file transfers.
 
   Curl is not a web site mirroring program. If you wanna use curl to mirror
   something: fine, go ahead and write a script that wraps around curl to make
@@ -134,7 +134,7 @@ FAQ
 
   * We focus on protocol related issues and improvements. If you wanna do more
     magic with the supported protocols than curl currently does, chances are
-    big I will agree. If you wanna add more protocols, I may very well
+    big we will agree. If you wanna add more protocols, we may very well
     agree.
 
   * If you want someone else to make all the work while you wait for us to
@@ -154,9 +154,9 @@ FAQ
   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.
+  The list of contributors in the docs/THANKS file 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.
 
@@ -171,9 +171,11 @@ FAQ
   sourceforge.net hosts several project tools we take advantage from like the
   bug tracker, mailing lists and more.
 
-  If you feel you want to show support our project with a donation, a very
-  nice way of doing that would be to buy "gift certificates" at useful online
-  shopping sites, such as amazon.com or thinkgeek.com.
+  If you want to support our project with a donation or similar, one way of
+  doing that would be to buy "gift certificates" at useful online shopping
+  sites, such as amazon.com or thinkgeek.com. Another way would be to sponsor
+  us through a banner-program or by simply helping us coding, documenting,
+  testing etc.
 
   1.7 What about CURL from curl.com?
 
@@ -375,6 +377,18 @@ FAQ
 
         curl -d "datatopost" -H "Content-Type: text/xml" [URL]
 
+  3.12 Why do FTP specific features over HTTP proxy fail?
+
+  Because when you use a HTTP proxy, the protocol spoken on the network will
+  be HTTP, even if you specify a FTP URL. This effectively means that you
+  normally can't use FTP specific features such as ftp upload and ftp quote
+  etc.
+
+  There is one exception to this rule, and that is if you can "tunnel through"
+  the given HTTP proxy. Proxy tunneling is enabled with a special option (-p)
+  and is generally not available as proxy admins usuable disable tunneling to
+  other ports than 443 (which is used for HTTPS access through proxies).
+
 4. Running Problems
 
   4.1. Problems connecting to SSL servers.
@@ -467,9 +481,9 @@ FAQ
   4.6. Can you tell me what error code 142 means?
 
   All error codes that are larger than the highest documented error code means
-  that curl has existed due to a timeout. There was no nice way for curl to
-  abort from such a condition and that's why it got this undocumented
-  error. This should not occur in releases after 7.4.1.
+  that curl has exited due to a crash. This is a serious error, and we
+  appreciate a detailed bug report from you that describes how we could go
+  ahead and repeat this!
 
   4.7. How do I keep user names and passwords secret in Curl command lines?
 
@@ -573,13 +587,7 @@ FAQ
 
   5.4 Does libcurl do Winsock initialization on win32 systems?
 
-  No.
-
-  On win32 systems, you need to init the winsock stuff manually, libcurl will
-  not do that for you. WSAStartup() and WSACleanup() should be used
-  accordingly. The reason for this is of course that a single application may
-  use several different libraries and parts, and there's no reason for every
-  single library to do this.
+  Yes (since 7.8.1) if told to in the curl_global_init() call.
 
   5.5 Does CURLOPT_FILE and CURLOPT_INFILE work on win32 ?
 

docs/FEATURES

@@ -56,7 +56,7 @@ FTP
  - download
  - authentication
  - kerberos security
- - PORT or PASV
+ - active/passive using PORT, EPRT, PASV or EPSV
  - single file size information (compare to HTTP HEAD)
  - 'type=' URL support
  - dir listing

docs/INSTALL

@@ -8,9 +8,12 @@
 
 Curl has been compiled and built on numerous different operating systems.
 
-If you're using Windows (95/98/NT/ME/2000 or whatever), VMS, RISC OS or OS/2,
-you should continue reading from one the paragraphs further down. All other
-systems should be capable of being installed as described below.
+Most systems build curl the same way (unix-style). Continue reading below for
+more details if you're one of them.
+
+If you're using Windows (95/98/NT/ME/2000/XP or similar), VMS, RISC OS or OS/2
+or cross-compile, you should continue reading from one the paragraphs further
+down.
 
 UNIX
 ====
@@ -33,8 +36,7 @@ UNIX
    The configure script always tries to find a working SSL library unless
    explicitly told not to. If you have OpenSSL installed in the default search
    path for your compiler/linker, you don't need to do anything special. If
-   you have OpenSSL installed in e.g /usr/local/ssl, you can run configure
-   like:
+   you have OpenSSL installed in /usr/local/ssl, you can run configure like:
 
 	./configure --with-ssl
 
@@ -43,13 +45,13 @@ UNIX
 
 	./configure --with-ssl=/opt/OpenSSL
 
-   If you insist on forcing a build *without* SSL support, even though you may
-   have it installed in your system, you can run configure like this:
+   If you insist on forcing a build without SSL support, even though you may
+   have OpenSSL installed in your system, you can run configure like this:
 
         ./configure --without-ssl
 
    If you have OpenSSL installed, but with the libraries in one place and the
-   header files somewhere else, you'll have to set the LDFLAGS and CPPFLAGS
+   header files somewhere else, you have to set the LDFLAGS and CPPFLAGS
    environment variables prior to running configure.  Something like this
    should work:
 
@@ -69,7 +71,7 @@ UNIX
      LIBS=-lRSAglue -lrsaref
      (as suggested by Doug Kaufman)
 
-   KNOWN PROBLEMS
+   KNOWN PROBLEMS (these ones should not happen anymore)
 
      If you happen to have autoconf installed, but a version older than 2.12
      you will get into trouble. Then you can still build curl by issuing these
@@ -98,8 +100,8 @@ UNIX
 
    MORE OPTIONS
 
-     Remember, to force configure to use the standard cc compiler if both
-     cc and gcc are present, run configure like
+     To force configure to use the standard cc compiler if both cc and gcc are
+     present, run configure like
 
        CC=cc ./configure
          or
@@ -127,11 +129,6 @@ UNIX
 
        ./configure --with-krb4=/usr/athena
 
-     If your system support shared libraries, but you want to built a static
-     version only, you can disable building the shared version by using:
-
-       ./configure --disable-shared
-
      If you're a curl developer and use gcc, you might want to enable more
      debug options with the --enable-debug option.
 
@@ -174,9 +171,9 @@ Win32
         Make the sources in the src/ drawer be a "win32 console application"
         project. Name it curl.
 
-        With VC++, add 'wsock32.lib' to the link libs when you build curl!
-        Borland seems to do that itself magically. Of course you have to
-        make sure it links with the libcurl too!
+        With VC++, add 'ws2_32.lib' to the link libs when you build curl!
+        Borland seems to do that itself magically. Of course you have to make
+        sure it links with the libcurl too!
 
         For VC++ 6, there's an included Makefile.vc6 that should be possible
         to use out-of-the-box.
@@ -325,13 +322,50 @@ VMS
    13-jul-2001
    N. Baggus
 
+CROSS COMPILE
+=============
+
+   (This section was graciously brought to us by Jim Duey, 23-oct-2001)
+
+   Download and unpack the cURL package.  Version should be 7.9.1 or later.
+
+   'cd' to the new directory. (ie. curl-7.9.1-pre4)
+
+   Set environment variables to point to the cross-compile toolchain and call
+   configure with any options you need.  Be sure and specify the '--host' and
+   '--build' parameters at configuration time.  The following script is an
+   example of cross-compiling for the IBM 405GP PowerPC processor using the
+   toolchain from MonteVista for Hardhat Linux.
+
+   (begin script)
+
+   #! /bin/sh
+
+   export PATH=$PATH:/opt/hardhat/devkit/ppc/405/bin
+   export CPPFLAGS="-I/opt/hardhat/devkit/ppc/405/target/usr/include"
+   export AR=ppc_405-ar
+   export AS=ppc_405-as
+   export LD=ppc_405-ld
+   export RANLIB=ppc_405-ranlib
+   export CC=ppc_405-gcc
+   export NM=ppc_405-nm
+
+   configure --target=powerpc-hardhat-linux \
+	--host=powerpc-hardhat-linux \
+	--build=i586-pc-linux-gnu \
+	--prefix=/opt/hardhat/devkit/ppc/405/target/usr/local \
+	--exec-prefix=/usr/local
+
+   (end script)
+
+   The '--prefix' parameter specifies where cURL will be installed.  If
+   'configure' completes successfully, do 'make' and 'make install' as usual.
+
 PORTS
 =====
    This is a probably incomplete list of known hardware and operating systems
    that curl has been compiled for:
 
-        - Ultrix 4.3a
-        - SINIX-Z v5
         - Alpha DEC OSF 4
         - Alpha Digital UNIX v3.2
         - Alpha FreeBSD 4.1
@@ -339,14 +373,22 @@ PORTS
         - Alpha OpenVMS V7.1-1H2
         - Alpha Tru64 v5.0 5.1
         - HP-PA HP-UX 9.X 10.X 11.X
+        - HP-PA Linux
         - MIPS IRIX 6.2, 6.5
+        - MIPS Linux
         - Power AIX 4.2, 4.3.1, 4.3.2
         - PowerPC Darwin 1.0
         - PowerPC Linux
+        - PowerPC Mac OS 9
         - PowerPC Mac OS X
+        - SINIX-Z v5
         - Sparc Linux
         - Sparc Solaris 2.4, 2.5, 2.5.1, 2.6, 7, 8
         - Sparc SunOS 4.1.X
+        - StrongARM (and other ARM) RISC OS 3.1, 4.02
+        - StrongARM Linux 2.4
+        - StrongARM NetBSD 1.4.1
+        - Ultrix 4.3a
         - i386 BeOS
         - i386 FreeBSD
         - i386 Linux 1.3, 2.0, 2.2, 2.3, 2.4
@@ -358,9 +400,9 @@ PORTS
         - i386 Windows 95, 98, ME, NT, 2000
         - ia64 Linux 2.3.99
         - m68k AmigaOS 3
+        - m68k Linux
         - m68k OpenBSD
-        - StrongARM NetBSD 1.4.1
-        - StrongARM (and other ARM) RISC OS 3.1, 4.02
+        - s390 Linux 
 
 OpenSSL
 =======

docs/INTERNALS

@@ -1,4 +1,4 @@
-                                       Updated for curl 7.8 on May 29, 2001
+                                    Updated for curl 7.9.1 on November 2, 2001
                                   _   _ ____  _     
                               ___| | | |  _ \| |    
                              / __| | | | |_) | |    
@@ -78,15 +78,15 @@ Library
  makes sure we stay absolutely platform independent.
 
  curl_easy_init() allocates an internal struct and makes some initializations.
- 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.
+ The returned handle does not reveal internals. This is the 'SessionHandle'
+ struct which works as an "anchor" struct for all curl_easy functions. All
+ connections performed will get connect-specific data allocated that should be
+ used for things related to particular connections/requests.
 
  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.
+ the 'SessionHandle' struct.
 
  curl_easy_perform() does a whole lot of things:
 
@@ -106,7 +106,7 @@ Library
    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.
+   inited/inherited from the SessionHandle struct.
 
  o Curl_do()
 
@@ -123,6 +123,13 @@ Library
    Curl_Transfer() function (in lib/transfer.c) to setup the transfer and
    returns.
 
+   Starting in 7.9.1, if this DO function fails and the connection is being
+   re-used, libcurl will then close this connection, setup a new connection
+   and re-issue the DO request on that. This is because there is no way to be
+   perfectly sure that we have discovered a dead connection before the DO
+   function and thus we might wrongly be re-using a connection that was closed
+   by the remote peer.
+
  o Transfer()
 
    Curl_perform() then calls Transfer() in lib/transfer.c that performs
@@ -144,7 +151,7 @@ Library
  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
+   connections 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
@@ -258,12 +265,12 @@ Persistent Connections
  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 "connection cache" (an array of pointers to
-   'connectdata' structs). There's one connectdata struct allocated for each
-   connection that libcurl knows about.
+ o The 'SessionHandle' 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 'SessionHandle' 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 before libcurl 7.7.
  o When we are about to perform a transfer with curl_easy_perform(), we first

docs/LIBCURL

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

docs/MANUAL

@@ -132,7 +132,7 @@ UPLOADING
 
   Upload all data on stdin to a specified ftp site:
 
-        curl -t ftp://ftp.upload.com/myfile
+        curl -T - ftp://ftp.upload.com/myfile
 
   Upload data from a specified file, login with user and password:
 
@@ -157,7 +157,7 @@ UPLOADING
 
   Upload all data on stdin to a specified http site:
 
-        curl -t http://www.upload.com/myfile
+        curl -T - http://www.upload.com/myfile
 
   Note that the http server must've been configured to accept PUT before this
   can be done successfully.
@@ -756,6 +756,17 @@ TELNET
   You might want the -N/--no-buffer option to switch off the buffered output
   for slow connections or similar.
 
+  Pass options to the telnet protocol negotiation, by using the -t option. To
+  tell the server we use a vt100 terminal, try something like:
+
+        curl -tTTYPE=vt100 telnet://remote.server.com
+
+  Other interesting options for it -t include:
+
+   - XDISPLOC=<X display> Sets the X display location.
+
+   - NEW_ENV=<var,val> Sets an environment variable.
+
   NOTE: the telnet protocol does not specify any way to login with a specified
   user and password so curl can't do that automatically. To do that, you need
   to track when the login prompt is received and send the username and

docs/Makefile.am

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

docs/README.win32

@@ -12,18 +12,11 @@ README.win32
   systems. While not being the main develop target, a fair share of curl users
   are win32-based.
 
-  Some documentation in this archive will be tricky to read for Windows
-  people, as they come in unix-style man pages. You can either download a
-  freely available nroff binary for win32 (*pointers appriciated*), convert
-  the files into plain-text on your neighbor's unix machine or run over to the
-  curl web site and view them as plain HTML.
+  The unix-style man pages are tricky to read on windows, so therefore are all
+  those pages also converted to HTML and those are also included in the
+  release archives.
 
-  The main curl.1 man page is "built-in". Use a command line similar to this
-  in order to extract a separate text file:
+  The main curl.1 man page is also "built-in" in the command line tool. Use a
+  command line similar to this 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

@@ -53,7 +53,7 @@ that have contributed with non-trivial parts:
  - Albert Chin-A-Young <china@thewrittenword.com>
  - Stephen Kick <skick@epicrealm.com>
  - Martin Hedenfalk <mhe@stacken.kth.se>
- - Richard Prescott
+ - Richard Prescott <rip at step.polymtl.ca>
  - Jason S. Priebe <priebe@wral-tv.com>
  - T. Bharath <TBharath@responsenetworks.com>
  - Alexander Kourakos <awk@users.sourceforge.net>
@@ -75,3 +75,4 @@ that have contributed with non-trivial parts:
  - Andrew Francis <locust@familyhealth.com.au>
  - Tomasz Lacki <Tomasz.Lacki@primark.pl>
  - Georg Huettenegger <georg@ist.org>
+ - John Lask <johnlask@hotmail.com>

docs/TODO

@@ -10,81 +10,66 @@ TODO
  send me patches that improve things! Also check the http://curl.haxx.se/dev
  web section for various development notes.
 
-To do in a future release (random order):
-
- * Make the connect non-blocking so that timeouts work for connect in 
-   multi-threaded programs 
-
- * Using FILE * in the libcurl API introduces a serious limitation since (at
-   least in the *nix falvours I know) you can fopen only the first 256
-   files. This means, that an application that first opens or fopens 256 files
-   has no chance to use libcurl. Using open and file descriptors instead of
-   FILE * would solve the problem. This implies a minor API
-   change/enhancement. ck1 <ck1@swissonline.ch>
-
- * It would be nice to be able to use "-d" (or something similar) to attach
-   parameters of EITHER the GET or POST type... It would either require
-   another curl argument to specify "GET" (obviously the default should remain
-   POST), or it would require a new curl argument (perhaps -G/--get-data).
- 
-   I know we're running out of letters, but it somehow feels a little
-   "cleaner" to just tag on each of your HTTP "parameters" (data-items) one by
-   one and let curl put them together, rather than having to put them together
-   myself and include them in the URL.
-
- * Add an interface that enables a user to select prefered SSL ciphers to use.
-
- * Make curl deal with cookies better. libcurl should be able to maintain a
-   "cookie jar". Updating it with cookies that is received, and using it to
-   pass cookies to the servers that have matching cookies in the jar.
-   http://curl.haxx.se/dev/cookie-jar.txt
+ LIBCURL
 
  * Consider an interface to libcurl that allows applications to easier get to
    know what cookies that are sent back in the response headers.
 
- * Make SSL session ids get used if multiple HTTPS documents from the same
-   host is requested. http://curl.haxx.se/dev/SSL_session_id.txt
+ * Make content encoding/decoding internally be made using a filter system.
 
- * HTTP PUT for files passed on stdin. Requires libcurl to send the file
-   with chunked content encoding. http://curl.haxx.se/dev/HTTP-PUT-stdin.txt
+ * The new 'multi' interface is being designed. Work out the details, start
+   implementing and write test applications!
+   [http://curl.haxx.se/dev/multi.h]
+
+ * Add a name resolve cache to libcurl to make repeated fetches to the same
+   host name (when persitancy isn't available) faster.
 
  * Introduce another callback interface for upload/download that makes one
    less copy of data and thus a faster operation.
-   http://curl.haxx.se/dev/no_copy_callbacks.txt
-
- * Suggested on the mailing list: CURLOPT_FTP_MKDIR...!
+   [http://curl.haxx.se/dev/no_copy_callbacks.txt]
 
  * Add configure options that disables certain protocols in libcurl to
    decrease footprint.  '--disable-[protocol]' where protocol is http, ftp,
    telnet, ldap, dict or file.
 
- * Extend the test suite to include telnet. The telnet could just do ftp or
-   http operations (for which we have test servers).
+ * Add asynchronous name resolving. http://curl.haxx.se/dev/async-resolver.txt
 
- * Make TELNET work on windows!
+ DOCUMENTATION
 
- * Add a command line option that allows the output file to get the same time
-   stamp as the remote file. libcurl already is capable of fetching the remote
-   file's date.
+ * Document all CURLcode error codes, why they happen and what most likely
+   will make them not happen again.
 
- * Make curl's SSL layer option capable of using other free SSL libraries.
-   Such as the Mozilla Security Services
-   (http://www.mozilla.org/projects/security/pki/nss/) and GNUTLS
-   (http://gnutls.hellug.gr/)
+ FTP
 
- * Add asynchronous name resolving, as this enables full timeout support for
-   fork() systems. http://curl.haxx.se/dev/async-resolver.txt
+ * FTP ASCII upload does not follow RFC959 section 3.1.1.1: "The sender
+   converts the data from an internal character representation to the standard
+   8-bit NVT-ASCII representation (see the Telnet specification).  The
+   receiver will convert the data from the standard form to his own internal
+   form."
 
- * Move non-URL related functions that are used by both the lib and the curl
-   application to a separate "portability lib".
+ * An option to only download remote FTP files if they're newer than the local
+   one is a good idea, and it would fit right into the same syntax as the
+   already working http dito works. It of course requires that 'MDTM' works,
+   and it isn't a standard FTP command.
 
- * Add libcurl support/interfaces for more languages. C++ wrapper perhaps?
+ * Suggested on the mailing list: CURLOPT_FTP_MKDIR...!
+
+ * Always use the FTP SIZE command before downloading, as that makes it more
+   likely that we know the size when downloading. Some sites support SIZE but
+   don't show the size in the RETR response!
+
+ HTTP
+
+ * HTTP PUT for files passed on stdin *OR* when the --crlf option is
+   used. Requires libcurl to send the file with chunked content
+   encoding. [http://curl.haxx.se/dev/HTTP-PUT-stdin.txt] When the filter
+   system mentioned above gets real, it'll be a piece of cake to add.
 
  * "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
    decompressing stuff. This work was started in October 1999 but halted again
    since it proved more work than we thought. It is still a good idea to
-   implement though.
+   implement though. This requires the filter system mentioned above.
 
  * Authentication: NTLM. Support for that MS crap called NTLM
    authentication. MS proxies and servers sometime require that. Since that
@@ -107,10 +92,37 @@ To do in a future release (random order):
    sends the password in cleartext over the network, this "Digest" method uses
    a challange-response protocol which increases security quite a lot.
 
- * Other proxies
-   Ftp-kind proxy, Socks5, whatever kind of proxies are there?
+ TELNET
 
- * 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.
+ * Make TELNET work on windows98!
 
+ SSL
+
+ * Add an interface to libcurl that enables "session IDs" to get
+   exported/imported. Cris Bailiff said: "OpenSSL has functions which can
+   serialise the current SSL state to a buffer of your choice, and
+   recover/reset the state from such a buffer at a later date - this is used
+   by mod_ssl for apache to implement and SSL session ID cache"
+
+ * Make curl's SSL layer option capable of using other free SSL libraries.
+   Such as the Mozilla Security Services
+   (http://www.mozilla.org/projects/security/pki/nss/) and GNUTLS
+   (http://gnutls.hellug.gr/)
+
+ CLIENT
+
+ * "curl ftp://site.com/*.txt"
+
+ * Several URLs can be specified to get downloaded. We should be able to use
+   the same syntax to specify several files to get uploaded (using the same
+   persistant connection), using -T.
+
+ TEST SUITE
+
+ * Extend the test suite to include more protocols. The telnet could just do
+   ftp or http operations (for which we have test servers).
+
+ * Make the test suite work on more platforms. OpenBSD and Mac OS. Remove
+   fork()s and it should become even more portable.
+
+ * Introduce a test suite that tests libcurl better and more explicitly.

docs/TheArtOfHttpScripting

@@ -1,6 +1,7 @@
+Online:  http://curl.haxx.se/docs/httpscripting.shtml
 Author:  Daniel Stenberg <daniel@haxx.se>
-Date:    September 15, 2000
-Version: 0.3
+Date:    October 31, 2001
+Version: 0.5
 
                 The Art Of Scripting HTTP Requests Using Curl
                 =============================================
@@ -47,7 +48,7 @@ Version: 0.3
 2. URL
 
  The Uniform Resource Locator format is how you specify the address of a
- particular resource on the internet. You know these, you've seen URLs like
+ particular resource on the Internet. You know these, you've seen URLs like
  http://curl.haxx.se or https://yourbank.com a million times.
 
 3. GET a page
@@ -55,7 +56,7 @@ Version: 0.3
  The simplest and most common request/operation made using HTTP is to get a
  URL. The URL could itself refer to a web page, an image or a file. The client
  issues a GET request to the server and receives the document it asked for.
- If you isse the command line
+ If you issue the command line
 
         curl http://curl.haxx.se
 
@@ -88,7 +89,7 @@ Version: 0.3
           <input type=submit name=press value="OK">
         </form>
 
-  In your favourite browser, this form will appear with a text box to fill in
+  In your favorite browser, this form will appear with a text box to fill in
   and a press-button labeled "OK". If you fill in '1905' and press the OK
   button, your browser will then create a new URL to get for you. The URL will
   get "junk.cgi?birthyear=1905&press=OK" appended to the path part of the
@@ -135,8 +136,8 @@ Version: 0.3
  4.3 FILE UPLOAD POST
 
   Back in late 1995 they defined a new way to post data over HTTP. It was
-  documented in the RFC 1867, why this method sometimes is refered to as
-  a rfc1867-posting.
+  documented in the RFC 1867, why this method sometimes is referred to as
+  a RFC1867-posting.
 
   This method is mainly designed to better support file uploads. A form that
   allows a user to upload a file could be written like this in HTML:
@@ -174,6 +175,19 @@ Version: 0.3
 
         curl -d "birthyear=1905&press=OK&person=daniel" [URL]
 
+ 4.5 FIGURE OUT WHAT A POST LOOKS LIKE
+
+  When you're about fill in a form and send to a server by using curl instead
+  of a browser, you're of course very interested in sending a POST exactly the
+  way your browser does.
+
+  An easy way to get to see this, is to save the HTML page with the form on
+  your local disk, modify the 'method' to a GET, and press the submit button
+  (you could also change the action URL if you want to).
+
+  You will then clearly see the data get appended to the URL, separated with a
+  '?'-letter as GET forms are supposed to.
+
 5. PUT
 
  The perhaps best way to upload data to a HTTP server is to use PUT. Then
@@ -182,7 +196,7 @@ Version: 0.3
 
  Put a file to a HTTP server with curl:
 
-        curl -t uploadfile www.uploadhttp.com/receive.cgi
+        curl -T uploadfile www.uploadhttp.com/receive.cgi
 
 6. AUTHENTICATION
 
@@ -200,7 +214,7 @@ Version: 0.3
  Sometimes your HTTP access is only available through the use of a HTTP
  proxy. This seems to be especially common at various companies. A HTTP proxy
  may require its own user and password to allow the client to get through to
- the internet. To specify those with curl, run something like:
+ the Internet. To specify those with curl, run something like:
 
         curl -U proxyuser:proxypassword curl.haxx.se
 
@@ -280,7 +294,7 @@ Version: 0.3
  contents to the server, unless of course they are expired.
 
  Many applications and servers use this method to connect a series of requests
- into a single logical session. To be able to use curl in such occations, we
+ into a single logical session. To be able to use curl in such occasions, we
  must be able to record and send back cookies the way the web application
  expects them. The same way browsers deal with them.
 
@@ -289,7 +303,6 @@ Version: 0.3
 
         curl -b "name=Daniel" www.cookiesite.com
 
-
  Cookies are sent as common HTTP headers. This is practical as it allows curl
  to record cookies simply by recording headers. Record cookies with curl by
  using the -D option like:
@@ -304,6 +317,23 @@ Version: 0.3
 
         curl -b stored_cookies_in_file www.cookiesite.com
 
+ Curl's "cookie engine" gets enabled when you use the -b option. If you only
+ want curl to understand received cookies, use -b with a file that doesn't
+ exist. Example, if you want to let curl understand cookies from a page and
+ follow a location (and thus possibly send back cookies it received), you can
+ invoke it like:
+
+        curl -b nada -L www.cookiesite.com
+
+ Curl has the ability to read and write cookie files that use the same file
+ format that Netscape and Mozilla do. It is a convenient way to share cookies
+ between browsers and automatic scripts. The -b switch automatically detects
+ if a given file is such a cookie file and parses it, and by using the
+ -c/--cookie-jar option you'll make curl write a new cookie file at the end of
+ an operation:
+
+        curl -b cookies.txt -c newcookies.txt www.cookiesite.com
+
 11. HTTPS
 
  There are a few ways to do secure HTTP transfers. The by far most common
@@ -328,7 +358,7 @@ Version: 0.3
   you need to enter the unlock-code before the certificate can be used by
   curl. The PIN-code can be specified on the command line or if not, entered
   interactively when curl queries for it. Use a certificate with curl on a
-  https server like:
+  HTTPS server like:
 
         curl -E mycert.pem https://that.secure.server.com
 
@@ -337,10 +367,12 @@ Version: 0.3
  RFC 2616 is a must to read if you want in-depth understanding of the HTTP
  protocol.
 
- RFC 2396 explains the URL syntax
+ RFC 2396 explains the URL syntax.
 
  RFC 2109 defines how cookies are supposed to work.
 
+ RFC 1867 defines the HTTP post upload format.
+
  http://www.openssl.org is the home of the OpenSSL project
 
  http://curl.haxx.se is the home of the cURL project

docs/VERSIONS

@@ -0,0 +1,64 @@
+                                  _   _ ____  _     
+                              ___| | | |  _ \| |    
+                             / __| | | | |_) | |    
+                            | (__| |_| |  _ <| |___ 
+                             \___|\___/|_| \_\_____|
+
+Version Numbers and Releases
+
+ Curl is not only curl. Curl is also libcurl. They're actually individually
+ versioned, but they mostly follow each other rather closely.
+
+ The version numbering is always built up using the same system:
+
+        X.Y[.Z][-preN]
+
+ Where
+   X is main version number
+   Y is release number
+   Z is patch number
+   N is pre-release number
+
+ One of these numbers will get bumped in each new release. The numbers to the
+ right of a bumped number will be reset to zero. If Z is zero, it is not
+ included in the version number. The pre release number is only included in
+ pre releases (they're never used in public, official, releases).
+
+ The main version number will get bumped when *really* big, world colliding
+ changes are made. The release number is bumped when big changes are
+ performed. The patch number is bumped when the changes are mere bugfixes and
+ only minor feature changes. The pre-release is a counter, to identify which
+ pre-release a certain release is.
+
+ When reaching the end of a pre-release period, the version without the
+ pre-release part will be released as a public release.
+
+ It means that after release 1.2.3, we can release 2.0 if something really big
+ has been made, 1.3 if not that big changes were made or 1.2.4 if mostly bugs
+ were fixed. Before 1.2.4 is released, we might release a 1.2.4-pre1 release
+ for the brave people to try before the actual release.
+
+ Bumping, as in increasing the number with 1, is unconditionally only
+ affecting one of the numbers (except the ones to the right of it, that may be
+ set to zero). 1 becomes 2, 3 becomes 4, 9 becomes 10, 88 becomes 89 and 99
+ becomes 100. So, after 1.2.9 comes 1.2.10. After 3.99.3, 3.100 might come.
+
+ All original curl source release archives are named according to the libcurl
+ version (not according to the curl client version that, as said before, might
+ differ).
+
+ As a service to any application that might want to support new libcurl
+ features while still being able to build with older versions, all releases
+ have the libcurl version stored in the curl/curl.h file using a static
+ numbering scheme that can be used for comparison. The version number is
+ defined as:
+        
+        #define LIBCURL_VERSION_NUM 0xXXYYZZ
+
+ Where XX, YY and ZZ are the main version, release and patch numbers in
+ hexadecimal. All three numbers are always represented using two digits.  1.2
+ would appear as "0x010200" while version 9.11.7 appears as "0x090b07".
+
+ This 6-digit hexadecimal number does not show pre-release number, and it is
+ always a greater number in a more recent release. It makes comparisons with
+ greater than and less than work.

docs/curl.1

@@ -2,7 +2,7 @@
 .\" nroff -man curl.1
 .\" Written by Daniel Stenberg
 .\"
-.TH curl 1 "16 Aug 2001" "Curl 7.8.1" "Curl Manual"
+.TH curl 1 "30 Nov 2001" "Curl 7.9.2" "Curl Manual"
 .SH NAME
 curl \- get a URL with FTP, TELNET, LDAP, GOPHER, DICT, FILE, HTTP or
 HTTPS syntax.
@@ -91,6 +91,12 @@ also be enforced by using an URL that ends with ";type=A". This option causes
 data sent to stdout to be in text mode for win32 systems.
 
 If this option is used twice, the second one will disable ASCII usage.
+.IP "--ciphers <list of ciphers>"
+(SSL) Specifies which ciphers to use in the connection. The list of ciphers
+must be using valid ciphers. Read up on SSL cipher list details on this URL:
+.I http://www.openssl.org/docs/apps/ciphers.html (Option added in curl 7.9)
+
+If this option is used severl times, the last one will override the others.
 .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
@@ -100,23 +106,24 @@ also the
 option.
 
 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
-continue appending data on the file where it was previously left,
-possibly because of a broken connection to the server. There must be
-a named physical file to append to for this to work.
-Note: Upload resume is depening on a command named SIZE not always
-present in all ftp servers! Upload resume is for FTP only.
-HTTP resume is only possible with HTTP/1.1 or later servers.
+.IP "-c/--cookie-jar <file name>"
+Specify to which file you want curl to write all cookies after a completed
+operation. Curl writes all cookies previously read from a specified file as
+well as all cookies received from remote server(s). If no cookies are known,
+no file will be written. The file will be written using the Netscape cookie
+file format. If you set the file name to a single dash, "-", the cookies will
+be written to stdout. (Option added in curl 7.9)
+
+If this option is used several times, the last specfied file name will be
+used.
 .IP "-C/--continue-at <offset>"
-Continue/Resume a previous file transfer at the given offset. The
-given offset is the exact number of bytes that will be skipped
-counted from the beginning of the source file before it is transfered
-to the destination.
-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.
+Continue/Resume a previous file transfer at the given offset. The given offset
+is the exact number of bytes that will be skipped counted from the beginning
+of the source file before it is transfered to the destination.  If used with
+uploads, the ftp server command SIZE will not be used by curl.
+
+Use "-C -" to tell curl to automatically find out where/how to resume the
+transfer. It then uses the given output/input files to figure that out.
 
 If this option is used several times, the last one will be used.
 .IP "-d/--data <data>"
@@ -154,10 +161,14 @@ 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 several times, the last one will be used.
-
 If this option is used several times, the ones following the first will
 append data.
+.IP "--disable-epsv"
+(FTP) Tell curl to disable the use of the EPSV command when doing passive FTP
+downloads. Curl will normally always first attempt to use EPSV before PASV,
+but with this option, it will not try using EPSV.
+
+IF this option is used several times, each occurrence will toggle this on/off.
 .IP "-D/--dump-header <file>"
 (HTTP/FTP)
 Write the HTTP headers to this file. Write the FTP file info to this
@@ -237,7 +248,7 @@ added in curl 7.6)
 When used, this option will make all data specified with -d/--data or
 --data-binary to be used in a HTTP GET request instead of the POST request
 that otherwise would be used. The data will be appended to the URL with a '?'
-separator.
+separator. (Option added in curl 7.9)
 .IP "-h/--help"
 Usage help.
 .IP "-H/--header <header>"
@@ -324,6 +335,8 @@ file in the user's home directory for login name and password. This is
 typically used for ftp on unix. If used with http, curl will enable user
 authentication. See
 .BR netrc(4)
+or
+.BR ftp(1)
 for details on the file format. Curl will not complain if that file
 hasn't the right permissions (it should not be world nor group
 readable). The environment variable "HOME" is used to find the home
@@ -452,6 +465,12 @@ 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 several times, the last one will be used.
+.IP "-R/--remote-time"
+When used, this will make libcurl attempt to figure out the timestamp of the
+remote file, and if that is available make the local file get that same
+timestamp.
+
+If this option is used twice, the second time disables this again.
 .IP "-s/--silent"
 Silent mode. Don't show progress meter or error messages.  Makes
 Curl mute.
@@ -470,14 +489,15 @@ XDISPLOC=<X display> Sets the X display location.
 
 NEW_ENV=<var,val> Sets an environment variable.
 .IP "-T/--upload-file <file>"
-Like -t, but this transfers the specified local file. If there is no
-file part in the specified URL, Curl will append the local file
-name. NOTE that you must use a trailing / on the last directory to
-really prove to Curl that there is no file name or curl will
-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 transfers the specified local file to the remote URL. If there is no file
+part in the specified URL, Curl will append the local file name. NOTE that you
+must use a trailing / on the last directory to really prove to Curl that there
+is no file name or curl will 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.
 
+Use the file name "-" (a single dash) to use stdin instead of a given file.
+
 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
@@ -553,6 +573,11 @@ The time, in seconds, it took from the start until the file transfer is just
 about to begin. This includes all pre-transfer commands and negotiations that
 are specific to the particular protocol(s) involved.
 .TP
+.B time_starttransfer
+The time, in seconds, it took from the start until the first byte is just about
+to be transfered. This includes time_pretransfer and also the time the
+server needs to calculate the result.
+.TP
 .B size_download
 The total amount of bytes that were downloaded.
 .TP
@@ -574,8 +599,13 @@ The average upload speed that curl measured for the complete upload.
 
 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.
+Use specified HTTP proxy. If the port number is not specified, it is assumed
+at port 1080.
+
+\fBNote\fP that all operations that are performed over a HTTP proxy will
+transparantly be converted to HTTP. It means that certain protocol specific
+operations might not be available. This is not the case if you can tunnel
+through the proxy, as done with the \fI-p/--proxytunnel\fP option.
 
 If this option is used several times, the last one will be used.
 .IP "-X/--request <command>"
@@ -623,6 +653,9 @@ Forces curl to use SSL version 3 when negotiating with a remote SSL server.
 .IP "-2/--sslv2"
 (HTTPS)
 Forces curl to use SSL version 2 when negotiating with a remote SSL server.
+.IP "-0/--http1.0"
+(HTTP) Forces curl to issue its requests using HTTP 1.0 instead of using its
+internally preferred: HTTP 1.1.
 .IP "-#/--progress-bar"
 Make curl display progress information as a progress bar instead of the
 default statistics.
@@ -766,6 +799,10 @@ Too many redirects. When following redirects, curl hit the maximum amount.
 Unknown TELNET option specified.
 .IP 49
 Malformed telnet option.
+.IP 51
+The remote peer's SSL certificate wasn't ok
+.IP 52
+The server didn't reply anything, which here is considered an error.
 .IP XX
 There will appear more error codes here in future releases. The existing ones
 are meant to never change.

docs/curl_easy_duphandle.3

@@ -0,0 +1,37 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" $Id$
+.\"
+.TH curl_easy_duphandle 3 "18 September 2001" "libcurl 7.9" "libcurl Manual"
+.SH NAME
+curl_easy_duphandle - Clone a libcurl session handle
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "CURL *curl_easy_duphandle(CURL *"handle ");"
+.ad
+.SH DESCRIPTION
+This function will return a new curl handle, a duplicate, using all the
+options previously set in the input curl \fIhandle\fP. Both handles can
+subsequently be used independently and they must both be freed with
+\fIcurl_easy_cleanup()\fP.
+
+All strings that the input handle has been told to point to (as opposed to
+copy) with previous calls to \fIcurl_easy_setopt\fP using char * inputs, will
+be pointed to by the new handle as well. You must therefore make sure to keep
+the data around until both handles have been cleaned up.
+
+The new handle will \fBnot\fP inherit any state information, no connections,
+no SSL sessions and no cookies.
+
+\fBNote\fP that even in multi-threaded programs, this function must be called
+in a synchronous way, the input handle may not be in use when cloned.
+
+This function was added in libcurl 7.9.
+.SH RETURN VALUE
+If this function returns NULL, something went wrong and no valid handle was
+returned.
+.SH "SEE ALSO"
+.BR curl_easy_init "(3)," curl_easy_cleanup "(3)," curl_global_init "(3)
+.SH BUGS
+Surely there are some, you tell me!

docs/curl_easy_getinfo.3

@@ -52,6 +52,12 @@ start until the file transfer is just about to begin. This includes all
 pre-transfer commands and negotiations that are specific to the particular
 protocol(s) involved.
 .TP
+.B CURLINFO_STARTTRANSFER_TIME
+Pass a pointer to a double to receive the time, in seconds, it took from the
+start until the first byte is just about to be transfered. This includes
+CURLINFO_PRETRANSFER_TIME and also the time the server needs to calculate
+the result.
+.TP
 .B CURLINFO_SIZE_UPLOAD
 Pass a pointer to a double to receive the total amount of bytes that were
 uploaded.

docs/curl_easy_setopt.3

@@ -2,83 +2,84 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_easy_setopt 3 "20 August 2001" "libcurl 7.8.1" "libcurl Manual"
+.TH curl_easy_setopt 3 "30 Nov 2001" "libcurl 7.9.2" "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 ", ...);"
+#include <curl/curl.h>
+
+CURLcode curl_easy_setopt(CURL *handle, CURLoption option, parameter);
 .ad
 .SH DESCRIPTION
-curl_easy_setopt() is called to tell libcurl how to behave in a number of
-ways. Most operations in libcurl have default actions, and by using the
-appropriate options you can make them behave differently (as documented).  All
-options are set with the
-.I option
-followed by a parameter. That parameter can be a long, a function pointer or
-an object pointer, all depending on what the option in question expects. Read
-this manual carefully as bad input values may cause libcurl to behave badly!
-You can only set one option in each function call. A typical application uses
-many curl_easy_setopt() calls in the setup phase.
+curl_easy_setopt() is used to tell libcurl how to behave. Most operations in
+libcurl have default actions, and by using the appropriate options to
+\fIcurl_easy_setopt\fP, you can change them.  All options are set with the
+\fIoption\fP followed by a \fIparameter\fP. That parameter can be a long, a
+function pointer or an object pointer, all depending on what the specific
+option expects. Read this manual carefully as bad input values may cause
+libcurl to behave badly!  You can only set one option in each function call. A
+typical application uses many curl_easy_setopt() calls in the setup phase.
 
-NOTE: strings passed to libcurl as 'char *' arguments, will not be copied by
-the library. Instead you should keep them available until libcurl no longer
-needs them. Failing to do so will cause very odd behaviour or even crashes.
+\fBNOTE:\fP strings passed to libcurl as 'char *' arguments, will not be
+copied by the library. Instead you should keep them available until libcurl no
+longer needs them. Failing to do so will cause very odd behavior or even
+crashes.
 
-More note: the options set with this function call are valid for the
-forthcoming data transfers that are performed when you invoke
-.I curl_easy_perform .
+\fBNOTE2:\fP options set with this function call are valid for the forthcoming
+data transfers that are performed when you invoke \fIcurl_easy_perform\fP.
 The options are not in any way reset between transfers, so if you want
 subsequent transfers with different options, you must change them between the
 transfers.
 
-The
-.I "handle"
-is the return code from the
-.I "curl_easy_init"
-call.
+The \fIhandle\fP is the return code from a \fIcurl_easy_init(3)\fP or
+\fIcurl_easy_duphandle(3)\fP call.
 .SH OPTIONS
-These options are in a bit of random order, but you'll figure it out!
+The options are listed in a sort of random order, but you'll figure it out!
 .TP 0.8i
 .B CURLOPT_FILE
-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. If you don't use a callback, you
-must pass a 'FILE *' as libcurl passes it to fwrite() when writing data.
+Data pointer to pass to the file write function. Note that if you specify the
+\fICURLOPT_WRITEFUNCTION\fP, this is the pointer you'll get as input. If you
+don't use a callback, you must pass a 'FILE *' as libcurl will pass this to
+fwrite() when writing data.
 
-NOTE: If you're using libcurl as a win32 DLL, you MUST use the
-\fICURLOPT_WRITEFUNCTION\fP if you set this option.
+\fBNOTE:\fP If you're using libcurl as a win32 DLL, you MUST use the
+\fICURLOPT_WRITEFUNCTION\fP if you set this option or you will experience
+crashes.
 .TP
 .B CURLOPT_WRITEFUNCTION
-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 \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).
+Function pointer that should match the following prototype: \fBsize_t
+function( void *ptr, size_t size, size_t nmemb, void *stream);\fP This
+function gets called by libcurl as soon as there is data available to pass
+available that needs to be saved. The size of the data pointed to by \fIptr\fP
+is \fIsize\fP multiplied with \fInmemb\fP.  Return the number of bytes
+actually taken care of. If that amount differs from the amount passed to your
+function, it'll signal an error to the library and it will abort the transfer
+and return \fICURLE_WRITE_ERROR\fP.
 
 Set the \fIstream\fP argument with the \fBCURLOPT_FILE\fP option.
+
+\fBNOTE:\fP you will be passed as much data as possible in all invokes, but
+you cannot possibly make any assumptions. It may be one byte, it may be
+thousands.
 .TP
 .B CURLOPT_INFILE
 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
+\fBNOTE:\fP 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 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 \fIptr\fP may
-be filled with at most \fIsize\fP multiplied with \fInmemb\fP number of
+Function pointer that should match the following prototype: \fBsize_t
+function( void *ptr, size_t size, size_t nmemb, void *stream);\fP 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 \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).
+it to abort the current transfer immediately (with a \fICURLE_READ_ERROR\fP
+return code).
 .TP
 .B CURLOPT_INFILESIZE
 When uploading a file to a remote site, this option should be used to tell
@@ -87,49 +88,67 @@ libcurl what the expected size of the infile is.
 .B CURLOPT_URL
 The actual URL to deal with. The parameter should be a char * to a zero
 terminated string. The string must remain present until curl no longer needs
-it, as it doesn't copy the string. NOTE: this option is required to be set
-before curl_easy_perform() is called.
+it, as it doesn't copy the string.
+
+\fBNOTE:\fP this option is (the only one) required to be set before
+\fIcurl_easy_perform(3)\fP is called.
 .TP
 .B CURLOPT_PROXY
-If you need libcurl to use a http proxy to access the outside world, set the
-proxy string with this option. The parameter should be a char * to a zero
-terminated string. To specify port number in this string, append :[port] to
-the end of the host name. The proxy string may be prefixed with
-[protocol]:// since any such prefix will be ignored.
+Set HTTP proxy to use. The parameter should be a char * to a zero terminated
+string holding the host name or dotted IP address. To specify port number in
+this string, append :[port] to the end of the host name. The proxy string may
+be prefixed with [protocol]:// since any such prefix will be ignored. The
+proxy's port number may optionally be specified with the separate option
+\fICURLOPT_PROXYPORT\fP.
+
+\fBNOTE:\fP when you tell the library to use a HTTP proxy, libcurl will
+transparently convert operations to HTTP even if you specify a FTP URL
+etc. This may have an impact on what other features of the library you can
+use, such as CURLOPT_QUOTE and similar FTP specifics that don't work unless
+you tunnel through the HTTP proxy. Such tunneling is activated with
+\fICURLOPT_HTTPPROXYTUNNEL\fP.
+
+\fBNOTE2:\fP libcurl respects the environment variables \fBhttp_proxy\fP,
+\fBftp_proxy\fP, \fBall_proxy\fP etc, if any of those is set.
 .TP
 .B CURLOPT_PROXYPORT
-Set this long with this option to set the proxy port to use unless it is
-specified in the proxy string CURLOPT_PROXY.
+Pass a long with this option to set the proxy port to connect to unless it is
+specified in the proxy string \fICURLOPT_PROXY\fP.
 .TP
 .B CURLOPT_HTTPPROXYTUNNEL
-Set the parameter to non-zero to get the library to tunnel all non-HTTP
-operations through the given HTTP proxy. Do note that there is a big
-difference to use a proxy and to tunnel through it. If you don't know what
-this means, you probably don't want this tunnel option. (Added in libcurl 7.3)
+Set the parameter to non-zero to get the library to tunnel all operations
+through a given HTTP proxy. Note that there is a big difference between using
+a proxy and to tunnel through it. If you don't know what this means, you
+probably don't want this tunneling option. (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. Very useful for libcurl and/or protocl
+information about its operations. Very useful for libcurl and/or protocol
 debugging and understanding.
+
+You hardly ever want this set in production use, you will almost always want
+this when you debug/report problems.
 .TP
 .B CURLOPT_HEADER
-A non-zero parameter tells the library to include the header in the
-output. This is only relevant for protocols that actually has a header
-preceeding the data (like HTTP).
+A non-zero parameter tells the library to include the header in the body
+output. This is only relevant for protocols that actually have headers
+preceding the data (like HTTP).
 .TP
 .B CURLOPT_NOPROGRESS
 A non-zero parameter tells the library to shut of the built-in progress meter
-completely. (NOTE: future versions of the lib is likely to not have any
-built-in progress meter at all).
+completely.
+
+\fBNOTE:\fP future versions of libcurl is likely to not have any built-in
+progress meter at all.
 .TP
 .B CURLOPT_NOBODY
 A non-zero parameter tells the library to not include the body-part in the
-output. This is only relevant for protocols that have a separate header and
-body part.
+output. This is only relevant for protocols that have separate header and body
+parts.
 .TP
 .B CURLOPT_FAILONERROR
 A non-zero parameter tells the library to fail silently if the HTTP code
-returned is equal or larger than 300. The default action would be to return
+returned is equal to or larger than 300. The default action would be to return
 the page normally, ignoring that code.
 .TP
 .B CURLOPT_UPLOAD
@@ -140,11 +159,13 @@ CURLOPT_INFILE and CURLOPT_INFILESIZE are also interesting for uploads.
 A non-zero parameter tells the library to do a regular HTTP post. This is a
 normal application/x-www-form-urlencoded kind, which is the most commonly used
 one by HTML forms. See the CURLOPT_POSTFIELDS option for how to specify the
-data to post and CURLOPT_POSTFIELDSIZE in how to set the data size.
+data to post and CURLOPT_POSTFIELDSIZE in how to set the data size. Starting
+with libcurl 7.8, this option is obsolete. Using the CURLOPT_POSTFIELDS option
+will imply this option.
 .TP
 .B CURLOPT_FTPLISTONLY
 A non-zero parameter tells the library to just list the names of an ftp
-directory, instead of doing a full directory listin that would include file
+directory, instead of doing a full directory listing that would include file
 sizes, dates etc.
 .TP
 .B CURLOPT_FTPAPPEND
@@ -152,90 +173,108 @@ A non-zero parameter tells the library to append to the remote file instead of
 overwrite it. This is only useful when uploading to a ftp site.
 .TP
 .B CURLOPT_NETRC
-A non-zero parameter tells the library to scan your
-.I ~/.netrc
-file to find user name and password for the remote site you are about to
-access. Do note that curl does not verify that the file has the correct
-properties set (as the standard unix ftp client does), and that only machine
-name, user name and password is taken into account (init macros and similar
-things aren't supported).
+A non-zero parameter tells the library to scan your \fI~/.netrc\fP file to
+find user name and password for the remote site you are about to access. Only
+machine name, user name and password is taken into account (init macros and
+similar things aren't supported).
+
+\fBNote:\fP libcurl does not verify that the file has the correct properties
+set (as the standard Unix ftp client does). It should only be readable by
+user.
 .TP
 .B CURLOPT_FOLLOWLOCATION
 A non-zero parameter tells the library to follow any Location: header that the
-server sends as part of a HTTP header. NOTE that this means that the library
-will resend the same request on the new location and follow new Location:
-headers all the way until no more such headers are returned.
+server sends as part of a HTTP header.
+
+\fBNOTE:\fP this means that the library will re-send the same request on the
+new location and follow new Location: headers all the way until no more such
+headers are returned. \fICURLOPT_MAXREDIRS\fP can be used to limit the number
+of redirects libcurl will follow.
 .TP
 .B CURLOPT_TRANSFERTEXT
 A non-zero parameter tells the library to use ASCII mode for ftp transfers,
 instead of the default binary transfer. For LDAP transfers it gets the data in
 plain text instead of HTML and for win32 systems it does not set the stdout to
-binary mode. This option can be useable when transfering text data between
-system with different views on certain characters, such as newlines or
+binary mode. This option can be usable when transferring text data between
+systems with different views on certain characters, such as newlines or
 similar.
 .TP
 .B CURLOPT_PUT
-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.
+A non-zero parameter tells the library to use HTTP PUT to transfer data. The
+data should be set with CURLOPT_INFILE and CURLOPT_INFILESIZE.
 .TP
 .B CURLOPT_USERPWD
-Pass a char * as parameter, which should be [username]:[password] to use for
+Pass a char * as parameter, which should be [user name]:[password] to use for
 the connection. If the password is left out, you will be prompted for it.
+\fICURLOPT_PASSWDFUNCTION\fP can be used to set your own prompt function.
 .TP
 .B CURLOPT_PROXYUSERPWD
-Pass a char * as parameter, which should be [username]:[password] to use for
+Pass a char * as parameter, which should be [user name]:[password] to use for
 the connection to the HTTP proxy. If the password is left out, you will be
-prompted for it.
+prompted for it. \fICURLOPT_PASSWDFUNCTION\fP can be used to set your own
+prompt function.
 .TP
 .B CURLOPT_RANGE
 Pass a char * as parameter, which should contain the specified range you
 want. It should be in the format "X-Y", where X or Y may be left out. HTTP
 transfers also support several intervals, separated with commas as in
-.I "X-Y,N-M"
-. Using this kind of multiple intervals will cause the HTTP server to send the
-response document in pieces.
+\fI"X-Y,N-M"\fP. Using this kind of multiple intervals will cause the HTTP
+server to send the response document in pieces (using standard MIME separation
+techniques).
 .TP
 .B CURLOPT_ERRORBUFFER
 Pass a char * to a buffer that the libcurl may store human readable error
 messages in. This may be more helpful than just the return code from the
 library. The buffer must be at least CURL_ERROR_SIZE big.
+
+\fBNote:\fP if the library does not return an error, the buffer may not have
+been touched. Do not rely on the contents in those cases.
 .TP
 .B CURLOPT_TIMEOUT
 Pass a long as parameter containing the maximum time in seconds that you allow
 the libcurl transfer operation to take. Normally, name lookups can take a
 considerable time and limiting operations to less than a few minutes risk
 aborting perfectly normal operations. This option will cause curl to use the
-SIGALRM to enable timeouting system calls.
-.B NOTE
-that this does not work in multi-threaded programs!
+SIGALRM to enable time-outing system calls.
+
+\fBNOTE:\fP this does not work in Unix multi-threaded programs, as it uses
+signals.
 .TP
 .B CURLOPT_POSTFIELDS
 Pass a char * as parameter, which should be the full data to post in a HTTP
-post operation. See also the CURLOPT_POST.
+post operation. This is a normal application/x-www-form-urlencoded kind, which
+is the most commonly used one by HTML forms. See also the CURLOPT_POST. Since
+7.8, using CURLOPT_POSTFIELDS implies CURLOPT_POST.
+
+\fBNote:\fP to make multipart/formdata posts (aka rfc1867-posts), check out
+the \fICURLOPT_HTTPPOST\fP option.
 .TP
 .B CURLOPT_POSTFIELDSIZE
 If you want to post data to the server without letting libcurl do a strlen()
-to measure the data size, this option must be used. Also, when this option is
-used, you can post fully binary data which otherwise is likely to fail. If
-this size is set to zero, the library will use strlen() to get the data
-size. (Added in libcurl 7.2)
+to measure the data size, this option must be used. When this option is used
+you can post fully binary data, which otherwise is likely to fail. If this
+size is set to zero, the library will use strlen() to get the size. (Added in
+libcurl 7.2)
 .TP
 .B CURLOPT_REFERER
 Pass a pointer to a zero terminated string as parameter. It will be used to
-set the referer: header in the http request sent to the remote server. This
-can be used to fool servers or scripts.
+set the Referer: header in the http request sent to the remote server. This
+can be used to fool servers or scripts. You can also set any custom header
+with \fICURLOPT_HTTPHEADER\fP.
 .TP
 .B CURLOPT_USERAGENT
 Pass a pointer to a zero terminated string as parameter. It will be used to
-set the user-agent: header in the http request sent to the remote server. This
-can be used to fool servers or scripts.
+set the User-Agent: header in the http request sent to the remote server. This
+can be used to fool servers or scripts. You can also set any custom header
+with \fICURLOPT_HTTPHEADER\fP.
 .TP
 .B CURLOPT_FTPPORT
 Pass a pointer to a zero terminated string as parameter. It will be used to
 get the IP address to use for the ftp PORT instruction. The PORT instruction
 tells the remote server to connect to our specified IP address. The string may
-be a plain IP address, a host name, an network interface name (under unix) or
-just a '-' letter to let the library use your systems default IP address.
+be a plain IP address, a host name, an network interface name (under Unix) or
+just a '-' letter to let the library use your systems default IP
+address. Default FTP operations are passive, and thus won't use PORT.
 .TP
 .B CURLOPT_LOW_SPEED_LIMIT
 Pass a long as parameter. It contains the transfer speed in bytes per second
@@ -258,82 +297,73 @@ set a cookie in the http request. The format of the string should be
 .TP
 .B CURLOPT_HTTPHEADER
 Pass a pointer to a linked list of HTTP headers to pass to the server in your
-HTTP request. The linked list should be a fully valid list of 'struct
-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. 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.
+HTTP request. The linked list should be a fully valid list of \fBstruct
+curl_slist\fP structs properly filled in. Use \fIcurl_slist_append(3)\fP to
+create the list and \fIcurl_slist_free_all(3)\fP 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:' (no data on the right side of the colon), the
+internally used header will get disabled. Thus, using this option you can add
+new headers, replace internal headers and remove internal headers.
+
+\fBNOTE:\fPThe most commonly replaced headers have "shortcuts" in the options
+CURLOPT_COOKIE, CURLOPT_USERAGENT and CURLOPT_REFERER.
 .TP
 .B CURLOPT_HTTPPOST
 Tells libcurl you want a multipart/formdata HTTP POST to be made and you
 instruct what data to pass on to the server.  Pass a pointer to a linked list
 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. The data in this list must remained intact until you close this
-curl handle again with curl_easy_cleanup().
+elegant way to do this, is to use \fIcurl_formadd(3)\fP as documented. The
+data in this list must remained intact until you close this curl handle again
+with \fIcurl_easy_cleanup(3)\fP.
 .TP
 .B CURLOPT_SSLCERT
 Pass a pointer to a zero terminated string as parameter. The string should be
-the file name of your certficicate in PEM format.
+the file name of your certificate in PEM format.
 .TP
 .B CURLOPT_SSLCERTPASSWD
 Pass a pointer to a zero terminated string as parameter. It will be used as
 the password required to use the CURLOPT_SSLCERT certificate. If the password
-is not supplied, you will be prompted for it.
+is not supplied, you will be prompted for it. \fICURLOPT_PASSWDFUNCTION\fP can
+be used to set your own prompt function.
 .TP
 .B CURLOPT_CRLF
-Convert unix newlines to CRLF newlines on FTP uploads.
+Convert Unix newlines to CRLF newlines on FTP uploads.
 .TP
 .B CURLOPT_QUOTE
 Pass a pointer to a linked list of FTP commands to pass to the server prior to
 your ftp request. The linked list should be a fully valid list of 'struct
-curl_slist' structs properly filled in. Use
-.I curl_slist_append(3)
-to append strings (commands) to the list, and clear the entire list afterwards
-with
-.I curl_slist_free_all(3)
+curl_slist' structs properly filled in. Use \fIcurl_slist_append(3)\fP to
+append strings (commands) to the list, and clear the entire list afterwards
+with \fIcurl_slist_free_all(3)\fP. Disable this operation again by setting a
+NULL to this option.
 .TP
 .B CURLOPT_POSTQUOTE
 Pass a pointer to a linked list of FTP commands to pass to the server after
 your ftp transfer request. The linked list should be a fully valid list of
 struct curl_slist structs properly filled in as described for
-.I "CURLOPT_QUOTE"
+\fICURLOPT_QUOTE\fP. Disable this operation again by setting a NULL to this
+option.
 .TP
 .B CURLOPT_WRITEHEADER
 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.
+you don't use your own callback to take care of the writing, this must be a
+valid FILE *. See also the \fICURLOPT_HEADERFUNCTION\fP option below on how to set a
+custom get-all-headers callback.
 .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)
+Function pointer that should match the following prototype: \fIsize_t
+function( void *ptr, size_t size, size_t nmemb, void *stream);\fP. This
+function gets called by libcurl as soon as there is received header data that
+needs to be written down. The headers are guaranteed to be written one-by-one
+and only complete lines are written. Parsing headers should be easy enough
+using this. The size of the data pointed to by \fIptr\fP is \fIsize\fP
+multiplied with \fInmemb\fP.  The pointer named \fIstream\fP will be the one
+you passed to libcurl with the \fICURLOPT_WRITEHEADER\fP 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 \fICURLE_WRITE_ERROR\fP 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
@@ -344,12 +374,12 @@ file.
 .B CURLOPT_SSLVERSION
 Pass a long as parameter. Set what version of SSL to attempt to use, 2 or
 3. By default, the SSL library will try to solve this by itself although some
-servers make this difficult why you at times will have to use this option.
+servers make this difficult why you at times may have to use this option.
 .TP
 .B CURLOPT_TIMECONDITION
 Pass a long as parameter. This defines how the CURLOPT_TIMEVALUE time value is
 treated. You can set this parameter to TIMECOND_IFMODSINCE or
-TIMECOND_IFUNMODSINCE. This is aa HTTP-only feature. (TBD)
+TIMECOND_IFUNMODSINCE. This is a HTTP-only feature. (TBD)
 .TP
 .B CURLOPT_TIMEVALUE
 Pass a long as parameter. This should be the time in seconds since 1 jan 1970,
@@ -359,8 +389,8 @@ isn't used, it will be TIMECOND_IFMODSINCE by default.
 .B CURLOPT_CUSTOMREQUEST
 Pass a pointer to a zero terminated string as parameter. It will be user
 instead of GET or HEAD when doing the HTTP request. This is useful for doing
-DELETE or other more obscure HTTP requests. Don't do this at will, make sure
-your server supports the command first.
+DELETE or other more or less obscure HTTP requests. Don't do this at will,
+make sure your server supports the command first.
 .TP
 .B CURLOPT_STDERR
 Pass a FILE * as parameter. This is the stream to use instead of stderr
@@ -378,29 +408,18 @@ krb4 awareness.  This is a string, 'clear', 'safe', 'confidential' or
 will be used. Set the string to NULL to disable kerberos4. The kerberos
 support only works for FTP. (Added in libcurl 7.3)
 .TP
-.B CURLOPT_WRITEINFO
-(NOT PRESENT IN 7.4 or later!)
-Pass a pointer to a zero terminated string as parameter. It will be used to
-report information after a successful request. This string may contain
-variables that will be substituted by their contents when output. Described
-elsewhere.
-.TP
 .B CURLOPT_PROGRESSFUNCTION
-Function pointer that should match the
-.BI curl_progress_callback
-prototype found in
-.I <curl/curl.h>
-This function gets called by libcurl instead of its internal
-equivalent. Unknown/unused argument values will be set to zero (like if you
-only download data, the upload size will remain 0). Returning a non-zero value
-from this callback will cause libcurl to abort the transfer and return
-CURLE_ABORTED_BY_CALLBACK.
+Function pointer that should match the \fIcurl_progress_callback\fP prototype
+found in \fI<curl/curl.h>\fP. This function gets called by libcurl instead of
+its internal equivalent with a frequent interval during data transfer.
+Unknown/unused argument values will be set to zero (like if you only download
+data, the upload size will remain 0). Returning a non-zero value from this
+callback will cause libcurl to abort the transfer and return
+\fICURLE_ABORTED_BY_CALLBACK\fP.
 .TP
 .B CURLOPT_PROGRESSDATA
 Pass a pointer that will be untouched by libcurl and passed as the first
-argument in the progress callback set with
-.I CURLOPT_PROGRESSFUNCTION
- .
+argument in the progress callback set with \fICURLOPT_PROGRESSFUNCTION\fP.
 .TP
 .B CURLOPT_SSL_VERIFYPEER
 Pass a long that is set to a non-zero value to make curl verify the peer's
@@ -413,67 +432,66 @@ verify the peer with. This only makes sense when used in combination with the
 CURLOPT_SSL_VERIFYPEER option. (Added in 7.4.2)
 .TP
 .B CURLOPT_PASSWDFUNCTION
-Pass a pointer to a curl_passwd_callback function that will then be called
+Pass a pointer to a \fIcurl_passwd_callback\fP function that will be called
 instead of the internal one if libcurl requests a password. The function must
-match this prototype:
-.BI "int my_getpass(void *client, char *prompt, char* buffer, int buflen );"
-If set to NULL, it equals to making the function always fail. If the function
-returns a non-zero value, it will abort the operation and an error
-(CURLE_BAD_PASSWORD_ENTERED) will be returned.
-.I client
-is a generic pointer, see CURLOPT_PASSWDDATA.
-.I prompt
+match this prototype: \fBint my_getpass(void *client, char *prompt, char*
+buffer, int buflen );\fP.  If set to NULL, it equals to making the function
+always fail. If the function returns a non-zero value, it will abort the
+operation and an error (CURLE_BAD_PASSWORD_ENTERED) will be returned.
+\fIclient\fP is a generic pointer, see \fICURLOPT_PASSWDDATA\fP.  \fIprompt\fP
 is a zero-terminated string that is text that prefixes the input request.
-.I buffer
-is a pointer to data where the entered password should be stored and
-.I buflen
-is the maximum number of bytes that may be written in the buffer.
-(Added in 7.4.2)
+\fIbuffer\fP is a pointer to data where the entered password should be stored
+and \fIbuflen\fP is the maximum number of bytes that may be written in the
+buffer.  (Added in 7.4.2)
 .TP
 .B CURLOPT_PASSWDDATA
 Pass a void * to whatever data you want. The passed pointer will be the first
-argument sent to the specifed CURLOPT_PASSWDFUNCTION function. (Added in
+argument sent to the specifed \fICURLOPT_PASSWDFUNCTION\fP function. (Added in
 7.4.2)
 .TP
 .B CURLOPT_FILETIME
 Pass a long. If it is a non-zero value, libcurl will attempt to get the
 modification date of the remote document in this operation. This requires that
 the remote server sends the time or replies to a time querying command. The
-curl_easy_getinfo() function with the CURLINFO_FILETIME argument can be used
-after a transfer to extract the received time (if any). (Added in 7.5)
+\fIcurl_easy_getinfo(3)\fP function with the \fICURLINFO_FILETIME\fP argument
+can be used after a transfer to extract the received time (if any). (Added in
+7.5)
 .TP
 .B CURLOPT_MAXREDIRS
 Pass a long. The set number will be the redirection limit. If that many
-redirections have been followed, the next redirect will cause an error. This
-option only makes sense if the CURLOPT_FOLLOWLOCATION is used at the same
-time. (Added in 7.5)
+redirections have been followed, the next redirect will cause an error
+(\fICURLE_TOO_MANY_REDIRECTS\fP). This option only makes sense if the
+\fICURLOPT_FOLLOWLOCATION\fP is used at the same time. (Added in 7.5)
 .TP
 .B CURLOPT_MAXCONNECTS
 Pass a long. The set number will be the persistant connection cache size. The
 set amount will be the maximum amount of simultaneous connections that libcurl
 may cache between file transfers. Default is 5, and there isn't much point in
 changing this value unless you are perfectly aware of how this work and
-changes libcurl's behaviour. Note: if you have already performed transfers
-with this curl handle, setting a smaller MAXCONNECTS than before may cause
-open connections to unnecessarily get closed. (Added in 7.7)
+changes libcurl's behaviour.
+
+\fBNOTE:\fP if you already have performed transfers with this curl handle,
+setting a smaller MAXCONNECTS than before may cause open connections to get
+closed unnecessarily. (Added in 7.7)
 .TP
 .B CURLOPT_CLOSEPOLICY
 Pass a long. This option sets what policy libcurl should use when the
 connection cache is filled and one of the open connections has to be closed to
 make room for a new connection. This must be one of the CURLCLOSEPOLICY_*
-defines. Use CURLCLOSEPOLICY_LEAST_RECENTLY_USED to make libcurl close the
-connection that was least recently used, that connection is also least likely
-to be capable of re-use. Use CURLCLOSEPOLICY_OLDEST to make libcurl close the
-oldest connection, the one that was created first among the ones in the
-connection cache. The other close policies are not support yet. (Added in 7.7)
+defines. Use \fICURLCLOSEPOLICY_LEAST_RECENTLY_USED\fP to make libcurl close
+the connection that was least recently used, that connection is also least
+likely to be capable of re-use. Use \fICURLCLOSEPOLICY_OLDEST\fP to make
+libcurl close the oldest connection, the one that was created first among the
+ones in the connection cache. The other close policies are not support
+yet. (Added in 7.7)
 .TP
 .B CURLOPT_FRESH_CONNECT
-Pass a long. Set to non-zero to make the next transfer use a new connection by
-force. If the connection cache is full before this connection, one of the
-existinf connections will be closed as according to the set policy. This
-option should be used with caution and only if you understand what it
-does. Set to 0 to have libcurl attempt re-use of an existing connection.
-(Added in 7.7)
+Pass a long. Set to non-zero to make the next transfer use a new (fresh)
+connection by force. If the connection cache is full before this connection,
+one of the existing connections will be closed as according to the selected or
+default policy. This option should be used with caution and only if you
+understand what it does. Set this to 0 to have libcurl attempt re-using an
+existing connection (default behavior).  (Added in 7.7)
 .TP
 .B CURLOPT_FORBID_REUSE
 Pass a long. Set to non-zero to make the next transfer explicitly close the
@@ -481,7 +499,7 @@ connection when done. Normally, libcurl keep all connections alive when done
 with one transfer in case there comes a succeeding one that can re-use them.
 This option should be used with caution and only if you understand what it
 does. Set to 0 to have libcurl keep the connection open for possibly later
-re-use. (Added in 7.7)
+re-use (default behavior). (Added in 7.7)
 .TP
 .B CURLOPT_RANDOM_FILE
 Pass a char * to a zero terminated file name. The file will be used to read
@@ -497,11 +515,10 @@ Pass a long. It should contain the maximum time in seconds that you allow the
 connection to the server to take.  This only limits the connection phase, once
 it has connected, this option is of no more use. Set to zero to disable
 connection timeout (it will then only timeout on the system's internal
-timeouts). See also the
-.I CURLOPT_TIMEOUT
-option.
-.B NOTE
-that this does not work in multi-threaded programs!
+timeouts). See also the \fICURLOPT_TIMEOUT\fP option.
+
+\fBNOTE:\fP this does not work in unix multi-threaded programs, as it uses
+signals.
 .TP
 .B CURLOPT_HTTPGET
 Pass a long. If the long is non-zero, this forces the HTTP request to get back
@@ -512,12 +529,54 @@ previously using the same curl handle. (Added in 7.8.1)
 Pass a long. Set if we should verify the Common name from the peer certificate
 in the SSL handshake, set 1 to check existence, 2 to ensure that it matches
 the provided hostname. (Added in 7.8.1)
+.TP
+.B CURLOPT_COOKIEJAR
+Pass a file name as char *, zero terminated. This will make libcurl dump all
+internally known cookies to the specified file when \fIcurl_easy_cleanup(3)\fP
+is called. If no cookies are known, no file will be created. Specify "-" to
+instead have the cookies written to stdout.
+.TP
+.B CURLOPT_SSL_CIPHER_LIST
+Pass a char *, pointing to a zero terminated string holding the list of
+ciphers to use for the SSL connection. The list must be syntactly correct, it
+consists of one or more cipher strings separated by colons. Commas or spaces
+are also acceptable separators but colons are normally used, \!, \- and \+ can
+be used as operators. Valid examples of cipher lists include 'RC4-SHA',
+\'SHA1+DES\', 'TLSv1' and 'DEFAULT'. The default list is normally set when you
+compile OpenSSL.
+
+You'll find more details about cipher lists on this URL:
+\fIhttp://www.openssl.org/docs/apps/ciphers.html\fP
+.TP
+.B CURLOPT_HTTP_VERSION
+Pass a long, set to one of the values described below. They force libcurl to
+use the specific HTTP versions. This is not sensible to do unless you have a
+good reason.
+.RS
+.TP 5
+.B CURL_HTTP_VERSION_NONE
+We don't care about what version the library uses. libcurl will use whatever
+it thinks fit.
+.TP
+.B CURL_HTTP_VERSION_1_0
+Enforce HTTP 1.0 requests.
+.TP
+.B CURL_HTTP_VERSION_1_1
+Enforce HTTP 1.1 requests.
+.RE
+.TP
+.B CURLOPT_FTP_USE_EPSV
+Pass a long. If the value is non-zero, it tells curl to use the EPSV command
+when doing passive FTP downloads (which is always does by default). Using EPSV
+means that it will first attempt to use EPSV before using PASV, but if you
+pass FALSE (zero) to this option, it will not try using EPSV, only plain PASV.
 .PP
 .SH RETURN VALUE
-0 means the option was set properly, non-zero means an error as
-.I <curl/curl.h>
-defines
+CURLE_OK (zero) means that the option was set properly, non-zero means an
+error occurred as \fI<curl/curl.h>\fP defines.
 .SH "SEE ALSO"
 .BR curl_easy_init "(3), " curl_easy_cleanup "(3), "
 .SH BUGS
-Surely there are some, you tell me!
+If you find any bugs, or just have questions, subscribe to one of the mailing
+lists and post. We won't bite.
+

docs/curl_formadd.3

@@ -0,0 +1,158 @@
+.\" You can view this file with:
+.\" nroff -man [file]
+.\" $Id$
+.\"
+.TH curl_formadd 3 "29 October 2001" "libcurl 7.9.1" "libcurl Manual"
+.SH NAME
+curl_formadd - add a section to a multipart/formdata HTTP POST
+.SH SYNOPSIS
+.B #include <curl/curl.h>
+.sp
+.BI "int curl_formadd(struct HttpPost ** " firstitem,
+.BI "struct HttpPost ** " lastitem, " ...);"
+.ad
+.SH DESCRIPTION
+curl_formadd() is used to append sections when building a multipart/formdata
+HTTP POST (sometimes refered to as rfc1867-style posts). Append one section at
+a time until you've added all the sections you want included and then you pass
+the \fIfirstitem\fP pointer as parameter to \fBCURLOPT_HTTPPOST\fP.
+\fIlastitem\fP is set after each call and on repeated invokes it should be
+left as set to allow repeated invokes to find the end of the list faster.
+
+After the \fIlastitem\fP pointer follow the real arguments. (If the following
+description confuses you, jump directly to the examples):
+
+\fBCURLFORM_COPYNAME\fP or \fBCURLFORM_PTRNAME\fP followed by a string is used
+for the name of the section. Optionally one may use \fBCURLFORM_NAMELENGTH\fP
+to specify the length of the name (allowing null characters within the
+name). All options that use the word COPY in their names copy the given
+contents, while the ones with PTR in their names simply points to the (static)
+data you must make sure remain until curl no longer needs it.
+
+The four options for providing values are: \fBCURLFORM_COPYCONTENTS\fP,
+\fBCURLFORM_PTRCONTENTS\fP, \fBCURLFORM_FILE\fP, or \fBCURLFORM_FILECONTENT\fP
+followed by a char or void pointer (allowed for PTRCONTENTS).
+
+\fBCURLFORM_FILECONTENT\fP does a normal post like \fBCURLFORM_COPYCONTENTS\fP
+but the actual value is read from the filename given as a string.
+
+Other arguments may be \fBCURLFORM_CONTENTTYPE\fP if the user wishes to
+specify one (for FILE if no type is given the library tries to provide the
+correct one; for CONTENTS no Content-Type is sent in this case).
+
+For \fBCURLFORM_PTRCONTENTS\fP or \fBCURLFORM_COPYNAME\fP the user may also
+add \fBCURLFORM_CONTENTSLENGTH\fP followed by the length as a long (if not
+given the library will use strlen to determine the length).
+
+For \fBCURLFORM_FILE\fP the user may send multiple files in one section by
+providing multiple \fBCURLFORM_FILE\fP arguments each followed by the filename
+(and each FILE is allowed to have a CONTENTTYPE).
+
+Another possibility to send single or multiple files in one section is to use
+\fBCURLFORM_ARRAY\fP that gets a struct curl_forms array pointer as its
+value. Each structure element has a CURLformoption and a char pointer. For the
+options only \fBCURLFORM_FILE\fP, \fBCURLFORM_CONTENTTYPE\fP, and
+\fBCURLFORM_END\fP (that is used to determine the end of the array and thus
+must be the option of the last and no other element of the curl_forms array)
+are allowed. The effect of this parameter is the same as giving multiple
+\fBCURLFORM_FILE\fP options possibly with \fBCURLFORM_CONTENTTYPE\fP after or
+before each \fBCURLFORM_FILE\fP option.
+
+The last argument in such an array must always be \fBCURLFORM_END\fP.
+
+The pointers \fI*firstitem\fP and \fI*lastitem\fP should both be pointing to
+NULL in the first call to this function. All list-data will be allocated by
+the function itself. You must call \fIcurl_formfree\fP after the form post has
+been done to free the resources again.
+
+This function will copy all input data except the data pointed to by the
+arguments after \fBCURLFORM_PTRNAME\fP and \fBCURLFORM_PTRCONTENTS\fP and keep
+its own version of it allocated until you call \fIcurl_formfree\fP. When
+you've passed the pointer to \fIcurl_easy_setopt\fP, you must not free the
+list until after you've called \fIcurl_easy_cleanup\fP for the curl handle. If
+you provide a pointer as an arguments after \fBCURLFORM_PTRNAME\fP or
+\fBCURLFORM_PTRCONTENTS\fP you must ensure that the pointer stays valid until
+you call \fIcurl_form_free\fP and \fIcurl_easy_cleanup\fP.
+
+See example below.
+.SH RETURN VALUE
+Returns non-zero if an error occurs.
+.SH EXAMPLE
+.nf
+
+ HttpPost* post = NULL;
+ HttpPost* last = NULL;
+ char namebuffer[] = "name buffer";
+ long namelength = strlen(namebuffer);
+ char buffer[] = "test buffer";
+ char htmlbuffer[] = "<HTML>test buffer</HTML>";
+ long htmlbufferlength = strlen(htmlbuffer);
+ struct curl_forms forms[3];
+ char file1[] = "my-face.jpg";
+ char file2[] = "your-face.jpg";
+ /* add null character into htmlbuffer, to demonstrate that
+    transfers of buffers containing null characters actually work
+ */
+ htmlbuffer[8] = '\\0';
+
+ /* Add simple name/content section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "name",
+              CURLFORM_COPYCONTENTS, "content", CURLFORM_END); 
+
+ /* Add simple name/content/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "htmlcode",
+              CURLFORM_COPYCONTENTS, "<HTML></HTML>",
+              CURLFORM_CONTENTTYPE, "text/html", CURLFORM_END);
+
+ /* Add name/ptrcontent section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "name_for_ptrcontent",
+              CURLFORM_PTRCONTENTS, buffer, CURLFORM_END);
+
+ /* Add ptrname/ptrcontent section */
+ curl_formadd(&post, &last, CURLFORM_PTRNAME, namebuffer,
+	      CURLFORM_PTRCONTENTS, buffer, CURLFORM_NAMELENGTH,
+	      namelength, CURLFORM_END);
+
+ /* Add name/ptrcontent/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "html_code_with_hole",
+              CURLFORM_PTRCONTENTS, htmlbuffer,
+              CURLFORM_CONTENTSLENGTH, htmlbufferlength,
+              CURLFORM_CONTENTTYPE, "text/html", CURLFORM_END);
+
+ /* Add simple file section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "picture",
+              CURLFORM_FILE, "my-face.jpg", CURLFORM_END);
+
+ /* Add file/contenttype section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "picture",
+              CURLFORM_FILE, "my-face.jpg",
+              CURLFORM_CONTENTTYPE, "image/jpeg", CURLFORM_END);
+
+ /* Add two file section */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "pictures",
+              CURLFORM_FILE, "my-face.jpg",
+              CURLFORM_FILE, "your-face.jpg", CURLFORM_END);
+
+ /* Add two file section using CURLFORM_ARRAY */
+ forms[0].option = CURLFORM_FILE;
+ forms[0].value  = file1;
+ forms[1].option = CURLFORM_FILE;
+ forms[1].value  = file2;
+ forms[2].option  = CURLFORM_END;
+
+ /* no option needed for the end marker */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "pictures",
+              CURLFORM_ARRAY, forms, CURLFORM_END);
+ /* Add the content of a file as a normal post text value */
+ curl_formadd(&post, &last, CURLFORM_COPYNAME, "filecontent",
+              CURLFORM_FILECONTENT, ".bashrc", CURLFORM_END);
+ /* Set the form info */
+ curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
+
+.SH "SEE ALSO"
+.BR curl_easy_setopt "(3), "
+.BR curl_formparse "(3) [deprecated], "
+.BR curl_formfree "(3)"
+.SH BUGS
+Surely there are some, you tell me!
+

docs/curl_formfree.3

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

docs/curl_formparse.3

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

docs/curl_global_init.3

@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_global_init 3 "14 August 2001" "libcurl 7.8.1" "libcurl Manual"
+.TH curl_global_init 3 "13 Nov 2001" "libcurl 7.9.1" "libcurl Manual"
 .SH NAME
 curl_global_init - Global libcurl initialisation
 .SH SYNOPSIS
@@ -11,8 +11,8 @@ curl_global_init - Global libcurl initialisation
 .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.
+This function should only 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.
@@ -23,6 +23,8 @@ init, as described below. Set the desired bits by ORing the values together.
 You must however \fBalways\fP use the \fIcurl_global_cleanup\fP function, as
 that cannot be called automatically for you by libcurl.
 
+Calling this function more than once will cause unpredictable results.
+
 This function was added in libcurl 7.8.
 .SH FLAGS
 .TP 5

docs/curl_slist_append.3

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

docs/examples/Makefile.am

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

docs/examples/ftpupload.c

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

docs/examples/httpput.c

@@ -0,0 +1,100 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ */
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include <curl/curl.h>
+
+/*
+ * This example shows a HTTP PUT operation. PUTs a file given as a command
+ * line argument to the URL also given on the command line.
+ *
+ * This example also uses its own read callback.
+ */
+
+size_t read_callback(void *ptr, size_t size, size_t nmemb, void *stream)
+{
+  size_t retcode;
+
+  /* in real-world cases, this would probably get this data differently
+     as this fread() stuff is exactly what the library already would do
+     by default internally */
+  retcode = fread(ptr, size, nmemb, stream);
+
+  fprintf(stderr, "*** We read %d bytes from file\n", retcode);
+
+  return retcode;
+}
+
+int main(int argc, char **argv)
+{
+  CURL *curl;
+  CURLcode res;
+  FILE *ftpfile;
+  FILE * hd_src ;
+  int hd ;
+  struct stat file_info;
+
+  char *file;
+  char *url;
+
+  if(argc < 3)
+    return 1;
+ 
+  file= argv[1];
+  url = argv[2];
+  
+  /* get the file size of the local file */
+  hd = open(file, O_RDONLY) ;
+  fstat(hd, &file_info);
+  close(hd) ;
+
+  /* get a FILE * of the same file, could also be made with
+     fdopen() from the previous descriptor, but hey this is just 
+     an example! */
+  hd_src = fopen(file, "rb");
+
+  /* In windows, this will init the winsock stuff */
+  curl_global_init(CURL_GLOBAL_ALL);
+
+  /* get a curl handle */
+  curl = curl_easy_init();
+  if(curl) {
+    /* we want to use our own read function */
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+
+    /* enable uploading */
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ;
+
+    /* HTTP PUT please */
+    curl_easy_setopt(curl, CURLOPT_PUT, TRUE);
+
+    /* specify target */
+    curl_easy_setopt(curl,CURLOPT_URL, url);
+
+    /* now specify which file to upload */
+    curl_easy_setopt(curl, CURLOPT_INFILE, hd_src);
+
+    /* and give the size of the upload (optional) */
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, file_info.st_size);
+
+    /* Now run off and do what you've been told! */
+    res = curl_easy_perform(curl);
+
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+  }
+  fclose(hd_src); /* close the local file */
+
+  curl_global_cleanup();
+  return 0;
+}

docs/examples/postit2.c

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

docs/index.html

@@ -0,0 +1,38 @@
+HTML>
+<HEAD>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
+<TITLE>Index to Curl documentation</TITLE>
+</HEAD>
+
+<BODY>
+<H1 ALIGN="CENTER">Index to Curl documentation</H1>
+
+<H2>Programs</H2>
+<P><A HREF="curl-config.html">curl-config.html</A>
+<P><A HREF="curl.html">curl.html</A>
+
+<H2>Library routines</H2>
+<P><A HREF="libcurl.html">libcurl.html</A>
+<P><A HREF="curl_easy_cleanup.html">curl_easy_cleanup.html</A>
+<P><A HREF="curl_easy_duphandle.html">curl_easy_duphandle.html</A>
+<P><A HREF="curl_easy_getinfo.html">curl_easy_getinfo.html</A>
+<P><A HREF="curl_easy_init.html">curl_easy_init.html</A>
+<P><A HREF="curl_easy_perform.html">curl_easy_perform.html</A>
+<P><A HREF="curl_easy_setopt.html">curl_easy_setopt.html</A>
+<P><A HREF="curl_escape.html">curl_escape.html</A>
+<P><A HREF="curl_formadd.html">curl_formadd.html</A>
+<P><A HREF="curl_formfree.html">curl_formfree.html</A>
+<P><A HREF="curl_formparse.html">curl_formparse.html</A>
+<P><A HREF="curl_getdate.html">curl_getdate.html</A>
+<P><A HREF="curl_getenv.html">curl_getenv.html</A>
+<P><A HREF="curl_global_cleanup.html">curl_global_cleanup.html</A>
+<P><A HREF="curl_global_init.html">curl_global_init.html</A>
+<P><A HREF="curl_mprintf.html">curl_mprintf.html</A>
+<P><A HREF="curl_slist_append.html">curl_slist_append.html</A>
+<P><A HREF="curl_slist_free_all.html">curl_slist_free_all.html</A>
+<P><A HREF="curl_strequal.html">curl_strequal.html</A>
+<P><A HREF="curl_strnequal.html">curl_strnequal.html</A>
+<P><A HREF="curl_unescape.html">curl_unescape.html</A>
+<P><A HREF="curl_version.html">curl_version.html</A>
+</BODY>
+</HTML>

docs/libcurl.3

@@ -53,11 +53,14 @@ portable environment variable reader
 .B curl_easy_getinfo()
 get information about a performed transfer
 .TP
-.B curl_formparse()
+.B curl_formadd()
 helps building a HTTP form POST
 .TP
+.B curl_formparse()
+helps building a HTTP form POST (deprecated since 7.9 use curl_formadd()!)
+.TP
 .B curl_formfree()
-free a list built with curl_formparse()
+free a list built with curl_formparse()/curl_formadd()
 .TP
 .B curl_slist_append()
 builds a linked list

include/curl/curl.h

@@ -7,7 +7,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -58,13 +58,19 @@ extern "C" {
 struct HttpPost {
   struct HttpPost *next; /* next entry in the list */
   char *name;     /* pointer to allocated name */
+  long namelength; /* length of name length */
   char *contents; /* pointer to allocated data contents */
+  long contentslength; /* length of contents field */
   char *contenttype; /* Content-Type */
   struct HttpPost *more; /* if one field name has more than one file, this
 			    link should link to following files */
   long flags;     /* as defined below */
 #define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */
 #define HTTPPOST_READFILE (1<<1) /* specified content is a file name */
+#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer
+                                   do not free in formfree */
+#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer
+                                       do not free in formfree */
 };
 
 typedef int (*curl_progress_callback)(void *clientp,
@@ -148,6 +154,7 @@ typedef enum {
   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 */
+  CURLE_GOT_NOTHING,             /* 52 - when this is a specific error */
   
   CURL_LAST /* never use! */
 } CURLcode;
@@ -205,10 +212,8 @@ typedef enum {
      in the CURLOPT_FLAGS to activate this */
   CINIT(RANGE, OBJECTPOINT, 7),
 
-#if 0
-  /* Configuration flags */
-  CINIT(FLAGS, LONG, 8),
-#endif
+  /* not used */
+
   /* Specified file stream to upload from (use as input): */
   CINIT(INFILE, OBJECTPOINT, 9),
 
@@ -291,7 +296,7 @@ typedef enum {
   CINIT(COOKIEFILE, OBJECTPOINT, 31),
 
   /* What version to specifly try to use.
-     3 = SSLv3, 2 = SSLv2, all else makes it try v3 first then v2 */
+     See CURL_SSLVERSION defines below. */
   CINIT(SSLVERSION, LONG, 32),
 
   /* What kind of HTTP time condition to use, see defines */
@@ -314,11 +319,8 @@ typedef enum {
   /* HTTP request, for odd commands like DELETE, TRACE and others */
   CINIT(STDERR, OBJECTPOINT, 37),
 
-#if 0
-  /* Progress mode set alternative progress mode displays. Alternative
-     ones should now be made by the client, not the lib! */     
-  CINIT(PROGRESSMODE, LONG, 38),
-#endif
+  /* 38 is not used */
+
   /* send linked-list of post-transfer QUOTE commands */
   CINIT(POSTQUOTE, OBJECTPOINT, 39),
 
@@ -448,9 +450,46 @@ typedef enum {
    * provided hostname. */
   CINIT(SSL_VERIFYHOST, LONG, 81),
 
+  /* Specify which file name to write all known cookies in after completed
+     operation. Set file name to "-" (dash) to make it go to stdout. */
+  CINIT(COOKIEJAR, OBJECTPOINT, 82),
+
+  /* Specify which SSL ciphers to use */
+  CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),
+
+  /* Specify which HTTP version to use! This must be set to one of the
+     CURL_HTTP_VERSION* enums set below. */
+  CINIT(HTTP_VERSION, LONG, 84),
+
+  /* Specificly switch on or off the FTP engine's use of the EPSV command. By
+     default, that one will always be attempted before the more traditional
+     PASV command. */     
+  CINIT(FTP_USE_EPSV, LONG, 85),
+  
   CURLOPT_LASTENTRY /* the last unusued */
 } CURLoption;
 
+  /* These enums are for use with the CURLOPT_HTTP_VERSION option. */
+enum {
+  CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
+                             like the library to choose the best possible
+                             for us! */
+  CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */
+  CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */
+  
+  CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
+};
+
+enum {
+  CURL_SSLVERSION_DEFAULT,
+  CURL_SSLVERSION_TLSv1,
+  CURL_SSLVERSION_SSLv2,
+  CURL_SSLVERSION_SSLv3,
+
+  CURL_SSLVERSION_LAST /* never use, keep last */
+};
+
+
 typedef enum {
   TIMECOND_NONE,
 
@@ -459,7 +498,7 @@ typedef enum {
   TIMECOND_LASTMOD,
 
   TIMECOND_LAST
-} TimeCond;
+} curl_TimeCond;
 
 #ifdef __BEOS__
 #include <support/SupportDefs.h>
@@ -483,6 +522,44 @@ int curl_formparse(char *string,
                    struct HttpPost **httppost,
                    struct HttpPost **last_post);
 
+/* name is uppercase CURLFORM_<name> */
+#ifdef CFINIT
+#undef CFINIT
+#endif
+#define CFINIT(name) CURLFORM_ ## name
+
+typedef enum {
+  CFINIT(NOTHING),        /********* the first one is unused ************/
+  
+  /*  */
+  CFINIT(COPYNAME),
+  CFINIT(PTRNAME),
+  CFINIT(NAMELENGTH),
+  CFINIT(COPYCONTENTS),
+  CFINIT(PTRCONTENTS),
+  CFINIT(CONTENTSLENGTH),
+  CFINIT(FILECONTENT),
+  CFINIT(ARRAY),
+  CFINIT(ARRAY_START), /* below are the options allowed within a array */
+  CFINIT(FILE),
+  CFINIT(CONTENTTYPE),
+  CFINIT(END),
+  CFINIT(ARRAY_END),   /* up are the options allowed within a array */
+
+  CURLFORM_LASTENTRY /* the last unusued */
+} CURLformoption;
+
+/* structure to be used as parameter for CURLFORM_ARRAY */
+struct curl_forms {
+	CURLformoption		option;
+	const char		*value;
+};
+
+/* new external form function */
+int curl_formadd(struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...);
+
 /* cleanup a form: */
 void curl_formfree(struct HttpPost *form);
 
@@ -495,8 +572,8 @@ char *curl_version(void);
 
 /* Escape and unescape URL encoding in strings. The functions return a new
  * allocated string or NULL if an error occurred.  */
-char *curl_escape(char *string, int length);
-char *curl_unescape(char *string, int length);
+char *curl_escape(const char *string, int length);
+char *curl_unescape(const char *string, int length);
 
 /* curl_global_init() should be invoked exactly once for each application that
    uses libcurl */
@@ -507,8 +584,8 @@ CURLcode curl_global_init(long flags);
 void curl_global_cleanup(void);
 
 /* This is the version number */
-#define LIBCURL_VERSION "7.8.1"
-#define LIBCURL_VERSION_NUM 0x070801
+#define LIBCURL_VERSION "7.9.2"
+#define LIBCURL_VERSION_NUM 0x070902
 
 /* linked-list structure for the CURLOPT_QUOTE option (and other) */
 struct curl_slist {
@@ -558,7 +635,9 @@ typedef enum {
   CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,
   CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,
 
-  CURLINFO_LASTONE          = 17
+  CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
+
+  CURLINFO_LASTONE          = 18
 } CURLINFO;
 
 /* unfortunately, the easy.h include file needs the options and info stuff

include/curl/easy.h

@@ -46,6 +46,21 @@ void curl_easy_cleanup(CURL *curl);
  */
 CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
 
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistant connections cannot
+ * be transfered. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL* curl_easy_duphandle(CURL *curl);
+
 #ifdef  __cplusplus
 }
 #endif

java/CurlGlue.java

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-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

@@ -1,35 +0,0 @@
-
-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

@@ -1,15 +0,0 @@
-                                  _   _ ____  _     
-                              ___| | | |  _ \| |    
-                             / __| | | | |_) | |    
-                            | (__| |_| |  _ <| |___ 
-                             \___|\___/|_| \_\_____|
-
-                                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

@@ -1,22 +0,0 @@
-#!/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

@@ -1,196 +0,0 @@
-
-#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

@@ -1,27 +0,0 @@
-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

@@ -10,13 +10,10 @@ EXTRA_DIST = getdate.y \
 
 lib_LTLIBRARIES = libcurl.la
 
-# Some flags needed when trying to cause warnings ;-)
-# CFLAGS = -DMALLOCDEBUG -g # -Wall #-pedantic
-
 INCLUDES = -I$(top_srcdir)/include
 
 
-libcurl_la_LDFLAGS = -version-info 2:1:0
+libcurl_la_LDFLAGS = -no-undefined -version-info 2:2:0
 # This flag accepts an argument of the form current[:revision[:age]]. So,
 # passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
 # 1.
@@ -59,7 +56,7 @@ escape.c       mprintf.c      telnet.c       \
 escape.h       getpass.c      netrc.c        telnet.h       \
 getinfo.c getinfo.h transfer.c strequal.c strequal.h easy.c \
 security.h security.c krb4.c krb4.h memdebug.c memdebug.h inet_ntoa_r.h \
-http_chunks.c http_chunks.h strtok.c strtok.h
+http_chunks.c http_chunks.h strtok.c strtok.h connect.c connect.h
 
 noinst_HEADERS = setup.h transfer.h
 

lib/Makefile.b32

@@ -23,7 +23,7 @@ INCDIRS    = -I$(CURNTDIR);$(TOPDIR)/include/
 # 'BCCDIR' has to be set up in your c:\autoexec.bat
 # i.e. SET BCCDIR = c:\Borland\BCC55
 # where c:\Borland\BCC55 is the compiler is installed
-LINKLIB	   = $(BCCDIR)/lib/psdk/wsock32.lib
+LINKLIB	   = $(BCCDIR)/lib/psdk/ws2_32.lib
 LIBCURLLIB = libcurl.lib
 
 .SUFFIXES: .c
@@ -58,7 +58,8 @@ SOURCES	   = \
 	version.c \
 	easy.c \
 	strequal.c \
-	strtok.c
+	strtok.c \
+	connect.c
 
 OBJECTS = $(SOURCES:.c=.obj)
 

lib/Makefile.b32.resp

@@ -27,5 +27,5 @@
 +version.obj &
 +easy.obj &
 +strequal.obj &
-+strtok.obj
-
++strtok.obj &
++connect.obj

lib/Makefile.m32

@@ -1,5 +1,4 @@
 #############################################################
-# $Id$
 #
 ## Makefile for building libcurl.a with MingW32 (GCC-2.95) and
 ## optionally OpenSSL (0.9.6)
@@ -12,7 +11,7 @@ CC = gcc
 AR = ar
 RANLIB = ranlib
 STRIP = strip -g
-OPENSSL_PATH = ../../openssl-0.9.6
+OPENSSL_PATH = ../../openssl-0.9.6b
 
 ########################################################
 ## Nothing more to do below this line!
@@ -36,14 +35,14 @@ libcurl_a_SOURCES = arpa_telnet.h file.c getpass.h netrc.h timeval.c base64.c \
 	ldap.h ssluse.h escape.c getenv.h mprintf.c telnet.c escape.h getpass.c netrc.c	\
 	telnet.h getinfo.c strequal.c strequal.h easy.c security.h		\
 	security.c krb4.h krb4.c memdebug.h memdebug.c inet_ntoa_r.h http_chunks.h http_chunks.c \
-	strtok.c
+	strtok.c connect.c
 
 libcurl_a_OBJECTS =  file.o timeval.o base64.o hostip.o progress.o \
 	formdata.o cookie.o http.o sendf.o ftp.o url.o dict.o if2ip.o \
 	speedcheck.o getdate.o transfer.o ldap.o ssluse.o version.o \
 	getenv.o escape.o mprintf.o telnet.o getpass.o netrc.o getinfo.o \
 	strequal.o easy.o security.o krb4.o memdebug.o http_chunks.o \
-	strtok.o
+	strtok.o connect.o
 
 LIBRARIES =  $(libcurl_a_LIBRARIES)
 SOURCES = $(libcurl_a_SOURCES)
@@ -62,7 +61,7 @@ libcurl.a: $(libcurl_a_OBJECTS) $(libcurl_a_DEPENDENCIES)
 
 libcurl.dll libcurldll.a: libcurl.a libcurl.def dllinit.o
 	-@erase $@
-	dllwrap --dllname $@ --output-lib libcurldll.a --export-all --def libcurl.def $(libcurl_a_LIBRARIES) dllinit.o -L$(OPENSSL_PATH)/out $(DLL_LIBS) -lwsock32
+	dllwrap --dllname $@ --output-lib libcurldll.a --export-all --def libcurl.def $(libcurl_a_LIBRARIES) dllinit.o -L$(OPENSSL_PATH)/out $(DLL_LIBS) -lwsock32 -lws2_32
 	$(STRIP) $@
 
 # remove the last line above to keep debug info

lib/Makefile.vc6

@@ -1,369 +1,218 @@
 #############################################################
-# $Id: Makefile.am,v 1.20 2001/08/08 07:46:44 bagder Exp $
 #
-## Makefile for building libcurl.lib with MSVC6
-## Use: nmake -f makefile.vc6 [release | release-ssl | debug]
-##      (default is release)
-##
-## Comments to: Troy Engel <tengel@sonic.net>
-## Updated by: Craig Davison <cd@securityfocus.com>
-## Updated by: SM <sm@technologist.com>
+# Makefile for building libcurl with MSVC6
+#
+# Usage: see usage message below
+#        Should be invoked from \lib directory
+#        Edit the paths and desired library name
+#        SSL path is only required if you intend compiling 
+#        with SSL.
+#
+# This make file leaves the result either a .lib or .dll file
+# in the \lib directory. It should be called from the \lib
+# directory.
+#
+# An option would have been to allow the source directory to
+# be specified, but I saw no requirement.
+#
+# Another option would have been to leave the .lib and .dll
+# files in the "cfg" directory, but then the make file
+# in \src would need to be changed.      
+#      
+##############################################################
+# CHANGE LOG 
+# ------------------------------------------------------------
+# 05.11.2001   John Lask   Initial Release
+# 
+#
+##############################################################
 
-PROGRAM_NAME = libcurl.lib
-PROGRAM_NAME_DEBUG = libcurld.lib
-#OPENSSL_PATH = ../../openssl-0.9.6b
+LIB_NAME       = libcurl
+LIB_NAME_DEBUG = libcurld
+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)/inc32" /I "$(OPENSSL_PATH)/inc32/openssl"
-LINKRS = link.exe -lib /out:$(PROGRAM_NAME) /LIBPATH:$(OPENSSL_PATH)/out32dll
-
+CCNODBG   = cl.exe /MD /O2 /D "NDEBUG"
+CCDEBUG   = cl.exe /MDd /Od /Gm /Zi  /D "_DEBUG" /GZ
+CFLAGSSSL = /D "USE_SSLEAY" /I "$(OPENSSL_PATH)/inc32" /I "$(OPENSSL_PATH)/inc32/openssl"
 CFLAGS = /I "../include" /nologo /W3 /GX /D "WIN32" /D "VC6" /D "_MBCS" /D "_LIB" /YX /FD /c /D "MSDOS"
+
+LNKDLL    = link.exe /DLL  /def:libcurl.def
+LNKLIB    = link.exe -lib
 LFLAGS    = /nologo
-LINKLIBS = wsock32.lib
-LINKSLIBS = libeay32.lib ssleay32.lib RSAglue.lib
+LFLAGSSSL = /LIBPATH:$(OPENSSL_PATH)/out32dll
+LINKLIBS  = ws2_32.lib
+SSLLIBS   = libeay32.lib ssleay32.lib RSAglue.lib
+CFGSET    = FALSE
 
-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 \
-	strtokr.obj
+######################
+# release
 
-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 \
-	strtokd.obj
+!IF "$(CFG)" == "release" 
+TARGET =$(LIB_NAME).lib
+DIROBJ =.\$(CFG)
+LNK    = $(LNKLIB) /out:$(TARGET)
+CC     = $(CCNODBG)
+CFGSET = TRUE
+!ENDIF
 
-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 \
-	strtokd.obj
+######################
+# release-dll
 
-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 \
-	strtok.obj
+!IF "$(CFG)" == "release-dll" 
+TARGET =$(LIB_NAME).dll
+DIROBJ =.\$(CFG)
+LNK    = $(LNKDLL) /out:$(TARGET) /IMPLIB:"$(LIB_NAME).lib"
+CC     = $(CCNODBG)
+CFGSET = TRUE
+!ENDIF
 
-all : release
+######################
+# release-ssl
 
-release: $(RELEASE_OBJS)
-	$(LINKR) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
+!IF "$(CFG)" == "release-ssl" 
+TARGET   =$(LIB_NAME).lib
+DIROBJ   =.\$(CFG)
+LNK      = $(LNKLIB) $(LFLAGSSSL) /out:$(TARGET)
+LINKLIBS = $(LINKLIBS) $(SSLLIBS)
+CC       = $(CCNODBG) $(CFLAGSSSL)
+CFGSET   = TRUE 
+!ENDIF
 
-debug: $(DEBUG_OBJS)
-	$(LINKD) $(LFLAGS) $(LINKLIBS) $(LINK_OBJS)
+######################
+# release-ssl-dll
 
-release-ssl: $(RELEASE_SSL_OBJS)
-	$(LINKRS) $(LFLAGS) $(LINKLIBS) $(LINKSLIBS) $(LINK_OBJS)
+!IF "$(CFG)" == "release-ssl-dll" 
+TARGET   =$(LIB_NAME).dll
+DIROBJ   =.\$(CFG)
+LNK      = $(LNKDLL) $(LFLAGSSSL) /out:$(TARGET) /IMPLIB:"$(LIB_NAME).lib" 
+LINKLIBS = $(LINKLIBS) $(SSLLIBS)
+CC       = $(CCNODBG)  $(CFLAGSSSL)
+CFGSET   = TRUE 
+!ENDIF
 
-## 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
-strtokr.obj:strtok.c
-	$(CCR) $(CFLAGS) strtok.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
-strtokd.obj:strtok.c
-	$(CCD) $(CFLAGS) strtok.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
-strtokrs.obj:strtok.c
-	$(CCRS) $(CFLAGS) strtok.c
 
+######################
+# debug
+
+!IF "$(CFG)" == "debug" 
+TARGET =$(LIB_NAME_DEBUG).lib
+DIROBJ =.\$(CFG)
+LNK    = $(LNKLIB) /out:$(TARGET)
+CC     = $(CCDEBUG)
+CFGSET = TRUE
+!ENDIF
+
+######################
+# debug-dll
+
+!IF "$(CFG)" == "debug-dll" 
+TARGET =$(LIB_NAME_DEBUG).dll
+DIROBJ =.\$(CFG)
+LNK    = $(LNKDLL) /out:$(TARGET) /IMPLIB:"$(LIB_NAME_DEBUG).lib"
+CC     = $(CCDEBUG)
+CFGSET = TRUE
+!ENDIF
+
+######################
+# debug-ssl
+#todo
+!IF "$(CFG)" == "debug-ssl" 
+TARGET   = $(LIB_NAME_DEBUG).lib
+DIROBJ   =.\$(CFG)
+LNK      = $(LNKLIB) $(LFLAGSSSL) /out:$(TARGET)
+LINKLIBS = $(LINKLIBS) $(SSLLIBS)
+CC       = $(CCDEBUG) $(CFLAGSSSL)
+CFGSET   = TRUE
+!ENDIF
+
+######################
+# debug-ssl-dll
+
+!IF "$(CFG)" == "debug-ssl-dll" 
+TARGET   =$(LIB_NAME_DEBUG).dll
+DIROBJ   =.\$(CFG)
+LNK      = $(LNKDLL) $(LFLAGSSSL) /out:$(TARGET) /IMPLIB:"$(LIB_NAME_DEBUG).lib" 
+LINKLIBS = $(LINKLIBS) $(SSLLIBS)
+CC       = $(CCDEBUG) $(CFLAGSSSL)
+CFGSET   = TRUE
+!ENDIF
+
+#######################
+# Usage
+#
+!IF "$(CFGSET)" == "FALSE"
+!MESSAGE Usage: nmake -f makefile.vc6 CFG=<config> <target>
+!MESSAGE where <config> is one of:
+!MESSAGE   release          - release static library
+!MESSAGE   release-dll      - release dll
+!MESSAGE   release-ssl      - release static library with ssl
+!MESSAGE   release-ssl-dll  - release dll library with ssl
+!MESSAGE   debug            - debug static library
+!MESSAGE   debug-dll        - debug dll
+!MESSAGE   debug-ssl        - debug static library with ssl
+!MESSAGE   debug-ssl-dll    - debug dll library with ssl
+!MESSAGE <target> can be left blank in which case all is assumed
+!ERROR please choose a valid configuration "$(CFG)"
+!ENDIF
+
+#######################
+#
+X_OBJS= \
+	$(DIROBJ)\base64.obj \
+	$(DIROBJ)\cookie.obj \
+	$(DIROBJ)\transfer.obj \
+	$(DIROBJ)\escape.obj \
+	$(DIROBJ)\formdata.obj \
+	$(DIROBJ)\ftp.obj \
+	$(DIROBJ)\http.obj \
+	$(DIROBJ)\http_chunks.obj \
+	$(DIROBJ)\ldap.obj \
+	$(DIROBJ)\dict.obj \
+	$(DIROBJ)\telnet.obj \
+	$(DIROBJ)\getdate.obj \
+	$(DIROBJ)\getenv.obj \
+	$(DIROBJ)\getpass.obj \
+	$(DIROBJ)\hostip.obj \
+	$(DIROBJ)\if2ip.obj \
+	$(DIROBJ)\mprintf.obj \
+	$(DIROBJ)\netrc.obj \
+	$(DIROBJ)\progress.obj \
+	$(DIROBJ)\sendf.obj \
+	$(DIROBJ)\speedcheck.obj \
+	$(DIROBJ)\ssluse.obj \
+	$(DIROBJ)\timeval.obj \
+	$(DIROBJ)\url.obj \
+	$(DIROBJ)\file.obj \
+	$(DIROBJ)\getinfo.obj \
+	$(DIROBJ)\version.obj \
+	$(DIROBJ)\easy.obj \
+	$(DIROBJ)\strequal.obj \
+	$(DIROBJ)\strtok.obj \
+	$(DIROBJ)\connect.obj
+
+
+all : $(TARGET)
+
+
+$(TARGET): $(X_OBJS)
+	$(LNK) $(LFLAGS) $(LINKLIBS) $(X_OBJS)
+
+$(X_OBJS): $(DIROBJ)
+
+$(DIROBJ):
+	@if not exist "$(DIROBJ)" mkdir $(DIROBJ)
+
+.SUFFIXES: .c .obj
+
+{.\}.c{$(DIROBJ)\}.obj:
+	$(CC) $(CFLAGS) /Fo"$@"  $<
 
 clean:
-	-@erase *.obj
+	-@erase $(DIROBJ)\*.obj
 	-@erase vc60.idb
 	-@erase vc60.pch
-
-distrib: clean
-	-@erase $(PROGRAM_NAME)
-

lib/arpa_telnet.h

@@ -42,7 +42,7 @@
 static const char *telnetoptions[]=
 {
   "BINARY",      "ECHO",           "RCP",           "SUPPRESS GO AHEAD",
-  "NAME",        "STATUS"          "TIMING MARK",   "RCTE",
+  "NAME",        "STATUS",         "TIMING MARK",   "RCTE",
   "NAOL",        "NAOP",           "NAOCRD",        "NAOHTS",
   "NAOHTD",      "NAOFFD",         "NAOVTS",        "NAOVTD",
   "NAOLFD",      "EXTEND ASCII",   "LOGOUT",        "BYTE MACRO",

lib/base64.c

@@ -32,9 +32,8 @@
  * This code will break if int is smaller than 32 bits
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "setup.h"
+
 #include <stdlib.h>
 #include <string.h>
 
@@ -261,3 +260,11 @@ void *suck(int *lenptr) {
 }
 #endif
 
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/connect.c

@@ -0,0 +1,576 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+
+#ifndef WIN32
+/* headers for non-win32 */
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h> /* required for free() prototype, without it, this crashes
+                       on macos 68K */
+#endif
+
+#endif
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+#ifdef WIN32
+#define HAVE_IOCTLSOCKET
+#include <windows.h>
+#include <winsock.h>
+#define EINPROGRESS WSAEINPROGRESS
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#define EISCONN     WSAEISCONN
+#endif
+
+#include "urldata.h"
+#include "sendf.h"
+#include "if2ip.h"
+
+/* The last #include file should be: */
+#ifdef MALLOCDEBUG
+#include "memdebug.h"
+#endif
+
+static
+int geterrno(void)
+{
+#ifdef WIN32
+  return (int)GetLastError();
+#else
+  return errno;
+#endif
+}
+
+/*************************************************************************
+ * Curl_nonblock
+ *
+ * Description:
+ *  Set the socket to either blocking or non-blocking mode.
+ */
+
+int Curl_nonblock(int socket,    /* operate on this */
+                  int nonblock   /* TRUE or FALSE */)
+{
+#undef SETBLOCK
+#ifdef HAVE_O_NONBLOCK
+  int flags;
+
+  flags = fcntl(socket, F_GETFL, 0);
+  if (TRUE == nonblock)
+    return fcntl(socket, F_SETFL, flags | O_NONBLOCK);
+  else
+    return fcntl(socket, F_SETFL, flags & (~O_NONBLOCK));
+#define SETBLOCK 1
+#endif
+
+#ifdef HAVE_FIONBIO
+  int flags;
+
+  flags = nonblock;
+  return ioctl(socket, FIONBIO, &flags);
+#define SETBLOCK 2
+#endif
+
+#ifdef HAVE_IOCTLSOCKET
+  int flags;
+  flags = nonblock;
+  return ioctlsocket(socket, FIONBIO, &flags);
+#define SETBLOCK 3
+#endif
+
+#ifdef HAVE_IOCTLSOCKET_CASE
+  return IoctlSocket(socket, FIONBIO, (long)nonblock);
+#define SETBLOCK 4
+#endif
+
+#ifdef HAVE_DISABLED_NONBLOCKING
+  return 0; /* returns success */
+#define SETBLOCK 5
+#endif
+
+#ifndef SETBLOCK
+#error "no non-blocking method was found/used/set"
+#endif
+}
+
+/*
+ * Return 0 on fine connect, -1 on error and 1 on timeout.
+ */
+static
+int waitconnect(int sockfd, /* socket */
+                int timeout_msec)
+{
+  fd_set fd;
+  fd_set errfd;
+  struct timeval interval;
+  int rc;
+
+  /* now select() until we get connect or timeout */
+  FD_ZERO(&fd);
+  FD_SET(sockfd, &fd);
+
+  FD_ZERO(&errfd);
+  FD_SET(sockfd, &errfd);
+
+  interval.tv_sec = timeout_msec/1000;
+  timeout_msec -= interval.tv_sec*1000;
+
+  interval.tv_usec = timeout_msec*1000;
+
+  rc = select(sockfd+1, NULL, &fd, &errfd, &interval);
+  if(-1 == rc)
+    /* error, no connect here, try next */
+    return -1;
+  
+  else if(0 == rc)
+    /* timeout, no connect today */
+    return 1;
+
+  if(FD_ISSET(sockfd, &errfd)) {
+    /* error condition caught */
+    return 2;
+  }
+
+  /* we have a connect! */
+  return 0;
+}
+
+#ifndef ENABLE_IPV6
+static CURLcode bindlocal(struct connectdata *conn,
+                          int sockfd)
+{
+#if !defined(WIN32)||defined(__CYGWIN32__)
+  /* We don't generally like checking for OS-versions, we should make this
+     HAVE_XXXX based, although at the moment I don't have a decent test for
+     this! */
+
+#ifdef HAVE_INET_NTOA
+
+#ifndef INADDR_NONE
+#define INADDR_NONE (unsigned long) ~0
+#endif
+
+  struct SessionHandle *data = conn->data;
+
+  /*************************************************************
+   * Select device to bind socket to
+   *************************************************************/
+  if (strlen(data->set.device)<255) {
+    struct sockaddr_in sa;
+    struct hostent *h=NULL;
+    char *hostdataptr=NULL;
+    size_t size;
+    char myhost[256] = "";
+    unsigned long in;
+
+    if(Curl_if2ip(data->set.device, myhost, sizeof(myhost))) {
+      h = Curl_getaddrinfo(data, myhost, 0, &hostdataptr);
+    }
+    else {
+      if(strlen(data->set.device)>1) {
+        h = Curl_getaddrinfo(data, data->set.device, 0, &hostdataptr);
+      }
+      if(h) {
+        /* we know data->set.device is shorter than the myhost array */
+        strcpy(myhost, data->set.device);
+      }
+    }
+
+    if(! *myhost) {
+      /* need to fix this
+         h=Curl_gethost(data,
+         getmyhost(*myhost,sizeof(myhost)),
+         hostent_buf,
+         sizeof(hostent_buf));
+      */
+      if(hostdataptr)
+        free(hostdataptr); /* allocated by Curl_getaddrinfo() */
+      return CURLE_HTTP_PORT_FAILED;
+    }
+
+    infof(data, "We bind local end to %s\n", myhost);
+
+    if ( (in=inet_addr(myhost)) != INADDR_NONE ) {
+
+      if ( h ) {
+        memset((char *)&sa, 0, sizeof(sa));
+        memcpy((char *)&sa.sin_addr,
+               h->h_addr,
+               h->h_length);
+        sa.sin_family = AF_INET;
+        sa.sin_addr.s_addr = in;
+        sa.sin_port = 0; /* get any port */
+	
+        if( bind(sockfd, (struct sockaddr *)&sa, sizeof(sa)) >= 0) {
+          /* we succeeded to bind */
+          struct sockaddr_in add;
+	
+          size = sizeof(add);
+          if(getsockname(sockfd, (struct sockaddr *) &add,
+                         (socklen_t *)&size)<0) {
+            failf(data, "getsockname() failed");
+            return CURLE_HTTP_PORT_FAILED;
+          }
+        }
+        else {
+          switch(errno) {
+          case EBADF:
+            failf(data, "Invalid descriptor: %d", errno);
+            break;
+          case EINVAL:
+            failf(data, "Invalid request: %d", errno);
+            break;
+          case EACCES:
+            failf(data, "Address is protected, user not superuser: %d", errno);
+            break;
+          case ENOTSOCK:
+            failf(data,
+                  "Argument is a descriptor for a file, not a socket: %d",
+                  errno);
+            break;
+          case EFAULT:
+            failf(data, "Inaccessable memory error: %d", errno);
+            break;
+          case ENAMETOOLONG:
+            failf(data, "Address too long: %d", errno);
+            break;
+          case ENOMEM:
+            failf(data, "Insufficient kernel memory was available: %d", errno);
+            break;
+          default:
+            failf(data, "errno %d\n", errno);
+            break;
+          } /* end of switch(errno) */
+	
+          return CURLE_HTTP_PORT_FAILED;
+        } /* end of else */
+	
+      } /* end of if  h */
+      else {
+	failf(data,"could't find my own IP address (%s)", myhost);
+	return CURLE_HTTP_PORT_FAILED;
+      }
+    } /* end of inet_addr */
+
+    else {
+      failf(data, "could't find my own IP address (%s)", myhost);
+      return CURLE_HTTP_PORT_FAILED;
+    }
+
+    if(hostdataptr)
+      free(hostdataptr); /* allocated by Curl_getaddrinfo() */
+
+    return CURLE_OK;
+
+  } /* end of device selection support */
+#endif /* end of HAVE_INET_NTOA */
+#endif /* end of not WIN32 */
+
+  return CURLE_HTTP_PORT_FAILED;
+}
+#endif /* end of ipv4-specific section */
+
+static
+int socketerror(int sockfd)
+{
+  int err = 0;
+  socklen_t errSize = sizeof(err);
+
+  if( -1 == getsockopt(sockfd, SOL_SOCKET, SO_ERROR,
+                       (void *)&err, &errSize))
+    err = geterrno();
+  
+  return err;
+}
+
+/*
+ * TCP connect to the given host with timeout, proxy or remote doesn't matter.
+ * There might be more than one IP address to try out. Fill in the passed
+ * pointer with the connected socket.
+ */
+
+CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
+                          Curl_addrinfo *remotehost, /* use one in here */
+                          int port,                  /* connect to this */
+                          int *sockconn,             /* the connected socket */
+                          Curl_ipconnect **addr)     /* the one we used */
+{
+  struct SessionHandle *data = conn->data;
+  int rc;
+  int sockfd=-1;
+  int aliasindex=0;
+
+  struct timeval after;
+  struct timeval before = Curl_tvnow();
+
+  /*************************************************************
+   * Figure out what maximum time we have left
+   *************************************************************/
+  long timeout_ms=300000; /* milliseconds, default to five minutes */
+  if(data->set.timeout || data->set.connecttimeout) {
+    double has_passed;
+
+    /* Evaluate in milliseconds how much time that has passed */
+    has_passed = Curl_tvdiff(Curl_tvnow(), data->progress.start);
+
+#ifndef min
+#define min(a, b)   ((a) < (b) ? (a) : (b))
+#endif
+
+    /* get the most strict timeout of the ones converted to milliseconds */
+    if(data->set.timeout &&
+       (data->set.timeout>data->set.connecttimeout))
+      timeout_ms = data->set.timeout*1000;
+    else
+      timeout_ms = data->set.connecttimeout*1000;
+
+    /* subtract the passed time */
+    timeout_ms -= (long)has_passed;
+
+    if(timeout_ms < 0)
+      /* a precaution, no need to continue if time already is up */
+      return CURLE_OPERATION_TIMEOUTED;
+  }
+
+#ifdef ENABLE_IPV6
+  /*
+   * Connecting with IPv6 support is so much easier and cleanly done
+   */
+  {
+    struct addrinfo *ai;
+    port =0; /* prevent compiler warning */
+
+    for (ai = remotehost; ai; ai = ai->ai_next, aliasindex++) {
+      sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+      if (sockfd < 0)
+        continue;
+
+      /* set socket non-blocking */
+      Curl_nonblock(sockfd, TRUE);
+
+      rc = connect(sockfd, ai->ai_addr, ai->ai_addrlen);
+
+      if(-1 == rc) {
+        int error=geterrno();
+
+        switch (error) {
+        case EINPROGRESS:
+        case EWOULDBLOCK:
+#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
+          /* On some platforms EAGAIN and EWOULDBLOCK are the
+           * same value, and on others they are different, hence
+           * the odd #if
+           */
+        case EAGAIN:
+#endif
+        case EINTR:
+
+          /* asynchronous connect, wait for connect or timeout */
+          rc = waitconnect(sockfd, timeout_ms);
+          break;
+        case ECONNREFUSED: /* no one listening */
+        default:
+          /* unknown error, fallthrough and try another address! */
+          failf(data, "Failed to connect");
+          break;
+        }
+      }
+      if(0 == rc) {
+        /* we might be connected, if the socket says it is OK! Ask it! */
+        int err;
+
+        err = socketerror(sockfd);
+        if ((0 == err) || (EISCONN == err)) {
+          /* we are connected, awesome! */
+          break;
+	}
+        /* we are _not_ connected, it was a false alert, continue please */
+      }
+
+      /* connect failed or timed out */
+      sclose(sockfd);
+      sockfd = -1;
+
+      /* get a new timeout for next attempt */
+      after = Curl_tvnow();
+      timeout_ms -= Curl_tvdiff(after, before);
+      if(timeout_ms < 0) {
+        failf(data, "connect() timed out!");
+        return CURLE_OPERATION_TIMEOUTED;
+      }
+      before = after;
+      continue;
+    }
+    if (sockfd < 0) {
+      failf(data, "connect() failed");
+      return CURLE_COULDNT_CONNECT;
+    }
+
+    /* now disable the non-blocking mode again */
+    Curl_nonblock(sockfd, FALSE);
+
+    if(addr)
+      *addr = ai; /* the address we ended up connected to */
+  }
+#else
+  /*
+   * Connecting with IPv4-only support
+   */
+  if(!remotehost->h_addr_list[0]) {
+    /* If there is no addresses in the address list, then we return
+       error right away */
+    failf(data, "no address available");
+    return CURLE_COULDNT_CONNECT;
+  }
+  /* create an IPv4 TCP socket */
+  sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  if(-1 == sockfd) {
+    failf(data, "couldn't create socket");
+    return CURLE_COULDNT_CONNECT; /* big time error */
+  }
+  
+  if(conn->data->set.device) {
+    /* user selected to bind the outgoing socket to a specified "device"
+       before doing connect */
+    CURLcode res = bindlocal(conn, sockfd);
+    if(res)
+      return res;
+  }
+
+  /* Convert socket to non-blocking type */
+  Curl_nonblock(sockfd, TRUE);
+
+  /* This is the loop that attempts to connect to all IP-addresses we
+     know for the given host. One by one. */
+  for(rc=-1, aliasindex=0;
+      rc && (struct in_addr *)remotehost->h_addr_list[aliasindex];
+      aliasindex++) {
+    struct sockaddr_in serv_addr;
+
+    /* do this nasty work to do the connect */
+    memset((char *) &serv_addr, '\0', sizeof(serv_addr));
+    memcpy((char *)&(serv_addr.sin_addr),
+           (struct in_addr *)remotehost->h_addr_list[aliasindex],
+           sizeof(struct in_addr));
+    serv_addr.sin_family = remotehost->h_addrtype;
+    serv_addr.sin_port = htons(port);
+  
+    rc = connect(sockfd, (struct sockaddr *)&serv_addr,
+                 sizeof(serv_addr));
+
+    if(-1 == rc) {
+      int error=geterrno();
+
+      switch (error) {
+      case EINPROGRESS:
+      case EWOULDBLOCK:
+#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
+        /* On some platforms EAGAIN and EWOULDBLOCK are the
+         * same value, and on others they are different, hence
+         * the odd #if
+         */
+      case EAGAIN:
+#endif
+
+        /* asynchronous connect, wait for connect or timeout */
+        rc = waitconnect(sockfd, timeout_ms);
+        break;
+      default:
+        /* unknown error, fallthrough and try another address! */
+        failf(data, "Failed to connect to IP number %d", aliasindex+1);
+        break;
+      }
+    }
+
+    if(0 == rc) {
+      int err = socketerror(sockfd);
+      if ((0 == err) || (EISCONN == err)) {
+        /* we are connected, awesome! */
+        break;
+      }
+      /* nope, not connected for real */
+      rc = -1;
+    }
+
+    if(0 != rc) {
+      /* get a new timeout for next attempt */
+      after = Curl_tvnow();
+      timeout_ms -= Curl_tvdiff(after, before);
+      if(timeout_ms < 0) {
+        failf(data, "Connect timeout on IP number %d", aliasindex+1);
+        break;
+      }
+      before = after;
+      continue; /* try next address */
+    }
+    break;
+  }
+  if(0 != rc) {
+    /* no good connect was made */
+    sclose(sockfd);
+    *sockconn = -1;
+    failf(data, "Couldn't connect to host");
+    return CURLE_COULDNT_CONNECT;
+  }
+  
+  /* now disable the non-blocking mode again */
+  Curl_nonblock(sockfd, FALSE);
+
+  if(addr)
+    /* this is the address we've connected to */
+    *addr = (struct in_addr *)remotehost->h_addr_list[aliasindex];
+#endif
+
+  /* allow NULL-pointers to get passed in */
+  if(sockconn)
+    *sockconn = sockfd;    /* the socket descriptor we've connected */
+
+  return CURLE_OK;
+}
+

lib/connect.h

@@ -0,0 +1,35 @@
+#ifndef __CONNECT_H
+#define __CONNECT_H
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+int Curl_nonblock(int socket,    /* operate on this */
+                  int nonblock   /* TRUE or FALSE */);
+
+CURLcode Curl_connecthost(struct connectdata *conn,
+                          Curl_addrinfo *host, /* connect to this */
+                          int port,       /* connect to this port number */
+                          int *sockconn,  /* not set if error is returned */
+                          Curl_ipconnect **addr /* the one we used */
+                          ); /*  index we used */
+#endif

lib/cookie.c

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

lib/cookie.h

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

lib/curllib.dsp

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

lib/dict.c

@@ -90,7 +90,7 @@ CURLcode Curl_dict(struct connectdata *conn)
   char *nthdef = NULL; /* This is not part of the protocol, but required
                           by RFC 2229 */
   CURLcode result=CURLE_OK;
-  struct UrlData *data=conn->data;
+  struct SessionHandle *data=conn->data;
 
   char *path = conn->path;
   long *bytecount = &conn->bytecount;
@@ -136,7 +136,7 @@ CURLcode Curl_dict(struct connectdata *conn)
       nth = atoi(nthdef);
     }
       
-    Curl_sendf(conn->firstsocket, conn,
+    result = Curl_sendf(conn->firstsocket, conn,
                         "CLIENT " LIBCURL_NAME " " LIBCURL_VERSION "\n"
                         "MATCH "
                         "%s "    /* database */
@@ -148,13 +148,13 @@ CURLcode Curl_dict(struct connectdata *conn)
                         strategy,
                         word
                         );
-    
+    if(result)
+      failf(data, "Failed sending DICT request");
+    else
       result = Curl_Transfer(conn, conn->firstsocket, -1, FALSE, bytecount,
                              -1, NULL); /* no upload */      
-      
     if(result)
       return result;
-    
   }
   else if (strnequal(path, DICT_DEFINE, sizeof(DICT_DEFINE)-1) ||
            strnequal(path, DICT_DEFINE2, sizeof(DICT_DEFINE2)-1) ||
@@ -186,17 +186,17 @@ CURLcode Curl_dict(struct connectdata *conn)
       nth = atoi(nthdef);
     }
       
-    Curl_sendf(conn->firstsocket, conn,
+    result = Curl_sendf(conn->firstsocket, conn,
                         "CLIENT " LIBCURL_NAME " " LIBCURL_VERSION "\n"
                         "DEFINE "
                         "%s "     /* database */
                         "%s\n"    /* word */
                         "QUIT\n",
-               
                         database,
-               word
-               );
-    
+                        word);
+    if(result)
+      failf(data, "Failed sending DICT request");
+    else
       result = Curl_Transfer(conn, conn->firstsocket, -1, FALSE, bytecount,
                              -1, NULL); /* no upload */
     
@@ -215,20 +215,27 @@ CURLcode Curl_dict(struct connectdata *conn)
         if (ppath[i] == ':')
           ppath[i] = ' ';
       }
-      Curl_sendf(conn->firstsocket, conn,
+      result = Curl_sendf(conn->firstsocket, conn,
                           "CLIENT " LIBCURL_NAME " " LIBCURL_VERSION "\n"
                           "%s\n"
-                 "QUIT\n",
-                 ppath);
-      
+                          "QUIT\n", ppath);
+      if(result)
+        failf(data, "Failed sending DICT request");
+      else
         result = Curl_Transfer(conn, conn->firstsocket, -1, FALSE, bytecount,
                                -1, NULL);
-      
       if(result)
         return result;
-      
     }
   }
 
   return CURLE_OK;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/dllinit.c

@@ -82,3 +82,11 @@ DllMain (
   return TRUE;
 }
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/easy.c

@@ -94,7 +94,7 @@ static CURLcode win32_init(void)
   WORD wVersionRequested;  
   WSADATA wsaData; 
   int err; 
-  wVersionRequested = MAKEWORD(1, 1); 
+  wVersionRequested = MAKEWORD(2, 0); 
     
   err = WSAStartup(wVersionRequested, &wsaData); 
     
@@ -103,14 +103,14 @@ static CURLcode win32_init(void)
     /* winsock.dll.     */ 
     return CURLE_FAILED_INIT; 
     
-  /* Confirm that the Windows Sockets DLL supports 1.1.*/ 
+  /* Confirm that the Windows Sockets DLL supports 2.0.*/ 
   /* Note that if the DLL supports versions greater */ 
-  /* than 1.1 in addition to 1.1, it will still return */ 
-  /* 1.1 in wVersion since that is the version we */ 
+  /* than 2.0 in addition to 2.0, it will still return */ 
+  /* 2.0 in wVersion since that is the version we */ 
   /* requested. */ 
     
-  if ( LOBYTE( wsaData.wVersion ) != 1 || 
-       HIBYTE( wsaData.wVersion ) != 1 ) { 
+  if ( LOBYTE( wsaData.wVersion ) != 2 || 
+       HIBYTE( wsaData.wVersion ) != 0 ) { 
     /* Tell the user that we couldn't find a useable */ 
 
     /* winsock.dll. */ 
@@ -175,7 +175,7 @@ void curl_global_cleanup(void)
 CURL *curl_easy_init(void)
 {
   CURLcode res;
-  struct UrlData *data;
+  struct SessionHandle *data;
 
   /* Make sure we inited the global SSL stuff */
   if (!initialized)
@@ -186,9 +186,6 @@ CURL *curl_easy_init(void)
   if(res != CURLE_OK)
     return NULL;
 
-  /* SAC */
-  data->device = NULL;
-
   return data;
 }
 
@@ -199,7 +196,7 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...)
   func_T param_func = (func_T)0;
   long param_long = 0;
   void *param_obj = NULL;
-  struct UrlData *data = curl;
+  struct SessionHandle *data = curl;
 
   va_start(arg, tag);
 
@@ -231,14 +228,14 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...)
 
 CURLcode curl_easy_perform(CURL *curl)
 {
-  struct UrlData *data = (struct UrlData *)curl;
+  struct SessionHandle *data = (struct SessionHandle *)curl;
 
   return Curl_perform(data);
 }
 
 void curl_easy_cleanup(CURL *curl)
 {
-  struct UrlData *data = (struct UrlData *)curl;
+  struct SessionHandle *data = (struct SessionHandle *)curl;
   Curl_close(data);
 }
 
@@ -246,10 +243,83 @@ CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...)
 {
   va_list arg;
   void *paramp;
-  struct UrlData *data = (struct UrlData *)curl;
+  struct SessionHandle *data = (struct SessionHandle *)curl;
 
   va_start(arg, info);
   paramp = va_arg(arg, void *);
 
   return Curl_getinfo(data, info, paramp);
 }
+
+CURL *curl_easy_duphandle(CURL *incurl)
+{
+  struct SessionHandle *data=(struct SessionHandle *)incurl;
+
+  struct SessionHandle *outcurl = (struct SessionHandle *)
+    malloc(sizeof(struct SessionHandle));
+
+  if(NULL == outcurl)
+    return NULL; /* failure */
+
+  /* start with clearing the entire new struct */
+  memset(outcurl, 0, sizeof(struct SessionHandle));
+
+  /*
+   * We setup a few buffers we need. We should probably make them
+   * get setup on-demand in the code, as that would probably decrease
+   * the likeliness of us forgetting to init a buffer here in the future.
+   */
+  outcurl->state.headerbuff=(char*)malloc(HEADERSIZE);
+  if(!outcurl->state.headerbuff) {
+    free(outcurl); /* free the memory again */
+    return NULL;
+  }
+  outcurl->state.headersize=HEADERSIZE;
+
+  /* copy all userdefined values */
+  outcurl->set = data->set;
+  outcurl->state.numconnects = data->state.numconnects;
+  outcurl->state.connects = (struct connectdata **)
+      malloc(sizeof(struct connectdata *) * outcurl->state.numconnects);
+
+  if(!outcurl->state.connects) {
+    free(outcurl->state.headerbuff);
+    free(outcurl);
+    return NULL;
+  }
+  memset(outcurl->state.connects, 0,
+         sizeof(struct connectdata *)*outcurl->state.numconnects);
+
+  outcurl->progress.flags    = data->progress.flags;
+  outcurl->progress.callback = data->progress.callback;
+
+  if(data->cookies)
+    /* If cookies are enabled in the parent handle, we enable them
+       in the clone as well! */
+    outcurl->cookies = Curl_cookie_init(data->cookies->filename,
+                                        outcurl->cookies);
+
+  /* duplicate all values in 'change' */
+  if(data->change.url) {
+    outcurl->change.url = strdup(data->change.url);
+    outcurl->change.url_alloc = TRUE;
+  }
+  if(data->change.proxy) {
+    outcurl->change.proxy = strdup(data->change.proxy);
+    outcurl->change.proxy_alloc = TRUE;
+  }
+  if(data->change.referer) {
+    outcurl->change.referer = strdup(data->change.referer);
+    outcurl->change.referer_alloc = TRUE;
+  }
+
+  return outcurl;
+}
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/escape.c

@@ -37,7 +37,7 @@
 #include "memdebug.h"
 #endif
 
-char *curl_escape(char *string, int length)
+char *curl_escape(const char *string, int length)
 {
   int alloc = (length?length:(int)strlen(string))+1;  
   char *ns = malloc(alloc);
@@ -75,7 +75,7 @@ char *curl_escape(char *string, int length)
   return ns;
 }
 
-char *curl_unescape(char *string, int length)
+char *curl_unescape(const char *string, int length)
 {
   int alloc = (length?length:(int)strlen(string))+1;
   char *ns = malloc(alloc);
@@ -110,3 +110,11 @@ char *curl_unescape(char *string, int length)
   return ns;
   
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/escape.h

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

lib/file.c

@@ -142,8 +142,8 @@ CURLcode Curl_file(struct connectdata *conn)
   struct stat statbuf;
   ssize_t expected_size=-1;
   ssize_t nread;
-  struct UrlData *data = conn->data;
-  char *buf = data->buffer;
+  struct SessionHandle *data = conn->data;
+  char *buf = data->state.buffer;
   int bytecount = 0;
   struct timeval start = Curl_tvnow();
   struct timeval now = start;
@@ -196,3 +196,11 @@ CURLcode Curl_file(struct connectdata *conn)
 
   return res;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/formdata.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -24,7 +24,82 @@
 /*
   Debug the form generator stand-alone by compiling this source file with:
 
-  gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -o formdata -I../include formdata.c
+  gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
+
+  run the 'formdata' executable the output should end with:
+  All Tests seem to have worked ...
+  and the following parts should be there:
+
+Content-Disposition: form-data; name="simple_COPYCONTENTS"
+value for simple COPYCONTENTS
+
+Content-Disposition: form-data; name="COPYCONTENTS_+_CONTENTTYPE"
+Content-Type: image/gif
+value for COPYCONTENTS + CONTENTTYPE
+
+Content-Disposition: form-data; name="PRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH"
+vlue for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH
+(or you might see P^@RNAME and v^@lue at the start)
+
+Content-Disposition: form-data; name="simple_PTRCONTENTS"
+value for simple PTRCONTENTS
+
+Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH"
+vlue for PTRCONTENTS + CONTENTSLENGTH
+(or you might see v^@lue at the start)
+
+Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE"
+Content-Type: text/plain
+vlue for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE
+(or you might see v^@lue at the start)
+
+Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="inet_ntoa_r.h"
+Content-Type: text/html
+...
+
+Content-Disposition: form-data; name="FILE1_+_FILE2"
+Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="Makefile.b32.resp"
+Content-Type: text/plain
+...
+
+Content-Disposition: form-data; name="FILE1_+_FILE2_+_FILE3"
+Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="Makefile.b32.resp"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+
+
+Content-Disposition: form-data; name="ARRAY: FILE1_+_FILE2_+_FILE3"
+Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="Makefile.b32.resp"
+Content-Type: text/plain
+...
+Content-Disposition: attachment; filename="inet_ntoa_r.h"
+Content-Type: text/plain
+...
+
+Content-Disposition: form-data; name="FILECONTENT"
+...
+
+  For the old FormParse used by curl_formparse use:
+
+  gcc -DHAVE_CONFIG_H -I../ -g -D_OLD_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
 
   run the 'formdata' executable and make sure the output is ok!
 
@@ -64,7 +139,7 @@
 /* This is a silly duplicate of the function in main.c to enable this source
    to compile stand-alone for better debugging */
 static void GetStr(char **string,
-		   char *value)
+		   const char *value)
 {
   if(*string)
     free(*string);
@@ -227,6 +302,7 @@ int FormParse(char *input,
 	    memset(post, 0, sizeof(struct HttpPost));
 	    GetStr(&post->name, name);      /* get the name */
 	    GetStr(&post->contents, contp); /* get the contents */
+            post->contentslength = 0;
 	    post->flags = flags;
 	    if(type) {
 	      GetStr(&post->contenttype, (char *)type); /* get type */
@@ -250,6 +326,7 @@ int FormParse(char *input,
 	     memset(subpost, 0, sizeof(struct HttpPost));
 	     GetStr(&subpost->name, name);      /* get the name */
 	     GetStr(&subpost->contents, contp); /* get the contents */
+             subpost->contentslength = 0;
 	     subpost->flags = flags;
 	     if(type) {
 	       GetStr(&subpost->contenttype, (char *)type); /* get type */
@@ -272,10 +349,12 @@ int FormParse(char *input,
 	GetStr(&post->name, name);      /* get the name */
 	if( contp[0]=='<' ) {
 	  GetStr(&post->contents, contp+1); /* get the contents */
+          post->contentslength = 0;
 	  post->flags = HTTPPOST_READFILE;
 	}
 	else {
 	  GetStr(&post->contents, contp); /* get the contents */
+          post->contentslength = 0;
 	  post->flags = 0;
 	}
 
@@ -307,6 +386,530 @@ int curl_formparse(char *input,
   return FormParse(input, httppost, last_post);
 }
 
+/***************************************************************************
+ *
+ * AddHttpPost()
+ *	
+ * Adds a HttpPost structure to the list, if parent_post is given becomes
+ * a subpost of parent_post instead of a direct list element.
+ *
+ * Returns newly allocated HttpPost on success and NULL if malloc failed.
+ *
+ ***************************************************************************/
+static struct HttpPost * AddHttpPost (char * name,
+                                      long namelength,
+                                      char * value,
+                                      long contentslength,
+				      char *contenttype,
+                                      long flags,
+                                      struct HttpPost *parent_post,
+                                      struct HttpPost **httppost,
+                                      struct HttpPost **last_post)
+{
+  struct HttpPost *post;
+  post = (struct HttpPost *)malloc(sizeof(struct HttpPost));
+  if(post) {
+    memset(post, 0, sizeof(struct HttpPost));
+    post->name = name;
+    post->namelength = name?(namelength?namelength:(long)strlen(name)):0;
+    post->contents = value;
+    post->contentslength = contentslength;
+    post->contenttype = contenttype;
+    post->flags = flags;
+  }
+  else
+    return NULL;
+  
+  if (parent_post) {
+    /* now, point our 'more' to the original 'more' */
+    post->more = parent_post->more;
+    
+    /* then move the original 'more' to point to ourselves */
+    parent_post->more = post;	         
+  }
+  else {
+    /* make the previous point to this */
+    if(*last_post)
+      (*last_post)->next = post;
+    else
+      (*httppost) = post;
+    
+    (*last_post) = post;  
+  }
+  return post;
+}
+
+/***************************************************************************
+ *
+ * AddFormInfo()
+ *	
+ * Adds a FormInfo structure to the list presented by parent_form_info.
+ *
+ * Returns newly allocated FormInfo on success and NULL if malloc failed/
+ * parent_form_info is NULL.
+ *
+ ***************************************************************************/
+static FormInfo * AddFormInfo(char *value,
+                              char *contenttype,
+                              FormInfo *parent_form_info)
+{
+  FormInfo *form_info;
+  form_info = (FormInfo *)malloc(sizeof(FormInfo));
+  if(form_info) {
+    memset(form_info, 0, sizeof(FormInfo));
+    if (value)
+      form_info->value = value;
+    if (contenttype)
+      form_info->contenttype = contenttype;
+    form_info->flags = HTTPPOST_FILENAME;
+  }
+  else
+    return NULL;
+  
+  if (parent_form_info) {
+    /* now, point our 'more' to the original 'more' */
+    form_info->more = parent_form_info->more;
+    
+    /* then move the original 'more' to point to ourselves */
+    parent_form_info->more = form_info;
+  }
+  else
+    return NULL;
+
+  return form_info;
+}
+
+/***************************************************************************
+ *
+ * ContentTypeForFilename()
+ *	
+ * Provides content type for filename if one of the known types (else
+ * (either the prevtype or the default is returned).
+ *
+ * Returns some valid contenttype for filename.
+ *
+ ***************************************************************************/
+static const char * ContentTypeForFilename (const char *filename,
+					    const char *prevtype)
+{
+  const char *contenttype = NULL;
+  unsigned int i;
+  /*
+   * No type was specified, we scan through a few well-known
+   * extensions and pick the first we match!
+   */
+  struct ContentType {
+    const char *extension;
+    const char *type;
+  };
+  static struct ContentType ctts[]={
+    {".gif",  "image/gif"},
+    {".jpg",  "image/jpeg"},
+    {".jpeg", "image/jpeg"},
+    {".txt",  "text/plain"},
+    {".html", "text/plain"}
+  };
+  
+  if(prevtype)
+    /* default to the previously set/used! */
+    contenttype = prevtype;
+  else
+    /* It seems RFC1867 defines no Content-Type to default to
+       text/plain so we don't actually need to set this: */
+    contenttype = HTTPPOST_CONTENTTYPE_DEFAULT;
+  
+  for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) {
+    if(strlen(filename) >= strlen(ctts[i].extension)) {
+      if(strequal(filename +
+		  strlen(filename) - strlen(ctts[i].extension),
+		  ctts[i].extension)) {
+	contenttype = ctts[i].type;
+	break;
+      }	      
+    }
+  }
+  /* we have a contenttype by now */
+  return contenttype;
+}
+
+/***************************************************************************
+ *
+ * AllocAndCopy()
+ *	
+ * Copies the data currently available under *buffer using newly allocated
+ * buffer (that becomes *buffer). Uses buffer_length if not null, else
+ * uses strlen to determine the length of the buffer to be copied
+ *
+ * Returns 0 on success and 1 if the malloc failed.
+ *
+ ***************************************************************************/
+static int AllocAndCopy (char **buffer, int buffer_length)
+{
+  const char *src = *buffer;
+  int length, add = 0;
+  if (buffer_length)
+    length = buffer_length;
+  else {
+    length = strlen(*buffer);
+    add = 1;
+  }
+  *buffer = (char*)malloc(length+add);
+  if (!*buffer)
+    return 1;
+  memcpy(*buffer, src, length);
+  /* if length unknown do null termination */
+  if (add)
+    (*buffer)[length] = '\0';
+  return 0;
+}
+
+/***************************************************************************
+ *
+ * FormAdd()
+ *	
+ * Stores a 'name=value' formpost parameter and builds the appropriate
+ * linked list.
+ *
+ * Has two principal functionalities: using files and byte arrays as
+ * post parts. Byte arrays are either copied or just the pointer is stored
+ * (as the user requests) while for files only the filename and not the
+ * content is stored.
+ *
+ * While you may have only one byte array for each name, multiple filenames
+ * are allowed (and because of this feature CURLFORM_END is needed after
+ * using CURLFORM_FILE).
+ *
+ * Examples:
+ *
+ * Simple name/value pair with copied contents:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_COPYCONTENTS, "value", CURLFORM_END);
+ *
+ * name/value pair where only the content pointer is remembered:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10, CURLFORM_END);
+ * (if CURLFORM_CONTENTSLENGTH is missing strlen () is used)
+ *
+ * storing a filename (CONTENTTYPE is optional!):
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_FILE, "filename1", CURLFORM_CONTENTTYPE, "plain/text",
+ * CURLFORM_END);
+ *
+ * storing multiple filenames:
+ * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
+ * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END);
+ *
+ * Returns:
+ * FORMADD_OK             on success
+ * FORMADD_MEMORY         if the FormInfo allocation fails
+ * FORMADD_OPTION_TWICE   if one option is given twice for one Form
+ * FORMADD_NULL           if a null pointer was given for a char
+ * FORMADD_MEMORY         if the allocation of a FormInfo struct failed
+ * FORMADD_UNKNOWN_OPTION if an unknown option was used
+ * FORMADD_INCOMPLETE     if the some FormInfo is not complete (or an error)
+ * FORMADD_MEMORY         if a HttpPost struct cannot be allocated
+ * FORMADD_MEMORY         if some allocation for string copying failed.
+ * FORMADD_ILLEGAL_ARRAY  if an illegal option is used in an array
+ *
+ ***************************************************************************/
+
+typedef enum {
+  FORMADD_OK, /* first, no error */
+
+  FORMADD_MEMORY,
+  FORMADD_OPTION_TWICE,
+  FORMADD_NULL,
+  FORMADD_UNKNOWN_OPTION,
+  FORMADD_INCOMPLETE,
+  FORMADD_ILLEGAL_ARRAY,
+
+  FORMADD_LAST /* last */
+} FORMcode;
+
+static
+FORMcode FormAdd(struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 va_list params)
+{
+  FormInfo *first_form, *current_form, *form;
+  FORMcode return_value = FORMADD_OK;
+  const char *prevtype = NULL;
+  struct HttpPost *post = NULL;
+  CURLformoption option;
+  struct curl_forms *forms = NULL;
+  const char *array_value; /* value read from an array */
+
+  /* This is a state variable, that if TRUE means that we're parsing an
+     array that we got passed to us. If FALSE we're parsing the input
+     va_list arguments. */
+  bool array_state = FALSE;
+
+  /*
+   * We need to allocate the first struct to fill in.
+   */
+  first_form = (FormInfo *)malloc(sizeof(struct FormInfo));
+  if(first_form) {
+    memset(first_form, 0, sizeof(FormInfo));
+    current_form = first_form;
+  }
+  else
+    return FORMADD_MEMORY;
+
+  /*
+   * Loop through all the options set.
+   */
+  while (1) {
+
+    /* break if we have an error to report */
+    if (return_value != FORMADD_OK)
+      break;
+
+    /* first see if we have more parts of the array param */
+    if ( array_state ) {
+      /* get the upcoming option from the given array */
+      option = forms->option;
+      array_value = forms->value;
+
+      forms++; /* advance this to next entry */
+      if (CURLFORM_END == option) {
+        /* end of array state */
+        array_state = FALSE;
+        continue;
+      }
+      else {
+        /* check that the option is OK in an array */
+
+        /* Daniel's note: do we really need to do this? */
+        if ( (option <= CURLFORM_ARRAY_START) ||
+             (option >= CURLFORM_ARRAY_END) ) {
+          return_value = FORMADD_ILLEGAL_ARRAY;
+          break;
+        }
+      }
+    }
+    else {
+      /* This is not array-state, get next option */
+      option = va_arg(params, CURLformoption);
+      if (CURLFORM_END == option)
+        break;
+    }
+
+    switch (option) {
+    case CURLFORM_ARRAY:
+      forms = va_arg(params, struct curl_forms *);
+      if (forms)
+        array_state = TRUE;
+      else
+        return_value = FORMADD_NULL;
+      break;
+
+      /*
+       * Set the Name property.
+       */
+    case CURLFORM_PTRNAME:
+      current_form->flags |= HTTPPOST_PTRNAME; /* fall through */
+    case CURLFORM_COPYNAME:
+      if (current_form->name)
+        return_value = FORMADD_OPTION_TWICE;
+      else {
+        char *name = va_arg(params, char *);
+        if (name)
+          current_form->name = name; /* store for the moment */
+        else
+          return_value = FORMADD_NULL;
+      }
+      break;
+    case CURLFORM_NAMELENGTH:
+      if (current_form->namelength)
+        return_value = FORMADD_OPTION_TWICE;
+      else
+        current_form->namelength = va_arg(params, long);
+      break;
+
+      /*
+       * Set the contents property.
+       */
+    case CURLFORM_PTRCONTENTS:
+      current_form->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
+    case CURLFORM_COPYCONTENTS:
+      if (current_form->value)
+        return_value = FORMADD_OPTION_TWICE;
+      else {
+        char *value = va_arg(params, char *);
+        if (value)
+          current_form->value = value; /* store for the moment */
+        else
+          return_value = FORMADD_NULL;
+      }
+      break;
+    case CURLFORM_CONTENTSLENGTH:
+      if (current_form->contentslength)
+        return_value = FORMADD_OPTION_TWICE;
+      else
+        current_form->contentslength = va_arg(params, long);
+      break;
+
+      /* Get contents from a given file name */
+    case CURLFORM_FILECONTENT:
+      if (current_form->flags != 0)
+        return_value = FORMADD_OPTION_TWICE;
+      else {
+        char *filename = va_arg(params, char *);
+        if (filename) {
+          current_form->value = strdup(filename);
+          current_form->flags |= HTTPPOST_READFILE;
+        }
+        else
+          return_value = FORMADD_NULL;
+      }
+      break;
+
+      /* We upload a file */
+    case CURLFORM_FILE:
+      {
+        const char *filename = NULL;
+        if (array_state)
+          filename = array_value;
+        else
+          filename = va_arg(params, const char *);
+        if (current_form->value) {
+          if (current_form->flags & HTTPPOST_FILENAME) {
+            if (filename) {
+              if (!(current_form = AddFormInfo(strdup(filename),
+                                               NULL, current_form)))
+                return_value = FORMADD_MEMORY;
+            }
+            else
+              return_value = FORMADD_NULL;
+          }
+          else
+            return_value = FORMADD_OPTION_TWICE;
+        }
+        else {
+          if (filename)
+            current_form->value = strdup(filename);
+          else
+            return_value = FORMADD_NULL;
+          current_form->flags |= HTTPPOST_FILENAME;
+        }
+        break;
+      }
+    case CURLFORM_CONTENTTYPE:
+      {
+	const char *contenttype = NULL;
+        if (array_state)
+          contenttype = array_value;
+        else
+          contenttype = va_arg(params, const char *);
+        if (current_form->contenttype) {
+          if (current_form->flags & HTTPPOST_FILENAME) {
+            if (contenttype) {
+              if (!(current_form = AddFormInfo(NULL,
+                                               strdup(contenttype),
+                                               current_form)))
+                return_value = FORMADD_MEMORY;
+            }
+	    else
+	      return_value = FORMADD_NULL;
+          }
+          else
+            return_value = FORMADD_OPTION_TWICE;
+        }
+        else {
+	  if (contenttype)
+	    current_form->contenttype = strdup(contenttype);
+	  else
+	    return_value = FORMADD_NULL;
+	}
+        break;
+      }
+    default:
+      fprintf (stderr, "got unknown CURLFORM_OPTION: %d\n", option);
+      return_value = FORMADD_UNKNOWN_OPTION;
+    }
+  }
+
+  if(FORMADD_OK == return_value) {
+    /* go through the list, check for copleteness and if everything is
+     * alright add the HttpPost item otherwise set return_value accordingly */
+    
+    post = NULL;
+    for(form = first_form;
+        form != NULL;
+        form = form->more) {
+      if ( ((!form->name || !form->value) && !post) ||
+           ( (form->contentslength) &&
+             (form->flags & HTTPPOST_FILENAME) ) ||
+           ( (form->flags & HTTPPOST_FILENAME) &&
+             (form->flags & HTTPPOST_PTRCONTENTS) ) ||
+           ( (form->flags & HTTPPOST_READFILE) &&
+             (form->flags & HTTPPOST_PTRCONTENTS) )
+           ) {
+        return_value = FORMADD_INCOMPLETE;
+        break;
+      }
+      else {
+        if ( (form->flags & HTTPPOST_FILENAME) &&
+             !form->contenttype ) {
+          /* our contenttype is missing */
+          form->contenttype
+            = strdup(ContentTypeForFilename(form->value, prevtype));
+        }
+        if ( !(form->flags & HTTPPOST_PTRNAME) &&
+             (form == first_form) ) {
+          /* copy name (without strdup; possibly contains null characters) */
+          if (AllocAndCopy(&form->name, form->namelength)) {
+            return_value = FORMADD_MEMORY;
+            break;
+          }
+        }
+        if ( !(form->flags & HTTPPOST_FILENAME) &&
+             !(form->flags & HTTPPOST_READFILE) && 
+             !(form->flags & HTTPPOST_PTRCONTENTS) ) {
+          /* copy value (without strdup; possibly contains null characters) */
+          if (AllocAndCopy(&form->value, form->contentslength)) {
+            return_value = FORMADD_MEMORY;
+            break;
+          }
+        }
+        if ( (post = AddHttpPost(form->name, form->namelength,
+                                 form->value, form->contentslength,
+                                 form->contenttype, form->flags,
+                                 post, httppost,
+                                 last_post)) == NULL) {
+          return_value = FORMADD_MEMORY;
+        }
+        if (form->contenttype)
+          prevtype = form->contenttype;
+      }
+    }
+  }
+
+  /* always delete the allocated memory before returning */
+  form = first_form;
+  while (form != NULL) {
+    FormInfo *delete_form;
+    
+    delete_form = form;
+    form = form->more;
+    free (delete_form);
+  }
+
+  return return_value;
+}
+
+int curl_formadd(struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...)
+{
+  va_list arg;
+  int result;
+  va_start(arg, last_post);
+  result = FormAdd(httppost, last_post, arg);
+  va_end(arg);
+  return result;
+}
+
 static int AddFormData(struct FormData **formp,
                        const void *line,
                        long length)
@@ -320,7 +923,7 @@ static int AddFormData(struct FormData **formp,
     length = strlen((char *)line);
 
   newform->line = (char *)malloc(length+1);
-  memcpy(newform->line, line, length+1);
+  memcpy(newform->line, line, length);
   newform->length = length;
   newform->line[length]=0; /* zero terminate for easier debugging */
   
@@ -404,9 +1007,9 @@ void curl_formfree(struct HttpPost *form)
     if(form->more)
       curl_formfree(form->more);
 
-    if(form->name)
+    if( !(form->flags & HTTPPOST_PTRNAME) && form->name)
       free(form->name); /* free the name */
-    if(form->contents)
+    if( !(form->flags & HTTPPOST_PTRCONTENTS) && form->contents)
       free(form->contents); /* free the contents */
     if(form->contenttype)
       free(form->contenttype); /* free the content type */
@@ -446,9 +1049,12 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
     /* boundary */
     size += AddFormDataf(&form, "\r\n--%s\r\n", boundary);
 
-    size += AddFormDataf(&form,
-			 "Content-Disposition: form-data; name=\"%s\"",
-			 post->name);
+    size += AddFormData(&form,
+                        "Content-Disposition: form-data; name=\"", 0);
+
+    size += AddFormData(&form, post->name, post->namelength);
+
+    size += AddFormData(&form, "\"", 0);
 
     if(post->more) {
       /* If used, this is a link to more file names, we must then do
@@ -525,7 +1131,7 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
 	}
       } else {
 	/* include the contents we got */
-	size += AddFormData(&form, post->contents, 0);
+	size += AddFormData(&form, post->contents, post->contentslength);
       }
     } while((file = file->more)); /* for each specified file for this field */
 
@@ -568,6 +1174,52 @@ int Curl_FormReader(char *buffer,
                     size_t size,
                     size_t nitems,
                     FILE *mydata)
+{
+  struct Form *form;
+  int wantedsize;
+  int gotsize = 0;
+
+  form=(struct Form *)mydata;
+
+  wantedsize = size * nitems;
+
+  if(!form->data)
+    return -1; /* nothing, error, empty */
+
+  do {
+  
+    if( (form->data->length - form->sent ) > wantedsize - gotsize) {
+
+      memcpy(buffer + gotsize , form->data->line + form->sent,
+             wantedsize - gotsize);
+
+      form->sent += wantedsize-gotsize;
+
+      return wantedsize;
+    }
+
+    memcpy(buffer+gotsize,
+           form->data->line + form->sent,
+           (form->data->length - form->sent) );
+    gotsize += form->data->length - form->sent;
+    
+    form->sent = 0;
+
+    form->data = form->data->next; /* advance */
+
+  } while(form->data);
+  /* If we got an empty line and we have more data, we proceed to the next
+     line immediately to avoid returning zero before we've reached the end.
+     This is the bug reported November 22 1999 on curl 6.3. (Daniel) */
+
+  return gotsize;
+}
+
+/* possible (old) fread() emulation that copies at most one line */
+int Curl_FormReadOneLine(char *buffer,
+                         size_t size,
+                         size_t nitems,
+                         FILE *mydata)
 {
   struct Form *form;
   int wantedsize;
@@ -609,6 +1261,152 @@ int Curl_FormReader(char *buffer,
 
 
 #ifdef _FORM_DEBUG
+int FormAddTest(const char * errormsg,
+                 struct HttpPost **httppost,
+                 struct HttpPost **last_post,
+                 ...)
+{
+  int result;
+  va_list arg;
+  va_start(arg, last_post);
+  if ((result = FormAdd(httppost, last_post, arg)))
+    fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result,
+             errormsg);
+  va_end(arg);
+  return result;
+}
+
+
+int main()
+{
+  char name1[] = "simple_COPYCONTENTS";
+  char name2[] = "COPYCONTENTS_+_CONTENTTYPE";
+  char name3[] = "PTRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH";
+  char name4[] = "simple_PTRCONTENTS";
+  char name5[] = "PTRCONTENTS_+_CONTENTSLENGTH";
+  char name6[] = "PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE";
+  char name7[] = "FILE1_+_CONTENTTYPE";
+  char name8[] = "FILE1_+_FILE2";
+  char name9[] = "FILE1_+_FILE2_+_FILE3";
+  char name10[] = "ARRAY: FILE1_+_FILE2_+_FILE3";
+  char name11[] = "FILECONTENT";
+  char value1[] = "value for simple COPYCONTENTS";
+  char value2[] = "value for COPYCONTENTS + CONTENTTYPE";
+  char value3[] = "value for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH";
+  char value4[] = "value for simple PTRCONTENTS";
+  char value5[] = "value for PTRCONTENTS + CONTENTSLENGTH";
+  char value6[] = "value for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE";
+  char value7[] = "inet_ntoa_r.h";
+  char value8[] = "Makefile.b32.resp";
+  char type2[] = "image/gif";
+  char type6[] = "text/plain";
+  char type7[] = "text/html";
+  int name3length = strlen(name3);
+  int value3length = strlen(value3);
+  int value5length = strlen(value4);
+  int value6length = strlen(value5);
+  int errors = 0;
+  int size;
+  int nread;
+  char buffer[4096];
+  struct HttpPost *httppost=NULL;
+  struct HttpPost *last_post=NULL;
+  struct curl_forms forms[4];
+
+  struct FormData *form;
+  struct Form formread;
+
+  if (FormAddTest("simple COPYCONTENTS test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name1, CURLFORM_COPYCONTENTS, value1,
+                  CURLFORM_END))
+    ++errors;
+  if (FormAddTest("COPYCONTENTS  + CONTENTTYPE test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2,
+                  CURLFORM_CONTENTTYPE, type2, CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  name3[1] = '\0';
+  value3[1] = '\0';
+  if (FormAddTest("PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH test",
+		  &httppost, &last_post,
+                  CURLFORM_PTRNAME, name3, CURLFORM_COPYCONTENTS, value3,
+                  CURLFORM_CONTENTSLENGTH, value3length,
+		  CURLFORM_NAMELENGTH, name3length, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4,
+                  CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  value5[1] = '\0';
+  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5,
+                  CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END))
+    ++errors;
+  /* make null character at start to check that contentslength works
+     correctly */
+  value6[1] = '\0';
+  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
+                  &httppost, &last_post,
+                  CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6,
+                  CURLFORM_CONTENTSLENGTH, value6length,
+                  CURLFORM_CONTENTTYPE, type6, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name7, CURLFORM_FILE, value7,
+                  CURLFORM_CONTENTTYPE, type7, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name8, CURLFORM_FILE, value7,
+                  CURLFORM_FILE, value8, CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILE1 + FILE2 + FILE3 test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name9, CURLFORM_FILE, value7,
+                  CURLFORM_FILE, value8, CURLFORM_FILE, value7, CURLFORM_END))
+    ++errors;
+  forms[0].option = CURLFORM_FILE;
+  forms[0].value  = value7;
+  forms[1].option = CURLFORM_FILE;
+  forms[1].value  = value8;
+  forms[2].option = CURLFORM_FILE;
+  forms[2].value  = value7;
+  forms[3].option  = CURLFORM_END;
+  if (FormAddTest("FILE1 + FILE2 + FILE3 ARRAY test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name10, CURLFORM_ARRAY, forms,
+                  CURLFORM_END))
+    ++errors;
+  if (FormAddTest("FILECONTENT test", &httppost, &last_post,
+                  CURLFORM_COPYNAME, name11, CURLFORM_FILECONTENT, value7,
+                  CURLFORM_END))
+    ++errors;
+
+  form=Curl_getFormData(httppost, &size);
+
+  Curl_FormInit(&formread, form);
+
+  do {
+    nread = Curl_FormReader(buffer, 1, sizeof(buffer),
+                            (FILE *)&formread);
+
+    if(-1 == nread)
+      break;
+    fwrite(buffer, nread, 1, stdout);
+  } while(1);
+
+  fprintf(stdout, "size: %d\n", size);
+  if (errors)
+    fprintf(stdout, "\n==> %d Test(s) failed!\n", errors);
+  else
+    fprintf(stdout, "\nAll Tests seem to have worked (please check output)\n");
+
+  return 0;
+}
+
+#endif
+
+#ifdef _OLD_FORM_DEBUG
 
 int main(int argc, char **argv)
 {
@@ -661,3 +1459,11 @@ int main(int argc, char **argv)
 }
 
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/formdata.h

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

lib/ftp.h

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

lib/getdate.c

@@ -1524,9 +1524,11 @@ yyerrhandle:
    the same signature as the function definition does. */
 #include "getdate.h"
 
+#ifndef WIN32 /* the windows dudes don't need these, does anyone really? */
 extern struct tm	*gmtime ();
 extern struct tm	*localtime ();
 extern time_t		mktime ();
+#endif
 
 /* Month and day table. */
 static TABLE const MonthDayTable[] = {
@@ -2124,3 +2126,11 @@ main (ac, av)
   /* NOTREACHED */
 }
 #endif /* defined (TEST) */
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/getdate.y

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

lib/getenv.c

@@ -21,6 +21,8 @@
  * $Id$
  *****************************************************************************/
 
+#include "setup.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -66,3 +68,11 @@ char *curl_getenv(const char *v)
 {
   return GetEnv(v);
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/getinfo.c

@@ -35,22 +35,24 @@
  * This is supposed to be called in the beginning of a permform() session
  * and should reset all session-info variables
  */
-CURLcode Curl_initinfo(struct UrlData *data)
+CURLcode Curl_initinfo(struct SessionHandle *data)
 {
   struct Progress *pro = &data->progress;
+  struct PureInfo *info =&data->info;
 
   pro->t_nslookup = 0;
   pro->t_connect = 0;
   pro->t_pretransfer = 0;
+  pro->t_starttransfer = 0;
 
-  pro->httpcode = 0;
-  pro->httpversion=0;
-  pro->filetime=0;
+  info->httpcode = 0;
+  info->httpversion=0;
+  info->filetime=-1; /* -1 is an illegal time and thus means unknown */
 
   return CURLE_OK;
 }
 
-CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
+CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...)
 {
   va_list arg;
   long *param_longp;
@@ -80,19 +82,19 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
   
   switch(info) {
   case CURLINFO_EFFECTIVE_URL:
-    *param_charp = data->url?data->url:(char *)"";
+    *param_charp = data->change.url?data->change.url:(char *)"";
     break;
   case CURLINFO_HTTP_CODE:
-    *param_longp = data->progress.httpcode;
+    *param_longp = data->info.httpcode;
     break;
   case CURLINFO_FILETIME:
-    *param_longp = data->progress.filetime;
+    *param_longp = data->info.filetime;
     break;
   case CURLINFO_HEADER_SIZE:
-    *param_longp = data->header_size;
+    *param_longp = data->info.header_size;
     break;
   case CURLINFO_REQUEST_SIZE:
-    *param_longp = data->request_size;
+    *param_longp = data->info.request_size;
     break;
   case CURLINFO_TOTAL_TIME:
     *param_doublep = data->progress.timespent;
@@ -106,6 +108,9 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
   case CURLINFO_PRETRANSFER_TIME:
     *param_doublep =  data->progress.t_pretransfer;
     break;
+  case CURLINFO_STARTTRANSFER_TIME:
+    *param_doublep = data->progress.t_starttransfer;
+    break;
   case CURLINFO_SIZE_UPLOAD:
     *param_doublep =  data->progress.uploaded;
     break;
@@ -119,7 +124,7 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
     *param_doublep = data->progress.ulspeed;
     break;
   case CURLINFO_SSL_VERIFYRESULT:
-    *param_longp = data->ssl.certverifyresult;
+    *param_longp = data->set.ssl.certverifyresult;
     break;
   case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
     *param_doublep = data->progress.size_dl;
@@ -132,3 +137,11 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...)
   }
   return CURLE_OK;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/getinfo.h

@@ -22,7 +22,7 @@
  *
  * $Id$
  *****************************************************************************/
-CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...);
-CURLcode Curl_initinfo(struct UrlData *data);
+CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...);
+CURLcode Curl_initinfo(struct SessionHandle *data);
 
 #endif

lib/getpass.c

@@ -35,9 +35,7 @@
  *   Daniel Stenberg <daniel@haxx.se>
  */
 
-#ifdef HAVE_CONFIG_H
-#  include <config.h>
-#endif
+#include "setup.h" /* setup.h is required for read() prototype */
 
 #ifndef HAVE_GETPASS_R
 
@@ -244,3 +242,11 @@ char *getpass(const char *prompt)
   return getpass_r(prompt, buf, sizeof(buf));
 }
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/hostip.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -28,7 +28,6 @@
 
 #define _REENTRANT
 
-
 #if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
 #include <winsock.h>
 #else
@@ -47,6 +46,9 @@
 #ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
 #endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>	/* required for free() prototypes */
+#endif
 #ifdef	VMS
 #include <inet.h>
 #include <stdlib.h>
@@ -55,6 +57,7 @@
 
 #include "urldata.h"
 #include "sendf.h"
+#include "hostip.h"
 
 #if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
 #include "inet_ntoa_r.h"
@@ -65,8 +68,168 @@
 #include "memdebug.h"
 #endif
 
+/*
+ * This is a wrapper function for freeing name information in a protocol
+ * independent way. This takes care of using the appropriate underlaying
+ * proper function.
+ */
+void Curl_freeaddrinfo(void *freethis)
+{
+#ifdef ENABLE_IPV6
+  freeaddrinfo(freethis);
+#else
+  free(freethis);
+#endif
+}
+
 /* --- resolve name or IP-number --- */
 
+#ifdef ENABLE_IPV6
+
+#ifdef MALLOCDEBUG
+/* These two are strictly for memory tracing and are using the same
+ * style as the family otherwise present in memdebug.c. I put these ones
+ * here since they require a bunch of struct types I didn't wanna include
+ * in memdebug.c
+ */
+int curl_getaddrinfo(char *hostname, char *service,
+                     struct addrinfo *hints,
+                     struct addrinfo **result,
+                     int line, const char *source)
+{
+  int res=(getaddrinfo)(hostname, service, hints, result);
+  if(0 == res) {
+    /* success */
+    if(logfile)
+      fprintf(logfile, "ADDR %s:%d getaddrinfo() = %p\n",
+              source, line, *result);
+  }
+  else {
+    if(logfile)
+      fprintf(logfile, "ADDR %s:%d getaddrinfo() failed\n",
+              source, line);
+  }
+  return res;
+}
+
+void curl_freeaddrinfo(struct addrinfo *freethis,
+                       int line, const char *source)
+{
+  (freeaddrinfo)(freethis);
+  if(logfile)
+    fprintf(logfile, "ADDR %s:%d freeaddrinfo(%p)\n",
+            source, line, freethis);
+}
+
+#endif
+
+/*
+ * Return name information about the given hostname and port number. If
+ * successful, the 'addrinfo' is returned and the forth argument will point to
+ * memory we need to free after use. That meory *MUST* be freed with
+ * Curl_freeaddrinfo(), nothing else.
+ */
+Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
+                                char *hostname,
+                                int port,
+                                char **bufp)
+{
+  struct addrinfo hints, *res;
+  int error;
+  char sbuf[NI_MAXSERV];
+
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = PF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_CANONNAME;
+  snprintf(sbuf, sizeof(sbuf), "%d", port);
+  error = getaddrinfo(hostname, sbuf, &hints, &res);
+  if (error) {
+    infof(data, "getaddrinfo(3) failed for %s\n", hostname);    
+    return NULL;
+  }
+  *bufp=(char *)res; /* make it point to the result struct */
+
+  return res;
+}
+#else /* following code is IPv4-only */
+
+#ifndef HAVE_GETHOSTBYNAME_R
+/**
+ * Performs a "deep" copy of a hostent into a buffer (returns a pointer to the
+ * copy). Make absolutely sure the destination buffer is big enough!
+ *
+ * Keith McGuigan 
+ * 10/3/2001 */
+static struct hostent* pack_hostent(char* buf, struct hostent* orig)
+{
+  char* bufptr;
+  struct hostent* copy;
+
+  int i;
+  char* str;
+  int len;
+
+  bufptr = buf;
+  copy = (struct hostent*)bufptr;
+
+  bufptr += sizeof(struct hostent);
+  copy->h_name = bufptr;
+  len = strlen(orig->h_name) + 1;
+  strncpy(bufptr, orig->h_name, len);
+  bufptr += len;
+
+  /* we align on even 64bit boundaries for safety */
+#define MEMALIGN(x) (((unsigned long)(x)&0xfffffff8)+8)
+
+  /* This must be aligned properly to work on many CPU architectures! */
+  copy->h_aliases = (char**)MEMALIGN(bufptr);
+
+  /* Figure out how many aliases there are */
+  for (i = 0; orig->h_aliases[i] != NULL; ++i);
+
+  /* Reserve room for the array */
+  bufptr += (i + 1) * sizeof(char*);
+
+  /* Clone all known aliases */
+  for(i = 0; (str = orig->h_aliases[i]); i++) {
+    len = strlen(str) + 1;
+    strncpy(bufptr, str, len);
+    copy->h_aliases[i] = bufptr;
+    bufptr += len;
+  }
+  /* Terminate the alias list with a NULL */
+  copy->h_aliases[i] = NULL;
+
+  copy->h_addrtype = orig->h_addrtype;
+  copy->h_length = orig->h_length;
+    
+  /* align it for (at least) 32bit accesses */
+  bufptr = (char *)MEMALIGN(bufptr);
+
+  copy->h_addr_list = (char**)bufptr;
+
+  /* Figure out how many addresses there are */
+  for (i = 0; orig->h_addr_list[i] != NULL; ++i);
+
+  /* Reserve room for the array */
+  bufptr += (i + 1) * sizeof(char*);
+
+  i = 0;
+  len = orig->h_length;
+  str = orig->h_addr_list[i];
+  while (str != NULL) {
+    memcpy(bufptr, str, len);
+    copy->h_addr_list[i] = bufptr;
+    bufptr += len;
+    str = orig->h_addr_list[++i];
+  }
+  copy->h_addr_list[i] = NULL;
+
+  return copy;
+}
+#endif
+
 static char *MakeIP(unsigned long num,char *addr, int addr_len)
 {
 #if defined(HAVE_INET_NTOA) || defined(HAVE_INET_NTOA_R)
@@ -88,29 +251,6 @@ static char *MakeIP(unsigned long num,char *addr, int addr_len)
   return (addr);
 }
 
-#ifdef ENABLE_IPV6
-struct addrinfo *Curl_getaddrinfo(struct UrlData *data,
-			       char *hostname,
-			       int port)
-{
-  struct addrinfo hints, *res;
-  int error;
-  char sbuf[NI_MAXSERV];
-
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = PF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_flags = AI_CANONNAME;
-  snprintf(sbuf, sizeof(sbuf), "%d", port);
-  error = getaddrinfo(hostname, sbuf, &hints, &res);
-  if (error) {
-    infof(data, "getaddrinfo(3) failed for %s\n", hostname);
-    return NULL;
-  }
-  return res;
-}
-#endif
-
 /* The original code to this function was once stolen from the Dancer source
    code, written by Bjorn Reese, it has since been patched and modified
    considerably. */
@@ -119,8 +259,9 @@ struct addrinfo *Curl_getaddrinfo(struct UrlData *data,
 #define INADDR_NONE (unsigned long) ~0
 #endif
 
-struct hostent *Curl_gethost(struct UrlData *data,
+Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
                                 char *hostname,
+                                int port,
                                 char **bufp)
 {
   struct hostent *h = NULL;
@@ -137,6 +278,7 @@ struct hostent *Curl_gethost(struct UrlData *data,
     return NULL; /* major failure */
   *bufp = buf;
 
+  port=0; /* unused in IPv4 code */
   ret = 0; /* to prevent the compiler warning */
 
   if ( (in=inet_addr(hostname)) != INADDR_NONE ) {
@@ -211,7 +353,22 @@ struct hostent *Curl_gethost(struct UrlData *data,
       free(buf);
       *bufp=NULL;
     }
+    else 
+      /* we make a copy of the hostent right now, right here, as the
+         static one we got a pointer to might get removed when we don't
+         want/expect that */
+      h = pack_hostent(buf, h);
 #endif
   }
   return (h);
 }
+
+#endif /* end of IPv4-specific code */
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/hostip.h

@@ -24,12 +24,24 @@
  *****************************************************************************/
 
 struct addrinfo;
-struct addrinfo *Curl_getaddrinfo(struct UrlData *data,
-                             char *hostname,
-                             int port);
+struct hostent;
+struct SessionHandle;
 
-struct hostent *Curl_gethost(struct UrlData *data,
+/* Get name info */
+Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
                                 char *hostname,
+                                int port,
                                 char **bufp);
+/* free name info */
+void Curl_freeaddrinfo(void *freethis);
+
+#ifdef MALLOCDEBUG
+void curl_freeaddrinfo(struct addrinfo *freethis,
+                       int line, const char *source);
+int curl_getaddrinfo(char *hostname, char *service,
+                     struct addrinfo *hints,
+                     struct addrinfo **result,
+                     int line, const char *source);
+#endif
 
 #endif

lib/http.c

@@ -125,22 +125,27 @@ send_buffer *add_buffer_init(void)
  * add_buffer_send() sends a buffer and frees all associated memory.
  */
 static
-size_t add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in)
+CURLcode add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in,
+                         long *bytes_written)
 {
   size_t amount;
-  if(conn->data->bits.verbose) {
-    fputs("> ", conn->data->err);
+  CURLcode result;
+
+  if(conn->data->set.verbose) {
+    fputs("> ", conn->data->set.err);
     /* this data _may_ contain binary stuff */
-    fwrite(in->buffer, in->size_used, 1, conn->data->err);
+    fwrite(in->buffer, in->size_used, 1, conn->data->set.err);
   }
 
-  Curl_write(conn, sockfd, in->buffer, in->size_used, &amount);
+  result = Curl_write(conn, sockfd, in->buffer, in->size_used, &amount);
 
   if(in->buffer)
     free(in->buffer);
   free(in);
 
-  return amount;
+  *bytes_written = amount;
+
+  return result;
 }
 
 
@@ -199,51 +204,16 @@ CURLcode add_buffer(send_buffer *in, const void *inptr, size_t size)
 /* end of the add_buffer functions */
 /* ------------------------------------------------------------------------- */
 
-/*
- * Read everything until a newline.
- */
-
-static
-int GetLine(int sockfd, char *buf, struct connectdata *conn)
-{
-  ssize_t nread;
-  int read_rc=1;
-  char *ptr;
-  struct UrlData *data=conn->data;
-
-  ptr=buf;
-
-  /* get us a full line, terminated with a newline */
-  for(nread=0;
-      (nread<BUFSIZE) && read_rc;
-      nread++, ptr++) {
-    if((CURLE_OK != Curl_read(conn, sockfd, ptr, 1, &nread)) ||
-       (nread <= 0) ||
-       (*ptr == '\n'))
-      break;
-  }
-  *ptr=0; /* zero terminate */
-  
-  if(data->bits.verbose) {
-    fputs("< ", data->err);
-    fwrite(buf, 1, nread, data->err);
-    fputs("\n", data->err);
-  }
-  return nread>0?nread:0;
-}
-
-
-
 /*
  * This function checks the linked list of custom HTTP headers for a particular
  * header (prefix).
  */
-static bool checkheaders(struct UrlData *data, const char *thisheader)
+static bool checkheaders(struct SessionHandle *data, const char *thisheader)
 {
   struct curl_slist *head;
   size_t thislen = strlen(thisheader);
 
-  for(head = data->headers; head; head=head->next) {
+  for(head = data->set.headers; head; head=head->next) {
     if(strnequal(head->data, thisheader, thislen)) {
       return TRUE;
     }
@@ -263,11 +233,29 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn,
 {
   int httperror=0;
   int subversion=0;
-  struct UrlData *data=conn->data;
+  struct SessionHandle *data=conn->data;
+  CURLcode result;
+
+  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;
+  char *line_start;
+
+#define SELECT_OK      0
+#define SELECT_ERROR   1
+#define SELECT_TIMEOUT 2
+  int error = SELECT_OK;
 
   infof(data, "Establish HTTP proxy tunnel to %s:%d\n", hostname, remote_port);
 
   /* OK, now send the connect request to the proxy */
+  result =
     Curl_sendf(tunnelsocket, conn,
                "CONNECT %s:%d HTTP/1.0\015\012"
                "%s"
@@ -275,19 +263,112 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn,
                "\r\n",
                hostname, remote_port,
                (conn->bits.proxy_user_passwd)?conn->allocptr.proxyuserpwd:"",
-             (data->useragent?conn->allocptr.uagent:"")
+               (data->set.useragent?conn->allocptr.uagent:"")
                );
+  if(result) {
+    failf(data, "Failed sending CONNECT to proxy");
+    return result;
+  }
 
-  /* wait for the proxy to send us a HTTP/1.0 200 OK header */
-  while(GetLine(tunnelsocket, data->buffer, conn)) {
-    if('\r' == data->buffer[0])
-      break; /* end of headers */
-    if(2 == sscanf(data->buffer, "HTTP/1.%d %d",
+  /* Now, read the full reply we get from the proxy */
+
+
+  if(data->set.timeout) {
+    /* if timeout is requested, find out how much remaining time we have */
+    timeout = data->set.timeout - /* timeout time */
+      Curl_tvdiff(Curl_tvnow(), conn->now)/1000; /* 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 (tunnelsocket, &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=data->state.buffer;
+  line_start = ptr;
+
+  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 (tunnelsocket+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, tunnelsocket, 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 possibly just a piece of the last
+         * line */
+        int i;
+
+        nread += gotbytes;
+        for(i = 0; i < gotbytes; ptr++, i++) {
+          perline++; /* amount of bytes in this line so far */
+          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->set.verbose) {
+              fputs("< ", data->set.err);
+              fwrite(line_start, perline, 1, data->set.err);
+              /* no need to output LF here, it is part of the data */
+            }
+            
+            if('\r' == line_start[0]) {
+              /* end of headers */
+              keepon=FALSE;
+              break; /* breaks out of loop, not switch */
+            }
+
+            if(2 == sscanf(line_start, "HTTP/1.%d %d",
                            &subversion,
                            &httperror)) {
               ;
             }
+
+            perline=0; /* line starts over here */
+            line_start = ptr+1;
           }
+        }
+      }
+      break;
+    } /* switch */
+  } /* while there's buffer left and loop is requested */
+
+  if(error)
+    return CURLE_READ_ERROR;
+
   if(200 != httperror) {
     if(407 == httperror)
       /* Added Nov 6 1998 */
@@ -306,7 +387,7 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn,
  */
 CURLcode Curl_http_connect(struct connectdata *conn)
 {
-  struct UrlData *data;
+  struct SessionHandle *data;
   CURLcode result;
 
   data=conn->data;
@@ -317,68 +398,69 @@ CURLcode Curl_http_connect(struct connectdata *conn)
    * us to the host we want to talk to.  Only after the connect
    * has occured, can we start talking SSL
    */
-  if (conn->protocol & PROT_HTTPS) {
-    if (data->bits.httpproxy) {
-      /* HTTPS through a proxy can only be done with a tunnel */
+
+  if(data->change.proxy &&
+     ((conn->protocol & PROT_HTTPS) || data->set.tunnel_thru_httpproxy)) {
+
+    /* either HTTPS over proxy, OR explicitly asked for a tunnel */
     result = Curl_ConnectHTTPProxyTunnel(conn, conn->firstsocket,
                                          conn->hostname, conn->remote_port);
     if(CURLE_OK != result)
       return result;
   }    
 
+  if(conn->protocol & PROT_HTTPS) {
     /* now, perform the SSL initialization for this socket */
     result = Curl_SSLConnect(conn);
     if(result)
       return result;
   }
 
-  if(conn->bits.user_passwd && !data->bits.this_is_a_follow) {
+  if(conn->bits.user_passwd && !data->state.this_is_a_follow) {
     /* Authorization: is requested, this is not a followed location, get the
        original host name */
-    data->auth_host = strdup(conn->hostname);
+    data->state.auth_host = strdup(conn->hostname);
   }
 
   return CURLE_OK;
 }
 
-/* called from curl_close() when this struct is about to get wasted, free
-   protocol-specific resources */
-CURLcode Curl_http_close(struct connectdata *conn)
-{
-  if(conn->data->auth_host)
-    free(conn->data->auth_host);
-  return CURLE_OK;
-}
-
 CURLcode Curl_http_done(struct connectdata *conn)
 {
-  struct UrlData *data;
+  struct SessionHandle *data;
   long *bytecount = &conn->bytecount;
   struct HTTP *http;
 
   data=conn->data;
   http=conn->proto.http;
 
-  if(HTTPREQ_POST_FORM == data->httpreq) {
+  if(HTTPREQ_POST_FORM == data->set.httpreq) {
     *bytecount = http->readbytecount + http->writebytecount;
       
     Curl_formclean(http->sendit); /* Now free that whole lot */
 
-    data->fread = http->storefread; /* restore */
-    data->in = http->in; /* restore */
+    data->set.fread = http->storefread; /* restore */
+    data->set.in = http->in; /* restore */
   }
-  else if(HTTPREQ_PUT == data->httpreq) {
+  else if(HTTPREQ_PUT == data->set.httpreq) {
     *bytecount = http->readbytecount + http->writebytecount;
   }
 
+  if(0 == (http->readbytecount + conn->headerbytecount)) {
+    /* nothing was read from the HTTP server, this can't be right
+       so we return an error here */
+    failf(data, "Empty reply from server\n");
+    return CURLE_GOT_NOTHING;
+  }
+
   return CURLE_OK;
 }
 
 
 CURLcode Curl_http(struct connectdata *conn)
 {
-  struct UrlData *data=conn->data;
-  char *buf = data->buffer; /* this is a short cut to the buffer */
+  struct SessionHandle *data=conn->data;
+  char *buf = data->state.buffer; /* this is a short cut to the buffer */
   CURLcode result=CURLE_OK;
   struct HTTP *http;
   struct Cookie *co=NULL; /* no cookies from start */
@@ -402,8 +484,8 @@ CURLcode Curl_http(struct connectdata *conn)
   conn->bits.close = FALSE;
 
   if ( (conn->protocol&(PROT_HTTP|PROT_FTP)) &&
-       data->bits.upload) {
-    data->httpreq = HTTPREQ_PUT;
+       data->set.upload) {
+    data->set.httpreq = HTTPREQ_PUT;
   }
   
   /* The User-Agent string has been built in url.c already, because it might
@@ -420,11 +502,12 @@ CURLcode Curl_http(struct connectdata *conn)
 
     /* To prevent the user+password to get sent to other than the original
        host due to a location-follow, we do some weirdo checks here */
-    if(!data->bits.this_is_a_follow ||
-       !data->auth_host ||
-       strequal(data->auth_host, conn->hostname)) {
-      sprintf(data->buffer, "%s:%s", data->user, data->passwd);
-      if(Curl_base64_encode(data->buffer, strlen(data->buffer),
+    if(!data->state.this_is_a_follow ||
+       !data->state.auth_host ||
+       strequal(data->state.auth_host, conn->hostname)) {
+      sprintf(data->state.buffer, "%s:%s",
+              data->state.user, data->state.passwd);
+      if(Curl_base64_encode(data->state.buffer, strlen(data->state.buffer),
                             &authorization) >= 0) {
         if(conn->allocptr.userpwd)
           free(conn->allocptr.userpwd);
@@ -434,31 +517,32 @@ CURLcode Curl_http(struct connectdata *conn)
       }
     }
   }
-  if((data->bits.http_set_referer) && !checkheaders(data, "Referer:")) {
+  if((data->change.referer) && !checkheaders(data, "Referer:")) {
     if(conn->allocptr.ref)
       free(conn->allocptr.ref);
-    conn->allocptr.ref = aprintf("Referer: %s\015\012", data->referer);
+    conn->allocptr.ref = aprintf("Referer: %s\015\012", data->change.referer);
   }
-  if(data->cookie && !checkheaders(data, "Cookie:")) {
+  if(data->set.cookie && !checkheaders(data, "Cookie:")) {
     if(conn->allocptr.cookie)
       free(conn->allocptr.cookie);
-    conn->allocptr.cookie = aprintf("Cookie: %s\015\012", data->cookie);
+    conn->allocptr.cookie = aprintf("Cookie: %s\015\012", data->set.cookie);
   }
 
   if(data->cookies) {
     co = Curl_cookie_getlist(data->cookies,
-                             host,
-                             ppath,
+                             host, ppath,
                              conn->protocol&PROT_HTTPS?TRUE:FALSE);
   }
-  if ((data->bits.httpproxy) && !(conn->protocol&PROT_HTTPS))  {
+  if (data->change.proxy &&
+      !data->set.tunnel_thru_httpproxy &&
+      !(conn->protocol&PROT_HTTPS))  {
     /* The path sent to the proxy is in fact the entire URL */
-    ppath = data->url;
+    ppath = data->change.url;
   }
-  if(HTTPREQ_POST_FORM == data->httpreq) {
+  if(HTTPREQ_POST_FORM == data->set.httpreq) {
     /* we must build the whole darned post sequence first, so that we have
        a size of the whole shebang before we start to send it */
-    http->sendit = Curl_getFormData(data->httppost, &http->postsize);
+    http->sendit = Curl_getFormData(data->set.httppost, &http->postsize);
   }
 
   if(!checkheaders(data, "Host:")) {
@@ -486,9 +570,9 @@ CURLcode Curl_http(struct connectdata *conn)
   if(!checkheaders(data, "Accept:"))
     http->p_accept = "Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*\r\n";
 
-  if(( (HTTPREQ_POST == data->httpreq) ||
-       (HTTPREQ_POST_FORM == data->httpreq) ||
-       (HTTPREQ_PUT == data->httpreq) ) &&
+  if(( (HTTPREQ_POST == data->set.httpreq) ||
+       (HTTPREQ_POST_FORM == data->set.httpreq) ||
+       (HTTPREQ_PUT == data->set.httpreq) ) &&
      conn->resume_from) {
     /**********************************************************************
      * Resuming upload in HTTP means that we PUT or POST and that we have
@@ -521,7 +605,8 @@ CURLcode Curl_http(struct connectdata *conn)
           readthisamountnow = BUFSIZE;
 
         actuallyread =
-          data->fread(data->buffer, 1, readthisamountnow, data->in);
+          data->set.fread(data->state.buffer, 1, readthisamountnow,
+                          data->set.in);
 
         passed += actuallyread;
         if(actuallyread != readthisamountnow) {
@@ -532,10 +617,10 @@ CURLcode Curl_http(struct connectdata *conn)
       } while(passed != conn->resume_from); /* loop until done */
 
       /* now, decrease the size of the read */
-      if(data->infilesize>0) {
-        data->infilesize -= conn->resume_from;
+      if(data->set.infilesize>0) {
+        data->set.infilesize -= conn->resume_from;
 
-        if(data->infilesize <= 0) {
+        if(data->set.infilesize <= 0) {
           failf(data, "File already completely uploaded\n");
           return CURLE_PARTIAL_FILE;
         }
@@ -549,16 +634,16 @@ CURLcode Curl_http(struct connectdata *conn)
      * or uploading and we always let customized headers override our internal
      * ones if any such are specified.
      */
-    if((data->httpreq == HTTPREQ_GET) &&
+    if((data->set.httpreq == HTTPREQ_GET) &&
        !checkheaders(data, "Range:")) {
       conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n", conn->range);
     }
-    else if((data->httpreq != HTTPREQ_GET) &&
+    else if((data->set.httpreq != HTTPREQ_GET) &&
             !checkheaders(data, "Content-Range:")) {
 
       if(conn->resume_from) {
         /* This is because "resume" was selected */
-        long total_expected_size= conn->resume_from + data->infilesize;
+        long total_expected_size= conn->resume_from + data->set.infilesize;
         conn->allocptr.rangeline = aprintf("Content-Range: bytes %s%ld/%ld\r\n",
                                       conn->range, total_expected_size-1,
                                       total_expected_size);
@@ -567,14 +652,18 @@ CURLcode Curl_http(struct connectdata *conn)
         /* 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",
-                                      conn->range, data->infilesize);
+                                      conn->range, data->set.infilesize);
       }
     }
   }
 
   do {
+    /* Use 1.1 unless the use specificly asked for 1.0 */
+    const char *httpstring=
+      data->set.httpversion==CURL_HTTP_VERSION_1_0?"1.0":"1.1";
+
     send_buffer *req_buffer;
-    struct curl_slist *headers=data->headers;
+    struct curl_slist *headers=data->set.headers;
 
     /* initialize a dynamic send-buffer */
     req_buffer = add_buffer_init();
@@ -582,7 +671,7 @@ CURLcode Curl_http(struct connectdata *conn)
     /* add the main request stuff */
     add_bufferf(req_buffer,
                 "%s " /* GET/HEAD/POST/PUT */
-                "%s HTTP/1.1\r\n" /* path */
+                "%s HTTP/%s\r\n" /* path */
                 "%s" /* proxyuserpwd */
                 "%s" /* userpwd */
                 "%s" /* range */
@@ -593,25 +682,25 @@ CURLcode Curl_http(struct connectdata *conn)
                 "%s" /* accept */
                 "%s", /* referer */
 
-                data->customrequest?data->customrequest:
-                (data->bits.no_body?"HEAD":
-                 ((HTTPREQ_POST == data->httpreq) ||
-                  (HTTPREQ_POST_FORM == data->httpreq))?"POST":
-                 (HTTPREQ_PUT == data->httpreq)?"PUT":"GET"),
-                ppath,
+                data->set.customrequest?data->set.customrequest:
+                (data->set.no_body?"HEAD":
+                 ((HTTPREQ_POST == data->set.httpreq) ||
+                  (HTTPREQ_POST_FORM == data->set.httpreq))?"POST":
+                 (HTTPREQ_PUT == data->set.httpreq)?"PUT":"GET"),
+                ppath, httpstring,
                 (conn->bits.proxy_user_passwd &&
                  conn->allocptr.proxyuserpwd)?conn->allocptr.proxyuserpwd:"",
                 (conn->bits.user_passwd && conn->allocptr.userpwd)?
                 conn->allocptr.userpwd:"",
                 (conn->bits.use_range && conn->allocptr.rangeline)?
                 conn->allocptr.rangeline:"",
-                (data->useragent && *data->useragent && conn->allocptr.uagent)?
+                (data->set.useragent && *data->set.useragent && conn->allocptr.uagent)?
                 conn->allocptr.uagent:"",
                 (conn->allocptr.cookie?conn->allocptr.cookie:""), /* Cookie: <data> */
                 (conn->allocptr.host?conn->allocptr.host:""), /* Host: host */
                 http->p_pragma?http->p_pragma:"",
                 http->p_accept?http->p_accept:"",
-                (data->bits.http_set_referer && conn->allocptr.ref)?conn->allocptr.ref:"" /* Referer: <data> <CRLF> */
+                (data->change.referer && conn->allocptr.ref)?conn->allocptr.ref:"" /* Referer: <data> <CRLF> */
                 );
 
     if(co) {
@@ -636,7 +725,7 @@ CURLcode Curl_http(struct connectdata *conn)
       co=NULL;
     }
 
-    if(data->timecondition) {
+    if(data->set.timecondition) {
       struct tm *thistime;
 
       /* Phil Karn (Fri, 13 Apr 2001) pointed out that the If-Modified-Since
@@ -651,9 +740,9 @@ CURLcode Curl_http(struct connectdata *conn)
       /* 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 *)gmtime_r(&data->timevalue, &keeptime);
+      thistime = (struct tm *)gmtime_r(&data->set.timevalue, &keeptime);
 #else
-      thistime = gmtime(&data->timevalue);
+      thistime = gmtime(&data->set.timevalue);
 #endif
       if(NULL == thistime) {
         failf(data, "localtime() failed!");
@@ -662,12 +751,12 @@ CURLcode Curl_http(struct connectdata *conn)
 
 #ifdef HAVE_STRFTIME
       /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
-      strftime(buf, BUFSIZE-1, "%a, %d %b %Y %H:%M:%S %Z", thistime);
+      strftime(buf, BUFSIZE-1, "%a, %d %b %Y %H:%M:%S GMT", thistime);
 #else
       /* TODO: Right, we *could* write a replacement here */
       strcpy(buf, "no strftime() support");
 #endif
-      switch(data->timecondition) {
+      switch(data->set.timecondition) {
       case TIMECOND_IFMODSINCE:
       default:
         add_bufferf(req_buffer,
@@ -702,28 +791,57 @@ CURLcode Curl_http(struct connectdata *conn)
       headers = headers->next;
     }
 
-    if(HTTPREQ_POST_FORM == data->httpreq) {
+    if(HTTPREQ_POST_FORM == data->set.httpreq) {
+      char contentType[256];
+      int linelength=0;
       if(Curl_FormInit(&http->form, http->sendit)) {
         failf(data, "Internal HTTP POST error!\n");
         return CURLE_HTTP_POST_ERROR;
       }
 
-      http->storefread = data->fread; /* backup */
-      http->in = data->in; /* backup */
+      http->storefread = data->set.fread; /* backup */
+      http->in = data->set.in; /* backup */
           
-      data->fread = (curl_read_callback)
+      data->set.fread = (curl_read_callback)
         Curl_FormReader; /* set the read function to read from the
                             generated form data */
-      data->in = (FILE *)&http->form;
+      data->set.in = (FILE *)&http->form;
 
       add_bufferf(req_buffer,
                   "Content-Length: %d\r\n", http->postsize-2);
 
+      if(!checkheaders(data, "Expect:")) {
+        /* if not disabled explicitly we add a Expect: 100-continue
+           to the headers which actually speeds up post operations (as
+           there is one packet coming back from the web server) */
+        add_bufferf(req_buffer,
+                    "Expect: 100-continue\r\n");
+        data->set.expect100header = TRUE;
+
+        /* Get Content-Type: line from Curl_FormReadOneLine, which happens
+           to always be the first line. We can know this for sure since
+           we always build the formpost linked list the same way! */
+        linelength = Curl_FormReadOneLine (contentType,
+                                           sizeof(contentType),
+                                           1,
+                                           (FILE *)&http->form);
+        if(linelength == -1) {
+          failf(data, "Could not get Content-Type header line!\n");
+          return CURLE_HTTP_POST_ERROR;
+        }
+        add_buffer(req_buffer, contentType, linelength);
+      }
+
       /* set upload size to the progress meter */
       Curl_pgrsSetUploadSize(data, http->postsize);
 
-      data->request_size = 
-        add_buffer_send(conn->firstsocket, conn, req_buffer);
+      /* fire away the whole request to the server */
+      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+                               &data->info.request_size);
+      if(result)
+        failf(data, "Failed sending POST request");
+      else
+        /* setup variables for the upcoming transfer */
         result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
                                &http->readbytecount,
                                conn->firstsocket,
@@ -733,24 +851,26 @@ CURLcode Curl_http(struct connectdata *conn)
         return result;
       }
     }
-    else if(HTTPREQ_PUT == data->httpreq) {
+    else if(HTTPREQ_PUT == data->set.httpreq) {
       /* Let's PUT the data to the server! */
 
-      if(data->infilesize>0) {
+      if(data->set.infilesize>0) {
         add_bufferf(req_buffer,
                     "Content-Length: %d\r\n\r\n", /* file size */
-                    data->infilesize );
+                    data->set.infilesize );
       }
       else
         add_bufferf(req_buffer, "\015\012");
 
       /* set the upload size to the progress meter */
-      Curl_pgrsSetUploadSize(data, data->infilesize);
+      Curl_pgrsSetUploadSize(data, data->set.infilesize);
 
       /* this sends the buffer and frees all the buffer resources */
-      data->request_size = 
-        add_buffer_send(conn->firstsocket, conn, req_buffer);
-
+      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+                               &data->info.request_size);
+      if(result)
+        failf(data, "Faied sending POST request");
+      else
         /* prepare for transfer */
         result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
                                &http->readbytecount,
@@ -761,17 +881,17 @@ CURLcode Curl_http(struct connectdata *conn)
       
     }
     else {
-      if(HTTPREQ_POST == data->httpreq) {
+      if(HTTPREQ_POST == data->set.httpreq) {
         /* this is the simple POST, using x-www-form-urlencoded style */
 
-        if(!data->postfields) {
+        if(!data->set.postfields) {
           /*
            * This is an attempt to do a POST without having anything to
            * actually send. Let's make a NULL pointer equal "" here. Good/bad
            * ?
            */
-          data->postfields = (char *)"";
-          data->postfieldsize = 0; /* it might been set to something illegal,
+          data->set.postfields = (char *)"";
+          data->set.postfieldsize = 0; /* it might been set to something illegal,
                                       anything > 0 would be! */
         }
 
@@ -780,34 +900,37 @@ CURLcode Curl_http(struct connectdata *conn)
              actually set your own */
           add_bufferf(req_buffer,
                       "Content-Length: %d\r\n",
-                      (data->postfieldsize?data->postfieldsize:
-                       strlen(data->postfields)) );
+                      (data->set.postfieldsize?data->set.postfieldsize:
+                       strlen(data->set.postfields)) );
 
         if(!checkheaders(data, "Content-Type:"))
           add_bufferf(req_buffer,
                       "Content-Type: application/x-www-form-urlencoded\r\n");
 
         /* and here comes the actual data */
-        if(data->postfieldsize) {
+        if(data->set.postfieldsize) {
           add_buffer(req_buffer, "\r\n", 2);
-          add_buffer(req_buffer, data->postfields,
-                     data->postfieldsize);
+          add_buffer(req_buffer, data->set.postfields,
+                     data->set.postfieldsize);
           add_buffer(req_buffer, "\r\n", 2);
         }
         else {
           add_bufferf(req_buffer,
                       "\r\n"
                       "%s\r\n",
-                      data->postfields );
+                      data->set.postfields );
         }
       }
       else
         add_buffer(req_buffer, "\r\n", 2);
 
       /* issue the request */
-      data->request_size = 
-        add_buffer_send(conn->firstsocket, conn, req_buffer);
+      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+                               &data->info.request_size);
 
+      if(result)
+        failf(data, "Failed sending HTTP request");
+      else
         /* HTTP GET/HEAD download: */
         result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE, bytecount,
                                -1, NULL); /* nothing to upload */
@@ -820,3 +943,11 @@ CURLcode Curl_http(struct connectdata *conn)
   return CURLE_OK;
 }
 
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/http.h

@@ -33,7 +33,6 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn,
 CURLcode Curl_http(struct connectdata *conn);
 CURLcode Curl_http_done(struct connectdata *conn);
 CURLcode Curl_http_connect(struct connectdata *conn);
-CURLcode Curl_http_close(struct connectdata *conn);
 
 /* The following functions are defined in http_chunks.c */
 void Curl_httpchunk_init(struct connectdata *conn);

lib/http_chunks.c

@@ -44,7 +44,7 @@
  * Chunk format (simplified):
  *
  * <HEX SIZE>[ chunk extension ] CRLF
- * <DATA>
+ * <DATA> CRLF
  *
  * Highlights from RFC2616 section 3.6 say:
 
@@ -220,3 +220,11 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
   }
   return CHUNKE_OK;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/if2ip.c

@@ -124,3 +124,11 @@ char *Curl_if2ip(char *interface, char *buf, int buf_size)
 #else
 #define if2ip(x) NULL
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/krb4.c

@@ -194,7 +194,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
   u_int32_t cs;
   struct krb4_data *d = app_data;
   struct sockaddr_in *localaddr  = (struct sockaddr_in *)LOCAL_ADDR;
-  char *host = conn->hp->h_name;
+  char *host = conn->hostaddr->h_name;
   ssize_t nread;
   int l = sizeof(conn->local_addr);
 
@@ -245,20 +245,20 @@ krb4_auth(void *app_data, struct connectdata *conn)
     return AUTH_CONTINUE;
   }
 
-  Curl_ftpsendf(conn->firstsocket, conn, "ADAT %s", p);
+  if(Curl_ftpsendf(conn, "ADAT %s", p))
+    return -2;
 
-  nread = Curl_GetFTPResponse(conn->firstsocket,
-                              conn->data->buffer, conn, NULL);
+  nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, NULL);
   if(nread < 0)
-    return /*CURLE_OPERATION_TIMEOUTED*/-1;
+    return -1;
   free(p);
 
-  if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){
+  if(/*ret != COMPLETE*/conn->data->state.buffer[0] != '2'){
     printf("Server didn't accept auth data.\n");
     return AUTH_ERROR;
   }
 
-  p = strstr(conn->data->buffer, "ADAT=");
+  p = strstr(conn->data->state.buffer, "ADAT=");
   if(!p){
     printf("Remote host didn't send adat reply.\n");
     return AUTH_ERROR;
@@ -313,21 +313,21 @@ void Curl_krb_kauth(struct connectdata *conn)
 
   save = Curl_set_command_prot(conn, prot_private);
 
-  Curl_ftpsendf(conn->firstsocket, conn,
-                "SITE KAUTH %s", conn->data->user);
+  if(Curl_ftpsendf(conn, "SITE KAUTH %s", conn->data->state.user))
+    return;
 
-  nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer,
+  nread = Curl_GetFTPResponse(conn->data->state.buffer,
                               conn, NULL);
   if(nread < 0)
     return /*CURLE_OPERATION_TIMEOUTED*/;
 
-  if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){
+  if(/*ret != CONTINUE*/conn->data->state.buffer[0] != '3'){
     Curl_set_command_prot(conn, save);
     /*code = -1;***/
     return;
   }
 
-  p = strstr(conn->data->buffer, "T=");
+  p = strstr(conn->data->state.buffer, "T=");
   if(!p) {
     printf("Bad reply from server.\n");
     Curl_set_command_prot(conn, save);
@@ -344,7 +344,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   tkt.length = tmp;
   tktcopy.length = tkt.length;
     
-  p = strstr(conn->data->buffer, "P=");
+  p = strstr(conn->data->state.buffer, "P=");
   if(!p) {
     printf("Bad reply from server.\n");
     Curl_set_command_prot(conn, save);
@@ -354,7 +354,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   for(; *p && *p != ' ' && *p != '\r' && *p != '\n'; p++);
   *p = 0;
 
-  des_string_to_key (conn->data->passwd, &key);
+  des_string_to_key (conn->data->state.passwd, &key);
   des_key_sched(&key, schedule);
     
   des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
@@ -363,7 +363,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   if (strcmp ((char*)tktcopy.dat + 8,
               KRB_TICKET_GRANTING_TICKET) != 0) {
     afs_string_to_key (passwd,
-                       krb_realmofhost(/*hostname*/conn->hp->h_name),
+                       krb_realmofhost(conn->hostaddr->h_name),
                        &key);
     des_key_sched (&key, schedule);
     des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
@@ -380,10 +380,10 @@ void Curl_krb_kauth(struct connectdata *conn)
   }
   memset (tktcopy.dat, 0, tktcopy.length);
 
-  Curl_ftpsendf(conn->firstsocket, conn,
-                "SITE KAUTH %s %s", name, p);
+  if(Curl_ftpsendf(conn, "SITE KAUTH %s %s", name, p))
+    return;
 
-  nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer,
+  nread = Curl_GetFTPResponse(conn->data->state.buffer,
                               conn, NULL);
   if(nread < 0)
     return /*CURLE_OPERATION_TIMEOUTED*/;
@@ -392,3 +392,11 @@ void Curl_krb_kauth(struct connectdata *conn)
 }
 
 #endif /* KRB4 */
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/ldap.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -47,6 +47,7 @@
 #include <curl/curl.h>
 #include "sendf.h"
 #include "escape.h"
+#include "transfer.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
@@ -94,9 +95,11 @@ static void DynaClose(void)
 #if defined(HAVE_DLOPEN) || defined(HAVE_LIBDL)
   if (libldap) {
     dlclose(libldap);
+    libldap=NULL;
   }
   if (liblber) {
     dlclose(liblber);
+    liblber=NULL;
   }
 #endif
 }
@@ -116,7 +119,7 @@ static void * DynaGetFunction(const char *name)
 
 static int WriteProc(void *param, char *text, int len)
 {
-  struct UrlData *data = (struct UrlData *)param;
+  struct SessionHandle *data = (struct SessionHandle *)param;
   len = 0; /* prevent compiler warning */
   Curl_client_write(data, CLIENTWRITE_BODY, text, 0);
   return 0;
@@ -142,9 +145,9 @@ CURLcode Curl_ldap(struct connectdata *conn)
   void *entryIterator;
 
   int ldaptext;
-  struct UrlData *data=conn->data;
+  struct SessionHandle *data=conn->data;
   
-  infof(data, "LDAP: %s %s\n", data->url);
+  infof(data, "LDAP: %s %s\n", data->change.url);
 
   DynaOpen();
   if (libldap == NULL) {
@@ -152,7 +155,7 @@ CURLcode Curl_ldap(struct connectdata *conn)
     return CURLE_LIBRARY_NOT_FOUND;
   }
 
-  ldaptext = data->bits.ftp_ascii; /* This is a dirty hack */
+  ldaptext = data->set.ftp_ascii; /* This is a dirty hack */
   
   /* The types are needed because ANSI C distinguishes between
    * pointer-to-object (data) and pointer-to-function.
@@ -173,12 +176,14 @@ CURLcode Curl_ldap(struct connectdata *conn)
 	  conn->hostname, conn->port);
     status = CURLE_COULDNT_CONNECT;
   } else {
-    rc = ldap_simple_bind_s(server, data->user, data->passwd);
+    rc = ldap_simple_bind_s(server,
+                            conn->bits.user_passwd?data->state.user:NULL,
+                            conn->bits.user_passwd?data->state.passwd:NULL);
     if (rc != 0) {
       failf(data, "LDAP: %s", ldap_err2string(rc));
       status = CURLE_LDAP_CANNOT_BIND;
     } else {
-      rc = ldap_url_search_s(server, data->url, 0, &result);
+      rc = ldap_url_search_s(server, data->change.url, 0, &result);
       if (rc != 0) {
 	failf(data, "LDAP: %s", ldap_err2string(rc));
 	status = CURLE_LDAP_SEARCH_FAILED;
@@ -211,5 +216,16 @@ CURLcode Curl_ldap(struct connectdata *conn)
   }
   DynaClose();
 
+  /* no data to transfer */
+  Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
+  
   return status;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/libcurl.def

@@ -31,4 +31,6 @@ EXPORTS
  	curl_mvfprintf @ 22 ;
 	curl_strequal @ 23 ;
 	curl_strnequal @ 24 ;
+        curl_easy_duphandle @ 25 ;
+        curl_formadd @ 26 ;
 

lib/memdebug.c

@@ -60,14 +60,21 @@ FILE *logfile;
 /* this sets the log file name */
 void curl_memdebug(const char *logname)
 {
+  if(logname)
     logfile = fopen(logname, "w");
+  else
+    logfile = stderr;
 }
 
 
 void *curl_domalloc(size_t size, int line, const char *source)
 {
   void *mem=(malloc)(size);
-  fprintf(logfile?logfile:stderr, "MEM %s:%d malloc(%d) = %p\n",
+  if(mem)
+    /* fill memory with junk */
+    memset(mem, 0xA5, size);
+  if(logfile)
+    fprintf(logfile, "MEM %s:%d malloc(%d) = %p\n",
             source, line, size, mem);
   return mem;
 }
@@ -85,7 +92,8 @@ char *curl_dostrdup(const char *str, int line, const char *source)
 
   mem=(strdup)(str);
   len=strlen(str)+1;
-  fprintf(logfile?logfile:stderr, "MEM %s:%d strdup(%p) (%d) = %p\n",
+  if(logfile)
+    fprintf(logfile, "MEM %s:%d strdup(%p) (%d) = %p\n",
             source, line, str, len, mem);
   return mem;
 }
@@ -93,7 +101,8 @@ char *curl_dostrdup(const char *str, int line, const char *source)
 void *curl_dorealloc(void *ptr, size_t size, int line, const char *source)
 {
   void *mem=(realloc)(ptr, size);
-  fprintf(logfile?logfile:stderr, "MEM %s:%d realloc(%p, %d) = %p\n",
+  if(logfile)
+    fprintf(logfile, "MEM %s:%d realloc(%p, %d) = %p\n",
             source, line, ptr, size, mem);
   return mem;
 }
@@ -108,14 +117,15 @@ void curl_dofree(void *ptr, int line, const char *source)
 
   (free)(ptr);
 
-  fprintf(logfile?logfile:stderr, "MEM %s:%d free(%p)\n",
-          source, line, ptr);
+  if(logfile)
+    fprintf(logfile, "MEM %s:%d free(%p)\n", source, line, ptr);
 }
 
 int curl_socket(int domain, int type, int protocol, int line, char *source)
 {
   int sockfd=(socket)(domain, type, protocol);
-  fprintf(logfile?logfile:stderr, "FD %s:%d socket() = %d\n",
+  if(logfile)
+    fprintf(logfile, "FD %s:%d socket() = %d\n",
             source, line, sockfd);
   return sockfd;
 }
@@ -124,7 +134,8 @@ int curl_accept(int s, struct sockaddr *addr, socklen_t *addrlen,
                 int line, const char *source)
 {
   int sockfd=(accept)(s, addr, addrlen);
-  fprintf(logfile?logfile:stderr, "FD %s:%d accept() = %d\n",
+  if(logfile)
+    fprintf(logfile, "FD %s:%d accept() = %d\n",
             source, line, sockfd);
   return sockfd;
 }
@@ -133,7 +144,8 @@ int curl_accept(int s, struct sockaddr *addr, socklen_t *addrlen,
 int curl_sclose(int sockfd, int line, char *source)
 {
   int res=sclose(sockfd);
-  fprintf(logfile?logfile:stderr, "FD %s:%d sclose(%d)\n",
+  if(logfile)
+    fprintf(logfile, "FD %s:%d sclose(%d)\n",
             source, line, sockfd);
   return res;
 }
@@ -142,7 +154,8 @@ FILE *curl_fopen(const char *file, const char *mode,
                  int line, const char *source)
 {
   FILE *res=(fopen)(file, mode);
-  fprintf(logfile?logfile:stderr, "FILE %s:%d fopen(\"%s\") = %p\n",
+  if(logfile)
+    fprintf(logfile, "FILE %s:%d fopen(\"%s\") = %p\n",
             source, line, file, res);
   return res;
 }
@@ -150,9 +163,18 @@ FILE *curl_fopen(const char *file, const char *mode,
 int curl_fclose(FILE *file, int line, const char *source)
 {
   int res=(fclose)(file);
-  fprintf(logfile?logfile:stderr, "FILE %s:%d fclose(%p)\n",
+  if(logfile)
+    fprintf(logfile, "FILE %s:%d fclose(%p)\n",
             source, line, file);
   return res;
 }
 
 #endif /* MALLOCDEBUG */
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/memdebug.h

@@ -6,6 +6,8 @@
 #include <memory.h>
 #endif
 
+extern FILE *logfile;
+
 /* memory functions */
 void *curl_domalloc(size_t size, int line, const char *source);
 void *curl_dorealloc(void *ptr, size_t size, int line, const char *source);
@@ -35,6 +37,11 @@ int curl_fclose(FILE *file, int line, const char *source);
 #define accept(sock,addr,len)\
  curl_accept(sock,addr,len,__LINE__,__FILE__)
 
+#define getaddrinfo(host,serv,hint,res) \
+  curl_getaddrinfo(host,serv,hint,res,__LINE__,__FILE__)
+#define freeaddrinfo(data) \
+  curl_freeaddrinfo(data,__LINE__,__FILE__)
+
 /* sclose is probably already defined, redefine it! */
 #undef sclose
 #define sclose(sockfd) curl_sclose(sockfd,__LINE__,__FILE__)

lib/mprintf.c

@@ -92,14 +92,7 @@
  *
  ****************************************************************************/
 
-static const char rcsid[] = "@(#)$Id$";
-
-/*
- * To test:
- *
- * Use WIDTH, PRECISION and NUMBERED ARGUMENT combined.
- */
-
+#include "setup.h"
 #include <sys/types.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -909,14 +902,14 @@ static int dprintf_formatf(
 	}
 	else {
 	  /* Write "(nil)" for a nil pointer.  */
-	  static char nil[] = "(nil)";
+	  static char strnil[] = "(nil)";
 	  register char *point;
 	  
-	  width -= sizeof(nil) - 1;
+	  width -= sizeof(strnil) - 1;
 	  if (p->flags & FLAGS_LEFT)
 	    while (width-- > 0)
 	      OUTCHAR(' ');
-	  for (point = nil; *point != '\0'; ++point)
+	  for (point = strnil; *point != '\0'; ++point)
 	    OUTCHAR(*point);
 	  if (! (p->flags & FLAGS_LEFT))
 	    while (width-- > 0)
@@ -1151,7 +1144,9 @@ int curl_msprintf(char *buffer, const char *format, ...)
   return retcode;
 }
 
+#ifndef WIN32 /* not needed on win32 */
 extern int fputc(int, FILE *);
+#endif
 
 int curl_mprintf(const char *format, ...)
 {
@@ -1230,3 +1225,11 @@ int main()
 }
 
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/multi.c

@@ -0,0 +1,309 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+#include <curl/curl.h>
+
+#include "multi.h" /* will become <curl/multi.h> soon */
+
+struct Curl_message {
+  /* the 'CURLMsg' is the part that is visible to the external user */
+  struct CURLMsg extmsg;
+  struct Curl_message *next;
+};
+
+typedef enum {
+  CURLM_STATE_INIT,
+  CURLM_STATE_CONNECT,
+  CURLM_STATE_DO,
+  CURLM_STATE_PERFORM,
+  CURLM_STATE_DONE,
+  CURLM_STATE_COMPLETED,
+
+  CURLM_STATE_LAST /* not a true state, never use this */
+} CURLMstate;
+
+struct Curl_one_easy {
+  /* first, two fields for the linked list of these */
+  struct Curl_one_easy *next;
+  struct Curl_one_easy *prev;
+  
+  CURL *easy_handle; /* this is the easy handle for this unit */
+  CURLMstate state;  /* the handle's state */
+  CURLcode result;   /* previous result */
+};
+
+
+#define CURL_MULTI_HANDLE 0x000bab1e
+
+#define GOOD_MULTI_HANDLE(x) ((x)&&(((struct Curl_multi *)x)->type == CURL_MULTI_HANDLE))
+#define GOOD_EASY_HANDLE(x) (x)
+
+/* This is the struct known as CURLM on the outside */
+struct Curl_multi {
+  /* First a simple identifier to easier detect if a user mix up
+     this multi handle with an easy handle. Set this to CURL_MULTI_HANDLE. */
+  long type;
+
+  /* We have a linked list with easy handles */
+  struct Curl_one_easy easy; 
+  /* This is the amount of entries in the linked list above. */
+  int num_easy;
+
+  /* this is a linked list of posted messages */
+  struct Curl_message *msgs;
+  /* amount of messages in the queue */
+  int num_msgs;
+
+};
+
+
+CURLM *curl_multi_init(void)
+{
+  struct Curl_multi *multi;
+
+  multi = (void *)malloc(sizeof(struct Curl_multi));
+
+  if(multi) {
+    memset(multi, 0, sizeof(struct Curl_multi));
+    multi->type = CURL_MULTI_HANDLE;
+  }
+  
+  return (CURLM *) multi;
+}
+
+CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                CURL *easy_handle)
+{
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  struct Curl_one_easy *easy;
+
+  /* First, make some basic checks that the CURLM handle is a good handle */
+  if(!GOOD_MULTI_HANDLE(multi))
+    return CURLM_BAD_HANDLE;
+  
+  /* Verify that we got a somewhat good easy handle too */
+  if(!GOOD_EASY_HANDLE(easy_handle))
+    return CURLM_BAD_EASY_HANDLE;
+
+  /* Now, time to add an easy handle to the multi stack */
+  easy = (struct Curl_one_easy *)malloc(sizeof(struct Curl_one_easy));
+  if(!easy)
+    return CURLM_OUT_OF_MEMORY;
+  
+  /* clean it all first (just to be sure) */
+  memset(easy, 0, sizeof(struct Curl_one_easy));
+
+  /* set the easy handle */
+  easy->easy_handle = easy_handle;
+  easy->state = CURLM_STATE_INIT;
+  
+  /* We add this new entry first in the list. We make our 'next' point to the
+     previous next and our 'prev' point back to the 'first' struct */
+  easy->next = multi->easy.next;
+  easy->prev = &multi->easy; 
+
+  /* make 'easy' the first node in the chain */
+  multi->easy.next = easy;
+
+  /* if there was a next node, make sure its 'prev' pointer links back to
+     the new node */
+  if(easy->next)
+    easy->next->prev = easy;
+
+  /* increase the node-counter */
+  multi->num_easy++;
+
+  return CURLM_OK;
+}
+
+CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                   CURL *curl_handle)
+{
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  struct Curl_one_easy *easy;
+
+  /* First, make some basic checks that the CURLM handle is a good handle */
+  if(!GOOD_MULTI_HANDLE(multi))
+    return CURLM_BAD_HANDLE;
+  
+  /* Verify that we got a somewhat good easy handle too */
+  if(!GOOD_EASY_HANDLE(curl_handle))
+    return CURLM_BAD_EASY_HANDLE;
+
+  /* scan through the list and remove the 'curl_handle' */
+  easy = multi->easy.next;
+  while(easy) {
+    if(easy->easy_handle == curl_handle)
+      break;
+    easy=easy->next;
+  }
+  if(easy) {
+    /* If the 'state' is not INIT or COMPLETED, we might need to do something
+       nice to put the easy_handle in a good known state when this returns. */
+
+    /* make the previous node point to our next */
+    if(easy->prev)
+      easy->prev->next = easy->next;
+    /* make our next point to our previous node */
+    if(easy->next)
+      easy->next->prev = easy->prev;
+    
+    /* NOTE NOTE NOTE
+       We do not touch the easy handle here! */
+    free(easy);
+
+    multi->num_easy--; /* one less to care about now */
+
+    return CURLM_OK;
+  }
+  else
+    return CURLM_BAD_EASY_HANDLE; /* twasn't found */
+}
+
+CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                           fd_set *read_fd_set, fd_set *write_fd_set,
+                           fd_set *exc_fd_set, int *max_fd)
+{
+  /* Scan through all the easy handles to get the file descriptors set.
+     Some easy handles may not have connected to the remote host yet,
+     and then we must make sure that is done. */
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  struct Curl_one_easy *easy;
+
+  if(!GOOD_MULTI_HANDLE(multi))
+    return CURLM_BAD_HANDLE;
+
+  easy=multi->easy.next;
+  while(easy) {
+    switch(easy->state) {
+    case CURLM_STATE_INIT:
+    case CURLM_STATE_CONNECT:
+    case CURLM_STATE_DO:
+    case CURLM_STATE_DONE:
+      /* we want curl_multi_perform() to get called, but we don't have any
+         file descriptors to set */
+      break;
+    case CURLM_STATE_PERFORM:
+      /* This should have a set of file descriptors for us to set.  */
+      /* after the transfer is done, go DONE */
+      break;
+    }
+    easy = easy->next; /* check next handle */
+  }
+
+  return CURLM_OK;
+}
+
+CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
+{
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  struct Curl_one_easy *easy;
+  bool done;
+
+  if(!GOOD_MULTI_HANDLE(multi))
+    return CURLM_BAD_HANDLE;
+
+  easy=multi->easy.next;
+  while(easy) {
+
+    switch(easy->state) {
+    case CURLM_STATE_INIT:
+      /* init this transfer. Hm, uh, I can't think of anything to init
+         right now, let's skip over to CONNECT at once!
+
+         easy->result = Curl_init(easy->easy_handle);     
+         if(CURLE_OK == easy->result)
+      */
+      /* after init, go CONNECT */
+      easy->state = CURLM_STATE_CONNECT;
+      break;
+    case CURLM_STATE_CONNECT:
+      /* connect */
+      easy->result = Curl_connect(easy->easy_handle);     
+      /* after connect, go DO */
+      if(CURLE_OK == easy->result)
+        easy->state = CURLM_STATE_DO;
+      break;
+    case CURLM_STATE_DO:
+      /* Do the fetch or put request */
+      easy->result = Curl_do(easy->easy_handle);
+      /* after do, go PERFORM */
+      if(CURLE_OK == easy->result)
+        easy->state = CURLM_STATE_PERFORM;
+      break;
+    case CURLM_STATE_PERFORM:
+      /* read/write data if it is ready to do so */
+      easy->result = Curl_readwrite(easy->easy_handle, &done);
+      /* hm, when we follow redirects, we may need to go back to the CONNECT
+         state */
+      /* after the transfer is done, go DONE */
+      if(TRUE == done)
+        easy->state = CURLM_STATE_DONE;
+      break;
+    case CURLM_STATE_DONE:
+      /* post-transfer command */
+      easy->result = Curl_done(easy->easy_handle);
+      /* after we have DONE what we're supposed to do, go COMPLETED */
+      if(CURLE_OK == easy->result)
+        easy->state = CURLM_STATE_COMPLETED;
+      break;
+    case CURLM_STATE_COMPLETED:
+      /* this is a completed transfer, it is likely to still be connected */
+
+      /* This node should be delinked from the list now and we should post
+         an information message that we are complete. */
+      break;
+    }
+    if((CURLM_STATE_COMPLETED != easy->state) &&
+       (CURLE_OK != easy->result)) {
+      /*
+       * If an error was returned, and we aren't in completed now,
+       * then we go to completed and consider this transfer aborted.
+       */
+      easy->state = CURLM_STATE_COMPLETED;
+    }
+
+    easy = easy->next; /* operate on next handle */
+  }
+  return CURLM_OK;
+}
+
+CURLMcode curl_multi_cleanup(CURLM *multi_handle)
+{
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  if(GOOD_MULTI_HANDLE(multi)) {
+    multi->type = 0; /* not good anymore */
+
+    /* remove all easy handles */
+
+    free(multi);
+
+    return CURLM_OK;
+  }
+  else
+    return CURLM_BAD_HANDLE;
+}
+
+CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue);
+

lib/multi.h

@@ -0,0 +1,183 @@
+#ifndef __CURL_MULTI_H
+#define __CURL_MULTI_H
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+/*
+  This is meant to be the "external" header file. Don't give away any
+  internals here!
+
+  This document presents a mixture of ideas from at least:
+  - Daniel Stenberg
+  - Steve Dekorte
+  - Sterling Hughes
+  - Ben Greear
+
+  -------------------------------------------
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+  
+  Example source using this interface: http://curl.haxx.se/dev/multi-app.c
+
+*/
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#include <curl/types.h>
+
+typedef void CURLM;
+
+typedef enum {
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
+  CURLM_LAST
+} CURLMcode;
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'whatever' points to
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    inititalize multi-style curl usage
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_remove_handle()
+  *
+  * Desc:    removes a curl handle from the multi stack again
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                   CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_fdset()
+  *
+  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+  *          poll() on. We want curl_multi_perform() called as soon as one of
+  *          them are ready.
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                           fd_set *read_fd_set,
+                           fd_set *write_fd_set,
+                           fd_set *exc_fd_set,
+                           int *max_fd);
+
+ /*
+  * Name:    curl_multi_perform()
+  *
+  * Desc:    When the app thinks there's data available for curl it calls this
+  *          function to read/write whatever there is right now. This returns
+  *          as soon as the reads and writes are done. This function does not
+  *          require that there actually is data available for reading or that
+  *          data can be written, it can be called just in case. It returns
+  *          the number of handles that still transfer data in the second
+  *          argument's integer-pointer.
+  *
+  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+  *          returns errors etc regarding the whole multi stack. There might
+  *          still have occurred problems on invidual transfers even when this
+  *          returns OK.
+  */
+CURLMcode curl_multi_perform(CURLM *multi_handle,
+                             int *running_handles);
+
+ /*
+  * Name:    curl_multi_cleanup()
+  *
+  * Desc:    Cleans up and removes a whole multi stack. It does not free or
+  *          touch any individual easy handles in any way. We need to define
+  *          in what state those handles will be if this function is called
+  *          in the middle of a transfer.
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there's any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be very simple and only contain
+ *          very basic informations. If more involved information is wanted,
+ *          we will provide the particular "transfer handle" in that struct
+ *          and that should/could/would be used in subsequent
+ *          curl_easy_getinfo() calls (or similar). The point being that we
+ *          must never expose complex structs to applications, as then we'll
+ *          undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                              int *msgs_in_queue);
+
+#endif

lib/netrc.c

@@ -201,3 +201,11 @@ int main(int argc, char **argv)
 }
 
 #endif
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/progress.c

@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___ 
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
@@ -70,7 +70,7 @@ static char *max5data(double bytes, char *max5)
   }
   if(bytes < (100*ONE_MEGABYTE)) {
     /* 'XX.XM' is good as long as we're less than 100 megs */
-    sprintf(max5, "%2.1fM", bytes/ONE_MEGABYTE);
+    sprintf(max5, "%4.1fM", bytes/ONE_MEGABYTE);
     return max5;
   }
   sprintf(max5, "%4dM", (int)bytes/ONE_MEGABYTE);
@@ -93,17 +93,17 @@ static char *max5data(double bytes, char *max5)
 
 void Curl_pgrsDone(struct connectdata *conn)
 {
-  struct UrlData *data = conn->data;
+  struct SessionHandle *data = conn->data;
   if(!(data->progress.flags & PGRS_HIDE)) {
     data->progress.lastshow=0;
     Curl_pgrsUpdate(conn); /* the final (forced) update */
     if(!data->progress.callback)
       /* only output if we don't use progress callback */
-      fprintf(data->err, "\n");
+      fprintf(data->set.err, "\n");
   }
 }
 
-void Curl_pgrsTime(struct UrlData *data, timerid timer)
+void Curl_pgrsTime(struct SessionHandle *data, timerid timer)
 {
   switch(timer) {
   default:
@@ -111,23 +111,25 @@ void Curl_pgrsTime(struct UrlData *data, timerid timer)
     /* mistake filter */
     break;
   case TIMER_STARTSINGLE:
-    /* This is set at the start of a single fetch, there may be several
-       fetches within an operation, why we add all other times relative
-       to this one */
+    /* This is set at the start of a single fetch */
     data->progress.t_startsingle = Curl_tvnow();
     break;
 
   case TIMER_NAMELOOKUP:
-    data->progress.t_nslookup += Curl_tvdiff(Curl_tvnow(),
-                                        data->progress.t_startsingle);
+    data->progress.t_nslookup =
+      (double)Curl_tvdiff(Curl_tvnow(), data->progress.t_startsingle)/1000.0;
     break;
   case TIMER_CONNECT:
-    data->progress.t_connect += Curl_tvdiff(Curl_tvnow(),
-                                       data->progress.t_startsingle);
+    data->progress.t_connect =
+      (double)Curl_tvdiff(Curl_tvnow(), data->progress.t_startsingle)/1000.0;
     break;
   case TIMER_PRETRANSFER:
-    data->progress.t_pretransfer += Curl_tvdiff(Curl_tvnow(),
-                                           data->progress.t_startsingle);
+    data->progress.t_pretransfer =
+      (double)Curl_tvdiff(Curl_tvnow(), data->progress.t_startsingle)/1000.0;
+    break;
+  case TIMER_STARTTRANSFER:
+    data->progress.t_starttransfer =
+      (double)Curl_tvdiff(Curl_tvnow(), data->progress.t_startsingle)/1000.0;
     break;
   case TIMER_POSTRANSFER:
     /* this is the normal end-of-transfer thing */
@@ -135,23 +137,23 @@ void Curl_pgrsTime(struct UrlData *data, timerid timer)
   }
 }
 
-void Curl_pgrsStartNow(struct UrlData *data)
+void Curl_pgrsStartNow(struct SessionHandle *data)
 {
   data->progress.speeder_c = 0; /* reset the progress meter display */
   data->progress.start = Curl_tvnow();
 }
 
-void Curl_pgrsSetDownloadCounter(struct UrlData *data, double size)
+void Curl_pgrsSetDownloadCounter(struct SessionHandle *data, double size)
 {
   data->progress.downloaded = size;
 }
 
-void Curl_pgrsSetUploadCounter(struct UrlData *data, double size)
+void Curl_pgrsSetUploadCounter(struct SessionHandle *data, double size)
 {
   data->progress.uploaded = size;
 }
 
-void Curl_pgrsSetDownloadSize(struct UrlData *data, double size)
+void Curl_pgrsSetDownloadSize(struct SessionHandle *data, double size)
 {
   if(size > 0) {
     data->progress.size_dl = size;
@@ -159,7 +161,7 @@ void Curl_pgrsSetDownloadSize(struct UrlData *data, double size)
   }
 }
 
-void Curl_pgrsSetUploadSize(struct UrlData *data, double size)
+void Curl_pgrsSetUploadSize(struct SessionHandle *data, double size)
 {
   if(size > 0) {
     data->progress.size_ul = size;
@@ -187,12 +189,14 @@ int Curl_pgrsUpdate(struct connectdata *conn)
 
   double total_transfer;
   double total_expected_transfer;
+  double timespent;
 
-  struct UrlData *data = conn->data;
+  struct SessionHandle *data = conn->data;
 
   int nowindex = data->progress.speeder_c% CURR_TIME;
   int checkindex;
-  int count;
+
+  int countindex; /* amount of seconds stored in the speeder array */
 
   char time_left[10];
   char time_total[10];
@@ -211,9 +215,9 @@ int Curl_pgrsUpdate(struct connectdata *conn)
   else if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
     if (!data->progress.callback) {
       if(conn->resume_from)
-        fprintf(data->err, "** Resuming transfer from byte position %d\n",
+        fprintf(data->set.err, "** Resuming transfer from byte position %d\n",
                 conn->resume_from);
-      fprintf(data->err,
+      fprintf(data->set.err,
               "  %% Total    %% Received %% Xferd  Average Speed          Time             Curr.\n"
               "                                 Dload  Upload Total    Current  Left    Speed\n");
     }
@@ -222,14 +226,18 @@ int Curl_pgrsUpdate(struct connectdata *conn)
 
   now = Curl_tvnow(); /* what time is it */
 
-  /* The exact time spent so far */
-  data->progress.timespent = Curl_tvdiff (now, data->progress.start);
+  /* The exact time spent so far (from the start) */
+  timespent = (double)Curl_tvdiff (now, data->progress.start)/1000;
+
+  data->progress.timespent = timespent;
 
   /* The average download speed this far */
-  data->progress.dlspeed = data->progress.downloaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0);
+  data->progress.dlspeed =
+    data->progress.downloaded/(timespent>0.01?timespent:1);
 
   /* The average upload speed this far */
-  data->progress.ulspeed = data->progress.uploaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0);
+  data->progress.ulspeed =
+    data->progress.uploaded/(timespent>0.01?timespent:1);
 
   if(data->progress.lastshow == Curl_tvlong(now))
     return 0; /* never update this more than once a second if the end isn't 
@@ -237,25 +245,59 @@ int Curl_pgrsUpdate(struct connectdata *conn)
   data->progress.lastshow = now.tv_sec;
 
   /* Let's do the "current speed" thing, which should use the fastest
-         of the dl/ul speeds */
+     of the dl/ul speeds. Store the fasted speed at entry 'nowindex'. */
   data->progress.speeder[ nowindex ] =
     data->progress.downloaded>data->progress.uploaded?
     data->progress.downloaded:data->progress.uploaded;
-  data->progress.speeder_c++; /* increase */
-  count = ((data->progress.speeder_c>=CURR_TIME)?
+
+  /* remember the exact time for this moment */
+  data->progress.speeder_time [ nowindex ] = now;
+
+  /* advance our speeder_c counter, which is increased every time we get
+     here and we expect it to never wrap as 2^32 is a lot of seconds! */
+  data->progress.speeder_c++;
+
+  /* figure out how many index entries of data we have stored in our speeder
+     array. With N_ENTRIES filled in, we have about N_ENTRIES-1 seconds of
+     transfer. Imagine, after one second we have filled in two entries,
+     after two seconds we've filled in three entries etc. */
+  countindex = ((data->progress.speeder_c>=CURR_TIME)?
                 CURR_TIME:data->progress.speeder_c) - 1;
+
+  /* first of all, we don't do this if there's no counted seconds yet */
+  if(countindex) {
+    long span_ms;
+
+    /* Get the index position to compare with the 'nowindex' position.
+       Get the oldest entry possible. While we have less than CURR_TIME
+       entries, the first entry will remain the oldest. */
     checkindex = (data->progress.speeder_c>=CURR_TIME)?
       data->progress.speeder_c%CURR_TIME:0;
 
-  /* find out the average speed the last CURR_TIME seconds */
+    /* Figure out the exact time for the time span */
+    span_ms = Curl_tvdiff(now,
+                          data->progress.speeder_time[checkindex]);
+    if(0 == span_ms)
+      span_ms=1; /* at least one millisecond MUST have passed */
+
+    /* Calculate the average speed the last 'countindex' seconds */
     data->progress.current_speed =
       (data->progress.speeder[nowindex]-
-     data->progress.speeder[checkindex])/(count?count:1);
+       data->progress.speeder[checkindex])/((double)span_ms/1000);
+  }
+  else
+    /* the first second we use the main average */
+    data->progress.current_speed =
+      (data->progress.ulspeed>data->progress.dlspeed)?
+      data->progress.ulspeed:data->progress.dlspeed;
 
   if(data->progress.flags & PGRS_HIDE)
     return 0;
-  else if(data->fprogress) {
-    result= data->fprogress(data->progress_client,
+
+  else if(data->set.fprogress) {
+    /* There's a callback set, so we call that instead of writing
+       anything ourselves. This really is the way to go. */
+    result= data->set.fprogress(data->set.progress_client,
                                 data->progress.size_dl,
                                 data->progress.downloaded,
                                 data->progress.size_ul,
@@ -310,7 +352,7 @@ int Curl_pgrsUpdate(struct connectdata *conn)
   if(total_expected_transfer)
     total_percen=(double)(total_transfer/total_expected_transfer)*100;
 
-  fprintf(data->err,
+  fprintf(data->set.err,
           "\r%3d %s  %3d %s  %3d %s  %s  %s %s %s %s %s",
           (int)total_percen,                            /* total % */
           max5data(total_expected_transfer, max5[2]),   /* total size */
@@ -327,5 +369,16 @@ int Curl_pgrsUpdate(struct connectdata *conn)
           max5data(data->progress.current_speed, max5[5]) /* current speed */
           );
 
+  /* we flush the output stream to make it appear as soon as possible */
+  fflush(data->set.err);
+
   return 0;
 }
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */

lib/progress.h

@@ -31,19 +31,20 @@ typedef enum {
   TIMER_NAMELOOKUP,
   TIMER_CONNECT,
   TIMER_PRETRANSFER,
+  TIMER_STARTTRANSFER,
   TIMER_POSTRANSFER,
   TIMER_STARTSINGLE,
   TIMER_LAST /* must be last */
 } timerid;
   
 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);
+void Curl_pgrsStartNow(struct SessionHandle *data);
+void Curl_pgrsSetDownloadSize(struct SessionHandle *data, double size);
+void Curl_pgrsSetUploadSize(struct SessionHandle *data, double size);
+void Curl_pgrsSetDownloadCounter(struct SessionHandle *data, double size);
+void Curl_pgrsSetUploadCounter(struct SessionHandle *data, double size);
 int Curl_pgrsUpdate(struct connectdata *);
-void Curl_pgrsTime(struct UrlData *data, timerid timer);
+void Curl_pgrsTime(struct SessionHandle *data, timerid timer);
 
 
 /* Don't show progress for sizes smaller than: */