7.9.7 commit

we don't need win32sockets.c anymore, we support this internally
fopen.c added, a fopen() style emulation for URL reading
2002-05-13 09:40:16 +00:00 · 2002-05-13 07:29:22 +00:00 · 2002-05-13 07:28:10 +00:00 · 2002-05-12 16:10:12 +00:00 · 2002-05-10 16:01:24 +00:00 · 2002-05-10 15:59:42 +00:00
48 changed files with 1604 additions and 420 deletions
--- a/144
+++ b/144
@@ -6,6 +6,150 @@

                               History of Changes

+Version 7.9.7
+
+Daniel (10 May 2002)
+- Kevin Roth adjusted the --trace-ascii output slightly.
+
+- Paul Harrington found out that src/writeout.c needed an additional header
+  file included for AIX builds
+
+Version 7.9.7-pre2
+
+Daniel (7 May 2002)
+- Updated the man page with --trace-ascii and -j/--junk-session-cookies.
+
+- Made --trace-ascii do pretty much the same as --trace but without the hex
+  part in the output.
+
+- Added CURLOPT_COOKIESESSION that when enabled makes libcurl ignore session
+  cookies read from a file. This option is enforced by the curl command line
+  tool using the new -j/--junk-session-cookies option. After discussions with
+  Kevin Roth. This makes it easier to use curl to fully emulate a browser's
+  behavior, even when it comes to "session cookies". Session cookies are
+  cookies that a normal browser discards when the browser is shut
+  down. They're identified by not having any expire date/time.
+
+- When CURLOPT_DEBUGDATA was set, it ruined the CURLOPT_STDERR setting and
+  this was discovered when --trace was made to crash.
+
+- Using -v and --trace at the same time confused matters. -v is now pretty
+  much ignored when --trace or --trace-ascii is used.
+
+- Made --trace (and --trace-ascii) support - as file name to pass output to
+  stdout instead. It makes it consistent with how other options work.
+
+Version 7.9.7-pre1
+
+Daniel (6 May 2002)
+- Added multi-post.c to the examples directory. I got the basic source for
+  this from Gustaf Hui.
+
+Daniel (3 May 2002)
+- CURL_MAX_WRITE_SIZE is now an exported #define in the curl/curl.h header and
+  can be used to figure out the maximum buffer size your write callback can
+  get.
+
+- CURLOPT_READDATA is now an alias for CURLOPT_INFILE and CURLOPT_WRITEDATE is
+  an alias for CURLOPT_FILE. These two were added for conformity. Most other
+  callback function's userdata are provided with options using a similar name-
+  scheme.
+
+- Added "--trace [file]" to the command line tool. It makes a very detailed
+  trace dump get stored, with a full protocol dump that includes all received
+  and transmitted data. This could be a very effective tool for debugging what
+  goes wrong. This dump includes every byte the way it is sent to/received
+  from the server. The dump is the plain-text version, so SSL transfers will
+  still be readable.
+
+- I found out that the DEBUGFUNCTION was not called properly everywhere as we
+  wanted it to. I fixed it.
+
+- -D now stores all headers to the same file if multiple URLs are given on the
+  command line! Kevin Roth made me aware of that it didn't already do this!
+
+- Gustaf Hui wrote an excellent formpost example that used the multi
+  interface.  Unfortunately, it didn't work due to several bugs in how
+  transfers were made when the multi interface was used.
+
+Daniel (2 May 2002)
+- Hanno Kranzhoff found out that when doing multiple transfers on the same
+  easy handle, the progress meter would show a bad "currently downloaded
+  value" when the transfer starts.
+
+Daniel (1 May 2002)
+- Applied another patch by Jacky Lam to make the name resolve info realloc()
+  stuff work properly.
+
+Daniel (28 April 2002)
+- curl_multi_info_read() is now implemented!
+
+Daniel (27 April 2002)
+- Updated BUGS, TODO, FAQ, INSTALL and added BINDINGS.
+
+- I think I fixed the DNS cache prune crach Jacky Lam found and reported.
+
+- I cleaned up the name prefix stuff in the hash and llist modules.
+
+- FTP responses should now be better on timing out properly. The timeout value
+  is maximum timeout for the entire request operation, but before this, the
+  timeout was used as a maximum allowed time between two reads...
+
+Daniel (26 April 2002)
+- Fixed the test suite http server to not use snprintf() anymore due to better
+  portability.
+
+Daniel (25 April 2002)
+- With Sterling Hughes' new DNS pruning, Jacky Lam asked if this wouldn't
+  cause problems since the pruning is only checking the entry time, and it
+  sure could cause problems. Therefor, I've now added and changed code so that
+  this should not be a problem. Nowhere in the code will be store name
+  resolved information around so that a sunsequent DNS cache prune should
+  cause a problem. This of course called for some mild internal changes.
+
+Daniel (23 April 2002)
+- Improved the 'no_proxy' check, as using port numbers in the URL confused it
+  previously. Reported by Erwan Legrand in bug report #547484.
+
+- The --interface option now works even on IPv6 enabled builds. Reported by
+  'thor'.
+
+Daniel (22 April 2002)
+- The #defines names starting with TIMECOND now has CURL_ prefixes. (The old
+  names are still #defined too.) Pointed out by Robert Olson.
+
+- Jacky Lam brought code that lets the name resolve function only use as much
+  memory as it actually needs. This only works on certain operating systems,
+  but is totally transparant to all users.
+
+Daniel (19 April 2002)
+- Bjorn Reese fixed pack_hostent to work properly with 64 bit pointers.
+
+Daniel (18 April 2002)
+- Sterling Hughes added code to prune old DNS cache entries, since Jacky Lam
+  experienced very big caches.
+
+Daniel (17 April 2002)
+- Dirk Manske patched the 301 response to work against the RFC but more like
+  common browsers do. If a POST get a 301 back, it'll switch to GET in the
+  next request (if location-following is enabled).
+
+Daniel (16 April 2002)
+- Dirk Manske posted a patch originally written by Ingo Wilken that introduced
+  two new CURLINFO_* values: CURLINFO_REDIRECT_TIME and
+  CURLINFO_REDIRECT_COUNT.
+
+Daniel (15 April 2002)
+- Jonatan Lander patched the verbose text 'Disables POST, goes with GET' to
+  reflect reality better, like when the first request isn't POST and when
+  the second isn't GET... :-)
+
+- Craig Davison pointed out that when curl_formadd()ing a file that doesn't
+  exist, libcurl doesn't return error. Now, curl_easy_perform() will return
+  CURLE_READ_ERROR if that is the case. Test 41 was added to verify this.
+
+Version 7.9.6
+
 Daniel (14 April 2002)
 - Dirk Manske brought a fix that makes libcurl strip off white spaces from the
  beginning of cookie contents.
--- a/docs/BINDINGS
+++ b/docs/BINDINGS
@@ -0,0 +1,91 @@
+                                  _   _ ____  _     
+                              ___| | | |  _ \| |    
+                             / __| | | | |_) | |    
+                            | (__| |_| |  _ <| |___ 
+                             \___|\___/|_| \_\_____|
+
+                               libcurl bindings
+
+Creative people have written particular bindings or interfaces for various
+environments and programming languages. Using one of these allows you to take
+advantage of curl powers from within your favourite language or system.
+
+This is a list of all known interfaces as of this writing.
+
+The bindings listed below are not part of the curl/libcurl distribution
+archives, but must be downloaded and installed separately.
+
+Basic
+
+  ScriptBasic bindings to libcurl. Writtten by Peter Verhas.
+  http://scriptbasic.com/
+
+C++
+
+  Maintained by Jean-Philippe Barrette-LaPierre.
+  http://curl.haxx.se/libcurl/cplusplus/
+
+Cocoa
+
+  Written by Dan Wood.
+  http://curlhandle.sourceforge.net/
+
+Dylan
+
+  Written by Chris Double.
+  http://dylanlibs.sourceforge.net/
+
+Java
+
+  Written by Daniel Stenberg.
+  http://curl.haxx.se/libcurl/java/
+
+Lua
+
+  Written by Steve Dekorte.
+  http://curl.haxx.se/libcurl/lua/
+
+Pascal
+
+  Free Pascal binding written by Jeffrey Pohlmeyer.
+  http://houston.quik.com/jkp/curlpas/
+
+Perl
+
+  Maintained by Cris Bailiff.
+  http://curl.haxx.se/libcurl/perl/
+
+PHP
+
+  Written by Sterling Hughes.
+  http://curl.haxx.se/libcurl/php/
+
+PostgreSQL
+
+  Written by Gian Paolo Ciceri.
+  http://gborg.postgresql.org/project/pgcurl/projdisplay.php
+
+Python
+
+  Written by Kjetil Jacobsen.
+  http://pycurl.sourceforge.net/
+
+Rexx
+
+  Written Mark Hessling. 
+  http://rexxcurl.sourceforge.net/
+
+Ruby
+
+  Written by Hirotaka Matsuyuki. 
+  http://www.d1.dion.ne.jp/~matuyuki/ruby.html
+
+Scheme
+
+  Bigloo binding written by Kirill Lisovsky.
+  http://curl.haxx.se/libcurl/scheme/
+
+Tcl
+
+  Written by Andr<64>s Garc<72>a. 
+  http://personal1.iddeo.es/andresgarci/tclcurl/english/docs.html
--- a/docs/BUGS
+++ b/docs/BUGS
@@ -8,28 +8,44 @@ $Id$
 BUGS

  Curl and libcurl have grown substantially since the beginning. At the time
-  of writing (mid March 2001), there are 23000 lines of source code, and by
+  of writing (end of April 2002), there are 32000 lines of source code, and by
  the time you read this it has probably grown even more.

  Of course there are lots of bugs left. And lots of misfeatures.

  To help us make curl the stable and solid product we want it to be, we need
-  bug reports and bug fixes. If you can't fix a bug yourself and submit a fix
-  for it, try to report an as detailed report as possible to the curl mailing
-  list to allow one of us to have a go at a solution. You should also post
-  your bug/problem at curl's bug tracking system over at
+  bug reports and bug fixes.
+
+WHERE TO REPORT
+
+  If you can't fix a bug yourself and submit a fix for it, try to report an as
+  detailed report as possible to the curl mailing list to allow one of us to
+  have a go at a solution. You should also post your bug/problem at curl's bug
+  tracking system over at

        http://sourceforge.net/bugs/?group_id=976

-  When reporting a bug, you should include information that will help us
-  understand what's wrong, what you expected to happen and how to repeat the
-  bad behavior. You therefore need to supply your operating system's name and
-  version number (uname -a under a unix is fine), what version of curl you're
-  using (curl -V is fine), what URL you were working with and anything else
-  you think matters.
+  (but please read the section below first before doing that)

-  Since curl deals with networks, it often helps us a lot if you include a
-  protocol debug dump with your bug report. The output you get by using the -v
+WHAT TO REPORT
+
+  When reporting a bug, you should include information that will help us
+  understand what's wrong what you expected to happen and how to repeat the
+  bad behavior. You therefore need to tell us:
+
+   - your operating system's name and version number (uname -a under a unix
+     is fine)
+   - what version of curl you're using (curl -V is fine)
+   - what URL you were working with (if possible), at least which protocol
+
+  and anything and everything else you think matters. Tell us what you
+  expected to happen, tell use what did happen, tell us how you could make it
+  work another way. Dig around, try out, test. Then include all the tiny bits
+  and pieces in your report. You will benefit from this yourself, as it will
+  enable us to help you quicker and more accurately.
+
+  Since curl deals with networks, it often helps us if you include a protocol
+  debug dump with your bug report. The output you get by using the -v
  flag. Usually, you also get more info by using -i so that is likely to be
  useful when reporting bugs as well.

--- a/docs/FAQ
+++ b/docs/FAQ
@@ -1,4 +1,4 @@
-Updated: March 11, 2002 (http://curl.haxx.se/docs/faq.shtml)
+Updated: April 27, 2002 (http://curl.haxx.se/docs/faq.shtml)
                                  _   _ ____  _     
                              ___| | | |  _ \| |    
                             / __| | | | |_) | |    
@@ -15,6 +15,7 @@ FAQ
  1.5 Who makes cURL?
  1.6 What do you get for making cURL?
  1.7 What about CURL from curl.com?
+  1.8 I have a problem who do I mail?

 2. Install Related Problems
  2.1 configure doesn't find OpenSSL even when it is installed
@@ -193,6 +194,21 @@ FAQ
  We recognize that we will be living in parallel with curl.com and wish them
  every success.

+  1.8 I have a problem who do I mail?
+
+  Please do not attempt to mail any single individual unless you really need
+  to. Keep curl-related questions on a suitable mailing list. All available
+  mailing lists are listed in the MANUAL document and online at
+  http://curl.haxx.se/mail/
+
+  Keeping curl-related questions and dicussions on mailing lists allows others
+  to join in and help, to share their ideas, contribute their suggestions and
+  spread their wisdom. Keeping discussions on public mailing lists also allows
+  for others to learn from this (both current and future users thanks to the
+  web based archives of the mailing lists), thus saving us from having to
+  repeat ourselves even more. Thanks for respecting this.
+
+
 2. Install Related Problems

  2.1. configure doesn't find OpenSSL even when it is installed
@@ -537,12 +553,8 @@ FAQ
  particular platform, try contacting the person who built the package/archive
  you have.

-  If there is a bug, post a bug report in the Curl Bug Track System over at
-  http://sourceforge.net/bugs/?group_id=976
-
-  Always include as many details you can think of, including curl version,
-  operating system name and version and complete instructions how to repeat
-  the bug.
+  If there is a bug, read the BUGS document first. Then report it as described
+  in there.

  4.9. Curl can't authenticate to the server that requires NTLM?

--- a/docs/INSTALL
+++ b/docs/INSTALL
@@ -395,13 +395,15 @@ CROSS COMPILE
 PORTS
 =====
   This is a probably incomplete list of known hardware and operating systems
-   that curl has been compiled for. If you know one system curl compiles and
+   that curl has been compiled for. If you know a system curl compiles and
   runs on, that isn't listed, please let us know!

        - Alpha DEC OSF 4
        - Alpha Digital UNIX v3.2
-        - Alpha FreeBSD 4.1
-        - Alpha Linux 2.2.16
+        - Alpha FreeBSD 4.1, 4.5
+        - Alpha Linux 2.2, 2.4
+        - Alpha NetBSD 1.5.2
+        - Alpha OpenBSD 3.0
        - Alpha OpenVMS V7.1-1H2
        - Alpha Tru64 v5.0 5.1
        - HP-PA HP-UX 9.X 10.X 11.X
@@ -409,7 +411,7 @@ PORTS
        - MIPS IRIX 6.2, 6.5
        - MIPS Linux
        - Pocket PC/Win CE 3.0
-        - Power AIX 4.2, 4.3.1, 4.3.2
+        - Power AIX 4.2, 4.3.1, 4.3.2, 5.1
        - PowerPC Darwin 1.0
        - PowerPC Linux
        - PowerPC Mac OS 9
--- a/docs/KNOWN_BUGS
+++ b/docs/KNOWN_BUGS
@@ -3,9 +3,6 @@ join in and help us correct one or more of these! Also be sure to check the
 changelog of the current development status, as one or more of these problems
 may have been fixed since this was written!

-* curl_formadd() fails on OSF1. Why? Fix! Need help from OSF1 dudes.
-  https://sourceforge.net/tracker/index.php?func=detail&aid=524433&group_id=976&atid=100976
-
 * Running 'make test' on Mac OS X gives 4 errors. This seems to be related
  to some kind of libtool problem:
  http://curl.haxx.se/mail/archive-2002-03/0029.html and
--- a/docs/Makefile.am
+++ b/docs/Makefile.am
@@ -16,7 +16,7 @@ SUBDIRS = examples libcurl

 EXTRA_DIST = MANUAL BUGS CONTRIBUTE FAQ FEATURES INTERNALS		\
 	     README.win32 RESOURCES TODO TheArtOfHttpScripting THANKS	\
-	     VERSIONS KNOWN_BUGS $(man_MANS) $(HTMLPAGES)
+	     VERSIONS KNOWN_BUGS BINDINGS $(man_MANS) $(HTMLPAGES)

 MAN2HTML= gnroff -man $< | man2html >$@

--- a/docs/RESOURCES
+++ b/docs/RESOURCES
@@ -5,10 +5,9 @@
                             \___|\___/|_| \_\_____|


-This document has been introduced in order to let you find documents that
-specify standards used by curl, software that extends curl, web pages with
-"competing" utilities and information pages that describe some of the tools
-that we use to build/compile/develop curl.
+This document lists documents that specify standards used by curl, software
+that extends curl, web pages with similar utilities and information pages that
+describe some of the tools that we use to build/compile/develop curl.

 Standards
 ---------
--- a/docs/TODO
+++ b/docs/TODO
@@ -53,16 +53,14 @@ TODO
   especially regular HTTP POST), the FTP command sending etc.

 * Go through the code and verify that libcurl deals with big files >2GB and
-   >4GB all over. Bug reports indicate that it doesn't currently work
-   properly.
+   >4GB all over. Bug reports (and source reviews) indicate that it doesn't
+   currently work properly.

 * Make the built-in progress meter use its own dedicated output stream, and
   make it possible to set it. Use stderr by default.

 DOCUMENTATION

- * Include documentation in the main archive about all the various libcurl
-   bindings.   

 FTP

@@ -77,7 +75,9 @@ TODO
   already working http dito works. It of course requires that 'MDTM' works,
   and it isn't a standard FTP command.

- * Add FTPS support with SSL for the data connection too.
+ * Add FTPS support with SSL for the data connection too.  This should be made
+   according to the specs written in draft-murray-auth-ftp-ssl-08.txt,
+   "Securing FTP with TLS"

 HTTP

--- a/docs/curl.1
+++ b/docs/curl.1
@@ -2,7 +2,7 @@
 .\" nroff -man curl.1
 .\" Written by Daniel Stenberg
 .\"
-.TH curl 1 "10 Apr 2002" "Curl 7.9.5" "Curl Manual"
+.TH curl 1 "7 May 2002" "Curl 7.9.7" "Curl Manual"
 .SH NAME
 curl \- transfer a URL
 .SH SYNOPSIS
@@ -99,10 +99,7 @@ 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
-of no more use. This option didn't work in win32 systems until 7.7.2.  See
-also the
-.I "--max-time"
-option.
+of no more use. See also the \fI--max-time\fP option.

 If this option is used several times, the last one will be used.
 .IP "-c/--cookie-jar <file name>"
@@ -125,6 +122,10 @@ 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 "--crlf"
+(FTP) Convert LF to CRLF in upload. Useful for MVS (OS/390).
+
+If this option is used twice, the second will again disable crlf converting.
 .IP "-d/--data <data>"
 (HTTP) Sends the specified data in a POST request to the HTTP server, in a way
 that can emulate as if a user has filled in a HTML form and pressed the submit
@@ -167,16 +168,17 @@ append data.
 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.
+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
-file if -I/--head is used.
+Write the protocol headers to the specified file.

 This option is handy to use when you want to store the cookies that a HTTP
 site sends to you. The cookies could then be read in a second curl invoke by
 using the -b/--cookie option!

+When used on FTP, the ftp server response lines are considered being "headers"
+and thus are saved there.
+
 If this option is used several times, the last one will be used.
 .IP "-e/--referer <URL>"
 (HTTP) Sends the "Referer Page" information to the HTTP server. This can also
@@ -187,6 +189,12 @@ previous URL when it follows a Location: header. The ";auto" string can be
 used alone, even if you don't set an initial referer.

 If this option is used several times, the last one will be used.
+.IP "--environment"
+(RISC OS ONLY) Sets a range of environment variables, using the names the -w
+option supports, to easier allow extraction of useful information after having
+run curl.
+
+If this option is used several times, each occurrence will toggle this on/off.
 .IP "--egd-file <file>"
 (HTTPS) Specify the path name to the Entropy Gathering Daemon socket. The
 socket is used to seed the random engine for SSL connections. See also the
@@ -207,13 +215,11 @@ peer. The certificate must be in PEM format.

 If this option is used several times, the last one will be used.
 .IP "-f/--fail"
-(HTTP)
-Fail silently (no output at all) on server errors. This is mostly done
-like this to better enable scripts etc to better deal with failed
-attempts. In normal cases when a HTTP server fails to deliver a
-document, it returns a HTML document stating so (which often also
-describes why and more). This flag will prevent curl from
-outputting that and fail silently instead.
+(HTTP) Fail silently (no output at all) on server errors. This is mostly done
+like this to better enable scripts etc to better deal with failed attempts. In
+normal cases when a HTTP server fails to deliver a document, it returns a HTML
+document stating so (which often also describes why and more). This flag will
+prevent curl from outputting that and fail silently instead.

 If this option is used twice, the second will again disable silent failure.
 .IP "-F/--form <name=content>"
@@ -241,13 +247,17 @@ This option can be used multiple times.
 This option switches off the "URL globbing parser". When you set this option,
 you can specify URLs that contain the letters {}[] without having them being
 interpreted by curl itself. Note that these letters are not normal legal URL
-contents but they should be encoded according to the URI standard. (Option
-added in curl 7.6)
+contents but they should be encoded according to the URI standard.
 .IP "-G/--get"
 When used, this option will make all data specified with -d/--data or
 --data-binary to be used in a HTTP GET request instead of the POST request
 that otherwise would be used. The data will be appended to the URL with a '?'
 separator. (Option added in curl 7.9)
+
+If used in combination with -I, the POST data will instead be appended to the
+URL with a HEAD request.
+
+If used multiple times, nothing special happens.
 .IP "-h/--help"
 Usage help.
 .IP "-H/--header <header>"
@@ -260,7 +270,7 @@ set headers without knowing perfectly well what you're doing. Replacing an
 internal header with one without content on the right side of the colon will
 prevent that header from appearing.

-This option can be used multiple times.
+This option can be used multiple times to add/replace/remove multiple headers.
 .IP "-i/--include"
 (HTTP)
 Include the HTTP-header in the output. The HTTP-header includes things
@@ -281,6 +291,13 @@ which this uses to get nothing but the header of a document. When used
 on a FTP file, curl displays the file size only.

 If this option is used twice, the second will again disable header only.
+.IP "-j/--junk-session-cookies"
+(HTTP) When curl is told to read cookies from a given file, this option will
+make it discard all "session cookies". This will basicly have the same effect
+as if a new session is started. Typical browsers always discard session
+cookies when they're closed down. (Added in 7.9.7)
+
+If this option is used several times, each occurrence will toggle this on/off.
 .IP "--krb4 <level>"
 (FTP) Enable kerberos4 authentication and use. The level must be entered and
 should be one of 'clear', 'safe', 'confidential' or 'private'. Should you use
@@ -312,6 +329,10 @@ Especially useful if you want to machine-parse the contents of an FTP
 directory since the normal directory view doesn't use a standard look
 or format.

+This option causes an FTP NLST command to be sent.  Some FTP servers
+list only files in their response to NLST; they do not include
+subdirectories and symbolic links.
+
 If this option is used twice, the second will again disable list only.
 .IP "-L/--location"
 (HTTP/HTTPS) If the server reports that the requested page has a different
@@ -325,10 +346,8 @@ If this option is used twice, the second will again disable location following.
 .IP "-m/--max-time <seconds>"
 Maximum time in seconds that you allow the whole operation to take.  This is
 useful for preventing your batch jobs from hanging for hours due to slow
-networks or links going down.  This doesn't work fully in win32 systems.
-See also the
-.I "--connect-timeout"
-option.
+networks or links going down.  This doesn't work fully in win32 systems.  See
+also the \fI--connect-timeout\fP option.

 If this option is used several times, the last one will be used.
 .IP "-M/--manual"
@@ -485,6 +504,12 @@ If this option is used twice, the second will again disable mute.
 When used with -s it makes curl show error message if it fails.

 If this option is used twice, the second will again disable show error.
+.IP "--stderr <file>"
+Redirect all writes to stderr to the specified file instead. If the file name
+is a plain '-', it is instead written to stdout. This option has no point when
+you're using a shell with decent redirecting capabilities.
+
+If this option is used several times, the last one will be used.
 .IP "-t/--telnet-option <OPT=val>"
 Pass options to the telnet protocol. Supported options are:

@@ -504,6 +529,24 @@ 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 "--trace <file>"
+Enables a full trace dump of all incoming and outgoing data, including
+descriptive information, to the given output file. Use "-" as filename to have
+the output sent to stdout.
+
+If this option is used several times, the last one will be used. (Added in
+curl 7.9.7)
+.IP "--trace-ascii <file>"
+Enables a full trace dump of all incoming and outgoing data, including
+descriptive information, to the given output file. Use "-" as filename to have
+the output sent to stdout.
+
+This is very similar to --trace, but leaves out the hex part and only shows
+the ASCII part of the dump. It makes smaller output that might be easier to
+read for untrained humans.
+
+If this option is used several times, the last one will be used. (Added in
+curl 7.9.7)
 .IP "-u/--user <user:password>"
 Specify user and password to use when fetching. See README.curl for detailed
 examples of how to use this. If no password is specified, curl will
@@ -654,6 +697,12 @@ Start the date expression with a dash (-) to make it request for a document
 that is older than the given date/time, default is a document that is newer
 than the specified date/time.

+If this option is used several times, the last one will be used.
+.IP "-Z/--max-redirs <num>"
+Set maximum number of redirection-followings allowed. If -L/--location is
+used, this option can be used to prevent curl from following redirections "in
+absurdum".
+
 If this option is used several times, the last one will be used.
 .IP "-3/--sslv3"
 (HTTPS)
@@ -669,16 +718,6 @@ Make curl display progress information as a progress bar instead of the
 default statistics.

 If this option is used twice, the second will again disable the progress bar.
-.IP "--crlf"
-(FTP) Convert LF to CRLF in upload. Useful for MVS (OS/390).
-
-If this option is used twice, the second will again disable crlf converting.
-.IP "--stderr <file>"
-Redirect all writes to stderr to the specified file instead. If the file name
-is a plain '-', it is instead written to stdout. This option has no point when
-you're using a shell with decent redirecting capabilities.
-
-If this option is used several times, the last one will be used.
 .SH FILES
 .I ~/.curlrc
 .RS
--- a/docs/examples/Makefile.am
+++ b/docs/examples/Makefile.am
@@ -4,11 +4,12 @@

 AUTOMAKE_OPTIONS = foreign no-dependencies

-EXTRA_DIST = README curlgtk.c sepheaders.c simple.c postit2.c \
-	     win32sockets.c persistant.c ftpget.c Makefile.example \
-	     multithread.c getinmemory.c ftpupload.c httpput.c \
-	     simplessl.c ftpgetresp.c http-post.c post-callback.c \
-	     multi-app.c multi-double.c multi-single.c
+EXTRA_DIST = README curlgtk.c sepheaders.c simple.c postit2.c		\
+	     persistant.c ftpget.c Makefile.example			\
+	     multithread.c getinmemory.c ftpupload.c httpput.c		\
+	     simplessl.c ftpgetresp.c http-post.c post-callback.c	\
+	     multi-app.c multi-double.c multi-single.c multi-post.c	\
+	     fopen.c

 all:
 	@echo "done"
--- a/docs/examples/fopen.c
+++ b/docs/examples/fopen.c
@@ -0,0 +1,222 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ *
+ * This example source code introduces an fopen()/fread()/fclose() emulation
+ * for URL reads. Using an approach similar to this, you could replace your
+ * program's fopen() with this url_fopen() and fread() with url_fread() and
+ * it should be possible to read remote streams instead of (only) local files.
+ *
+ * See the main() function at the bottom that shows a tiny app in action.
+ *
+ * This source code is a proof of concept. It will need further attention to
+ * become production-use useful and solid.
+ *
+ * This example requires libcurl 7.9.7 or later.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+struct data {
+  int type;
+  union {
+    CURL *curl;
+    FILE *file;
+  } handle;
+
+  /* TODO: We should perhaps document the biggest possible buffer chunk we can
+     get from libcurl in one single callback... */
+  char buffer[CURL_MAX_WRITE_SIZE];
+
+  char *readptr; /* read from here */
+  int bytes;     /* bytes available from read pointer */
+
+  CURLMcode m;   /* stored from a previous url_fread() */
+};
+
+typedef struct data URL_FILE;
+
+/* we use a global one for convenience */
+CURLM *multi_handle;
+
+static
+size_t write_callback(char *buffer,
+                      size_t size,
+                      size_t nitems,
+                      void *userp)
+{
+  URL_FILE *url = (URL_FILE *)userp;
+  size *= nitems;
+
+  memcpy(url->readptr, buffer, size);
+  url->readptr += size;
+  url->bytes += size;
+
+  return size;
+}
+
+URL_FILE *url_fopen(char *url, char *operation)
+{
+  /* this code could check for URLs or types in the 'url' and
+     basicly use the real fopen() for standard files */
+
+  URL_FILE *file;
+  int still_running;
+
+  file = (URL_FILE *)malloc(sizeof(URL_FILE));
+  if(!file)
+    return NULL;
+
+  memset(file, 0, sizeof(URL_FILE));
+
+  file->type = 1; /* marked as URL, use 0 for plain file */
+  file->handle.curl = curl_easy_init();
+
+  curl_easy_setopt(file->handle.curl, CURLOPT_URL, url);
+  curl_easy_setopt(file->handle.curl, CURLOPT_FILE, file);
+  curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, FALSE);
+  curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback);
+
+  if(!multi_handle)
+    multi_handle = curl_multi_init();
+
+  curl_multi_add_handle(multi_handle, file->handle.curl);
+
+  while(CURLM_CALL_MULTI_PERFORM ==
+        curl_multi_perform(multi_handle, &still_running));
+
+  /* if still_running would be 0 now, we should return NULL */
+
+  return file;
+}
+
+void url_fclose(URL_FILE *file)
+{
+  /* make sure the easy handle is not in the multi handle anymore */
+  curl_multi_remove_handle(multi_handle, file->handle.curl);
+
+  /* cleanup */
+  curl_easy_cleanup(file->handle.curl);
+}
+
+
+
+size_t url_fread(void *ptr, size_t size, size_t nmemb, URL_FILE *file)
+{
+  fd_set fdread;
+  fd_set fdwrite;
+  fd_set fdexcep;
+  int maxfd;
+  struct timeval timeout;
+  int rc;
+  int still_running = 0;
+
+  if(!file->bytes) { /* no data available at this point */
+
+    file->readptr = file->buffer; /* reset read pointer */
+
+    if(CURLM_CALL_MULTI_PERFORM == file->m) {
+      while(CURLM_CALL_MULTI_PERFORM ==
+            curl_multi_perform(multi_handle, &still_running)) {
+        if(file->bytes) {
+          printf("(fread) WOAH! THis happened!\n");
+          break;        
+        }
+      }
+      if(!still_running) {
+        printf("NO MORE RUNNING AROUND!\n");
+        return 0;
+      }
+    }
+
+    FD_ZERO(&fdread);
+    FD_ZERO(&fdwrite);
+    FD_ZERO(&fdexcep);
+  
+    /* set a suitable timeout to fail on */
+    timeout.tv_sec = 500; /* 5 minutes */
+    timeout.tv_usec = 0;
+
+    /* get file descriptors from the transfers */
+    curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+
+    rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+
+    switch(rc) {
+    case -1:
+      /* select error */
+      break;
+    case 0:
+      break;
+    default:
+      /* timeout or readable/writable sockets */
+      do {
+        file->m = curl_multi_perform(multi_handle, &still_running);
+
+        if(file->bytes)
+          /* we have received data, return that now */
+          break;
+
+      } while(CURLM_CALL_MULTI_PERFORM == file->m);
+
+
+      if(!still_running)
+        printf("NO MORE RUNNING AROUND!\n");
+
+      break;
+    }
+  }
+  else
+    printf("(fread) Skip network read\n");
+
+  if(file->bytes) {
+    /* data already available, return that */
+    int want = size * nmemb;
+
+    if(file->bytes < want)
+      want = file->bytes;
+
+    memcpy(ptr, file->readptr, want);
+    file->readptr += want;
+    file->bytes -= want;
+
+    printf("(fread) return %d bytes\n", want);
+
+    return want;
+  }
+  return 0; /* no data available to return */
+}
+
+
+int main(int argc, char *argv[])
+{
+  URL_FILE *handle;
+  int nread;
+  char buffer[256];
+
+  handle = url_fopen("http://www.haxx.se", "r");
+
+  if(!handle) {
+    printf("couldn't url_fopen()\n");
+  }
+
+  do {
+    nread = url_fread(buffer, sizeof(buffer), 1, handle);
+
+    printf("We got: %d bytes\n", nread);
+  } while(nread);
+
+  url_fclose(handle);
+
+  return 0;
+}
--- a/docs/examples/multi-post.c
+++ b/docs/examples/multi-post.c
@@ -0,0 +1,126 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * $Id$
+ *
+ * This is an example application source code using the multi interface
+ * to do a multipart formpost without "blocking".
+ */
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include <curl/curl.h>
+
+int main(int argc, char *argv[])
+{
+  CURL *curl;
+  CURLcode res;
+
+  CURLM *multi_handle;
+  int still_running;
+
+  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();
+  multi_handle = curl_multi_init();
+
+  /* initalize custom header list (stating that Expect: 100-continue is not
+     wanted */
+  headerlist = curl_slist_append(headerlist, buf);
+  if(curl && multi_handle) {
+    int perform=0;
+
+    /* what URL that receives this POST */
+    curl_easy_setopt(curl, CURLOPT_URL,
+                     "http://www.fillinyoururl.com/upload.cgi");
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
+
+    curl_multi_add_handle(multi_handle, curl);
+
+    while(CURLM_CALL_MULTI_PERFORM ==
+          curl_multi_perform(multi_handle, &still_running));
+
+    while(still_running) {
+      struct timeval timeout;
+      int rc; /* select() return code */
+
+      fd_set fdread;
+      fd_set fdwrite;
+      fd_set fdexcep;
+      int maxfd;
+
+      FD_ZERO(&fdread);
+      FD_ZERO(&fdwrite);
+      FD_ZERO(&fdexcep);
+
+      /* set a suitable timeout to play around with */
+      timeout.tv_sec = 1;
+      timeout.tv_usec = 0;
+
+      /* get file descriptors from the transfers */
+      curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+
+      rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+
+      switch(rc) {
+      case -1:
+        /* select error */
+        break;
+      case 0:
+        printf("timeout!\n");
+      default:
+        /* timeout or readable/writable sockets */
+        printf("perform!\n");
+        while(CURLM_CALL_MULTI_PERFORM ==
+              curl_multi_perform(multi_handle, &still_running));
+        printf("running: %d!\n", still_running);
+        break;
+      }
+    }
+
+    curl_multi_cleanup(multi_handle);
+
+    /* always cleanup */
+    curl_easy_cleanup(curl);
+
+    /* then cleanup the formpost chain */
+    curl_formfree(formpost);
+
+    /* free slist */
+    curl_slist_free_all (headerlist);
+  }
+  return 0;
+}
--- a/docs/examples/win32sockets.c
+++ b/docs/examples/win32sockets.c
@@ -1,49 +0,0 @@
-
-/*
- * Note: This is only required if you use curl 7.8 or lower, later 
- * versions provide an option to curl_global_init() that does the
- * win32 initialization for you.
- */
-
-/*
- * These are example functions doing socket init that Windows
- * require. If you don't use windows, you can safely ignore this crap.
- */
-
-#include <windows.h>
-
-void win32_cleanup(void)
-{
-  WSACleanup();
-}
-
-int win32_init(void)
-{
-  WORD wVersionRequested;  
-  WSADATA wsaData; 
-  int err; 
-  wVersionRequested = MAKEWORD(1, 1); 
-    
-  err = WSAStartup(wVersionRequested, &wsaData); 
-    
-  if (err != 0) 
-    /* Tell the user that we couldn't find a useable */ 
-    /* winsock.dll.     */ 
-    return 1;
-    
-  /* Confirm that the Windows Sockets DLL supports 1.1.*/ 
-  /* Note that if the DLL supports versions greater */ 
-  /* than 1.1 in addition to 1.1, it will still return */ 
-  /* 1.1 in wVersion since that is the version we */ 
-  /* requested. */ 
-    
-  if ( LOBYTE( wsaData.wVersion ) != 1 || 
-       HIBYTE( wsaData.wVersion ) != 1 ) { 
-    /* Tell the user that we couldn't find a useable */ 
-
-    /* winsock.dll. */ 
-    WSACleanup(); 
-    return 1; 
-  }
-  return 0; /* 0 is ok */
-}
--- a/docs/libcurl-the-guide
+++ b/docs/libcurl-the-guide
@@ -949,11 +949,11 @@ Security Considerations
    .netrc is a pretty handy file/feature that allows you to login quickly and
    automaticly to frequently visited sites. The file contains passwords in
    clear text and is a real security risk. In some cases, your .netrc is also
-    stored in a home directory that is NFS mounter or used on another network
+    stored in a home directory that is NFS mounted or used on another network
    based file system, so the clear text password will fly through your
    network every time anyone reads that file!

-    To avoid this problem, don't use .netrc files and never store passwords as
+    To avoid this problem, don't use .netrc files and never store passwords in
    plain text anywhere.

  Clear Text Passwords
--- a/docs/libcurl/curl_easy_getinfo.3
+++ b/docs/libcurl/curl_easy_getinfo.3
@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_easy_init 3 "31 Jan 2001" "libcurl 7.9.4" "libcurl Manual"
+.TH curl_easy_init 3 "25 Apr 2002" "libcurl 7.9.7" "libcurl Manual"
 .SH NAME
 curl_easy_getinfo - Extract information from a curl session (added in 7.4)
 .SH SYNOPSIS
@@ -38,7 +38,9 @@ CURLOPT_FILETIME option to \fIcurl_easy_setopt(3)\fP. (Added in 7.5)
 .TP
 .B CURLINFO_TOTAL_TIME
 Pass a pointer to a double to receive the total transaction time in seconds
-for the previous transfer.
+for the previous transfer. This time does not include the connect time, so if
+you want the complete operation time, you should add the
+CURLINFO_CONNECT_TIME.
 .TP
 .B CURLINFO_NAMELOOKUP_TIME
 Pass a pointer to a double to receive the time, in seconds, it took from the
@@ -60,6 +62,16 @@ 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_REDIRECT_TIME
+Pass a pointer to a double to receive the total time, in seconds, it took for
+all redirection steps include name lookup, connect, pretransfer and transfer
+before final transaction was started. CURLINFO_REDIRECT_TIME contains the
+complete execution time for multiple redirections.  (Added in 7.9.7)
+.TP
+.B CURLINFO_REDIRECT_COUNT
+Pass a pointer to a long to receive the total number of redirections that were
+actually followed.  (Added in 7.9.7)
+.TP
 .B CURLINFO_SIZE_UPLOAD
 Pass a pointer to a double to receive the total amount of bytes that were
 uploaded.
--- a/docs/libcurl/curl_easy_setopt.3
+++ b/docs/libcurl/curl_easy_setopt.3
@@ -2,7 +2,7 @@
 .\" nroff -man [file]
 .\" $Id$
 .\"
-.TH curl_easy_setopt 3 "12 Apr 2002" "libcurl 7.9.6" "libcurl Manual"
+.TH curl_easy_setopt 3 "3 May 2002" "libcurl 7.9.6" "libcurl Manual"
 .SH NAME
 curl_easy_setopt - Set curl easy-session options
 .SH SYNOPSIS
@@ -36,7 +36,7 @@ The \fIhandle\fP is the return code from a \fIcurl_easy_init(3)\fP or
 .SH OPTIONS
 The options are listed in a sort of random order, but you'll figure it out!
 .TP 0.4i
-.B CURLOPT_FILE
+.B CURLOPT_WRITEDATA
 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
@@ -45,6 +45,8 @@ fwrite() when writing data.
 \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.
+
+This option is also known with the older name \fBCURLOPT_FILE\fP.
 .TP
 .B CURLOPT_WRITEFUNCTION
 Function pointer that should match the following prototype: \fBsize_t
@@ -60,15 +62,18 @@ 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.
+thousands. The maximum amount of data that can be passed to the write callback
+is defined in the curl.h header file: CURL_MAX_WRITE_SIZE.
 .TP
-.B CURLOPT_INFILE
+.B CURLOPT_READDATA
 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 *.

 \fBNOTE:\fP If you're using libcurl as a win32 DLL, you MUST use a
 \fICURLOPT_READFUNCTION\fP if you set this option.
+
+This option is also known with the older name \fBCURLOPT_INFILE\fP.
 .TP
 .B CURLOPT_READFUNCTION
 Function pointer that should match the following prototype: \fBsize_t
@@ -166,6 +171,10 @@ will imply this option.
 A non-zero parameter tells the library to just list the names of an ftp
 directory, instead of doing a full directory listing that would include file
 sizes, dates etc.
+
+This causes an FTP NLST command to be sent.  Beware that some FTP servers
+list only files in their response to NLST; they do not include
+subdirectories and symbolic links.
 .TP
 .B CURLOPT_FTPAPPEND
 A non-zero parameter tells the library to append to the remote file instead of
@@ -293,6 +302,13 @@ want the transfer to start from.
 Pass a pointer to a zero terminated string as parameter. It will be used to
 set a cookie in the http request. The format of the string should be
 [NAME]=[CONTENTS]; Where NAME is the cookie name.
+
+If you need to set mulitple cookies, you need to set them all using a single
+option and thus you need to concat them all in one single string. Set multiple
+cookies in one string like this: "name1=content1; name2=content2;" etc.
+
+Using this option multiple times will only make the latest string override the
+previously ones.
 .TP
 .B CURLOPT_HTTPHEADER
 Pass a pointer to a linked list of HTTP headers to pass to the server in your
@@ -428,8 +444,8 @@ 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,
-and the time will be used as specified in CURLOPT_TIMECONDITION or if that
-isn't used, it will be TIMECOND_IFMODSINCE by default.
+and the time will be used in a condition as specified with
+CURLOPT_TIMECONDITION.
 .TP
 .B CURLOPT_CUSTOMREQUEST
 Pass a pointer to a zero terminated string as parameter. It will be user
--- a/docs/libcurl/curl_multi_fdset.3
+++ b/docs/libcurl/curl_multi_fdset.3
@@ -1,6 +1,6 @@
 .\" $Id$
 .\"
-.TH curl_multi_fdset 3 "1 March 2002" "libcurl 7.9.5" "libcurl Manual"
+.TH curl_multi_fdset 3 "3 May 2002" "libcurl 7.9.5" "libcurl Manual"
 .SH NAME
 curl_multi_fdset - add an easy handle to a multi session
 .SH SYNOPSIS
@@ -17,6 +17,10 @@ This function extracts file descriptor information from a given multi_handle.
 libcurl returns its fd_set sets. The application can use these to select() or
 poll() on. The curl_multi_perform() function should be called as soon as one
 of them are ready to be read from or written to.
+
+NOTE that once this call is made, you must not remove the sets you point to,
+as libcurl will need to be able to read them. It needs them after select()
+calls, to know if certain sockets are readable or writable.
 .SH RETURN VALUE
 CURLMcode type, general libcurl multi interface error code.
 .SH "SEE ALSO"
--- a/include/curl/curl.h
+++ b/include/curl/curl.h
@@ -86,6 +86,8 @@ typedef int (*curl_progress_callback)(void *clientp,
                                      double ultotal,
                                      double ulnow);

+#define CURL_MAX_WRITE_SIZE 20480
+
 typedef size_t (*curl_write_callback)(char *buffer,
                                      size_t size,
                                      size_t nitems,
@@ -535,10 +537,18 @@ typedef enum {

  /* set the data for the debug function */
  CINIT(DEBUGDATA, OBJECTPOINT, 95),
+
+  /* mark this as start of a cookie session */
+  CINIT(COOKIESESSION, LONG, 96),
  
  CURLOPT_LASTENTRY /* the last unusued */
 } CURLoption;

+  /* two convenient "aliases" that follow the name scheme better */
+#define CURLOPT_WRITEDATA CURLOPT_FILE
+#define CURLOPT_READDATA  CURLOPT_INFILE 
+
+
  /* 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
@@ -561,15 +571,26 @@ enum {


 typedef enum {
-  TIMECOND_NONE,
+  CURL_TIMECOND_NONE,

-  TIMECOND_IFMODSINCE,
-  TIMECOND_IFUNMODSINCE,
-  TIMECOND_LASTMOD,
+  CURL_TIMECOND_IFMODSINCE,
+  CURL_TIMECOND_IFUNMODSINCE,
+  CURL_TIMECOND_LASTMOD,

-  TIMECOND_LAST
+  CURL_TIMECOND_LAST
 } curl_TimeCond;

+/* for backwards compatibility */
+#ifndef TIMECOND_IFMODSINCE
+#define TIMECOND_IFMODSINCE CURL_TIMECOND_IFMODSINCE
+#endif
+#ifndef TIMECOND_IFUNMODSINCE
+#define TIMECOND_IFUNMODSINCE CURL_TIMECOND_IFUNMODSINCE
+#endif
+#ifndef TIMECOND_LASTMOD
+#define TIMECOND_LASTMOD CURL_TIMECOND_LASTMOD
+#endif
+
 #ifdef __BEOS__
 #include <support/SupportDefs.h>
 #endif
@@ -663,8 +684,8 @@ CURLcode curl_global_init(long flags);
 void curl_global_cleanup(void);

 /* This is the version number */
-#define LIBCURL_VERSION "7.9.6"
-#define LIBCURL_VERSION_NUM 0x070906
+#define LIBCURL_VERSION "7.9.7"
+#define LIBCURL_VERSION_NUM 0x070907

 /* linked-list structure for the CURLOPT_QUOTE option (and other) */
 struct curl_slist {
@@ -718,9 +739,12 @@ typedef enum {

  CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,

+  CURLINFO_REDIRECT_TIME   = CURLINFO_DOUBLE + 19,
+  CURLINFO_REDIRECT_COUNT  = CURLINFO_LONG + 20,
+
  /* Fill in new entries here! */

-  CURLINFO_LASTONE          = 19
+  CURLINFO_LASTONE          = 21
 } CURLINFO;

 /* unfortunately, the easy.h and multi.h include files need options and info
--- a/lib/connect.c
+++ b/lib/connect.c
@@ -185,7 +185,6 @@ int waitconnect(int sockfd, /* socket */
  return 0;
 }

-#ifndef ENABLE_IPV6
 static CURLcode bindlocal(struct connectdata *conn,
                          int sockfd)
 {
@@ -207,22 +206,28 @@ static CURLcode bindlocal(struct connectdata *conn,
   *************************************************************/
  if (strlen(data->set.device)<255) {
    struct sockaddr_in sa;
-    struct hostent *h=NULL;
-    char *hostdataptr=NULL;
+    Curl_addrinfo *h=NULL;
    size_t size;
    char myhost[256] = "";
    in_addr_t in;

    if(Curl_if2ip(data->set.device, myhost, sizeof(myhost))) {
-      h = Curl_resolv(data, myhost, 0, &hostdataptr);
+      /*
+       * We now have the numerical IPv4-style x.y.z.w in the 'myhost' buffer
+       */
+      h = Curl_resolv(data, myhost, 0);
    }
    else {
      if(strlen(data->set.device)>1) {
-        h = Curl_resolv(data, data->set.device, 0, &hostdataptr);
-      }
-      if(h) {
-        /* we know data->set.device is shorter than the myhost array */
-        strcpy(myhost, data->set.device);
+        /*
+         * This was not an interface, resolve the name as a host name
+         * or IP number
+         */
+        h = Curl_resolv(data, data->set.device, 0);
+        if(h) {
+          /* we know data->set.device is shorter than the myhost array */
+          strcpy(myhost, data->set.device);
+        }
      }
    }

@@ -243,10 +248,13 @@ static CURLcode bindlocal(struct connectdata *conn,

      if ( h ) {
        memset((char *)&sa, 0, sizeof(sa));
-        memcpy((char *)&sa.sin_addr,
-               h->h_addr,
-               h->h_length);
+#ifdef ENABLE_IPV6
+        memcpy((char *)&sa.sin_addr, h->ai_addr, h->ai_addrlen);        
+        sa.sin_family = h->ai_family;
+#else
+        memcpy((char *)&sa.sin_addr, h->h_addr, h->h_length);
        sa.sin_family = AF_INET;
+#endif
        sa.sin_addr.s_addr = in;
        sa.sin_port = 0; /* get any port */
 	
@@ -314,7 +322,7 @@ static CURLcode bindlocal(struct connectdata *conn,

  return CURLE_HTTP_PORT_FAILED;
 }
-#endif /* end of ipv4-specific section */
+

 static
 int socketerror(int sockfd)
@@ -345,6 +353,7 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
  int rc;
  int sockfd=-1;
  int aliasindex=0;
+  char *hostname;

  struct timeval after;
  struct timeval before = Curl_tvnow();
@@ -385,8 +394,8 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
    }
  }

-  infof(data, "About to connect() to %s:%d\n",
-        data->change.proxy?conn->proxyhost:conn->hostname, port);
+  hostname = data->change.proxy?conn->proxyhost:conn->hostname;
+  infof(data, "About to connect() to %s:%d\n", hostname, port);

 #ifdef ENABLE_IPV6
  /*
@@ -401,6 +410,14 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
      if (sockfd < 0)
        continue;

+      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;
+      }
+
      /* set socket non-blocking */
      Curl_nonblock(sockfd, TRUE);

@@ -427,7 +444,7 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
        case ECONNREFUSED: /* no one listening */
        default:
          /* unknown error, fallthrough and try another address! */
-          failf(data, "Failed to connect: %d", error);
+          failf(data, "Failed connect to %s: %d", hostname, error);
          break;
        }
      }
@@ -457,10 +474,8 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
      before = after;
      continue;
    }
-    if (sockfd < 0) {
-      failf(data, "connect() failed");
+    if (sockfd < 0)
      return CURLE_COULDNT_CONNECT;
-    }

    /* leave the socket in non-blocking mode */

@@ -532,8 +547,8 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
        break;
      default:
        /* unknown error, fallthrough and try another address! */
-        failf(data, "Failed to connect to IP number %d: %d",
-              aliasindex+1, error);
+        failf(data, "Failed to connect to %s IP number %d: %d",
+              hostname, aliasindex+1, error);
        break;
      }
    }
@@ -565,7 +580,6 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
    /* no good connect was made */
    sclose(sockfd);
    *sockconn = -1;
-    failf(data, "Couldn't connect to host");
    return CURLE_COULDNT_CONNECT;
  }

--- a/lib/cookie.c
+++ b/lib/cookie.c
@@ -93,6 +93,21 @@ Example set of cookies:
 #include "memdebug.h"
 #endif

+static void
+free_cookiemess(struct Cookie *co)
+{
+  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);
+}
+
 /****************************************************************************
 *
 * Curl_cookie_add()
@@ -326,22 +341,19 @@ Curl_cookie_add(struct CookieInfo *c,
    if(7 != fields) {
      /* we did not find the sufficient number of fields to recognize this
         as a valid line, abort and go home */
-
-      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);
+      free_cookiemess(co);
      return NULL;
    }

  }

+  if(!c->running &&    /* read from a file */
+     c->newsession &&  /* clean session cookies */
+     !co->expires) {   /* this is a session cookie since it doesn't expire! */
+    free_cookiemess(co);
+    return NULL;
+  }
+
  co->livecookie = c->running;

  /* now, we have parsed the incoming line, we must now check if this
@@ -462,8 +474,12 @@ Curl_cookie_add(struct CookieInfo *c,
 * Inits a cookie struct to read data from a local file. This is always
 * called before any cookies are set. File may be NULL.
 *
+ * If 'newsession' is TRUE, discard all "session cookies" on read from file.
+ *
 ****************************************************************************/
-struct CookieInfo *Curl_cookie_init(char *file, struct CookieInfo *inc)
+struct CookieInfo *Curl_cookie_init(char *file,
+                                    struct CookieInfo *inc,
+                                    bool newsession)
 {
  char line[MAX_COOKIE_LINE];
  struct CookieInfo *c;
@@ -491,6 +507,8 @@ struct CookieInfo *Curl_cookie_init(char *file, struct CookieInfo *inc)
  else
    fp = file?fopen(file, "r"):NULL;

+  c->newsession = newsession; /* new session? */
+
  if(fp) {
    char *lineptr;
    bool headerline;
@@ -513,7 +531,7 @@ struct CookieInfo *Curl_cookie_init(char *file, struct CookieInfo *inc)
      fclose(fp);
  }

-  c->running = TRUE; /* now, we're running */
+  c->running = TRUE;          /* now, we're running */

  return c;
 }
--- a/lib/cookie.h
+++ b/lib/cookie.h
@@ -55,9 +55,10 @@ struct CookieInfo {
  /* linked list of cookies we know of */
  struct Cookie *cookies;

-  char *filename; /* file we read from/write to */
-  bool running;   /* state info, for cookie adding information */
+  char *filename;  /* file we read from/write to */
+  bool running;    /* state info, for cookie adding information */
  long numcookies; /* number of cookies in the "jar" */
+  bool newsession; /* new session, discard session cookies on load */
 };

 /* This is the maximum line length we accept for a cookie line */
@@ -75,7 +76,7 @@ struct CookieInfo {
 struct Cookie *Curl_cookie_add(struct CookieInfo *, bool header, char *line,
                               char *domain);

-struct CookieInfo *Curl_cookie_init(char *, struct CookieInfo *);
+struct CookieInfo *Curl_cookie_init(char *, struct CookieInfo *, bool);
 struct Cookie *Curl_cookie_getlist(struct CookieInfo *, char *, char *, bool);
 void Curl_cookie_freelist(struct Cookie *);
 void Curl_cookie_cleanup(struct CookieInfo *);
--- a/lib/easy.c
+++ b/lib/easy.c
@@ -238,7 +238,7 @@ CURLcode curl_easy_perform(CURL *curl)
      data->hostcache = Curl_global_host_cache_get();
    }
    else {
-      data->hostcache = curl_hash_alloc(7, Curl_freeaddrinfo);
+      data->hostcache = Curl_hash_alloc(7, Curl_freeaddrinfo);
    }
  }

@@ -249,7 +249,7 @@ void curl_easy_cleanup(CURL *curl)
 {
  struct SessionHandle *data = (struct SessionHandle *)curl;
  if (!Curl_global_host_cache_use(data)) {
-    curl_hash_destroy(data->hostcache);
+    Curl_hash_destroy(data->hostcache);
  }
  Curl_close(data);
 }
@@ -312,7 +312,8 @@ CURL *curl_easy_duphandle(CURL *incurl)
    /* 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);
+                                        outcurl->cookies,
+                                        data->set.cookiesession);

  /* duplicate all values in 'change' */
  if(data->change.url) {
--- a/lib/file.c
+++ b/lib/file.c
@@ -140,7 +140,7 @@ CURLcode Curl_file(struct connectdata *conn)
  */
  CURLcode res = CURLE_OK;
  struct stat statbuf;
-  ssize_t expected_size=-1;
+  double expected_size=-1;
  ssize_t nread;
  struct SessionHandle *data = conn->data;
  char *buf = data->state.buffer;
@@ -155,7 +155,7 @@ CURLcode Curl_file(struct connectdata *conn)
 /*VMS?? -- This only works reliable for STREAMLF files */
  if( -1 != fstat(fd, &statbuf)) {
    /* we could stat it, then read out the size */
-    expected_size = statbuf.st_size;
+    expected_size = (double)statbuf.st_size;
  }

  /* The following is a shortcut implementation of file reading
--- a/lib/formdata.c
+++ b/lib/formdata.c
@@ -1044,22 +1044,24 @@ void curl_formfree(struct curl_httppost *form)
  } while((form=next)); /* continue */
 }

-struct FormData *Curl_getFormData(struct curl_httppost *post,
-                                  int *sizep)
+CURLcode Curl_getFormData(struct FormData **finalform,
+                          struct curl_httppost *post,
+                          int *sizep)
 {
  struct FormData *form = NULL;
  struct FormData *firstform;
-
  struct curl_httppost *file;
+  CURLcode result = CURLE_OK;

  int size =0;
  char *boundary;
  char *fileboundary=NULL;
  struct curl_slist* curList;

+  *finalform=NULL; /* default form is empty */

  if(!post)
-    return NULL; /* no input => no output! */
+    return result; /* no input => no output! */

  boundary = Curl_FormBoundary();
  
@@ -1166,20 +1168,24 @@ struct FormData *Curl_getFormData(struct curl_httppost *post,
 /*VMS?? Stream files are OK, as are FIXED & VAR files WITHOUT implied CC */
 /*VMS?? For implied CC, every record needs to have a \n appended & 1 added to SIZE */
 	if(fileread) {
-	  while((nread = fread(buffer, 1, 1024, fileread))) {
-	    size += AddFormData(&form,
-				buffer,
-				nread);
-	  }
+	  while((nread = fread(buffer, 1, 1024, fileread)))
+	    size += AddFormData(&form, buffer, nread);
+
          if(fileread != stdin)
            fclose(fileread);
 	}
        else {
+#if 0
          /* File wasn't found, add a nothing field! */
 	  size += AddFormData(&form, "", 0);
+#endif
+          Curl_formclean(firstform);
+          free(boundary);
+          *finalform = NULL;
+          return CURLE_READ_ERROR;
 	}
      }
- else {
+      else {
 	/* include the contents we got */
 	size += AddFormData(&form, post->contents, post->contentslength);
      }
@@ -1205,7 +1211,9 @@ struct FormData *Curl_getFormData(struct curl_httppost *post,

  free(boundary);

-  return firstform;
+  *finalform=firstform;
+
+  return result;
 }

 int Curl_FormInit(struct Form *form, struct FormData *formdata )
--- a/lib/formdata.h
+++ b/lib/formdata.h
@@ -53,8 +53,10 @@ typedef struct FormInfo {

 int Curl_FormInit(struct Form *form, struct FormData *formdata );

-struct FormData *Curl_getFormData(struct HttpPost *post,
-                                  int *size);
+CURLcode
+Curl_getFormData(struct FormData **,
+                 struct HttpPost *post,
+                 int *size);

 /* fread() emulation */
 int Curl_FormReader(char *buffer,
--- a/lib/ftp.c
+++ b/lib/ftp.c
@@ -210,16 +210,6 @@ int Curl_GetFTPResponse(char *buf,
  if (ftpcode)
    *ftpcode = 0; /* 0 for errors */

-  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 (sockfd, &readfd);     /* read socket */

@@ -235,11 +225,22 @@ int Curl_GetFTPResponse(char *buf,
  keepon=TRUE;

  while((nread<BUFSIZE) && (keepon && !error)) {
-    readfd = rkeepfd;		   /* set every lap */
-    interval.tv_sec = timeout;
-    interval.tv_usec = 0;
+    /* check and reset timeout value every lap */
+    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 */
+      }
+    }
+
+    if(!ftp->cache) {
+      readfd = rkeepfd;		   /* set every lap */
+      interval.tv_sec = timeout;
+      interval.tv_usec = 0;

-    if(!ftp->cache)
      switch (select (sockfd+1, &readfd, NULL, NULL, &interval)) {
      case -1: /* select() error, stop reading */
        error = SELECT_ERROR;
@@ -253,6 +254,7 @@ int Curl_GetFTPResponse(char *buf,
        error = SELECT_OK;
        break;
      }
+    }
    if(SELECT_OK == error) {
      /*
       * This code previously didn't use the kerberos sec_read() code
@@ -1205,19 +1207,19 @@ CURLcode ftp_use_port(struct connectdata *conn)

  if(data->set.ftpport) {
    if(Curl_if2ip(data->set.ftpport, myhost, sizeof(myhost))) {
-      h = Curl_resolv(data, myhost, 0, &hostdataptr);
+      h = Curl_resolv(data, myhost, 0);
    }
    else {
      int len = strlen(data->set.ftpport);
      if(len>1)
-        h = Curl_resolv(data, data->set.ftpport, 0, &hostdataptr);
+        h = Curl_resolv(data, data->set.ftpport, 0);
      if(h)
        strcpy(myhost, data->set.ftpport); /* buffer overflow risk */
    }
  }
  if(! *myhost) {
    char *tmp_host = getmyhost(myhost, sizeof(myhost));
-    h=Curl_resolv(data, tmp_host, 0, &hostdataptr);
+    h=Curl_resolv(data, tmp_host, 0);
  }
  infof(data, "We connect from %s\n", myhost);
  
@@ -1360,7 +1362,6 @@ CURLcode ftp_use_pasv(struct connectdata *conn)
  int modeoff;
  unsigned short connectport; /* the local port connect() should use! */
  unsigned short newport; /* remote port, not necessary the local one */
-  char *hostdataptr=NULL;
  
  /* newhost must be able to hold a full IP-style address in ASCII, which
     in the IPv6 case means 5*8-1 = 39 letters */
@@ -1450,16 +1451,19 @@ CURLcode ftp_use_pasv(struct connectdata *conn)
  if(data->change.proxy) {
    /*
     * This is a tunnel through a http proxy and we need to connect to the
-     * proxy again here. We already have the name info for it since the
-     * previous lookup.
+     * proxy again here.
+     *
+     * We don't want to rely on a former host lookup that might've expired
+     * now, instead we remake the lookup here and now!
     */
-    addr = conn->hostaddr;
+    addr = Curl_resolv(data, conn->proxyhost, conn->port);
    connectport =
-      (unsigned short)conn->port; /* we connect to the proxy's port */
+      (unsigned short)conn->port; /* we connect to the proxy's port */    
+
  }
  else {
    /* normal, direct, ftp connection */
-    addr = Curl_resolv(data, newhostp, newport, &hostdataptr);
+    addr = Curl_resolv(data, newhostp, newport);
    if(!addr) {
      failf(data, "Can't resolve new host %s:%d", newhostp, newport);
      return CURLE_FTP_CANT_GET_HOST;
--- a/lib/getinfo.c
+++ b/lib/getinfo.c
@@ -54,6 +54,7 @@ CURLcode Curl_initinfo(struct SessionHandle *data)
  pro->t_pretransfer = 0;
  pro->t_starttransfer = 0;
  pro->timespent = 0;
+  pro->t_redirect = 0;

  info->httpcode = 0;
  info->httpversion=0;
@@ -148,6 +149,12 @@ CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...)
  case CURLINFO_CONTENT_LENGTH_UPLOAD:
    *param_doublep = data->progress.size_ul;
    break;
+  case CURLINFO_REDIRECT_TIME:
+    *param_doublep =  data->progress.t_redirect;
+    break;
+  case CURLINFO_REDIRECT_COUNT:
+    *param_longp = data->set.followlocation;
+    break;
  case CURLINFO_CONTENT_TYPE:
    *param_charp = data->info.contenttype;
    break;
--- a/lib/hash.c
+++ b/lib/hash.c
@@ -72,7 +72,7 @@ _hash_element_dtor (void *user, void *element)
 /* {{{ void curl_hash_init (curl_hash *, int, curl_hash_dtor)
 */
 void 
-curl_hash_init (curl_hash *h, int slots, curl_hash_dtor dtor)
+Curl_hash_init (curl_hash *h, int slots, curl_hash_dtor dtor)
 {
  int i;

@@ -82,7 +82,7 @@ curl_hash_init (curl_hash *h, int slots, curl_hash_dtor dtor)

  h->table = (curl_llist **) malloc(slots * sizeof(curl_llist *));
  for (i = 0; i < slots; ++i) {
-    h->table[i] = curl_llist_alloc((curl_llist_dtor) _hash_element_dtor);
+    h->table[i] = Curl_llist_alloc((curl_llist_dtor) _hash_element_dtor);
  }
 }
 /* }}} */
@@ -90,7 +90,7 @@ curl_hash_init (curl_hash *h, int slots, curl_hash_dtor dtor)
 /* {{{ curl_hash *curl_hash_alloc (int, curl_hash_dtor)
 */
 curl_hash *
-curl_hash_alloc (int slots, curl_hash_dtor dtor)
+Curl_hash_alloc (int slots, curl_hash_dtor dtor)
 {
  curl_hash *h;

@@ -98,7 +98,7 @@ curl_hash_alloc (int slots, curl_hash_dtor dtor)
  if (NULL == h)
    return NULL;

-  curl_hash_init(h, slots, dtor);
+  Curl_hash_init(h, slots, dtor);

  return h;
 }
@@ -142,7 +142,7 @@ _mk_hash_element (curl_hash_element **e, char *key, size_t key_len, const void *
 /* {{{ int curl_hash_add (curl_hash *, char *, size_t, const void *)
 */
 int 
-curl_hash_add (curl_hash *h, char *key, size_t key_len, const void *p)
+Curl_hash_add (curl_hash *h, char *key, size_t key_len, const void *p)
 {
  curl_hash_element  *he;
  curl_llist_element *le;
@@ -162,7 +162,7 @@ curl_hash_add (curl_hash *h, char *key, size_t key_len, const void *p)
  if (_mk_hash_element(&he, key, key_len, p) != 0) 
    return 0;

-  if (curl_llist_insert_next(l, CURL_LLIST_TAIL(l), he)) {
+  if (Curl_llist_insert_next(l, CURL_LLIST_TAIL(l), he)) {
    ++h->size;
    return 1;
  }
@@ -174,7 +174,7 @@ curl_hash_add (curl_hash *h, char *key, size_t key_len, const void *p)
 /* {{{ int curl_hash_delete (curl_hash *, char *, size_t)
 */
 int 
-curl_hash_delete(curl_hash *h, char *key, size_t key_len)
+Curl_hash_delete(curl_hash *h, char *key, size_t key_len)
 {
  curl_hash_element  *he;
  curl_llist_element *le;
@@ -185,7 +185,7 @@ curl_hash_delete(curl_hash *h, char *key, size_t key_len)
       le = CURL_LLIST_NEXT(le)) {
    he = CURL_LLIST_VALP(le);
    if (_hash_key_compare(he->key, he->key_len, key, key_len)) {
-      curl_llist_remove(l, le, (void *) h);
+      Curl_llist_remove(l, le, (void *) h);
      --h->size;
      return 1;
    }
@@ -198,7 +198,7 @@ curl_hash_delete(curl_hash *h, char *key, size_t key_len)
 /* {{{ int curl_hash_find (curl_hash *, char *, size_t, void **)
 */
 int 
-curl_hash_find(curl_hash *h, char *key, size_t key_len, void **p)
+Curl_hash_find(curl_hash *h, char *key, size_t key_len, void **p)
 {
  curl_llist_element *le;
  curl_hash_element  *he;
@@ -221,13 +221,16 @@ curl_hash_find(curl_hash *h, char *key, size_t key_len, void **p)
 /* {{{ void curl_hash_apply (curl_hash *, void *, void (*)(void *, curl_hash_element *))
 */
 void 
-curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *))
+Curl_hash_apply(curl_hash *h, void *user,
+                void (*cb)(void *, curl_hash_element *))
 {
  curl_llist_element  *le;
  int                  i;

  for (i = 0; i < h->slots; ++i) {
-    for (le = CURL_LLIST_HEAD(h->table[i]); le != NULL; le = CURL_LLIST_NEXT(le)) {
+    for (le = CURL_LLIST_HEAD(h->table[i]);
+         le != NULL;
+         le = CURL_LLIST_NEXT(le)) {
      cb(user, (curl_hash_element *) CURL_LLIST_VALP(le));
    }
  }
@@ -237,22 +240,47 @@ curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *
 /* {{{ void curl_hash_clean (curl_hash *)
 */
 void
-curl_hash_clean(curl_hash *h)
+Curl_hash_clean(curl_hash *h)
 {
  int i;

  for (i = 0; i < h->slots; ++i) {
-    curl_llist_destroy(h->table[i], (void *) h);
+    Curl_llist_destroy(h->table[i], (void *) h);
  }

  free(h->table);
 }
 /* }}} */

+/* {{{ void curl_hash_clean_with_criterium (curl_hash *, void *,
+   int (*)(void *, void *))
+ */
+void
+Curl_hash_clean_with_criterium(curl_hash *h, void *user,
+                               int (*comp)(void *, void *))
+{
+  curl_llist_element *le;
+  curl_llist_element *lnext;
+  int i;
+
+  for (i = 0; i < h->slots; ++i) {
+    le = CURL_LLIST_HEAD(h->table[i]);
+    while(le != NULL)
+      if (comp(user, ((curl_hash_element *) CURL_LLIST_VALP(le))->ptr)) {
+        lnext = CURL_LLIST_NEXT(le);
+        Curl_llist_remove(h->table[i], le, (void *) h);
+        --h->size;
+        le = lnext;
+      }
+      else
+        le = CURL_LLIST_NEXT(le);
+  }
+}
+
 /* {{{ int curl_hash_count (curl_hash *)
 */
 int 
-curl_hash_count(curl_hash *h)
+Curl_hash_count(curl_hash *h)
 {
  return h->size;
 }
@@ -261,12 +289,12 @@ curl_hash_count(curl_hash *h)
 /* {{{ void curl_hash_destroy (curl_hash *)
 */
 void 
-curl_hash_destroy(curl_hash *h)
+Curl_hash_destroy(curl_hash *h)
 {
  if (!h)
    return;

-  curl_hash_clean(h);
+  Curl_hash_clean(h);
  free(h);
 }
 /* }}} */
--- a/lib/hash.h
+++ b/lib/hash.h
@@ -45,18 +45,18 @@ typedef struct _curl_hash_element {
 } curl_hash_element;


-void curl_hash_init(curl_hash *, int, curl_hash_dtor);
-curl_hash *curl_hash_alloc(int, curl_hash_dtor);
-int curl_hash_add(curl_hash *, char *, size_t, const void *);
-int curl_hash_delete(curl_hash *h, char *key, size_t key_len);
-int curl_hash_find(curl_hash *, char *, size_t, void **p);
-void curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *));
-int curl_hash_count(curl_hash *h);
-void curl_hash_clean(curl_hash *h);
-void curl_hash_destroy(curl_hash *h);
-
-#define curl_hash_update curl_hash_add
+void Curl_hash_init(curl_hash *, int, curl_hash_dtor);
+curl_hash *Curl_hash_alloc(int, curl_hash_dtor);
+int Curl_hash_add(curl_hash *, char *, size_t, const void *);
+int Curl_hash_delete(curl_hash *h, char *key, size_t key_len);
+int Curl_hash_find(curl_hash *, char *, size_t, void **p);
+void Curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *));
+int Curl_hash_count(curl_hash *h);
+void Curl_hash_clean(curl_hash *h);
+void Curl_hash_clean_with_criterium(curl_hash *h, void *user, int (*comp)(void *, void *));
+void Curl_hash_destroy(curl_hash *h);

+#define Curl_hash_update Curl_hash_add

 #endif

--- a/lib/hostip.c
+++ b/lib/hostip.c
@@ -79,7 +79,7 @@ static int host_cache_initialized;
 void Curl_global_host_cache_init(void)
 {
  if (!host_cache_initialized) {
-    curl_hash_init(&hostname_cache, 7, Curl_freeaddrinfo);
+    Curl_hash_init(&hostname_cache, 7, Curl_freeaddrinfo);
    host_cache_initialized = 1;
  }
 }
@@ -92,7 +92,7 @@ curl_hash *Curl_global_host_cache_get(void)
 void Curl_global_host_cache_dtor(void)
 {
  if (host_cache_initialized) {
-    curl_hash_clean(&hostname_cache);
+    Curl_hash_clean(&hostname_cache);
    host_cache_initialized = 0;
  }
 }
@@ -152,6 +152,38 @@ _create_hostcache_id(char *server, int port, ssize_t *entry_len)
  return id;
 }

+struct hostcache_prune_data {
+  int cache_timeout;
+  int now;
+};
+
+static int
+_curl_hostcache_timestamp_remove(void *datap, void *hc)
+{
+  struct hostcache_prune_data *data = 
+    (struct hostcache_prune_data *) datap;
+  struct curl_dns_cache_entry *c = (struct curl_dns_cache_entry *) hc;
+  
+  if (data->now - c->timestamp < data->cache_timeout) {
+    return 0;
+  }
+  
+  return 1;
+}
+
+static void
+hostcache_prune(curl_hash *hostcache, int cache_timeout, int now)
+{
+  struct hostcache_prune_data user;
+
+  user.cache_timeout = cache_timeout;
+  user.now = now;
+  
+  Curl_hash_clean_with_criterium(hostcache, 
+                                 (void *) &user, 
+                                 _curl_hostcache_timestamp_remove);
+}
+
 /* Macro to save redundant free'ing of entry_id */
 #define _hostcache_return(__v) \
 { \
@@ -161,51 +193,50 @@ _create_hostcache_id(char *server, int port, ssize_t *entry_len)

 Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
                           char *hostname,
-                           int port,
-                           char **bufp)
+                           int port)
 {
  char *entry_id = NULL;
  struct curl_dns_cache_entry *p = NULL;
  ssize_t entry_len;
  time_t now;
+  char *bufp;

  /* If the host cache timeout is 0, we don't do DNS cach'ing
     so fall through */
  if (data->set.dns_cache_timeout == 0) {
-    return Curl_getaddrinfo(data, hostname, port, bufp);
+    return Curl_getaddrinfo(data, hostname, port, &bufp);
  }

+  time(&now);
+
+  /* Remove outdated entries from the hostcache */
+  hostcache_prune(data->hostcache, 
+                  data->set.dns_cache_timeout, 
+                  now);
+
  /* Create an entry id, based upon the hostname and port */
  entry_len = strlen(hostname);
  entry_id = _create_hostcache_id(hostname, port, &entry_len);
  /* If we can't create the entry id, don't cache, just fall-through
     to the plain Curl_getaddrinfo() */
  if (!entry_id) {
-    return Curl_getaddrinfo(data, hostname, port, bufp);
+    return Curl_getaddrinfo(data, hostname, port, &bufp);
  }
  
-  time(&now);
  /* See if its already in our dns cache */
-  if (entry_id && curl_hash_find(data->hostcache, entry_id, entry_len+1, (void **) &p)) {
-    /* Do we need to check for a cache timeout? */
-    if (data->set.dns_cache_timeout != -1) {
-      /* Return if the entry has not timed out */
-      if ((now - p->timestamp) < data->set.dns_cache_timeout) {
-        _hostcache_return(p->addr);
-      }
-    }
-    else {
-      _hostcache_return(p->addr);
-    }
+  if (entry_id &&
+      Curl_hash_find(data->hostcache, entry_id, entry_len+1, (void **) &p)) {
+    _hostcache_return(p->addr);
  }

  /* Create a new cache entry */
-  p = (struct curl_dns_cache_entry *) malloc(sizeof(struct curl_dns_cache_entry));
+  p = (struct curl_dns_cache_entry *)
+    malloc(sizeof(struct curl_dns_cache_entry));
  if (!p) {
   _hostcache_return(NULL);
  }

-  p->addr = Curl_getaddrinfo(data, hostname, port, bufp);
+  p->addr = Curl_getaddrinfo(data, hostname, port, &bufp);
  if (!p->addr) {
    free(p);
    _hostcache_return(NULL);
@@ -213,7 +244,7 @@ Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
  p->timestamp = now;

  /* Save it in our host cache */
-  curl_hash_update(data->hostcache, entry_id, entry_len+1, (const void *) p);
+  Curl_hash_update(data->hostcache, entry_id, entry_len+1, (const void *) p);

  _hostcache_return(p->addr);
 }
@@ -304,7 +335,7 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
    /* This seems to be an IPv6-capable stack, use PF_UNSPEC for the widest
     * possible checks. And close the socket again.
     */
-    close(s);
+    sclose(s);
 
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = pf;
@@ -329,7 +360,7 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
 *
 * Keith McGuigan 
 * 10/3/2001 */
-static struct hostent* pack_hostent(char* buf, struct hostent* orig)
+static struct hostent* pack_hostent(char** buf, struct hostent* orig)
 {
  char* bufptr;
  struct hostent* copy;
@@ -338,7 +369,7 @@ static struct hostent* pack_hostent(char* buf, struct hostent* orig)
  char* str;
  int len;

-  bufptr = buf;
+  bufptr = *buf;
  copy = (struct hostent*)bufptr;

  bufptr += sizeof(struct hostent);
@@ -348,10 +379,12 @@ static struct hostent* pack_hostent(char* buf, struct hostent* orig)
  bufptr += len;

  /* we align on even 64bit boundaries for safety */
-#define MEMALIGN(x) (((unsigned long)(x)&0xfffffff8)+8)
+#define MEMALIGN(x) ((x)+(8-(((unsigned long)(x))&0x7)))

  /* This must be aligned properly to work on many CPU architectures! */
-  copy->h_aliases = (char**)MEMALIGN(bufptr);
+  bufptr = MEMALIGN(bufptr);
+  
+  copy->h_aliases = (char**)bufptr;

  /* Figure out how many aliases there are */
  for (i = 0; orig->h_aliases[i] != NULL; ++i);
@@ -373,7 +406,7 @@ static struct hostent* pack_hostent(char* buf, struct hostent* orig)
  copy->h_length = orig->h_length;
    
  /* align it for (at least) 32bit accesses */
-  bufptr = (char *)MEMALIGN(bufptr);
+  bufptr = MEMALIGN(bufptr);

  copy->h_addr_list = (char**)bufptr;

@@ -394,6 +427,7 @@ static struct hostent* pack_hostent(char* buf, struct hostent* orig)
  }
  copy->h_addr_list[i] = NULL;

+  *buf=(char *)realloc(*buf, (int)bufptr-(int)(*buf));
  return copy;
 }
 #endif
@@ -419,14 +453,30 @@ static char *MakeIP(unsigned long num,char *addr, int addr_len)
  return (addr);
 }

-/* 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. */
-
 #ifndef INADDR_NONE
 #define INADDR_NONE (in_addr_t) ~0
 #endif

+static void hostcache_fixoffset(struct hostent *h, int offset)
+{
+  int i=0;
+  h->h_name=(char *)((int)h->h_name+offset);
+  h->h_aliases=(char **)((int)h->h_aliases+offset);
+  while(h->h_aliases[i]) {
+    h->h_aliases[i]=(char *)((int)h->h_aliases[i]+offset);
+    i++;
+  }
+  h->h_addr_list=(char **)((int)h->h_addr_list+offset);
+  i=0;
+  while(h->h_addr_list[i]) {
+    h->h_addr_list[i]=(char *)((int)h->h_addr_list[i]+offset);
+    i++;
+  }
+}
+
+/* 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. */
 Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
                                char *hostname,
                                int port,
@@ -441,16 +491,15 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
   * everything. OSF1 is known to require at least 8872 bytes. The buffer
   * required for storing all possible aliases and IP numbers is according to
   * Stevens' Unix Network Programming 2nd editor, p. 304: 8192 bytes! */
-  int *buf = (int *)malloc(CURL_NAMELOOKUP_SIZE);
-  if(!buf)
-    return NULL; /* major failure */
-  *bufp = (char *)buf;
-
  port=0; /* unused in IPv4 code */
  ret = 0; /* to prevent the compiler warning */

  if ( (in=inet_addr(hostname)) != INADDR_NONE ) {
    struct in_addr *addrentry;
+    int *buf = (int *)malloc(128);
+    if(!buf)
+      return NULL; /* major failure */
+    *bufp = (char *)buf;

    h = (struct hostent*)buf;
    h->h_addr_list = (char**)(buf + sizeof(*h));
@@ -462,30 +511,78 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
    h->h_length = sizeof(*addrentry);
    h->h_name = *(h->h_addr_list) + h->h_length;
    /* bad one h->h_name = (char*)(h->h_addr_list + h->h_length); */
-    MakeIP(ntohl(in),h->h_name, CURL_NAMELOOKUP_SIZE - (long)(h->h_name) + (long)buf);
+    MakeIP(ntohl(in),h->h_name, 128 - (long)(h->h_name) + (long)buf);
  }
 #if defined(HAVE_GETHOSTBYNAME_R)
  else {
    int h_errnop;
+    int res=ERANGE;
+    int step_size=200;
+    int *buf = (int *)malloc(CURL_NAMELOOKUP_SIZE);
+    if(!buf)
+      return NULL; /* major failure */
+    *bufp=(char *)buf;
+
     /* Workaround for gethostbyname_r bug in qnx nto. It is also _required_
        for some of these functions. */
    memset(buf, 0, CURL_NAMELOOKUP_SIZE);
 #ifdef HAVE_GETHOSTBYNAME_R_5
    /* Solaris, IRIX and more */
-    if ((h = gethostbyname_r(hostname,
-                             (struct hostent *)buf,
-                             (char *)buf + sizeof(struct hostent),
-                             CURL_NAMELOOKUP_SIZE - sizeof(struct hostent),
-                             &h_errnop)) == NULL )
+    while(!h) {
+      h = gethostbyname_r(hostname,
+                          (struct hostent *)buf,
+                          (char *)buf + sizeof(struct hostent),
+                          step_size - sizeof(struct hostent),
+                          &h_errnop);
+
+      /* If the buffer is too small, it returns NULL and sets errno to
+         ERANGE. The errno is thread safe if this is compiled with
+         -D_REENTRANT as then the 'errno' variable is a macro defined to
+         get used properly for threads. */
+
+      if(h || (errno != ERANGE))
+        break;
+      
+      step_size+=200;
+    }
+
+#ifdef MALLOCDEBUG
+    infof(data, "gethostbyname_r() uses %d bytes\n", step_size);
+#endif
+
+    if(h) {
+      int offset;
+      h=(struct hostent *)realloc(buf, step_size);
+      offset=(int)h-(int)buf;
+      hostcache_fixoffset(h, offset);
+      buf=(int *)h;
+      *bufp=(char *)buf;
+    }
+    else
 #endif
 #ifdef HAVE_GETHOSTBYNAME_R_6
    /* Linux */
-    if( gethostbyname_r(hostname,
-                        (struct hostent *)buf,
-                        (char *)buf + sizeof(struct hostent),
-                        CURL_NAMELOOKUP_SIZE - sizeof(struct hostent),
-                        &h, /* DIFFERENCE */
-                        &h_errnop))
+    while((res=gethostbyname_r(hostname,
+                               (struct hostent *)buf,
+                               (char *)buf + sizeof(struct hostent),
+                               step_size - sizeof(struct hostent),
+                               &h, /* DIFFERENCE */
+                               &h_errnop))==ERANGE) {
+      step_size+=200;
+    }
+    
+#ifdef MALLOCDEBUG
+    infof(data, "gethostbyname_r() uses %d bytes\n", step_size);
+#endif
+    if(!res) {
+      int offset;
+      h=(struct hostent *)realloc(buf, step_size);
+      offset=(int)h-(int)buf;
+      hostcache_fixoffset(h, offset);
+      buf=(int *)h;
+      *bufp=(char *)buf;
+    }
+    else
 #endif
 #ifdef HAVE_GETHOSTBYNAME_R_3
    /* AIX, Digital Unix, HPUX 10, more? */
@@ -498,8 +595,8 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
       * size dilemma. */

      ret = gethostbyname_r(hostname,
-                          (struct hostent *)buf,
-                          (struct hostent_data *)(buf + sizeof(struct hostent)));
+                            (struct hostent *)buf,
+                            (struct hostent_data *)(buf + sizeof(struct hostent)));
    else
      ret = -1; /* failure, too smallish buffer size */
    
@@ -518,14 +615,17 @@ Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
  else {
    if ((h = gethostbyname(hostname)) == NULL ) {
      infof(data, "gethostbyname(2) failed for %s\n", hostname);
-      free(buf);
      *bufp=NULL;
    }
    else 
+    {
+      char *buf=(char *)malloc(CURL_NAMELOOKUP_SIZE);
      /* 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((char *)buf, h);
+      h = pack_hostent(&buf, h);
+      *bufp=(char *)buf;
+    }
 #endif
  }
  return (h);
--- a/lib/hostip.h
+++ b/lib/hostip.h
@@ -37,8 +37,7 @@ curl_hash *Curl_global_host_cache_get(void);

 Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
 			   char *hostname,
-			   int port,
-			   char **bufp);
+			   int port);

 /* Get name info */
 Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
--- a/lib/http.c
+++ b/lib/http.c
@@ -562,7 +562,13 @@ CURLcode Curl_http(struct connectdata *conn)
  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->set.httppost, &http->postsize);
+     result = Curl_getFormData(&http->sendit, data->set.httppost,
+                               &http->postsize);
+     if(CURLE_OK != result) {
+       /* Curl_getFormData() doesn't use failf() */
+       failf(data, "failed creating formpost data");
+       return result;
+     }
  }

  if(!checkheaders(data, "Host:")) {
@@ -775,16 +781,16 @@ CURLcode Curl_http(struct connectdata *conn)
      strcpy(buf, "no strftime() support");
 #endif
      switch(data->set.timecondition) {
-      case TIMECOND_IFMODSINCE:
+      case CURL_TIMECOND_IFMODSINCE:
      default:
        add_bufferf(req_buffer,
                    "If-Modified-Since: %s\r\n", buf);
        break;
-      case TIMECOND_IFUNMODSINCE:
+      case CURL_TIMECOND_IFUNMODSINCE:
        add_bufferf(req_buffer,
                    "If-Unmodified-Since: %s\r\n", buf);
        break;
-      case TIMECOND_LASTMOD:
+      case CURL_TIMECOND_LASTMOD:
        add_bufferf(req_buffer,
                    "Last-Modified: %s\r\n", buf);
        break;
--- a/lib/krb4.c
+++ b/lib/krb4.c
@@ -197,7 +197,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
  int checksum;
  u_int32_t cs;
  struct krb4_data *d = app_data;
-  char *host = conn->hostaddr->h_name;
+  char *host = conn->hostname;
  ssize_t nread;
  int l = sizeof(conn->local_addr);
  struct SessionHandle *data = conn->data;
@@ -362,7 +362,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(conn->hostaddr->h_name),
+                       krb_realmofhost(conn->hostname),
                       &key);
    des_key_sched (&key, schedule);
    des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat,
--- a/lib/llist.c
+++ b/lib/llist.c
@@ -33,7 +33,7 @@
 #include "memdebug.h"
 #endif
 void 
-curl_llist_init(curl_llist *l, curl_llist_dtor dtor)
+Curl_llist_init(curl_llist *l, curl_llist_dtor dtor)
 {
  l->size = 0;
  l->dtor = dtor;
@@ -42,7 +42,7 @@ curl_llist_init(curl_llist *l, curl_llist_dtor dtor)
 }

 curl_llist *
-curl_llist_alloc(curl_llist_dtor dtor)
+Curl_llist_alloc(curl_llist_dtor dtor)
 {
  curl_llist *list;

@@ -50,13 +50,13 @@ curl_llist_alloc(curl_llist_dtor dtor)
  if(NULL == list)
    return NULL;

-  curl_llist_init(list, dtor);
+  Curl_llist_init(list, dtor);

  return list;
 }

 int
-curl_llist_insert_next(curl_llist *list, curl_llist_element *e, const void *p)
+Curl_llist_insert_next(curl_llist *list, curl_llist_element *e, const void *p)
 {
  curl_llist_element  *ne;

@@ -84,7 +84,7 @@ curl_llist_insert_next(curl_llist *list, curl_llist_element *e, const void *p)
 }

 int 
-curl_llist_insert_prev(curl_llist *list, curl_llist_element *e, const void *p)
+Curl_llist_insert_prev(curl_llist *list, curl_llist_element *e, const void *p)
 {
  curl_llist_element *ne;

@@ -111,7 +111,7 @@ curl_llist_insert_prev(curl_llist *list, curl_llist_element *e, const void *p)
 }

 int 
-curl_llist_remove(curl_llist *list, curl_llist_element *e, void *user)
+Curl_llist_remove(curl_llist *list, curl_llist_element *e, void *user)
 {
  if (e == NULL || list->size == 0)
    return 1;
@@ -139,28 +139,28 @@ curl_llist_remove(curl_llist *list, curl_llist_element *e, void *user)
 }

 int 
-curl_llist_remove_next(curl_llist *list, curl_llist_element *e, void *user)
+Curl_llist_remove_next(curl_llist *list, curl_llist_element *e, void *user)
 {
-  return curl_llist_remove(list, e->next, user);
+  return Curl_llist_remove(list, e->next, user);
 }

 int 
-curl_llist_remove_prev(curl_llist *list, curl_llist_element *e, void *user)
+Curl_llist_remove_prev(curl_llist *list, curl_llist_element *e, void *user)
 {
-  return curl_llist_remove(list, e->prev, user);
+  return Curl_llist_remove(list, e->prev, user);
 }

 size_t 
-curl_llist_count(curl_llist *list)
+Curl_llist_count(curl_llist *list)
 {
  return list->size;
 }

 void 
-curl_llist_destroy(curl_llist *list, void *user)
+Curl_llist_destroy(curl_llist *list, void *user)
 {
  while (list->size > 0) {
-    curl_llist_remove(list, CURL_LLIST_TAIL(list), user);
+    Curl_llist_remove(list, CURL_LLIST_TAIL(list), user);
  }

  free(list);
--- a/lib/llist.h
+++ b/lib/llist.h
@@ -44,14 +44,14 @@ typedef struct _curl_llist {
  size_t size;
 } curl_llist;

-void curl_llist_init(curl_llist *, curl_llist_dtor);
-curl_llist *curl_llist_alloc(curl_llist_dtor);
-int curl_llist_insert_next(curl_llist *, curl_llist_element *, const void *);
-int curl_llist_insert_prev(curl_llist *, curl_llist_element *, const void *);
-int curl_llist_remove(curl_llist *, curl_llist_element *, void *);
-int curl_llist_remove_next(curl_llist *, curl_llist_element *, void *);
-size_t curl_llist_count(curl_llist *);
-void curl_llist_destroy(curl_llist *, void *);
+void Curl_llist_init(curl_llist *, curl_llist_dtor);
+curl_llist *Curl_llist_alloc(curl_llist_dtor);
+int Curl_llist_insert_next(curl_llist *, curl_llist_element *, const void *);
+int Curl_llist_insert_prev(curl_llist *, curl_llist_element *, const void *);
+int Curl_llist_remove(curl_llist *, curl_llist_element *, void *);
+int Curl_llist_remove_next(curl_llist *, curl_llist_element *, void *);
+size_t Curl_llist_count(curl_llist *);
+void Curl_llist_destroy(curl_llist *, void *);

 #define CURL_LLIST_HEAD(__l) ((__l)->head)
 #define CURL_LLIST_TAIL(__l) ((__l)->tail)
--- a/lib/multi.c
+++ b/lib/multi.c
@@ -30,6 +30,11 @@
 #include "transfer.h"
 #include "url.h"

+/* The last #include file should be: */
+#ifdef MALLOCDEBUG
+#include "memdebug.h"
+#endif
+
 struct Curl_message {
  /* the 'CURLMsg' is the part that is visible to the external user */
  struct CURLMsg extmsg;
@@ -77,9 +82,14 @@ struct Curl_multi {
  int num_easy;

  /* this is a linked list of posted messages */
-  struct Curl_message *msgs;
-  /* amount of messages in the queue */
-  int num_msgs;
+  struct Curl_message *msgs; /* the messages remain here until the handle is
+                                closed */
+  struct Curl_message *lastmsg; /* points to the last entry */
+  struct Curl_message *readptr; /* NULL before no one read anything */
+
+  int num_msgs; /* amount of messages in the queue */
+  int num_read; /* amount of read messages */
+
  /* Hostname cache */
  curl_hash *hostcache;
 };
@@ -259,7 +269,7 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
      }
      else {
        if (multi->hostcache == NULL) {
-          multi->hostcache = curl_hash_alloc(7, Curl_freeaddrinfo);
+          multi->hostcache = Curl_hash_alloc(7, Curl_freeaddrinfo);
        }

        easy->easy_handle->hostcache = multi->hostcache;
@@ -301,10 +311,41 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
    case CURLM_STATE_DONE:
      /* post-transfer command */
      easy->result = Curl_done(easy->easy_conn);
-      /* after we have DONE what we're supposed to do, go COMPLETED */
-      if(CURLE_OK == easy->result)
-        easy->state = CURLM_STATE_COMPLETED;
+
+      /* after we have DONE what we're supposed to do, go COMPLETED, and
+         it doesn't matter what the Curl_done() returned! */
+      easy->state = CURLM_STATE_COMPLETED;
+
+      /* clear out the usage of the shared DNS cache */
+      easy->easy_handle->hostcache = NULL;
+
+        /* now add a node to the Curl_message linked list with this info */
+      {
+        struct Curl_message *msg = (struct Curl_message *)
+          malloc(sizeof(struct Curl_message));
+
+        if(!msg)
+          return CURLM_OUT_OF_MEMORY;
+
+        msg->extmsg.msg = CURLMSG_DONE;
+        msg->extmsg.easy_handle = easy->easy_handle;
+        msg->extmsg.data.result = easy->result;
+        msg->next=NULL;
+
+        if(multi->lastmsg) {
+          multi->lastmsg->next = msg;
+          multi->lastmsg = msg;
+        }
+        else {
+          multi->msgs = msg;
+          multi->lastmsg = msg;
+        }
+        multi->num_msgs++; /* increase message counter */
+          
+      }
+      result = CURLM_CALL_MULTI_PERFORM;
      break;
+
    case CURLM_STATE_COMPLETED:
      /* this is a completed transfer, it is likely to still be connected */

@@ -329,16 +370,40 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)

    easy = easy->next; /* operate on next handle */
  }
+
  return result;
 }

 CURLMcode curl_multi_cleanup(CURLM *multi_handle)
 {
  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  struct Curl_one_easy *easy;
+  struct Curl_one_easy *nexteasy;
+  struct Curl_message *msg;
+  struct Curl_message *nextmsg;
+
  if(GOOD_MULTI_HANDLE(multi)) {
    multi->type = 0; /* not good anymore */
-    curl_hash_destroy(multi->hostcache);
+    Curl_hash_destroy(multi->hostcache);
+
    /* remove all easy handles */
+    easy = multi->easy.next;
+    while(easy) {
+      nexteasy=easy->next;
+      /* clear out the usage of the shared DNS cache */
+      easy->easy_handle->hostcache = NULL;
+
+      free(easy);
+      easy = nexteasy;
+    }
+
+    /* remove all struct Curl_message nodes left */
+    msg = multi->msgs;
+    while(msg) {
+      nextmsg = msg->next;
+      free(msg);
+      msg = nextmsg;
+    }

    free(multi);

@@ -348,7 +413,33 @@ CURLMcode curl_multi_cleanup(CURLM *multi_handle)
    return CURLM_BAD_HANDLE;
 }

-CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue);
+CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue)
+{
+  struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
+  if(GOOD_MULTI_HANDLE(multi)) {
+    CURLMsg *msg;
+
+    if(!multi->readptr && !multi->num_read)
+      multi->readptr = multi->msgs;
+
+    if(!multi->readptr) {
+      *msgs_in_queue = 0;
+      return NULL;
+    }
+    
+    multi->num_read++;
+
+    *msgs_in_queue = multi->num_msgs - multi->num_read;
+    msg = &multi->readptr->extmsg;
+
+    /* advance read pointer */
+    multi->readptr = multi->readptr->next;
+
+    return msg;
+  }
+  else
+    return NULL;
+}

 /*
 * local variables:
--- a/lib/progress.c
+++ b/lib/progress.c
@@ -45,6 +45,10 @@

 #include "progress.h"

+#define _MPRINTF_REPLACE /* use our functions only */
+#include <curl/mprintf.h>
+
+
 static void time2str(char *r, int t)
 {
  int h = (t/3600);
@@ -103,6 +107,15 @@ void Curl_pgrsDone(struct connectdata *conn)
  }
 }

+/* reset all times except redirect */
+void Curl_pgrsResetTimes(struct SessionHandle *data)
+{
+  data->progress.t_nslookup = 0.0;
+  data->progress.t_connect = 0.0;
+  data->progress.t_pretransfer = 0.0;
+  data->progress.t_starttransfer = 0.0;
+}
+
 void Curl_pgrsTime(struct SessionHandle *data, timerid timer)
 {
  switch(timer) {
@@ -134,6 +147,10 @@ void Curl_pgrsTime(struct SessionHandle *data, timerid timer)
  case TIMER_POSTRANSFER:
    /* this is the normal end-of-transfer thing */
    break;
+  case TIMER_REDIRECT:
+    data->progress.t_redirect =
+      (double)Curl_tvdiff(Curl_tvnow(), data->progress.t_startsingle)/1000.0;
+    break;
  }
 }

--- a/lib/progress.h
+++ b/lib/progress.h
@@ -34,6 +34,7 @@ typedef enum {
  TIMER_STARTTRANSFER,
  TIMER_POSTRANSFER,
  TIMER_STARTSINGLE,
+  TIMER_REDIRECT,
  TIMER_LAST /* must be last */
 } timerid;
  
@@ -44,6 +45,7 @@ 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_pgrsResetTimes(struct SessionHandle *data);
 void Curl_pgrsTime(struct SessionHandle *data, timerid timer);


--- a/lib/sendf.c
+++ b/lib/sendf.c
@@ -392,13 +392,15 @@ int Curl_debug(struct SessionHandle *data, curl_infotype type,
    return (*data->set.fdebug)(data, type, ptr, size,
                               data->set.debugdata);

-  if(type >= CURLINFO_DATA_IN)
-    /* don't do the data parts now */
-    return 0;
-
-  fwrite(s_infotype[type], 2, 1, data->set.err);
-  fwrite(ptr, size, 1, data->set.err);
-
+  switch(type) {
+  case CURLINFO_TEXT:
+  case CURLINFO_HEADER_OUT:
+    fwrite(s_infotype[type], 2, 1, data->set.err);
+    fwrite(ptr, size, 1, data->set.err);
+    break;
+  default: /* nada */
+    break;
+  }
  return 0;
 }

--- a/lib/transfer.c
+++ b/lib/transfer.c
@@ -178,8 +178,12 @@ CURLcode Curl_readwrite(struct connectdata *conn,
  int didwhat=0;

  do {
+    /* If we still have reading to do, we check if we have a readable
+       socket. Sometimes the reafdp is NULL, it no fd_set was done using
+       the multi interface and then we can do nothing but to attempt a
+       read to be sure. */
    if((k->keepon & KEEP_READ) &&
-       FD_ISSET(conn->sockfd, &k->readfd)) {
+       (!k->readfdp || FD_ISSET(conn->sockfd, k->readfdp))) {

      /* read! */
      result = Curl_read(conn, conn->sockfd, k->buf,
@@ -294,6 +298,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
           *****/

          if (('\n' == *k->p) || ('\r' == *k->p)) {
+            int headerlen;
            /* Zero-length header line means end of headers! */

            if ('\r' == *k->p)
@@ -341,14 +346,16 @@ CURLcode Curl_readwrite(struct connectdata *conn,
            if (data->set.http_include_header)
              k->writetype |= CLIENTWRITE_BODY;

+            headerlen = k->p - data->state.headerbuff;
+
            result = Curl_client_write(data, k->writetype,
                                       data->state.headerbuff,
-                                       k->p - data->state.headerbuff);
+                                       headerlen);
            if(result)
              return result;

-            data->info.header_size += k->p - data->state.headerbuff;
-            conn->headerbytecount += k->p - data->state.headerbuff;
+            data->info.header_size += headerlen;
+            conn->headerbytecount += headerlen;

            if(!k->header) {
              /*
@@ -591,6 +598,10 @@ CURLcode Curl_readwrite(struct connectdata *conn,
          if (data->set.http_include_header)
            k->writetype |= CLIENTWRITE_BODY;

+          if(data->set.verbose)
+            Curl_debug(data, CURLINFO_HEADER_IN,
+                       k->p, k->hbuflen);
+
          result = Curl_client_write(data, k->writetype, k->p,
                                     k->hbuflen);
          if(result)
@@ -680,6 +691,10 @@ CURLcode Curl_readwrite(struct connectdata *conn,
        } /* this is the first time we write a body part */
        k->bodywrites++;

+        /* pass data to the debug function before it gets "dechunked" */
+        if(data->set.verbose)
+          Curl_debug(data, CURLINFO_DATA_IN, k->str, nread);
+
        if(conn->bits.chunk) {
          /*
           * Bless me father for I have sinned. Here comes a chunked
@@ -735,8 +750,12 @@ CURLcode Curl_readwrite(struct connectdata *conn,
      } /* if (! header and data to read ) */
    } /* if( read from socket ) */

+    /* If we still have writing to do, we check if we have a writable
+       socket. Sometimes the writefdp is NULL, it no fd_set was done using
+       the multi interface and then we can do nothing but to attempt a
+       write to be sure. */
    if((k->keepon & KEEP_WRITE) &&
-       FD_ISSET(conn->writesockfd, &k->writefd)) {
+       (!k->writefdp || FD_ISSET(conn->writesockfd, k->writefdp)) ) {
      /* write */

      int i, si;
@@ -820,6 +839,11 @@ CURLcode Curl_readwrite(struct connectdata *conn,
        conn->upload_present = 0; /* no more bytes left */
      }

+      if(data->set.verbose)
+        Curl_debug(data, CURLINFO_DATA_OUT, conn->upload_fromhere,
+                   bytes_written);
+      
+
      k->writebytecount += bytes_written;
      Curl_pgrsSetUploadCounter(data, (double)k->writebytecount);

@@ -913,6 +937,9 @@ CURLcode Curl_readwrite_init(struct connectdata *conn)
  Curl_pgrsTime(data, TIMER_PRETRANSFER);
  Curl_speedinit(data);

+  Curl_pgrsSetUploadCounter(data, 0);
+  Curl_pgrsSetDownloadCounter(data, 0);
+
  if (!conn->getheader) {
    k->header = FALSE;
    if(conn->size > 0)
@@ -943,6 +970,9 @@ CURLcode Curl_readwrite_init(struct connectdata *conn)
    k->rkeepfd = k->readfd;
    k->wkeepfd = k->writefd;

+    k->writefdp = &k->writefd; /* store the address of the set */
+    k->readfdp = &k->readfd;   /* store the address of the set */
+
  }

  return CURLE_OK;
@@ -958,11 +988,13 @@ void Curl_single_fdset(struct connectdata *conn,
  if(conn->keep.keepon & KEEP_READ) {
    FD_SET(conn->sockfd, read_fd_set);
    *max_fd = conn->sockfd;
+    conn->keep.readfdp = read_fd_set; /* store the address of the set */
  }
  if(conn->keep.keepon & KEEP_WRITE) {
    FD_SET(conn->writesockfd, write_fd_set);
    if(conn->writesockfd > *max_fd)
      *max_fd = conn->writesockfd;
+    conn->keep.writefdp = write_fd_set; /* store the address of the set */
  }
  /* we don't use exceptions, only touch that one to prevent compiler
     warnings! */
@@ -1009,8 +1041,7 @@ Transfer(struct connectdata *conn)
    interval.tv_sec = 1;
    interval.tv_usec = 0;

-    switch (select (k->maxfd, &k->readfd, &k->writefd, NULL,
-                    &interval)) {
+    switch (select (k->maxfd, k->readfdp, k->writefdp, NULL, &interval)) {
    case -1: /* select() error, stop reading */
 #ifdef EINTR
      /* The EINTR is not serious, and it seems you might get this more
@@ -1262,7 +1293,6 @@ CURLcode Curl_perform(struct SessionHandle *data)
         */
        switch(data->info.httpcode) {
        case 300: /* Multiple Choices */
-        case 301: /* Moved Permanently */
        case 306: /* Not used */
        case 307: /* Temporary Redirect */
        default:  /* for all unknown ones */
@@ -1270,6 +1300,27 @@ CURLcode Curl_perform(struct SessionHandle *data)
           * seem to be OK to POST to.
           */
          break;
+        case 301: /* Moved Permanently */
+          /* (quote from RFC2616, section 10.3.2):
+           * 
+           *  Note: When automatically redirecting a POST request after
+           *  receiving a 301 status code, some existing HTTP/1.0 user agents
+           *  will erroneously change it into a GET request.
+           *
+           * ----
+           * Warning: Because most of importants user agents do this clear
+           * RFC2616 violation, many webservers expect this misbehavior. So
+           * these servers often answers to a POST request with an error page.
+           * To be sure that libcurl gets the page that most user agents
+           * would get, libcurl has to force GET:
+           */
+          if( data->set.httpreq == HTTPREQ_POST
+              || data->set.httpreq == HTTPREQ_POST_FORM) {
+            infof(data,
+                  "Violate RFC 2616/10.3.2 and switch from POST to GET\n");
+            data->set.httpreq = HTTPREQ_GET;
+          }
+          break;
        case 302: /* Found */
          /* (From 10.3.3)

@@ -1291,8 +1342,11 @@ CURLcode Curl_perform(struct SessionHandle *data)
        case 303: /* See Other */
          /* Disable both types of POSTs, since doing a second POST when
           * following isn't what anyone would want! */
-          data->set.httpreq = HTTPREQ_GET; /* enforce GET request */
-          infof(data, "Disables POST, goes with GET\n");
+          if(data->set.httpreq != HTTPREQ_GET) {
+            data->set.httpreq = HTTPREQ_GET; /* enforce GET request */
+            infof(data, "Disables POST, goes with %s\n",
+                  data->set.no_body?"HEAD":"GET");
+          }
          break;
        case 304: /* Not Modified */
          /* 304 means we did a conditional request and it was "Not modified".
@@ -1309,6 +1363,8 @@ CURLcode Curl_perform(struct SessionHandle *data)
           */
          break;
        }
+        Curl_pgrsTime(data, TIMER_REDIRECT);
+        Curl_pgrsResetTimes(data);
        continue;
      }
    }
--- a/lib/url.c
+++ b/lib/url.c
@@ -495,13 +495,33 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
    data->set.ssl.version = va_arg(param, long);
    break;

+  case CURLOPT_COOKIESESSION:
+    /*
+     * Set this option to TRUE to start a new "cookie session". It will
+     * prevent the forthcoming read-cookies-from-file actions to accept
+     * cookies that are marked as being session cookies, as they belong to a
+     * previous session.
+     *
+     * In the original Netscape cookie spec, "session cookies" are cookies
+     * with no expire date set. RFC2109 describes the same action if no
+     * 'Max-Age' is set and RFC2965 includes the RFC2109 description and adds
+     * a 'Discard' action that can enforce the discard even for cookies that
+     * have a Max-Age.
+     *
+     * We run mostly with the original cookie spec, as hardly anyone implements
+     * anything else.
+     */
+    data->set.cookiesession = (bool)va_arg(param, long);
+    break;
+
  case CURLOPT_COOKIEFILE:
    /*
     * Set cookie file to read and parse. Can be used multiple times.
     */
    cookiefile = (char *)va_arg(param, void *);
    if(cookiefile)
-      data->cookies = Curl_cookie_init(cookiefile, data->cookies);
+      data->cookies = Curl_cookie_init(cookiefile, data->cookies,
+                                       data->set.cookiesession);
    break;

  case CURLOPT_COOKIEJAR:
@@ -514,7 +534,8 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
     * Activate the cookie parser. This may or may not already
     * have been made.
     */
-    data->cookies = Curl_cookie_init(NULL, data->cookies);
+    data->cookies = Curl_cookie_init(NULL, data->cookies,
+                                     data->set.cookiesession);
    break;
  case CURLOPT_WRITEHEADER:
    /*
@@ -819,6 +840,7 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
     * defaults to CURLOPT_STDERR for normal operations.
     */
    data->set.debugdata = va_arg(param, void *);
+    break;
  case CURLOPT_STDERR:
    /*
     * Set to a FILE * that should receive all error writes. This
@@ -1241,7 +1263,8 @@ ConnectionStore(struct SessionHandle *data,
  return i;
 }

-static CURLcode ConnectPlease(struct connectdata *conn)
+static CURLcode ConnectPlease(struct connectdata *conn,
+                              Curl_addrinfo *hostaddr)
 {
  CURLcode result;
  Curl_ipconnect *addr;
@@ -1250,7 +1273,7 @@ static CURLcode ConnectPlease(struct connectdata *conn)
   * Connect to server/proxy
   *************************************************************/
  result= Curl_connecthost(conn,
-                           conn->hostaddr,
+                           hostaddr,
                           conn->port,
                           &conn->firstsocket,
                           &addr);
@@ -1264,7 +1287,7 @@ static CURLcode ConnectPlease(struct connectdata *conn)
    memset((char *) &conn->serv_addr, '\0', sizeof(conn->serv_addr));
    memcpy((char *)&(conn->serv_addr.sin_addr),
           (struct in_addr *)addr, sizeof(struct in_addr));
-    conn->serv_addr.sin_family = conn->hostaddr->h_addrtype;
+    conn->serv_addr.sin_family = hostaddr->h_addrtype;
    conn->serv_addr.sin_port = htons(conn->port);
 #endif
  }
@@ -1272,7 +1295,8 @@ static CURLcode ConnectPlease(struct connectdata *conn)
  return result;
 }

-static void verboseconnect(struct connectdata *conn)
+static void verboseconnect(struct connectdata *conn,
+                           Curl_addrinfo *hostaddr)
 {
 #ifdef HAVE_INET_NTOA_R
  char ntoa_buf[64];
@@ -1281,6 +1305,7 @@ static void verboseconnect(struct connectdata *conn)

  /* Figure out the ip-number and display the first host name it shows: */
 #ifdef ENABLE_IPV6
+  (void)hostaddr; /* not used in the IPv6 enabled version */
  {
    char hbuf[NI_MAXHOST];
 #ifdef NI_WITHSCOPEID
@@ -1305,7 +1330,8 @@ static void verboseconnect(struct connectdata *conn)
  {
    struct in_addr in;
    (void) memcpy(&in.s_addr, &conn->serv_addr.sin_addr, sizeof (in.s_addr));
-    infof(data, "Connected to %s (%s) port %d\n", conn->hostaddr->h_name,
+    infof(data, "Connected to %s (%s) port %d\n",
+          hostaddr?hostaddr->h_name:"[re-used]",
 #if defined(HAVE_INET_NTOA_R)
          inet_ntoa_r(in, ntoa_buf, sizeof(ntoa_buf)),
 #else
@@ -1327,6 +1353,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
  struct connectdata *conn_temp;
  char endbracket;
  int urllen;
+  Curl_addrinfo *hostaddr;
 #ifdef HAVE_ALARM
  unsigned int prev_alarm;
 #endif
@@ -1611,9 +1638,16 @@ static CURLcode CreateConnection(struct SessionHandle *data,

      nope=no_proxy?strtok_r(no_proxy, ", ", &no_proxy_tok_buf):NULL;
      while(nope) {
-        if(strlen(nope) <= strlen(conn->name)) {
+        unsigned int namelen;
+        char *endptr = strchr(conn->name, ':');
+        if(endptr)
+          namelen=endptr-conn->name;
+        else
+          namelen=strlen(conn->name);
+
+        if(strlen(nope) <= namelen) {
          char *checkn=
-            conn->name + strlen(conn->name) - strlen(nope);
+            conn->name + namelen - strlen(nope);
          if(strnequal(nope, checkn, strlen(nope))) {
            /* no proxy for this host! */
            break;
@@ -2165,33 +2199,31 @@ static CURLcode CreateConnection(struct SessionHandle *data,
  /*************************************************************
   * Resolve the name of the server or proxy
   *************************************************************/
-  if(!data->change.proxy) {
+  if(conn->bits.reuse) {
+    /* re-used connection, no resolving is necessary */
+    hostaddr = NULL;
+  }
+  else if(!data->change.proxy) {
    /* If not connecting via a proxy, extract the port from the URL, if it is
     * there, thus overriding any defaults that might have been set above. */
    conn->port =  conn->remote_port; /* it is the same port */

    /* Resolve target host right on */
-    if(!conn->hostaddr) {
-      /* it might already be set if reusing a connection */
-      conn->hostaddr = Curl_resolv(data, conn->name, conn->port,
-                                   &conn->hostent_buf);
-    }
-    if(!conn->hostaddr) {
+    hostaddr = Curl_resolv(data, conn->name, conn->port);
+
+    if(!hostaddr) {
      failf(data, "Couldn't resolve host '%s'", conn->name);
      result =  CURLE_COULDNT_RESOLVE_HOST;
      /* don't return yet, we need to clean up the timeout first */
    }
  }
-  else if(!conn->hostaddr) {
-    /* This is a proxy that hasn't been resolved yet. It may be resolved
-       if we're reusing an existing connection. */
+  else {
+    /* This is a proxy that hasn't been resolved yet. */

    /* resolve proxy */
-    /* it might already be set if reusing a connection */
-    conn->hostaddr = Curl_resolv(data, conn->proxyhost, conn->port,
-                                 &conn->hostent_buf);
+    hostaddr = Curl_resolv(data, conn->proxyhost, conn->port);

-    if(!conn->hostaddr) {
+    if(!hostaddr) {
      failf(data, "Couldn't resolve proxy '%s'", conn->proxyhost);
      result = CURLE_COULDNT_RESOLVE_PROXY;
      /* don't return yet, we need to clean up the timeout first */
@@ -2275,14 +2307,14 @@ static CURLcode CreateConnection(struct SessionHandle *data,
  
  if(-1 == conn->firstsocket) {
    /* Connect only if not already connected! */
-    result = ConnectPlease(conn);
+    result = ConnectPlease(conn, hostaddr);
    Curl_pgrsTime(data, TIMER_CONNECT); /* connect done, good or bad */

    if(CURLE_OK != result)
      return result;

    if(data->set.verbose)
-      verboseconnect(conn);
+      verboseconnect(conn, hostaddr);

    if(conn->curl_connect) {
      /* is there a protocol-specific connect() procedure? */
@@ -2301,7 +2333,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
  else {
    Curl_pgrsTime(data, TIMER_CONNECT); /* we're connected already */
    if(data->set.verbose)
-      verboseconnect(conn);
+      verboseconnect(conn, hostaddr);
  }

  conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
--- a/lib/urldata.h
+++ b/lib/urldata.h
@@ -83,7 +83,7 @@
 #include "http_chunks.h" /* for the structs and enum stuff */

 /* Download buffer size, keep it fairly big for speed reasons */
-#define BUFSIZE (1024*20)
+#define BUFSIZE CURL_MAX_WRITE_SIZE

 /* Initial size of the buffer to store headers in, it'll be enlarged in case
   of need. */
@@ -249,6 +249,10 @@ struct Curl_transfer_keeper {
  char *uploadbuf;
  int maxfd;

+  /* pointers to the actual descriptors we check */
+  fd_set *readfdp;
+  fd_set *writefdp;
+
  /* the file descriptors to play with */
  fd_set readfd;
  fd_set writefd;
@@ -282,9 +286,6 @@ struct connectdata {
 #define PROT_FTPS    (1<<9)
 #define PROT_SSL     (1<<10) /* protocol requires SSL */

-  Curl_addrinfo *hostaddr; /* IP-protocol independent host info pointer list */
-  char *hostent_buf; /* pointer to allocated memory for name info */
-
 #ifdef ENABLE_IPV6
  struct addrinfo *serv_addr;   /* the particular host we use */
 #else
@@ -451,6 +452,7 @@ struct Progress {
  double t_connect;
  double t_pretransfer;
  double t_starttransfer;
+  double t_redirect;

  struct timeval start;
  struct timeval t_startsingle;
@@ -605,6 +607,7 @@ struct UserDefined {
  char *key_passwd;     /* plain text private key password */
  char *crypto_engine;  /* name of the crypto engine to use */
  char *cookiejar;      /* dump all cookies to this file */
+  bool cookiesession;   /* new cookie session? */
  bool crlf;            /* convert crlf on ftp upload(?) */
  struct curl_slist *quote;     /* after connection is established */
  struct curl_slist *postquote; /* after the transfer */
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -17,5 +17,8 @@
 /* Define if you have the <utime.h> header file */
 #undef HAVE_UTIME_H

-/* Define if you have thhe <sys/utime.h> header file */
+/* Define if you have the <sys/utime.h> header file */
 #undef HAVE_SYS_UTIME_H
+
+/* Define if you have the <sys/select.h> header file */
+#undef HAVE_SYS_SELECT_H
--- a/src/main.c
+++ b/src/main.c
@@ -351,7 +351,8 @@ static void help(void)
  puts(" -h/--help          This help text\n"
       " -H/--header <line> Custom header to pass to server. (H)\n"
       " -i/--include       Include the HTTP-header in the output (H)\n"
-       " -I/--head          Fetch document info only (HTTP HEAD/FTP SIZE)\n"
+       " -I/--head          Fetch document info only (HTTP HEAD/FTP SIZE)");
+  puts(" -j/--junk-session-cookies Ignore session cookies read from file (H)\n"
       "    --interface <interface> Specify the interface to be used\n"
       "    --krb4 <level>  Enable krb4 with specified security level (F)\n"
       " -K/--config        Specify which config file to read\n"
@@ -370,9 +371,11 @@ static void help(void)
  puts(" -r/--range <range> Retrieve a byte range from a HTTP/1.1 or FTP server\n"
       " -R/--remote-time   Set the remote file's time on the local output\n"
       " -s/--silent        Silent mode. Don't output anything\n"
-       " -S/--show-error    Show error. With -s, make curl show errors when they occur\n"
-       "    --stderr <file> Where to redirect stderr. - means stdout.\n"
+       " -S/--show-error    Show error. With -s, make curl show errors when they occur");
+  puts("    --stderr <file> Where to redirect stderr. - means stdout.\n"
       " -t/--telnet-option <OPT=val> Set telnet option\n"
+       "    --trace <file>  Dump a network/debug trace to the given file\n"
+       "    --trace-ascii <file>  Like --trace but without the hex output\n"
       " -T/--upload-file <file> Transfer/upload <file> to remote site\n"
       "    --url <URL>     Another way to specify URL to work with");
  puts(" -u/--user <user[:password]> Specify user and password to use\n"
@@ -409,6 +412,7 @@ struct Configurable {
  char *cookie;     /* single line with specified cookies */
  char *cookiejar;  /* write to this file */
  char *cookiefile; /* read from this file */
+  bool cookiesession; /* new session? */
  bool use_resume;
  bool resume_from_current;
  bool disable_epsv;
@@ -452,6 +456,11 @@ struct Configurable {
  bool crlf;
  char *customrequest;
  char *krb4level;
+  char *trace_dump; /* file to dump the network trace to, or NULL */
+  FILE *trace_stream;
+  bool trace_fopened;
+  bool trace_ascii;
+
  long httpversion;
  bool progressmode;
  bool nobuffer;
@@ -960,6 +969,8 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
 #ifdef USE_ENVIRONMENT
    {"5f", "environment", FALSE},
 #endif
+    {"5g", "trace",      TRUE},
+    {"5h", "trace-ascii", TRUE},
    {"0", "http1.0",     FALSE},
    {"1", "tlsv1",       FALSE},
    {"2", "sslv2",       FALSE},
@@ -991,6 +1002,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
    {"H", "header",      TRUE},
    {"i", "include",     FALSE},
    {"I", "head",        FALSE},
+    {"j", "junk-session-cookies", FALSE},
    {"K", "config",      TRUE},
    {"l", "list-only",   FALSE},
    {"L", "location",    FALSE},
@@ -1140,6 +1152,13 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
        config->writeenv ^= TRUE;
        break;
 #endif
+      case 'g': /* --trace */
+        GetStr(&config->trace_dump, nextarg);
+        break;
+      case 'h': /* --trace-ascii */
+        GetStr(&config->trace_dump, nextarg);
+        config->trace_ascii = TRUE;
+        break;
      default: /* the URL! */
        {
          struct getout *url;
@@ -1372,6 +1391,9 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
    case 'i':
      config->conf ^= CONF_HEADER; /* include the HTTP header as well */
      break;
+    case 'j':
+      config->cookiesession ^= TRUE;
+      break;
    case 'I':
      /*
       * This is a bit tricky. We either SET both bits, or we clear both
@@ -1504,7 +1526,8 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
      break;
    case 't':
      /* Telnet options */
-      config->telnet_options = curl_slist_append(config->telnet_options, nextarg);
+      config->telnet_options =
+        curl_slist_append(config->telnet_options, nextarg);
      break;
    case 'T':
      /* we are uploading */
@@ -1571,16 +1594,16 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
        nextarg++;
      default:
        /* If-Modified-Since: (section 14.28 in RFC2068) */
-        config->timecond = TIMECOND_IFMODSINCE;
+        config->timecond = CURL_TIMECOND_IFMODSINCE;
        break;
      case '-':
        /* If-Unmodified-Since:  (section 14.24 in RFC2068) */
-        config->timecond = TIMECOND_IFUNMODSINCE;
+        config->timecond = CURL_TIMECOND_IFUNMODSINCE;
        nextarg++;
        break;
      case '=':
        /* Last-Modified:  (section 14.29 in RFC2068) */
-        config->timecond = TIMECOND_LASTMOD;
+        config->timecond = CURL_TIMECOND_LASTMOD;
        nextarg++;
        break;
      }
@@ -1591,7 +1614,7 @@ static ParameterError getparameter(char *flag, /* f or -long-flag */
        struct stat statbuf;
        if(-1 == stat(nextarg, &statbuf)) {
          /* failed, remove time condition */
-          config->timecond = TIMECOND_NONE;
+          config->timecond = CURL_TIMECOND_NONE;
        }
        else {
          /* pull the time out from the file */
@@ -1914,6 +1937,101 @@ void progressbarinit(struct ProgressData *bar,
  bar->out = config->errors;
 }

+static
+void dump(const char *text,
+          FILE *stream, unsigned char *ptr, size_t size,
+          bool nohex)
+{
+  size_t i;
+  size_t c;
+
+  unsigned int width=0x10;
+
+  if(nohex)
+    /* without the hex output, we can fit more on screen */
+    width = 0x40;
+
+  fprintf(stream, "%s, %d bytes (0x%x)\n", text, size, size);
+
+  for(i=0; i<size; i+= width) {
+
+    fprintf(stream, "%04x: ", i);
+
+    if(!nohex) {
+      /* hex not disabled, show it */
+      for(c = 0; c < width; c++)
+        if(i+c < size)
+          fprintf(stream, "%02x ", ptr[i+c]);
+        else
+          fputs("   ", stream);
+    }
+
+    for(c = 0; (c < width) && (i+c < size); c++) {
+      /* check for 0D0A; if found, skip past and start a new line of output */
+      if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+        i+=(c+2-width);
+        break;
+      }
+      fprintf(stream, "%c",
+              (ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
+      /* check again for 0D0A, to avoid an extra \n if it's at width */
+      if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+        i+=(c+3-width);
+        break;
+      }
+    }
+    fputc('\n', stream); /* newline */
+  }
+}
+
+static
+int my_trace(CURL *handle, curl_infotype type,
+             unsigned char *data, size_t size,
+             void *userp)
+{
+  struct Configurable *config = (struct Configurable *)userp;
+  FILE *output=config->errors;
+  const char *text;
+
+  (void)handle; /* prevent compiler warning */
+
+  if(!config->trace_stream) {
+    /* open for append */
+    if(strequal("-", config->trace_dump))
+      config->trace_stream = stdout;
+    else {
+      config->trace_stream = fopen(config->trace_dump, "w");
+      config->trace_fopened = TRUE;
+    }
+  }
+
+  if(config->trace_stream)
+    output = config->trace_stream;
+
+  switch (type) {
+  case CURLINFO_TEXT:
+    fprintf(output, "== Info: %s", data);
+  default: /* in case a new one is introduced to shock us */
+    return 0;
+
+  case CURLINFO_HEADER_OUT:
+    text = "=> Send header";
+    break;
+  case CURLINFO_DATA_OUT:
+    text = "=> Send data ";
+    break;
+  case CURLINFO_HEADER_IN:
+    text = "<= Recv header";
+    break;
+  case CURLINFO_DATA_IN:
+    text = "<= Recv data";
+    break;
+  }
+
+  dump(text, output, data, size, config->trace_ascii);
+  return 0;
+}
+
 void free_config_fields(struct Configurable *config)
 {
  if(config->random_file)
@@ -2125,6 +2243,18 @@ operate(struct Configurable *config, int argc, char *argv[])

  urlnode = config->url_list;

+  if(config->headerfile) {
+    /* open file for output: */
+    if(strcmp(config->headerfile,"-")) {
+      heads.filename = config->headerfile;
+      headerfilep=NULL;
+    }
+    else
+      headerfilep=stdout;
+    heads.stream = headerfilep;
+    heads.config = config;
+  }
+
  /* loop through the list of given URLs */
  while(urlnode) {

@@ -2291,18 +2421,6 @@ operate(struct Configurable *config, int argc, char *argv[])
         config->resume_from_current) {
        config->resume_from = -1; /* -1 will then force get-it-yourself */
      }
-      if(config->headerfile) {
-        /* open file for output: */
-        if(strcmp(config->headerfile,"-")) {
-          heads.filename = config->headerfile;
-          headerfilep=NULL;
-        }
-        else
-          headerfilep=stdout;
-        heads.stream = headerfilep;
-        heads.config = config;
-      }
-    
      if(outs.stream && isatty(fileno(outs.stream)) &&
         !(config->conf&(CONF_UPLOAD|CONF_HTTPPOST)))
        /* we send the output to a tty and it isn't an upload operation,
@@ -2377,7 +2495,6 @@ operate(struct Configurable *config, int argc, char *argv[])
      curl_easy_setopt(curl, CURLOPT_INFILESIZE, infilesize);
      curl_easy_setopt(curl, CURLOPT_URL, url);     /* what to fetch */
      curl_easy_setopt(curl, CURLOPT_PROXY, config->proxy); /* proxy to use */
-      curl_easy_setopt(curl, CURLOPT_VERBOSE, config->conf&CONF_VERBOSE);
      curl_easy_setopt(curl, CURLOPT_HEADER, config->conf&CONF_HEADER);
      curl_easy_setopt(curl, CURLOPT_NOPROGRESS, config->conf&CONF_NOPROGRESS);
      curl_easy_setopt(curl, CURLOPT_NOBODY, config->conf&CONF_NOBODY);
@@ -2447,6 +2564,9 @@ operate(struct Configurable *config, int argc, char *argv[])
      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, config->cookiefile);
      /* cookie jar was added in 7.9 */
      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, config->cookiejar);
+      /* cookie session added in 7.9.7 */
+      curl_easy_setopt(curl, CURLOPT_COOKIESESSION, config->cookiesession);
+
      curl_easy_setopt(curl, CURLOPT_SSLVERSION, config->ssl_version);
      curl_easy_setopt(curl, CURLOPT_TIMECONDITION, config->timecond);
      curl_easy_setopt(curl, CURLOPT_TIMEVALUE, config->condtime);
@@ -2485,6 +2605,14 @@ operate(struct Configurable *config, int argc, char *argv[])
      if(config->disable_epsv)
        /* disable it */
        curl_easy_setopt(curl, CURLOPT_FTP_USE_EPSV, FALSE);
+
+      /* new in curl 7.9.7 */
+      if(config->trace_dump) {
+        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
+        curl_easy_setopt(curl, CURLOPT_DEBUGDATA, config);
+        config->conf |= CONF_VERBOSE; /* force verbose */
+      }
+      curl_easy_setopt(curl, CURLOPT_VERBOSE, config->conf&CONF_VERBOSE);
      
      res = curl_easy_perform(curl);
        
@@ -2512,9 +2640,6 @@ operate(struct Configurable *config, int argc, char *argv[])
        fprintf(config->errors, "curl: (%d) %s\n", res, errorbuffer);
 #endif

-      if(config->headerfile && !headerfilep && heads.stream)
-        fclose(heads.stream);
-
      if (outfile && !strequal(outfile, "-") && outs.stream)
        fclose(outs.stream);

@@ -2568,6 +2693,12 @@ operate(struct Configurable *config, int argc, char *argv[])

  } /* while-loop through all URLs */

+  if(config->headerfile && !headerfilep && heads.stream)
+    fclose(heads.stream);
+
+  if(config->trace_fopened)
+    fclose(config->trace_stream);
+
  if(allocuseragent)
    free(config->useragent);

--- a/src/version.h
+++ b/src/version.h
@@ -1,3 +1,3 @@
 #define CURL_NAME "curl"
-#define CURL_VERSION "7.9.6"
+#define CURL_VERSION "7.9.7"
 #define CURL_ID CURL_NAME " " CURL_VERSION " (" OS ") "
--- a/src/writeout.c
+++ b/src/writeout.c
@@ -21,9 +21,15 @@
 * $Id$
 *****************************************************************************/

+#include "setup.h"
+
 #include <stdio.h>
 #include <string.h>

+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
 #include <curl/curl.h>

 #define _MPRINTF_REPLACE /* we want curl-functions instead of native ones */
--- a/tests/server/sws.c
+++ b/tests/server/sws.c
@@ -21,9 +21,6 @@ char *spitout(FILE *stream, char *main, char *sub, int *size);
 #define DEFAULT_LOGFILE "log/sws.log"
 #endif

-#define DOCBUFSIZE 4
-#define BUFFERSIZE (DOCBUFSIZE * 1024)
-
 #define VERSION "cURL test suite HTTP server/0.1"

 #define REQUEST_DUMP "log/server.input"
@@ -73,7 +70,7 @@ static void sigpipe_handler(int sig)
 static void sigterm_handler(int sig)
 {
    char logbuf[100];
-    snprintf(logbuf, 100, "Got signal %d, terminating", sig);
+    sprintf(logbuf, "Got signal %d, terminating", sig);
    logmsg(logbuf);
    sigterm = 1;
 }
@@ -136,12 +133,12 @@ void storerequest(char *reqbuf)
 }


-#define REQBUFSIZ 50000
-#define REQBUFSIZ_TXT "49999"
+#define REQBUFSIZ 150000
+#define REQBUFSIZ_TXT "149999"

 /* very-big-path support */
-#define MAXDOCNAMELEN 40000
-#define MAXDOCNAMELEN_TXT "39999"
+#define MAXDOCNAMELEN 140000
+#define MAXDOCNAMELEN_TXT "139999"

 #define REQUEST_KEYWORD_SIZE 256
 static int get_request(int sock, int *part)
Author	SHA1	Message	Date
Daniel Stenberg	edb1756050	7.9.7 commit	2002-05-13 09:40:16 +00:00
Daniel Stenberg	5215f6f654	we don't need win32sockets.c anymore, we support this internally	2002-05-13 07:29:22 +00:00
Daniel Stenberg	1913b4eeed	fopen.c added, a fopen() style emulation for URL reading	2002-05-13 07:28:10 +00:00
Daniel Stenberg	b44a4da5df	Friday's fixes	2002-05-12 16:10:12 +00:00
Daniel Stenberg	919878fbb2	AIX 5.1	2002-05-10 16:01:24 +00:00
Daniel Stenberg	06bdf83419	Kein Roth made --trace-ascii look even better, and make OD 0A occurances get output as plain newlines.	2002-05-10 15:59:42 +00:00
Daniel Stenberg	2ff2810a92	AIX wants sys/select.h for the fd_set stuff in curl/multi.h, and even though it is a bit ugly work-around to add this here, it is still a working work- around! ;-)	2002-05-10 14:37:39 +00:00
Daniel Stenberg	20d9c1b30d	Patrick Smith's contributed docs improvements for when NLST is used by curl...	2002-05-07 23:36:53 +00:00
Daniel Stenberg	bbe10cb0cb	7.9.7-pre2	2002-05-07 21:52:38 +00:00
Daniel Stenberg	daba8f3a70	Added --trace-ascii support	2002-05-07 13:13:17 +00:00
Daniel Stenberg	1458c3668d	--trace-ascii and --junk-session-cookies were added	2002-05-07 13:12:12 +00:00
Daniel Stenberg	980a47b42b	support for ingoring session cookies added	2002-05-07 09:58:13 +00:00
Daniel Stenberg	f7ca561b06	the code for case CURLOPT_DEBUGDATA code broke the CURLOPT_STDERR one!	2002-05-06 18:30:17 +00:00
Daniel Stenberg	cacd756efd	recent fiddling	2002-05-06 13:44:00 +00:00
Daniel Stenberg	8539e76cb9	CURLOPT_FILE and CURLOPT_INFILE have better aliases now: CURLOPT_WRITEDATA and CURLOPT_READDATA	2002-05-06 13:43:35 +00:00
Daniel Stenberg	3bbf694d5a	Added multi-post.c, based on the source file posted by Gustaf Hui	2002-05-06 13:38:28 +00:00
Daniel Stenberg	44debdde62	Better support for being used with the multi interface without the *fd_set() and proper select()ing have been made.	2002-05-05 12:11:03 +00:00
Daniel Stenberg	c6cf2b8e93	--trace is a 7.9.7 function	2002-05-05 09:09:17 +00:00
Daniel Stenberg	69c5452b25	added -Z/--max-redirs and --trace changed order of a few others to keep the a-z order	2002-05-05 09:08:26 +00:00
Daniel Stenberg	d321056e8d	made VERBOSE output more like it used to be, HEADER_IN is thus also ignored by the internal debugfunction callback	2002-05-04 15:36:07 +00:00
Daniel Stenberg	d9a1a59f22	CURL_MAX_WRITE_SIZE is a new exported define that informs about the biggest sized buffer that may be passed to a write callback	2002-05-03 14:50:29 +00:00
Daniel Stenberg	0b898b5a8a	fixed return code	2002-05-03 12:40:37 +00:00
Daniel Stenberg	a9e0885be0	another week of changes	2002-05-03 12:21:07 +00:00
Daniel Stenberg	57ff28c9b7	- Added "--trace [file]" to the command line tool. It makes a very detailed trace dump get stored, with a full protocol dump that includes all received and transmitted data. This could be a very effective tool for debugging what goes wrong. This dump includes every byte the way it is sent to/received from the server. The dump is the plain-text version, so SSL transfers will still be readable.	2002-05-03 12:14:09 +00:00
Daniel Stenberg	86cc34c0de	made the DEBUGFUNCTION get called properly on a few more places, especially for DATA_IN and DATA_OUT.	2002-05-03 12:07:32 +00:00
Daniel Stenberg	39028f1bd4	make sure our own printf() clones are used	2002-05-03 12:06:04 +00:00
Daniel Stenberg	71f4c05665	-D now stores all headers to the same file if multiple URLs are given on the command line!	2002-05-03 09:47:25 +00:00
Daniel Stenberg	9ef9797998	clarified that you must keep the variables that you point to!	2002-05-02 22:34:31 +00:00
Daniel Stenberg	ab9374de57	spell	2002-05-02 22:15:21 +00:00
Daniel Stenberg	913e997061	use and set the fd_set pointers instead of the actual values, as then we work properly with the multi interface when the user has provided the fd_sets!	2002-05-02 22:14:31 +00:00
Daniel Stenberg	8e50d6b6f3	added two pointers to the fd_set variables to read/write from, as sometimes we need to point to user-provided fd_sets	2002-05-02 22:13:35 +00:00
Daniel Stenberg	2db0744a7b	return CURLM_CALL_MULTI_PERFORM in one more case, and check return code from malloc()	2002-05-02 22:12:14 +00:00
Daniel Stenberg	2de0028349	make sure the dns cache pointers in the easy handles are NULLed	2002-05-02 18:07:38 +00:00
Daniel Stenberg	35d04c5398	Hanno Kranzhoff noticed we didn't properly reset the download/upload counters before transfers, when doing multiple ones on the same handle.	2002-05-02 08:52:09 +00:00
Daniel Stenberg	b1becd0ed5	Jacky Lam's fix to make the realloc() of the hostent data work properly even when the realloc() actually gets a new memory block	2002-05-01 11:36:13 +00:00
Daniel Stenberg	bd9650bc81	how to set more than one cookie	2002-04-30 07:37:02 +00:00
Daniel Stenberg	969a25d1b2	implemented curl_multi_info_read() which I had forgotten before!	2002-04-27 22:21:51 +00:00
Daniel Stenberg	f144f77ba7	updated some docs	2002-04-27 20:19:55 +00:00
Daniel Stenberg	abea1f8910	clarified	2002-04-27 18:31:49 +00:00
Daniel Stenberg	8eaa7fec76	one added, one edited	2002-04-27 18:12:26 +00:00
Daniel Stenberg	fdace647e8	shorter introduction	2002-04-27 18:01:54 +00:00
Daniel Stenberg	d7531c18fc	updated	2002-04-27 18:00:10 +00:00
Daniel Stenberg	ef3f978784	Added BINDINGS, lists all available libcurl bindings as of this date.	2002-04-27 17:02:38 +00:00
Daniel Stenberg	e410860e0e	fixes on rainy saturday in the end of April, 2002	2002-04-27 13:26:32 +00:00
Daniel Stenberg	c64fca1b0c	Fixed the FTP response reader to deal with timeouts better. Previously it would reset the timeout for each incoming data, which would make veeery slow responses be allowed to take even more time since the timeout would only be reached if the time between two received data chunks was longer than the set timeout value...	2002-04-27 13:24:06 +00:00
Daniel Stenberg	15b2a3af91	(Curl_GetFTPResponse) moved some code to only get performed when actually needed	2002-04-27 13:09:37 +00:00
Daniel Stenberg	8358505b6d	Now uses Curl_ as prefix for internal global symbols. curl_ should only be used for "exported" globals.	2002-04-27 13:07:51 +00:00
Daniel Stenberg	1c42779845	DNC cache prune crash removed, made the name spacing follow the general rule: "Curl_" prefix for library-wide private symbols, "curl_" is for exported symbols.	2002-04-27 13:06:40 +00:00
Daniel Stenberg	32823f17e0	openbsd on Alpha was no problemos	2002-04-26 12:58:07 +00:00
Daniel Stenberg	e1c2e3f5e9	test suite portability fix	2002-04-26 12:57:49 +00:00
Daniel Stenberg	044755b30f	handles much larger POSTs, replaced snprintf() with sprintf() since this needs to be more portable and in the test server we can skip the extra safety	2002-04-26 07:48:05 +00:00
Daniel Stenberg	9aa22399a8	another week of changes	2002-04-26 07:45:39 +00:00
Daniel Stenberg	f564905ac4	adjusted to the new Curl_resolv() proto	2002-04-25 19:26:29 +00:00
Daniel Stenberg	00e4f81446	prevent persistant connections to do name resolves	2002-04-25 19:18:19 +00:00
Daniel Stenberg	8927ddec16	In order to not get problems with DNS cache pruning, we no longer store any name resolved data in any curl handle struct. That way, we won't mind if the cache entries are pruned for the next time we need them. We'll just resolve them again instead. This changes the Curl_resolv() proto. It modifies the SessionHandle struct but perhaps most importantly, it'll make the internals somewhat dependent on the DNS cache not being disabled as that will cripple operations somewhat. Especially for persistant connections.	2002-04-25 19:00:57 +00:00
Daniel Stenberg	f6525ae200	the TOTAL_TIME is not really total, as it excludes the connect time...	2002-04-25 16:45:15 +00:00
Daniel Stenberg	0be7944d66	use the hostname pointer instead of using IPv4-only info from a struct	2002-04-25 15:50:49 +00:00
Daniel Stenberg	47819ea86e	clarified a bit with the timecondition stuff	2002-04-24 10:16:46 +00:00
Daniel Stenberg	96ce3461ad	no, this doesn't look like it bugs	2002-04-24 10:16:00 +00:00
Daniel Stenberg	8b6d555421	NetBSD alpha works, also tried a newer FreeBSD on alpha	2002-04-24 10:15:37 +00:00
Daniel Stenberg	3b9ef8dfc8	removed warning about signed/unsigned comparison	2002-04-23 14:57:37 +00:00
Daniel Stenberg	db6d4bcf47	the 80 column police narrowed this source code! B-]	2002-04-23 14:56:21 +00:00
Daniel Stenberg	471f1d694f	fixes bug report #547484 , no_proxy doesn't properly strip off port numbers from the host names before comparing	2002-04-23 13:34:28 +00:00
Daniel Stenberg	495f6f6bd3	use new timecond defines	2002-04-23 00:05:21 +00:00
Daniel Stenberg	36e35b6f60	allow binding the local end of a connection even when using IPv6, thus we now have --interface working properly	2002-04-22 23:56:13 +00:00
Daniel Stenberg	192606bc4b	use double where it is supposed to	2002-04-22 23:54:43 +00:00
Daniel Stenberg	53a9fdf078	use sclose() to close sockets	2002-04-22 23:53:49 +00:00
Daniel Stenberg	ef436bdbe8	renamed the TIMECOND defines to be CURL_ prefixed	2002-04-22 23:53:15 +00:00
Daniel Stenberg	72d722b07b	The timecond stuff now have CURL_ prefixes	2002-04-22 13:33:56 +00:00
Daniel Stenberg	21fc402c01	Jacky Lam's adjust resolve-buffer size patch applied. Slightly edited by Daniel.	2002-04-22 13:31:16 +00:00
Daniel Stenberg	381f77756d	pack_hostent does not handle 64 bit pointers correctly. A Bj�rn Reese patch.	2002-04-19 11:00:26 +00:00
Sterling Hughes	a386562d9a	Prune old hostcache entries with each call... This can be optimized a tidbit, but this is a start.	2002-04-17 20:13:55 +00:00
Daniel Stenberg	2bc84fb163	Dirk Manske's two new infos	2002-04-17 07:21:17 +00:00
Daniel Stenberg	08f8917acb	Dirk Manske's fix for HTTP response code 301, that now behaves more like browsers do. Which thus breaks the RFC 2616...	2002-04-17 07:16:49 +00:00
Daniel Stenberg	62d205a2ec	Dirk Manske brought the patch that introduces two new CURLINFO_* values: CURLINFO_REDIRECT_TIME and CURLINFO_REDIRECT_COUNT.	2002-04-16 07:59:20 +00:00
Daniel Stenberg	29e873b12d	Jonatan Lander fixed the "Disables POST, goes with GET" output to be more connected with reality! ;-)	2002-04-15 13:47:06 +00:00
Daniel Stenberg	95f78080ab	This makes formposting with a specified file missing fail. curl_easy_perform will then return CURLE_READ_ERROR.	2002-04-15 11:19:03 +00:00