New Curl version 7.10.3

27 files changed, 1613 insertions, 1184 deletions

diff --git a/Source/CTest/Curl/CMakeLists.txt b/Source/CTest/Curl/CMakeLists.txt
index 9464e0d..16d28d2 100644
--- a/Source/CTest/Curl/CMakeLists.txt
+++ b/Source/CTest/Curl/CMakeLists.txt
@@ -2,7 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 1.5)
 PROJECT(LIBCURL C)
 
 SET(PACKAGE "curl")
-SET(VERSION "7.10.2")
+SET(VERSION "7.10.3")
 SET(PACKAGE_TARNAME " ")
 SET(OPERATING_SYSTEM ${CMAKE_SYSTEM_NAME})
 
diff --git a/Source/CTest/Curl/base64.c b/Source/CTest/Curl/base64.c
index 41c451a..183df27 100644
--- a/Source/CTest/Curl/base64.c
+++ b/Source/CTest/Curl/base64.c
@@ -61,6 +61,8 @@ static void decodeQuantum(unsigned char *dest, char *src)
       x = (x << 6) + 62;
     else if(src[i] == '/')
       x = (x << 6) + 63;
+    else if(src[i] == '=')
+      x = (x << 6);
   }
 
   dest[2] = (unsigned char)(x & 255); x >>= 8;
@@ -78,6 +80,7 @@ static void base64Decode(unsigned char *dest, char *src, int *rawLength)
   int length = 0;
   int equalsTerm = 0;
   int i;
+  int numQuantums;
   unsigned char lastQuantum[3];
         
   while((src[length] != '=') && src[length])
@@ -85,16 +88,18 @@ static void base64Decode(unsigned char *dest, char *src, int *rawLength)
   while(src[length+equalsTerm] == '=')
     equalsTerm++;
   
+  numQuantums = (length + equalsTerm) / 4;
   if(rawLength)
-    *rawLength = (length * 3 / 4) - equalsTerm;
+    *rawLength = (numQuantums * 3) - equalsTerm;
   
-  for(i = 0; i < length/4 - 1; i++) {
+  for(i = 0; i < numQuantums - 1; i++) {
     decodeQuantum(dest, src);
     dest += 3; src += 4;
   }
 
   decodeQuantum(lastQuantum, src);
-  for(i = 0; i < 3 - equalsTerm; i++) dest[i] = lastQuantum[i];
+  for(i = 0; i < 3 - equalsTerm; i++)
+    dest[i] = lastQuantum[i];
         
 }
 
@@ -194,20 +199,21 @@ int Curl_base64_decode(const char *str, void *data)
 #define TEST_NEED_SUCK
 void *suck(int *);
 
-int main(int argc, char **argv, char **envp) {
-        char *base64;
-        int base64Len;
-        unsigned char *data;
-        int dataLen;
+int main(int argc, char **argv, char **envp)
+{
+  char *base64;
+  int base64Len;
+  unsigned char *data;
+  int dataLen;
         
-        data = (unsigned char *)suck(&dataLen);
-        base64Len = Curl_base64_encode(data, dataLen, &base64);
-
-        fprintf(stderr, "%d\n", base64Len);
-        fprintf(stdout, "%s",   base64);
+  data = (unsigned char *)suck(&dataLen);
+  base64Len = Curl_base64_encode(data, dataLen, &base64);
 
-        free(base64); free(data);
-        return 0;
+  fprintf(stderr, "%d\n", base64Len);
+  fprintf(stdout, "%s",   base64);
+  
+  free(base64); free(data);
+  return 0;
 }
 #endif
 
@@ -220,47 +226,47 @@ int main(int argc, char **argv, char **envp) {
 #define TEST_NEED_SUCK
 void *suck(int *);
 
-int main(int argc, char **argv, char **envp) {
-        char *base64;
-        int base64Len;
-        unsigned char *data;
-        int dataLen;
-        
-        base64 = (char *)suck(&base64Len);
-        data = (unsigned char *)malloc(base64Len * 3/4 + 8);
-        dataLen = Curl_base64_decode(base64, data);
-
-        fprintf(stderr, "%d\n", dataLen);
-        fwrite(data,1,dataLen,stdout);
+int main(int argc, char **argv, char **envp)
+{
+  char *base64;
+  int base64Len;
+  unsigned char *data;
+  int dataLen;
         
-
-        free(base64); free(data);
-        return 0;
+  base64 = (char *)suck(&base64Len);
+  data = (unsigned char *)malloc(base64Len * 3/4 + 8);
+  dataLen = Curl_base64_decode(base64, data);
+  
+  fprintf(stderr, "%d\n", dataLen);
+  fwrite(data,1,dataLen,stdout);
+  
+  free(base64); free(data);
+  return 0;
 }
 #endif
 
 #ifdef TEST_NEED_SUCK
 /* this function 'sucks' in as much as possible from stdin */
-void *suck(int *lenptr) {
-        int cursize = 8192;
-        unsigned char *buf = NULL;
-        int lastread;
-        int len = 0;
-        
-        do {
-                cursize *= 2;
-                buf = (unsigned char *)realloc(buf, cursize);
-                memset(buf + len, 0, cursize - len);
-                lastread = fread(buf + len, 1, cursize - len, stdin);
-                len += lastread;
-        } while(!feof(stdin));
+void *suck(int *lenptr)
+{
+  int cursize = 8192;
+  unsigned char *buf = NULL;
+  int lastread;
+  int len = 0;
         
-        lenptr[0] = len;
-        return (void *)buf;
+  do {
+    cursize *= 2;
+    buf = (unsigned char *)realloc(buf, cursize);
+    memset(buf + len, 0, cursize - len);
+    lastread = fread(buf + len, 1, cursize - len, stdin);
+    len += lastread;
+  } while(!feof(stdin));
+  
+  lenptr[0] = len;
+  return (void *)buf;
 }
 #endif
 
-
 /*
  * local variables:
  * eval: (load-file "../curl-mode.el")
diff --git a/Source/CTest/Curl/connect.c b/Source/CTest/Curl/connect.c
index eb6f4f3..5aa9f8b 100644
--- a/Source/CTest/Curl/connect.c
+++ b/Source/CTest/Curl/connect.c
@@ -176,10 +176,9 @@ int waitconnect(int sockfd, /* socket */
     /* timeout, no connect today */
     return 1;
 
-  if(FD_ISSET(sockfd, &errfd)) {
+  if(FD_ISSET(sockfd, &errfd))
     /* error condition caught */
     return 2;
-  }
 
   /* we have a connect! */
   return 0;
@@ -380,6 +379,11 @@ CURLcode Curl_is_connected(struct connectdata *conn,
       return CURLE_OPERATION_TIMEOUTED;
     }
   }
+  if(conn->bits.tcpconnect) {
+    /* we are connected already! */
+    *connected = TRUE;
+    return CURLE_OK;
+  }
 
   /* check for connect without timeout as we want to return immediately */
   rc = waitconnect(sockfd, 0);
@@ -646,6 +650,15 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
       }
     }
 
+    /* The '1 == rc' comes from the waitconnect(), and not from connect().
+       We can be sure of this since connect() cannot return 1. */
+    if((1 == rc) && (data->state.used_interface == Curl_if_multi)) {
+      /* Timeout when running the multi interface, we return here with a
+         CURLE_OK return code. */
+      rc = 0;
+      break;
+    }
+
     if(0 == rc) {
       int err = socketerror(sockfd);
       if ((0 == err) || (EISCONN == err)) {
@@ -658,12 +671,6 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
     }
 
     if(0 != rc) {
-      if(data->state.used_interface == Curl_if_multi) {
-        /* When running the multi interface, we bail out here */
-        rc = 0;
-        break;
-      }
-
       /* get a new timeout for next attempt */
       after = Curl_tvnow();
       timeout_ms -= Curl_tvdiff(after, before);
diff --git a/Source/CTest/Curl/curl/curl.h b/Source/CTest/Curl/curl/curl.h
index c56c965..689b585 100644
--- a/Source/CTest/Curl/curl/curl.h
+++ b/Source/CTest/Curl/curl/curl.h
@@ -66,9 +66,9 @@ struct curl_httppost {
   char *contents; /* pointer to allocated data contents */
   long contentslength; /* length of contents field */
 
-        /* CMC: Added support for buffer uploads */
-        char *buffer; /* pointer to allocated buffer contents */
-        long bufferlength; /* length of buffer field */
+  /* CMC: Added support for buffer uploads */
+  char *buffer; /* pointer to allocated buffer contents */
+  long bufferlength; /* length of buffer field */
 
   char *contenttype; /* Content-Type */
   struct curl_slist* contentheader; /* list of extra headers for this form */
@@ -96,7 +96,9 @@ typedef int (*curl_progress_callback)(void *clientp,
                                       double ultotal,
                                       double ulnow);
 
-#define CURL_MAX_WRITE_SIZE 20480
+  /* Tests have proven that 20K is a very bad buffer size for uploads on
+     Windows, while 16K for some odd reason performed a lot better. */
+#define CURL_MAX_WRITE_SIZE 16384
 
 typedef size_t (*curl_write_callback)(char *buffer,
                                       size_t size,
@@ -160,7 +162,7 @@ typedef enum {
   CURLE_FTP_COULDNT_RETR_FILE,   /* 19 */
   CURLE_FTP_WRITE_ERROR,         /* 20 */
   CURLE_FTP_QUOTE_ERROR,         /* 21 */
-  CURLE_HTTP_NOT_FOUND,          /* 22 */
+  CURLE_HTTP_RETURNED_ERROR,     /* 22 */
   CURLE_WRITE_ERROR,             /* 23 */
   CURLE_MALFORMAT_USER,          /* 24 - user name is illegally specified */
   CURLE_FTP_COULDNT_STOR_FILE,   /* 25 - failed FTP upload */
@@ -207,6 +209,7 @@ typedef enum {
 
 /* Make a spelling correction for the operation timed-out define */
 #define CURLE_OPERATION_TIMEDOUT CURLE_OPERATION_TIMEOUTED
+#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
 
 typedef enum {
   CURLPROXY_HTTP = 0,
@@ -610,6 +613,11 @@ typedef enum {
      the response to be compressed. */
   CINIT(ENCODING, OBJECTPOINT, 102),
  
+  /* Set pointer to private data */
+  CINIT(PRIVATE, OBJECTPOINT, 103),
+
+  /* Set aliases for HTTP 200 in the HTTP Response header */
+  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
 
   CURLOPT_LASTENTRY /* the last unused */
 } CURLoption;
@@ -803,8 +811,8 @@ CURLcode curl_global_init(long flags);
 void curl_global_cleanup(void);
 
 /* This is the version number */
-#define LIBCURL_VERSION "7.10.2"
-#define LIBCURL_VERSION_NUM 0x070a02
+#define LIBCURL_VERSION "7.10.3"
+#define LIBCURL_VERSION_NUM 0x070a03
 
 /* linked-list structure for the CURLOPT_QUOTE option (and other) */
 struct curl_slist {
@@ -861,16 +869,13 @@ typedef enum {
   CURLINFO_REDIRECT_TIME   = CURLINFO_DOUBLE + 19,
   CURLINFO_REDIRECT_COUNT  = CURLINFO_LONG + 20,
 
+  CURLINFO_PRIVATE = CURLINFO_STRING + 21,
+
   /* Fill in new entries here! */
 
-  CURLINFO_LASTONE          = 21
+  CURLINFO_LASTONE          = 22
 } CURLINFO;
 
-/* unfortunately, the easy.h and multi.h include files need options and info
-  stuff before they can be included! */
-#include "easy.h" /* nothing in curl is fun without the easy stuff */
-#include "multi.h"
-
 typedef enum {
   CURLCLOSEPOLICY_NONE, /* first, never use this */
 
@@ -894,35 +899,56 @@ typedef enum {
  * Setup defines, protos etc for the sharing stuff.
  */
 
-/* Different types of locks that a share can aquire */
+/* Different data locks for a single share */
 typedef enum {
-  CURL_LOCK_TYPE_NONE = 0,
-  CURL_LOCK_TYPE_COOKIE = 1<<0,
-  CURL_LOCK_TYPE_DNS = 1<<1,
-  CURL_LOCK_TYPE_SSL_SESSION = 2<<1,
-  CURL_LOCK_TYPE_CONNECT = 2<<2,
-  CURL_LOCK_TYPE_LAST
-} curl_lock_type;
+  CURL_LOCK_DATA_NONE = 0,
+  CURL_LOCK_DATA_COOKIE = 1,
+  CURL_LOCK_DATA_DNS = 2,
+  CURL_LOCK_DATA_SSL_SESSION = 3,
+  CURL_LOCK_DATA_CONNECT = 4,
+  CURL_LOCK_DATA_LAST
+} curl_lock_data;
+
+/* Different lock access types */
+typedef enum {
+  CURL_LOCK_ACCESS_NONE = 0,   /* unspecified action */
+  CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
+  CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
+  CURL_LOCK_ACCESS_LAST        /* never use */
+} curl_lock_access;
+
+typedef void (*curl_lock_function)(CURL *handle,
+                                   curl_lock_data data,
+                                   curl_lock_access access,
+                                   void *userptr);
+typedef void (*curl_unlock_function)(CURL *handle,
+                                     curl_lock_data data,
+                                     void *userptr);
+
+typedef void CURLSH;
 
-typedef void (*curl_lock_function)(CURL *, curl_lock_type, void *);
-typedef void (*curl_unlock_function)(CURL *, curl_lock_type, void *);
+typedef enum {
+  CURLSHE_OK,  /* all is fine */
+  CURLSHE_BAD_OPTION, /* 1 */
+  CURLSHE_IN_USE,     /* 2 */
+  CURLSHE_INVALID,    /* 3 */
+  CURLSHE_LAST /* never use */
+} CURLSHcode;
 
-typedef struct {
-  unsigned int specifier;
-  unsigned int locked;
-  unsigned int dirty;
-  
-  curl_lock_function lockfunc;
-  curl_unlock_function unlockfunc;
-  void *clientdata;
-} curl_share;
-
-curl_share *curl_share_init (void);
-CURLcode curl_share_setopt (curl_share *, curl_lock_type, int);
-CURLcode curl_share_set_lock_function (curl_share *, curl_lock_function);
-CURLcode curl_share_set_unlock_function (curl_share *, curl_unlock_function);
-CURLcode curl_share_set_lock_data (curl_share *, void *);
-CURLcode curl_share_destroy (curl_share *);
+typedef enum {
+  CURLSHOPT_NONE,  /* don't use */
+  CURLSHOPT_SHARE,   /* specify a data type to share */
+  CURLSHOPT_UNSHARE, /* specify shich data type to stop sharing */
+  CURLSHOPT_LOCKFUNC,   /* pass in a 'curl_lock_function' pointer */
+  CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
+  CURLSHOPT_USERDATA,   /* pass in a user data pointer used in the lock/unlock
+                           callback functions */
+  CURLSHOPT_LAST  /* never use */
+} CURLSHoption;
+
+CURLSH *curl_share_init(void);
+CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
+CURLSHcode curl_share_cleanup(CURLSH *);
 
 /****************************************************************************
  * Structures for querying information about the curl library at runtime.
@@ -965,4 +991,9 @@ curl_version_info_data *curl_version_info(CURLversion);
 }
 #endif
 
+/* unfortunately, the easy.h and multi.h include files need options and info
+  stuff before they can be included! */
+#include "easy.h" /* nothing in curl is fun without the easy stuff */
+#include "multi.h"
+
 #endif /* __CURL_CURL_H */
diff --git a/Source/CTest/Curl/easy.c b/Source/CTest/Curl/easy.c
index b128180..145db5a 100644
--- a/Source/CTest/Curl/easy.c
+++ b/Source/CTest/Curl/easy.c
@@ -233,15 +233,17 @@ CURLcode curl_easy_perform(CURL *curl)
 {
   struct SessionHandle *data = (struct SessionHandle *)curl;
 
-  if (!data->hostcache) {
-    if (Curl_global_host_cache_use(data)) {
-      data->hostcache = Curl_global_host_cache_get();
-    }
-    else {
-      data->hostcache = Curl_hash_alloc(7, Curl_freeaddrinfo);
+  if (Curl_global_host_cache_use(data) && data->hostcache != Curl_global_host_cache_get()) {
+    if (data->hostcache) {
+      Curl_hash_destroy(data->hostcache);
     }
+    data->hostcache = Curl_global_host_cache_get();
   }
 
+  if (!data->hostcache) {
+    data->hostcache = Curl_hash_alloc(7, Curl_freednsinfo);
+  }
+  
   return Curl_perform(data);
 }
 
diff --git a/Source/CTest/Curl/escape.c b/Source/CTest/Curl/escape.c
index 0ec7ae5..b35333d 100644
--- a/Source/CTest/Curl/escape.c
+++ b/Source/CTest/Curl/escape.c
@@ -41,6 +41,7 @@ char *curl_escape(const char *string, int length)
 {
   int alloc = (length?length:(int)strlen(string))+1;  
   char *ns = malloc(alloc);
+  char *testing_ptr = NULL;
   unsigned char in;
   int newlen = alloc;
   int index=0;
@@ -55,9 +56,14 @@ char *curl_escape(const char *string, int length)
       newlen += 2; /* the size grows with two, since this'll become a %XX */
       if(newlen > alloc) {
         alloc *= 2;
-        ns = realloc(ns, alloc);
-        if(!ns)
+        testing_ptr = realloc(ns, alloc);
+        if(!testing_ptr) {
+          free( ns );
           return NULL;
+        }
+        else {
+          ns = testing_ptr;
+        }
       }
       sprintf(&ns[index], "%%%02X", in);
 
@@ -80,6 +86,10 @@ char *curl_unescape(const char *string, int length)
   unsigned char in;
   int index=0;
   unsigned int hex;
+ 
+  if( !ns ) {
+    return NULL;
+  }  
   
   while(--alloc > 0) {
     in = *string;
@@ -97,7 +107,6 @@ char *curl_unescape(const char *string, int length)
   }
   ns[index]=0; /* terminate it */
   return ns;
-  
 }
 
 void curl_free(void *p)
diff --git a/Source/CTest/Curl/formdata.c b/Source/CTest/Curl/formdata.c
index b3503f3..15cbea0 100644
--- a/Source/CTest/Curl/formdata.c
+++ b/Source/CTest/Curl/formdata.c
@@ -1319,7 +1319,7 @@ int Curl_FormReader(char *buffer,
   wantedsize = size * nitems;
 
   if(!form->data)
-    return -1; /* nothing, error, empty */
+    return 0; /* nothing, error, empty */
 
   do {
   
diff --git a/Source/CTest/Curl/ftp.c b/Source/CTest/Curl/ftp.c
index ac5f841..9d4af81 100644
--- a/Source/CTest/Curl/ftp.c
+++ b/Source/CTest/Curl/ftp.c
@@ -173,9 +173,9 @@ static CURLcode AllowServerConnect(struct SessionHandle *data,
  * response and extract the relevant return code for the invoking function.
  */
 
-int Curl_GetFTPResponse(char *buf,
-                        struct connectdata *conn,
-                        int *ftpcode)
+CURLcode Curl_GetFTPResponse(int *nreadp, /* return number of bytes read */
+                             struct connectdata *conn,
+                             int *ftpcode) /* return the ftp-code */
 {
   /* Brand new implementation.
    * We cannot read just one byte per read() and then go back to select()
@@ -185,28 +185,21 @@ int Curl_GetFTPResponse(char *buf,
    * line in a response or continue reading.  */
 
   int sockfd = conn->firstsocket;
-  int nread;   /* total size read */
   int perline; /* count bytes per line */
   bool keepon=TRUE;
   ssize_t gotbytes;
   char *ptr;
-  int timeout = 3600; /* default timeout in seconds */
+  int timeout;              /* timeout in seconds */
   struct timeval interval;
   fd_set rkeepfd;
   fd_set readfd;
   struct SessionHandle *data = conn->data;
   char *line_start;
-  int code=0; /* default "error code" to return */
-
-#define SELECT_OK       0
-#define SELECT_ERROR    1 /* select() problems */
-#define SELECT_TIMEOUT  2 /* took too long */
-#define SELECT_MEMORY   3 /* no available memory */
-#define SELECT_CALLBACK 4 /* aborted by callback */
-
-  int error = SELECT_OK;
-
+  int code=0; /* default ftp "error code" to return */
+  char *buf = data->state.buffer;
+  CURLcode result = CURLE_OK;
   struct FTP *ftp = conn->proto.ftp;
+  struct timeval now = Curl_tvnow();
 
   if (ftpcode)
     *ftpcode = 0; /* 0 for errors */
@@ -221,20 +214,25 @@ int Curl_GetFTPResponse(char *buf,
   ptr=buf;
   line_start = buf;
 
-  nread=0;
+  *nreadp=0;
   perline=0;
   keepon=TRUE;
 
-  while((nread<BUFSIZE) && (keepon && !error)) {
+  while((*nreadp<BUFSIZE) && (keepon && !result)) {
     /* check and reset timeout value every lap */
-    if(data->set.timeout) {
+    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 */
-      }
+    else
+      /* Even without a requested timeout, we only wait response_time
+         seconds for the full response to arrive before we bail out */
+      timeout = ftp->response_time -
+        Curl_tvdiff(Curl_tvnow(), now)/1000; /* spent time */
+
+    if(timeout <=0 ) {
+      failf(data, "Transfer aborted due to timeout");
+      return CURLE_OPERATION_TIMEDOUT; /* already too little time */
     }
 
     if(!ftp->cache) {
@@ -244,19 +242,18 @@ int Curl_GetFTPResponse(char *buf,
 
       switch (select (sockfd+1, &readfd, NULL, NULL, &interval)) {
       case -1: /* select() error, stop reading */
-        error = SELECT_ERROR;
-        failf(data, "Transfer aborted due to select() error");
+        result = CURLE_RECV_ERROR;
+        failf(data, "Transfer aborted due to select() error: %d", errno);
         break;
       case 0: /* timeout */
-        error = SELECT_TIMEOUT;
+        result = CURLE_OPERATION_TIMEDOUT;
         failf(data, "Transfer aborted due to timeout");
         break;
       default:
-        error = SELECT_OK;
         break;
       }
     }
-    if(SELECT_OK == error) {
+    if(CURLE_OK == result) {
       /*
        * This code previously didn't use the kerberos sec_read() code
        * to read, but when we use Curl_read() it may do so. Do confirm
@@ -272,8 +269,7 @@ int Curl_GetFTPResponse(char *buf,
         ftp->cache_size = 0; /* zero the size just in case */
       }
       else {
-        int res = Curl_read(conn, sockfd, ptr,
-                            BUFSIZE-nread, &gotbytes);
+        int res = Curl_read(conn, sockfd, ptr, BUFSIZE-*nreadp, &gotbytes);
         if(res < 0)
           /* EWOULDBLOCK */
           continue; /* go looping again */
@@ -286,7 +282,7 @@ int Curl_GetFTPResponse(char *buf,
         ;
       else if(gotbytes <= 0) {
         keepon = FALSE;
-        error = SELECT_ERROR;
+        result = CURLE_RECV_ERROR;
         failf(data, "Connection aborted");
       }
       else {
@@ -295,7 +291,7 @@ int Curl_GetFTPResponse(char *buf,
          * line */
         int i;
 
-        nread += gotbytes;
+        *nreadp += gotbytes;
         for(i = 0; i < gotbytes; ptr++, i++) {
           perline++;
           if(*ptr=='\n') {
@@ -315,7 +311,7 @@ int Curl_GetFTPResponse(char *buf,
             result = Curl_client_write(data, CLIENTWRITE_HEADER,
                                        line_start, perline);
             if(result)
-              return -SELECT_CALLBACK;
+              return result;
                                        
 #define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
                         isdigit((int)line[2]) && (' ' == line[3]))
@@ -350,13 +346,13 @@ int Curl_GetFTPResponse(char *buf,
           if(ftp->cache)
             memcpy(ftp->cache, line_start, ftp->cache_size);
           else
-            return -SELECT_MEMORY; /**BANG**/
+            return CURLE_OUT_OF_MEMORY; /**BANG**/
         }
       } /* there was data */
     } /* if(no error) */
   } /* while there's buffer left and loop is requested */
 
-  if(!error)
+  if(!result)
     code = atoi(buf);
 
 #ifdef KRB4
@@ -378,13 +374,10 @@ int Curl_GetFTPResponse(char *buf,
   }
 #endif
 
-  if(error)
-    return -error;
-
   if(ftpcode)
     *ftpcode=code; /* return the initial number like this */
 
-  return nread; /* total amount of bytes read */
+  return result;
 }
 
 /*
@@ -417,6 +410,7 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
   /* no need to duplicate them, the data struct won't change */
   ftp->user = data->state.user;
   ftp->passwd = data->state.passwd;
+  ftp->response_time = 3600; /* set default response time-out */
 
   if (data->set.tunnel_thru_httpproxy) {
     /* We want "seamless" FTP operations through HTTP proxy tunnel */
@@ -436,9 +430,9 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
 
 
   /* The first thing we do is wait for the "220*" line: */
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
   if(ftpcode != 220) {
     failf(data, "This doesn't seem like a nice ftp-server response");
@@ -467,9 +461,9 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
   FTPSENDF(conn, "USER %s", ftp->user);
 
   /* wait for feedback */
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
   if(ftpcode == 530) {
     /* 530 User ... access denied
@@ -481,9 +475,9 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
     /* 331 Password required for ...
        (the server requires to send the user's password too) */
     FTPSENDF(conn, "PASS %s", ftp->passwd);
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+    if(result)
+      return result;
 
     if(ftpcode == 530) {
       /* 530 Login incorrect.
@@ -516,8 +510,11 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
     /* we may need to issue a KAUTH here to have access to the files
      * do it if user supplied a password
      */
-    if(data->state.passwd && *data->state.passwd)
-      Curl_krb_kauth(conn);
+    if(data->state.passwd && *data->state.passwd) {
+      result = Curl_krb_kauth(conn);
+      if(result)
+        return result;
+    }
 #endif
   }
   else {
@@ -529,9 +526,9 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
   FTPSENDF(conn, "PWD", NULL);
 
   /* wait for feedback */
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
   if(ftpcode == 257) {
     char *dir = (char *)malloc(nread+1);
@@ -544,7 +541,7 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
        The directory name can contain any character; embedded double-quotes
        should be escaped by double-quotes (the "quote-doubling" convention).
     */
-    if('\"' == *ptr) {
+    if(dir && ('\"' == *ptr)) {
       /* it started good */
       ptr++;
       while(ptr && *ptr) {
@@ -570,6 +567,8 @@ CURLcode Curl_ftp_connect(struct connectdata *conn)
     }
     else {
       /* couldn't get the path */
+      free(dir);
+      infof(data, "Failed to figure out path\n");
     }
 
   }
@@ -594,7 +593,6 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
   struct SessionHandle *data = conn->data;
   struct FTP *ftp = conn->proto.ftp;
   ssize_t nread;
-  char *buf = data->state.buffer; /* this is our buffer */
   int ftpcode;
   CURLcode result=CURLE_OK;
 
@@ -633,11 +631,24 @@ CURLcode Curl_ftp_done(struct connectdata *conn)
   conn->secondarysocket = -1;
 
   if(!ftp->no_transfer) {
-    /* now let's see what the server says about the transfer we just
-       performed: */
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    /* Let's see what the server says about the transfer we just performed,
+       but lower the timeout as sometimes this connection has died while 
+       the data has been transfered. This happens when doing through NATs
+       etc that abandon old silent connections.
+    */
+    ftp->response_time = 60; /* give it only a minute for now */
+
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+
+    ftp->response_time = 3600; /* set this back to one hour waits */
+  
+    if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) {
+      failf(data, "control connection looks dead");
+      return result;
+    }
+
+    if(result)
+      return result;
 
     if(!ftp->dont_check) {
       /* 226 Transfer complete, 250 Requested file action okay, completed. */
@@ -680,9 +691,9 @@ CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
     if (item->data) {
       FTPSENDF(conn, "%s", item->data);
 
-      nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
-      if (nread < 0)
-        return CURLE_OPERATION_TIMEOUTED;
+      result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+      if (result)
+        return result;
 
       if (ftpcode >= 400) {
         failf(conn->data, "QUOT string not accepted: %s", item->data);
@@ -711,9 +722,9 @@ CURLcode ftp_cwd(struct connectdata *conn, char *path)
   CURLcode result;
   
   FTPSENDF(conn, "CWD %s", path);
-  nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
-  if (nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if (result)
+    return result;
 
   if (ftpcode != 250) {
     failf(conn->data, "Couldn't cd to %s", path);
@@ -741,26 +752,34 @@ CURLcode ftp_getfiletime(struct connectdata *conn, char *file)
      again a grey area as the MDTM is not kosher RFC959 */
   FTPSENDF(conn, "MDTM %s", file);
 
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
-  if(ftpcode == 213) {
-    /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
-       last .sss part is optional and means fractions of a second */
-    int year, month, day, hour, minute, second;
-    if(6 == sscanf(buf+4, "%04d%02d%02d%02d%02d%02d",
-                   &year, &month, &day, &hour, &minute, &second)) {
-      /* we have a time, reformat it */
-      time_t secs=time(NULL);
-      sprintf(buf, "%04d%02d%02d %02d:%02d:%02d",
-              year, month, day, hour, minute, second);
-      /* now, convert this into a time() value: */
-      conn->data->info.filetime = curl_getdate(buf, &secs);
-    }
-    else {
-      infof(conn->data, "unsupported MDTM reply format\n");
+  switch(ftpcode) {
+  case 213:
+    {
+      /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
+         last .sss part is optional and means fractions of a second */
+      int year, month, day, hour, minute, second;
+      if(6 == sscanf(buf+4, "%04d%02d%02d%02d%02d%02d",
+                     &year, &month, &day, &hour, &minute, &second)) {
+        /* we have a time, reformat it */
+        time_t secs=time(NULL);
+        sprintf(buf, "%04d%02d%02d %02d:%02d:%02d",
+                year, month, day, hour, minute, second);
+        /* now, convert this into a time() value: */
+        conn->data->info.filetime = curl_getdate(buf, &secs);
+      }
     }
+    break;
+  default:
+    infof(conn->data, "unsupported MDTM reply format\n");
+    break;
+  case 550: /* "No such file or directory" */
+    failf(conn->data, "Given file does not exist");
+    result = CURLE_FTP_COULDNT_RETR_FILE;
+    break;
   }
   return  result;
 }
@@ -778,14 +797,13 @@ static CURLcode ftp_transfertype(struct connectdata *conn,
   struct SessionHandle *data = conn->data;
   int ftpcode;
   ssize_t nread;
-  char *buf=data->state.buffer;
   CURLcode result;
 
   FTPSENDF(conn, "TYPE %s", ascii?"A":"I");
 
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
   
   if(ftpcode != 200) {
     failf(data, "Couldn't set %s mode",
@@ -814,9 +832,9 @@ CURLcode ftp_getsize(struct connectdata *conn, char *file,
   CURLcode result;
 
   FTPSENDF(conn, "SIZE %s", file);
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
   if(ftpcode == 213) {
     /* get the size from the ascii string: */
@@ -975,7 +993,6 @@ CURLcode ftp_use_port(struct connectdata *conn)
   struct SessionHandle *data=conn->data;
   int portsock=-1;
   ssize_t nread;
-  char *buf = data->state.buffer; /* this is our buffer */
   int ftpcode; /* receive FTP response codes in this */
   CURLcode result;
 
@@ -1155,9 +1172,9 @@ CURLcode ftp_use_port(struct connectdata *conn)
         return result;
     }
     
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+    if(result)
+      return result;
     
     if (ftpcode != 200) {
       failf(data, "Server does not grok %s", *modep);
@@ -1301,9 +1318,9 @@ CURLcode ftp_use_port(struct connectdata *conn)
       return result;
   }
 
-  nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-  if(nread < 0)
-    return CURLE_OPERATION_TIMEOUTED;
+  result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+  if(result)
+    return result;
 
   if(ftpcode != 200) {
     failf(data, "Server does not grok PORT, try without it!");
@@ -1375,9 +1392,9 @@ CURLcode ftp_use_pasv(struct connectdata *conn,
     result = Curl_ftpsendf(conn, "%s", mode[modeoff]);
     if(result)
       return result;
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+    if(result)
+      return result;
     if (ftpcode == results[modeoff])
       break;
   }
@@ -1522,7 +1539,7 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
   ssize_t nread;
   int ftpcode; /* for ftp status */
 
-  /* the ftp struct is already inited in ftp_connect() */
+  /* the ftp struct is already inited in Curl_ftp_connect() */
   struct FTP *ftp = conn->proto.ftp;
   long *bytecountp = ftp->bytecountp;
 
@@ -1582,8 +1599,8 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
             readthisamountnow = BUFSIZE;
 
           actuallyread =
-            data->set.fread(data->state.buffer, 1, readthisamountnow,
-                            data->set.in);
+            conn->fread(data->state.buffer, 1, readthisamountnow,
+                        conn->fread_in);
 
           passed += actuallyread;
           if(actuallyread != readthisamountnow) {
@@ -1614,7 +1631,7 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
       }
     }
 
-    /* Send everything on data->set.in to the socket */
+    /* Send everything on data->state.in to the socket */
     if(data->set.ftp_append) {
       /* we append onto the file instead of rewriting it */
       FTPSENDF(conn, "APPE %s", ftp->file);
@@ -1623,9 +1640,9 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
       FTPSENDF(conn, "STOR %s", ftp->file);
     }
 
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+    if(result)
+      return result;
 
     if(ftpcode>=400) {
       failf(data, "Failed FTP upload:%s", buf+3);
@@ -1799,9 +1816,9 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
 
         FTPSENDF(conn, "REST %d", conn->resume_from);
 
-        nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-        if(nread < 0)
-          return CURLE_OPERATION_TIMEOUTED;
+        result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+        if(result)
+          return result;
 
         if(ftpcode != 350) {
           failf(data, "Couldn't use REST: %s", buf+4);
@@ -1812,9 +1829,9 @@ CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
       FTPSENDF(conn, "RETR %s", ftp->file);
     }
 
-    nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
-    if(nread < 0)
-      return CURLE_OPERATION_TIMEOUTED;
+    result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
+    if(result)
+      return result;
 
     if((ftpcode == 150) || (ftpcode == 125)) {
 
@@ -1919,7 +1936,7 @@ CURLcode ftp_perform(struct connectdata *conn,
   struct SessionHandle *data=conn->data;
   char *buf = data->state.buffer; /* this is our buffer */
 
-  /* the ftp struct is already inited in ftp_connect() */
+  /* the ftp struct is already inited in Curl_ftp_connect() */
   struct FTP *ftp = conn->proto.ftp;
 
   /* Send any QUOTE strings? */
@@ -1980,7 +1997,7 @@ CURLcode ftp_perform(struct connectdata *conn,
        well, we "emulate" a HTTP-style header in our output. */
 
 #ifdef HAVE_STRFTIME
-    if(data->set.get_filetime && data->info.filetime) {
+    if(data->set.get_filetime && (data->info.filetime>=0) ) {
       struct tm *tm;
 #ifdef HAVE_LOCALTIME_R
       struct tm buffer;
diff --git a/Source/CTest/Curl/ftp.h b/Source/CTest/Curl/ftp.h
index 2f8c15a..60440db 100644
--- a/Source/CTest/Curl/ftp.h
+++ b/Source/CTest/Curl/ftp.h
@@ -29,8 +29,8 @@ CURLcode Curl_ftp_done(struct connectdata *conn);
 CURLcode Curl_ftp_connect(struct connectdata *conn);
 CURLcode Curl_ftp_disconnect(struct connectdata *conn);
 CURLcode Curl_ftpsendf(struct connectdata *, const char *fmt, ...);
-int Curl_GetFTPResponse(char *buf, struct connectdata *conn,
-                        int *ftpcode);
+CURLcode Curl_GetFTPResponse(int *nread, struct connectdata *conn,
+                             int *ftpcode);
 CURLcode Curl_ftp_nextconnect(struct connectdata *conn);
 #endif
 
diff --git a/Source/CTest/Curl/getinfo.c b/Source/CTest/Curl/getinfo.c
index 6639833..f8a4a10 100644
--- a/Source/CTest/Curl/getinfo.c
+++ b/Source/CTest/Curl/getinfo.c
@@ -158,6 +158,9 @@ CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...)
   case CURLINFO_CONTENT_TYPE:
     *param_charp = data->info.contenttype;
     break;
+  case CURLINFO_PRIVATE:
+    *param_charp = data->set.private?data->set.private:(char *)"";
+    break;
   default:
     return CURLE_BAD_FUNCTION_ARGUMENT;
   }
diff --git a/Source/CTest/Curl/hostip.c b/Source/CTest/Curl/hostip.c
index 07fb1d2..d79e832 100644
--- a/Source/CTest/Curl/hostip.c
+++ b/Source/CTest/Curl/hostip.c
@@ -88,7 +88,7 @@ static Curl_addrinfo *my_getaddrinfo(struct SessionHandle *data,
 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_freednsinfo);
     host_cache_initialized = 1;
   }
 }
@@ -287,17 +287,25 @@ struct Curl_dns_entry *Curl_resolv(struct SessionHandle *data,
 /*
  * This is a wrapper function for freeing name information in a protocol
  * independent way. This takes care of using the appropriate underlaying
- * proper function.
+ * function.
  */
-void Curl_freeaddrinfo(void *freethis)
+void Curl_freeaddrinfo(Curl_addrinfo *p)
 {
-  struct Curl_dns_entry *p = (struct Curl_dns_entry *) freethis;
-
 #ifdef ENABLE_IPV6
-  freeaddrinfo(p->addr);
+  freeaddrinfo(p);
 #else
-  free(p->addr);
+  free(p);
 #endif
+}
+
+/*
+ * Free a cache dns entry.
+ */
+void Curl_freednsinfo(void *freethis)
+{
+  struct Curl_dns_entry *p = (struct Curl_dns_entry *) freethis;
+
+  Curl_freeaddrinfo(p->addr);
 
   free(p);
 }
@@ -623,16 +631,28 @@ static Curl_addrinfo *my_getaddrinfo(struct SessionHandle *data,
                           &h, /* DIFFERENCE */
                           &h_errnop);
       /* Redhat 8, using glibc 2.2.93 changed the behavior. Now all of a
-         sudden this function seems to be setting EAGAIN if the given buffer
-         size is too small. Previous versions are known to return ERANGE for
-         the same. */
+         sudden this function returns EAGAIN if the given buffer size is too
+         small. Previous versions are known to return ERANGE for the same
+         problem.
+
+         This wouldn't be such a big problem if older versions wouldn't
+         sometimes return EAGAIN on a common failure case. Alas, we can't
+         assume that EAGAIN *or* ERANGE means ERANGE for any given version of
+         glibc.
+
+         For now, we do that and thus we may call the function repeatedly and
+         fail for older glibc versions that return EAGAIN, until we run out
+         of buffer size (step_size grows beyond CURL_NAMELOOKUP_SIZE).
+
+         If anyone has a better fix, please tell us!
+      */
 
       if((ERANGE == res) || (EAGAIN == res)) {
         step_size+=200;
         continue;
       }
       break;
-    } while(1);
+    } while(step_size <= CURL_NAMELOOKUP_SIZE);
 
     if(!h) /* failure */
       res=1;
diff --git a/Source/CTest/Curl/hostip.h b/Source/CTest/Curl/hostip.h
index 78a17e2..169ed17 100644
--- a/Source/CTest/Curl/hostip.h
+++ b/Source/CTest/Curl/hostip.h
@@ -65,7 +65,10 @@ struct Curl_dns_entry *Curl_resolv(struct SessionHandle *data,
 void Curl_scan_cache_used(void *user, void *ptr);
 
 /* free name info */
-void Curl_freeaddrinfo(void *freethis);
+void Curl_freeaddrinfo(Curl_addrinfo *freeaddr);
+
+/* free cached name info */
+void Curl_freednsinfo(void *freethis);
 
 #ifdef MALLOCDEBUG
 void curl_freeaddrinfo(struct addrinfo *freethis,
diff --git a/Source/CTest/Curl/http.c b/Source/CTest/Curl/http.c
index 24794e2..91ae720 100644
--- a/Source/CTest/Curl/http.c
+++ b/Source/CTest/Curl/http.c
@@ -98,12 +98,65 @@
 #include "memdebug.h"
 #endif
 
+/* fread() emulation to provide POST and/or request data */
+static int readmoredata(char *buffer,
+                        size_t size,
+                        size_t nitems,
+                        void *userp)
+{
+  struct connectdata *conn = (struct connectdata *)userp;
+  struct HTTP *http = conn->proto.http;
+  int fullsize = size * nitems;
+
+  if(0 == http->postsize)
+    /* nothing to return */
+    return 0;
+  
+  /* make sure that a HTTP request is never sent away chunked! */
+  conn->bits.forbidchunk= (http->sending == HTTPSEND_REQUEST)?TRUE:FALSE;
+
+  if(http->postsize <= fullsize) {
+    memcpy(buffer, http->postdata, http->postsize);
+    fullsize = http->postsize;
+
+    if(http->backup.postsize) {
+      /* move backup data into focus and continue on that */
+      http->postdata = http->backup.postdata;
+      http->postsize = http->backup.postsize;
+      conn->fread =    http->backup.fread;
+      conn->fread_in = http->backup.fread_in;
+
+      http->sending++; /* move one step up */
+
+      http->backup.postsize=0;
+    }
+    else
+      http->postsize = 0;
+
+    return fullsize;
+  }
+
+  memcpy(buffer, http->postdata, fullsize);
+  http->postdata += fullsize;
+  http->postsize -= fullsize;
+
+  return fullsize;
+}
+
 /* ------------------------------------------------------------------------- */
 /*
  * The add_buffer series of functions are used to build one large memory chunk
  * from repeated function invokes. Used so that the entire HTTP request can
  * be sent in one go.
  */
+
+struct send_buffer {
+  char *buffer;
+  size_t size_max;
+  size_t size_used;
+};
+typedef struct send_buffer send_buffer;
+
 static CURLcode
  add_buffer(send_buffer *in, const void *inptr, size_t size);
 
@@ -126,44 +179,66 @@ send_buffer *add_buffer_init(void)
  * add_buffer_send() sends a buffer and frees all associated memory.
  */
 static
-CURLcode add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in,
-                         long *bytes_written)
+CURLcode add_buffer_send(send_buffer *in,
+                         int sockfd,
+                         struct connectdata *conn,
+                         long *bytes_written) /* add the number of sent
+                                                 bytes to this counter */
 {
   ssize_t amount;
   CURLcode res;
   char *ptr;
   int size;
+  struct HTTP *http = conn->proto.http;
 
   /* The looping below is required since we use non-blocking sockets, but due
      to the circumstances we will just loop and try again and again etc */
 
   ptr = in->buffer;
   size = in->size_used;
-  do {
-    res = Curl_write(conn, sockfd, ptr, size, &amount);
 
-    if(CURLE_OK != res)
-      break;
+  res = Curl_write(conn, sockfd, ptr, size, &amount);
+
+  if(CURLE_OK == res) {
 
     if(conn->data->set.verbose)
       /* this data _may_ contain binary stuff */
       Curl_debug(conn->data, CURLINFO_HEADER_OUT, ptr, amount);
 
+    *bytes_written += amount;
+    
     if(amount != size) {
+      /* The whole request could not be sent in one system call. We must queue
+         it up and send it later when we get the chance. We must not loop here
+         and wait until it might work again. */
+
       size -= amount;
       ptr += amount;
+    
+      /* backup the currently set pointers */
+      http->backup.fread = conn->fread;
+      http->backup.fread_in = conn->fread_in;
+      http->backup.postdata = http->postdata;
+      http->backup.postsize = http->postsize;
+
+      /* set the new pointers for the request-sending */
+      conn->fread = (curl_read_callback)readmoredata;
+      conn->fread_in = (void *)conn;
+      http->postdata = ptr;
+      http->postsize = size;
+
+      http->send_buffer = in;
+      http->sending = HTTPSEND_REQUEST;
+      
+      return CURLE_OK;
     }
-    else
-      break;
-
-  } while(1);
 
+    /* the full buffer was sent, clean up and return */
+  }
   if(in->buffer)
     free(in->buffer);
   free(in);
 
-  *bytes_written += amount;
-
   return res;
 }
 
@@ -224,20 +299,74 @@ CURLcode add_buffer(send_buffer *in, const void *inptr, size_t size)
 /* ------------------------------------------------------------------------- */
 
 /*
+ * Curl_compareheader()
+ *
+ * Returns TRUE if 'headerline' contains the 'header' with given 'content'.
+ * Pass headers WITH the colon.
+ */
+bool
+Curl_compareheader(char *headerline,    /* line to check */
+                   const char *header,  /* header keyword _with_ colon */
+                   const char *content) /* content string to find */
+{
+  /* RFC2616, section 4.2 says: "Each header field consists of a name followed
+   * by a colon (":") and the field value. Field names are case-insensitive.
+   * The field value MAY be preceded by any amount of LWS, though a single SP
+   * is preferred." */
+
+  size_t hlen = strlen(header);
+  size_t clen;
+  size_t len;
+  char *start;
+  char *end;
+
+  if(!strnequal(headerline, header, hlen))
+    return FALSE; /* doesn't start with header */
+
+  /* pass the header */
+  start = &headerline[hlen];
+
+  /* pass all white spaces */
+  while(*start && isspace((int)*start))
+    start++;
+
+  /* find the end of the header line */
+  end = strchr(start, '\r'); /* lines end with CRLF */
+  if(!end) {
+    /* in case there's a non-standard compliant line here */
+    end = strchr(start, '\n');
+
+    if(!end)
+      /* hm, there's no line ending here, use the zero byte! */
+      end = strchr(start, '\0');
+  }
+
+  len = end-start; /* length of the content part of the input line */
+  clen = strlen(content); /* length of the word to find */
+
+  /* find the content string in the rest of the line */
+  for(;len>=clen;len--, start++) {
+    if(strnequal(start, content, clen))
+      return TRUE; /* match! */
+  }
+
+  return FALSE; /* no match */
+}
+
+/*
  * This function checks the linked list of custom HTTP headers for a particular
  * header (prefix).
  */
-static bool checkheaders(struct SessionHandle *data, const char *thisheader)
+static char *checkheaders(struct SessionHandle *data, const char *thisheader)
 {
   struct curl_slist *head;
   size_t thislen = strlen(thisheader);
 
   for(head = data->set.headers; head; head=head->next) {
-    if(strnequal(head->data, thisheader, thislen)) {
-      return TRUE;
-    }
+    if(strnequal(head->data, thisheader, thislen))
+      return head->data;
   }
-  return FALSE;
+  return NULL;
 }
 
 /*
@@ -440,6 +569,10 @@ CURLcode Curl_http_connect(struct connectdata *conn)
   if(conn->bits.user_passwd && !data->state.this_is_a_follow) {
     /* Authorization: is requested, this is not a followed location, get the
        original host name */
+    if (data->state.auth_host)
+      /* Free to avoid leaking memory on multiple requests*/
+      free(data->state.auth_host);
+
     data->state.auth_host = strdup(conn->hostname);
   }
 
@@ -454,13 +587,21 @@ CURLcode Curl_http_done(struct connectdata *conn)
   data=conn->data;
   http=conn->proto.http;
 
+  /* set the proper values (possibly modified on POST) */
+  conn->fread = data->set.fread; /* restore */
+  conn->fread_in = data->set.in; /* restore */
+
+  if(http->send_buffer) {
+    send_buffer *buff = http->send_buffer;
+    
+    free(buff->buffer);
+    free(buff);
+  }
+
   if(HTTPREQ_POST_FORM == data->set.httpreq) {
     conn->bytecount = http->readbytecount + http->writebytecount;
       
     Curl_formclean(http->sendit); /* Now free that whole lot */
-
-    data->set.fread = http->storefread; /* restore */
-    data->set.in = http->in; /* restore */
   }
   else if(HTTPREQ_PUT == data->set.httpreq)
     conn->bytecount = http->readbytecount + http->writebytecount;
@@ -475,7 +616,6 @@ CURLcode Curl_http_done(struct connectdata *conn)
   return CURLE_OK;
 }
 
-
 CURLcode Curl_http(struct connectdata *conn)
 {
   struct SessionHandle *data=conn->data;
@@ -523,7 +663,7 @@ CURLcode Curl_http(struct connectdata *conn)
        host due to a location-follow, we do some weirdo checks here */
     if(!data->state.this_is_a_follow ||
        !data->state.auth_host ||
-       strequal(data->state.auth_host, conn->hostname)) {
+       curl_strequal(data->state.auth_host, conn->hostname)) {
       sprintf(data->state.buffer, "%s:%s",
               data->state.user, data->state.passwd);
       if(Curl_base64_encode(data->state.buffer, strlen(data->state.buffer),
@@ -547,12 +687,30 @@ CURLcode Curl_http(struct connectdata *conn)
     conn->allocptr.cookie = aprintf("Cookie: %s\015\012", data->set.cookie);
   }
 
+  if(!conn->bits.upload_chunky && (data->set.httpreq != HTTPREQ_GET)) {
+    /* not a chunky transfer but data is to be sent */
+    char *ptr = checkheaders(data, "Transfer-Encoding:");
+    if(ptr) {
+      /* Some kind of TE is requested, check if 'chunked' is chosen */
+      if(Curl_compareheader(ptr, "Transfer-Encoding:", "chunked"))
+        /* we have been told explicitly to upload chunky so deal with it! */
+        conn->bits.upload_chunky = TRUE;
+    }
+  }
+
   if(conn->bits.upload_chunky) {
+    /* RFC2616 section 4.4:
+       Messages MUST NOT include both a Content-Length header field and a
+       non-identity transfer-coding. If the message does include a non-
+       identity transfer-coding, the Content-Length MUST be ignored. */
+
     if(!checkheaders(data, "Transfer-Encoding:")) {
       te = "Transfer-Encoding: chunked\r\n";
     }
-    /* else
-       our header was already added, what to do now? */
+    else {
+      /* The "Transfer-Encoding:" header was already added. */
+      te = "";
+    }
   }
 
   if(data->cookies) {
@@ -847,16 +1005,16 @@ CURLcode Curl_http(struct connectdata *conn)
         return CURLE_HTTP_POST_ERROR;
       }
 
-      http->storefread = data->set.fread; /* backup */
-      http->in = data->set.in; /* backup */
-          
-      data->set.fread = (curl_read_callback)
-        Curl_FormReader; /* set the read function to read from the
-                            generated form data */
-      data->set.in = (FILE *)&http->form;
+      /* set the read function to read from the generated form data */
+      conn->fread = (curl_read_callback)Curl_FormReader;
+      conn->fread_in = &http->form;
 
-      add_bufferf(req_buffer,
-                  "Content-Length: %d\r\n", http->postsize);
+      http->sending = HTTPSEND_BODY;
+
+      if(!conn->bits.upload_chunky)
+        /* only add Content-Length if not uploading chunked */
+        add_bufferf(req_buffer,
+                    "Content-Length: %d\r\n", http->postsize);
 
       if(!checkheaders(data, "Expect:")) {
         /* if not disabled explicitly we add a Expect: 100-continue
@@ -896,7 +1054,7 @@ CURLcode Curl_http(struct connectdata *conn)
       Curl_pgrsSetUploadSize(data, http->postsize);
 
       /* fire away the whole request to the server */
-      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+      result = add_buffer_send(req_buffer, conn->firstsocket, conn, 
                                &data->info.request_size);
       if(result)
         failf(data, "Failed sending POST request");
@@ -914,22 +1072,22 @@ CURLcode Curl_http(struct connectdata *conn)
 
     case HTTPREQ_PUT: /* Let's PUT the data to the server! */
 
-      if(data->set.infilesize>0) {
+      if((data->set.infilesize>0) && !conn->bits.upload_chunky)
+        /* only add Content-Length if not uploading chunked */
         add_bufferf(req_buffer,
-                    "Content-Length: %d\r\n\r\n", /* file size */
+                    "Content-Length: %d\r\n", /* file size */
                     data->set.infilesize );
-      }
-      else
-        add_bufferf(req_buffer, "\015\012");
+
+      add_bufferf(req_buffer, "\r\n");
 
       /* set the upload size to the progress meter */
       Curl_pgrsSetUploadSize(data, data->set.infilesize);
 
       /* this sends the buffer and frees all the buffer resources */
-      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+      result = add_buffer_send(req_buffer, conn->firstsocket, conn,
                                &data->info.request_size);
       if(result)
-        failf(data, "Faied sending POST request");
+        failf(data, "Failed sending POST request");
       else
         /* prepare for transfer */
         result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
@@ -943,14 +1101,20 @@ CURLcode Curl_http(struct connectdata *conn)
     case HTTPREQ_POST:
       /* this is the simple POST, using x-www-form-urlencoded style */
 
-      if(!checkheaders(data, "Content-Length:"))
-        /* we allow replacing this header, although it isn't very wise to
-           actually set your own */
-        add_bufferf(req_buffer,
-                    "Content-Length: %d\r\n",
-                    data->set.postfieldsize?
-                    data->set.postfieldsize:
-                    (data->set.postfields?strlen(data->set.postfields):0) );
+      if(!conn->bits.upload_chunky) {
+        /* We only set Content-Length and allow a custom Content-Length if
+           we don't upload data chunked, as RFC2616 forbids us to set both
+           kinds of headers (Transfer-Encoding: chunked and Content-Length) */
+
+        if(!checkheaders(data, "Content-Length:"))
+          /* we allow replacing this header, although it isn't very wise to
+             actually set your own */
+          add_bufferf(req_buffer,
+                      "Content-Length: %d\r\n",
+                      data->set.postfieldsize?
+                      data->set.postfieldsize:
+                      (data->set.postfields?strlen(data->set.postfields):0) );
+      }
 
       if(!checkheaders(data, "Content-Type:"))
         add_bufferf(req_buffer,
@@ -958,18 +1122,28 @@ CURLcode Curl_http(struct connectdata *conn)
 
       add_buffer(req_buffer, "\r\n", 2);
 
-      /* and here comes the actual data */
-      if(data->set.postfieldsize && data->set.postfields) {
-        add_buffer(req_buffer, data->set.postfields,
-                   data->set.postfieldsize);
+      /* and here we setup the pointers to the actual data */
+      if(data->set.postfields) {
+        if(data->set.postfieldsize)
+          http->postsize = data->set.postfieldsize;
+        else
+          http->postsize = strlen(data->set.postfields);
+        http->postdata = data->set.postfields;
+
+        http->sending = HTTPSEND_BODY;
+
+        conn->fread = (curl_read_callback)readmoredata;
+        conn->fread_in = (void *)conn;
+
+        /* set the upload size to the progress meter */
+        Curl_pgrsSetUploadSize(data, http->postsize);
       }
-      else if(data->set.postfields)
-        add_bufferf(req_buffer,
-                    "%s",
-                    data->set.postfields );
+      else
+        /* set the upload size to the progress meter */
+        Curl_pgrsSetUploadSize(data, data->set.infilesize);
 
-      /* issue the request */
-      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+      /* issue the request, headers-only */
+      result = add_buffer_send(req_buffer, conn->firstsocket, conn,
                                &data->info.request_size);
 
       if(result)
@@ -978,15 +1152,15 @@ CURLcode Curl_http(struct connectdata *conn)
         result =
           Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
                         &http->readbytecount,
-                        data->set.postfields?-1:conn->firstsocket,
-                        data->set.postfields?NULL:&http->writebytecount);
+                        conn->firstsocket,
+                        &http->writebytecount);
       break;
 
     default:
       add_buffer(req_buffer, "\r\n", 2);
       
       /* issue the request */
-      result = add_buffer_send(conn->firstsocket, conn, req_buffer,
+      result = add_buffer_send(req_buffer, conn->firstsocket, conn,
                                &data->info.request_size);
 
       if(result)
@@ -995,7 +1169,8 @@ CURLcode Curl_http(struct connectdata *conn)
         /* HTTP GET/HEAD download: */
         result = Curl_Transfer(conn, conn->firstsocket, -1, TRUE,
                                &http->readbytecount,
-                               -1, NULL); /* nothing to upload */
+                               http->postdata?conn->firstsocket:-1,
+                               http->postdata?&http->writebytecount:NULL);
     }
     if(result)
       return result;
diff --git a/Source/CTest/Curl/http.h b/Source/CTest/Curl/http.h
index d78322c..2f40ea1 100644
--- a/Source/CTest/Curl/http.h
+++ b/Source/CTest/Curl/http.h
@@ -24,6 +24,10 @@
  * $Id$
  ***************************************************************************/
 #ifndef CURL_DISABLE_HTTP
+bool Curl_compareheader(char *headerline,     /* line to check */
+                        const char *header,   /* header keyword _with_ colon */
+                        const char *content); /* content string to find */
+
 /* ftp can use this as well */
 CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn,
                                      int tunnelsocket,
diff --git a/Source/CTest/Curl/if2ip.h b/Source/CTest/Curl/if2ip.h
index 2be0ea5..3cb0a46 100644
--- a/Source/CTest/Curl/if2ip.h
+++ b/Source/CTest/Curl/if2ip.h
@@ -29,5 +29,40 @@ extern char *Curl_if2ip(char *interface, char *buf, int buf_size);
 #else
 #define Curl_if2ip(a,b,c) NULL
 #endif
+#ifdef __INTERIX
+/* Nedelcho Stanev's work-around for SFU 3.0 */
+struct ifreq {
+#define IFNAMSIZ 16
+#define IFHWADDRLEN 6
+  union {
+    char ifrn_name[IFNAMSIZ]; /* if name, e.g. "en0" */
+  } ifr_ifrn;
+
+ union {
+   struct sockaddr ifru_addr;
+   struct sockaddr ifru_broadaddr;
+   struct sockaddr ifru_netmask;
+   struct sockaddr ifru_hwaddr;
+   short ifru_flags;
+   int ifru_metric;
+   int ifru_mtu;
+ } ifr_ifru;
+};
+
+/* This define was added by Daniel to avoid an extra #ifdef INTERIX in the
+   C code. */
+#define ifr_dstaddr ifr_addr
+
+#define ifr_name ifr_ifrn.ifrn_name /* interface name */
+#define ifr_addr ifr_ifru.ifru_addr /* address */
+#define ifr_broadaddr ifr_ifru.ifru_broadaddr /* broadcast address */
+#define ifr_netmask ifr_ifru.ifru_netmask /* interface net mask */
+#define ifr_flags ifr_ifru.ifru_flags /* flags */
+#define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */
+#define ifr_metric ifr_ifru.ifru_metric /* metric */
+#define ifr_mtu ifr_ifru.ifru_mtu /* mtu */
+
+#define SIOCGIFADDR _IOW('s', 102, struct ifreq) /* Get if addr */ 
+#endif /* interix */
 
 #endif
diff --git a/Source/CTest/Curl/krb4.c b/Source/CTest/Curl/krb4.c
index ab38d30..af8fc87 100644
--- a/Source/CTest/Curl/krb4.c
+++ b/Source/CTest/Curl/krb4.c
@@ -202,6 +202,7 @@ krb4_auth(void *app_data, struct connectdata *conn)
   ssize_t nread;
   int l = sizeof(conn->local_addr);
   struct SessionHandle *data = conn->data;
+  CURLcode result;
 
   if(getsockname(conn->firstsocket,
                  (struct sockaddr *)LOCAL_ADDR, &l) < 0)
@@ -246,13 +247,15 @@ krb4_auth(void *app_data, struct connectdata *conn)
     return AUTH_CONTINUE;
   }
 
-  if(Curl_ftpsendf(conn, "ADAT %s", p))
+  result = Curl_ftpsendf(conn, "ADAT %s", p);
+
+  free(p);
+
+  if(result)
     return -2;
 
-  nread = Curl_GetFTPResponse(data->state.buffer, conn, NULL);
-  if(nread < 0)
+  if(Curl_GetFTPResponse(&nread, conn, NULL))
     return -1;
-  free(p);
 
   if(data->state.buffer[0] != '2'){
     Curl_failf(data, "Server didn't accept auth data");
@@ -299,7 +302,7 @@ struct Curl_sec_client_mech Curl_krb4_client_mech = {
     krb4_decode
 };
 
-void Curl_krb_kauth(struct connectdata *conn)
+CURLcode Curl_krb_kauth(struct connectdata *conn)
 {
   des_cblock key;
   des_key_schedule schedule;
@@ -309,18 +312,19 @@ void Curl_krb_kauth(struct connectdata *conn)
   char passwd[100];
   int tmp;
   ssize_t nread;
-        
   int save;
+  CURLcode result;
 
   save = Curl_set_command_prot(conn, prot_private);
 
-  if(Curl_ftpsendf(conn, "SITE KAUTH %s", conn->data->state.user))
-    return;
+  result = Curl_ftpsendf(conn, "SITE KAUTH %s", conn->data->state.user);
+
+  if(result)
+    return result;
 
-  nread = Curl_GetFTPResponse(conn->data->state.buffer,
-                              conn, NULL);
-  if(nread < 0)
-    return /*CURLE_OPERATION_TIMEOUTED*/;
+  result = Curl_GetFTPResponse(&nread, conn, NULL);
+  if(result)
+    return result;
 
   if(conn->data->state.buffer[0] != '3'){
     Curl_set_command_prot(conn, save);
@@ -331,7 +335,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   if(!p) {
     Curl_failf(conn->data, "Bad reply from server");
     Curl_set_command_prot(conn, save);
-    return;
+    return CURLE_FTP_WEIRD_SERVER_REPLY;
   }
 
   p += 2;
@@ -339,7 +343,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   if(tmp < 0) {
     Curl_failf(conn->data, "Failed to decode base64 in reply.\n");
     Curl_set_command_prot(conn, save);
-    return;
+    return CURLE_FTP_WEIRD_SERVER_REPLY;
   }
   tkt.length = tmp;
   tktcopy.length = tkt.length;
@@ -348,7 +352,7 @@ void Curl_krb_kauth(struct connectdata *conn)
   if(!p) {
     Curl_failf(conn->data, "Bad reply from server");
     Curl_set_command_prot(conn, save);
-    return;
+    return CURLE_FTP_WEIRD_SERVER_REPLY;
   }
   name = p + 2;
   for(; *p && *p != ' ' && *p != '\r' && *p != '\n'; p++);
@@ -376,19 +380,21 @@ void Curl_krb_kauth(struct connectdata *conn)
   if(Curl_base64_encode(tktcopy.dat, tktcopy.length, &p) < 0) {
     failf(conn->data, "Out of memory base64-encoding.");
     Curl_set_command_prot(conn, save);
-    return;
+    return CURLE_OUT_OF_MEMORY;
   }
   memset (tktcopy.dat, 0, tktcopy.length);
 
-  if(Curl_ftpsendf(conn, "SITE KAUTH %s %s", name, p))
-    return;
-
-  nread = Curl_GetFTPResponse(conn->data->state.buffer,
-                              conn, NULL);
-  if(nread < 0)
-    return /*CURLE_OPERATION_TIMEOUTED*/;
+  result = Curl_ftpsendf(conn, "SITE KAUTH %s %s", name, p);
   free(p);
+  if(result)
+    return result;
+
+  result = Curl_GetFTPResponse(&nread, conn, NULL);
+  if(result)
+    return result;
   Curl_set_command_prot(conn, save);
+
+  return CURLE_OK;
 }
 
 #endif /* KRB4 */
diff --git a/Source/CTest/Curl/krb4.h b/Source/CTest/Curl/krb4.h
index 8057058..ad314b5 100644
--- a/Source/CTest/Curl/krb4.h
+++ b/Source/CTest/Curl/krb4.h
@@ -22,6 +22,6 @@
  *
  * $Id$
  ***************************************************************************/
-void Curl_krb_kauth(struct connectdata *conn);
+CURLcode Curl_krb_kauth(struct connectdata *conn);
 
 #endif
diff --git a/Source/CTest/Curl/multi.c b/Source/CTest/Curl/multi.c
index f901f3a..8548354 100644
--- a/Source/CTest/Curl/multi.c
+++ b/Source/CTest/Curl/multi.c
@@ -313,9 +313,8 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
         easy->easy_handle->hostcache = Curl_global_host_cache_get();
       }
       else {
-        if (multi->hostcache == NULL) {
-          multi->hostcache = Curl_hash_alloc(7, Curl_freeaddrinfo);
-        }
+        if (multi->hostcache == NULL)
+          multi->hostcache = Curl_hash_alloc(7, Curl_freednsinfo);
 
         easy->easy_handle->hostcache = multi->hostcache;
       }
diff --git a/Source/CTest/Curl/security.c b/Source/CTest/Curl/security.c
index aa11a8f..c8f3c22 100644
--- a/Source/CTest/Curl/security.c
+++ b/Source/CTest/Curl/security.c
@@ -279,32 +279,6 @@ Curl_sec_write(struct connectdata *conn, int fd, char *buffer, int length)
 }
 
 int
-Curl_sec_vfprintf2(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
-{
-  char *buf;
-  int ret;
-  if(conn->data_prot == prot_clear)
-    return vfprintf(f, fmt, ap);
-  else {
-    buf = aprintf(fmt, ap);
-    ret = buffer_write(&conn->out_buffer, buf, strlen(buf));
-    free(buf);
-    return ret;
-  }
-}
-
-int
-Curl_sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...)
-{
-    int ret;
-    va_list ap;
-    va_start(ap, fmt);
-    ret = Curl_sec_vfprintf2(conn, f, fmt, ap);
-    va_end(ap);
-    return ret;
-}
-
-int
 Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
 {
   char ch = c;
@@ -313,7 +287,8 @@ Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
     
   buffer_write(&conn->out_buffer, &ch, 1);
   if(c == '\n' || conn->out_buffer.index >= 1024 /* XXX */) {
-    Curl_sec_write(conn, fileno(F), conn->out_buffer.data, conn->out_buffer.index);
+    Curl_sec_write(conn, fileno(F), conn->out_buffer.data,
+                   conn->out_buffer.index);
     conn->out_buffer.index = 0;
   }
   return c;
@@ -346,53 +321,6 @@ Curl_sec_read_msg(struct connectdata *conn, char *s, int level)
     return code;
 }
 
-/* modified to return how many bytes written, or -1 on error ***/
-int
-Curl_sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
-{
-    int ret = 0;
-    char *buf;
-    void *enc;
-    int len;
-    if(!conn->sec_complete)
-        return vfprintf(f, fmt, ap);
-    
-    buf = aprintf(fmt, ap);
-    len = (conn->mech->encode)(conn->app_data, buf, strlen(buf),
-                               conn->command_prot, &enc,
-                               conn);
-    free(buf);
-    if(len < 0) {
-        failf(conn->data, "Failed to encode command.");
-        return -1;
-    }
-    if(Curl_base64_encode(enc, len, &buf) < 0){
-      failf(conn->data, "Out of memory base64-encoding.");
-      return -1;
-    }
-    if(conn->command_prot == prot_safe)
-        ret = fprintf(f, "MIC %s", buf);
-    else if(conn->command_prot == prot_private)
-        ret = fprintf(f, "ENC %s", buf);
-    else if(conn->command_prot == prot_confidential)
-        ret = fprintf(f, "CONF %s", buf);
-
-    free(buf);
-    return ret;
-}
-
-int
-Curl_sec_fprintf(struct connectdata *conn, FILE *f, const char *fmt, ...)
-{
-    va_list ap;
-    int ret;
-    va_start(ap, fmt);
-    ret = Curl_sec_vfprintf(conn, f, fmt, ap);
-    va_end(ap);
-    return ret;
-}
-
-
 enum protection_level
 Curl_set_command_prot(struct connectdata *conn, enum protection_level level)
 {
@@ -414,14 +342,14 @@ sec_prot_internal(struct connectdata *conn, int level)
   }
 
   if(level){
+    int code;
     if(Curl_ftpsendf(conn, "PBSZ %u", s))
       return -1;
 
-    nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, NULL);
-    if(nread < 0)
+    if(Curl_GetFTPResponse(&nread, conn, &code))
       return -1;
 
-    if(conn->data->state.buffer[0] != '2'){
+    if(code/100 != '2'){
       failf(conn->data, "Failed to set protection buffer size.");
       return -1;
     }
@@ -437,8 +365,7 @@ sec_prot_internal(struct connectdata *conn, int level)
   if(Curl_ftpsendf(conn, "PROT %c", level["CSEP"]))
     return -1;
 
-  nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, NULL);
-  if(nread < 0)
+  if(Curl_GetFTPResponse(&nread, conn, NULL))
     return -1;
 
   if(conn->data->state.buffer[0] != '2'){
@@ -496,8 +423,7 @@ Curl_sec_login(struct connectdata *conn)
     if(Curl_ftpsendf(conn, "AUTH %s", (*m)->name))
       return -1;
 
-    nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
-    if(nread < 0)
+    if(Curl_GetFTPResponse(&nread, conn, &ftpcode))
       return -1;
 
     if(conn->data->state.buffer[0] != '3'){
diff --git a/Source/CTest/Curl/sendf.c b/Source/CTest/Curl/sendf.c
index 6ebe014..0eef961 100644
--- a/Source/CTest/Curl/sendf.c
+++ b/Source/CTest/Curl/sendf.c
@@ -154,9 +154,19 @@ void Curl_failf(struct SessionHandle *data, const char *fmt, ...)
     vsnprintf(data->set.errorbuffer, CURL_ERROR_SIZE, fmt, ap);
     data->state.errorbuf = TRUE; /* wrote error string */
 
-    if(data->set.verbose)
-      Curl_debug(data, CURLINFO_TEXT, data->set.errorbuffer,
-                 strlen(data->set.errorbuffer));
+    if(data->set.verbose) {
+      int len = strlen(data->set.errorbuffer);
+      bool doneit=FALSE;
+      if(len < CURL_ERROR_SIZE) {
+        doneit = TRUE;
+        data->set.errorbuffer[len] = '\n';
+        data->set.errorbuffer[++len] = '\0';
+      }
+      Curl_debug(data, CURLINFO_TEXT, data->set.errorbuffer, len);
+      if(doneit)
+        /* cut off the newline again */
+        data->set.errorbuffer[--len]=0;
+    }
   }
   va_end(ap);
 }
@@ -235,6 +245,9 @@ CURLcode Curl_write(struct connectdata *conn, int sockfd,
         /* this is basicly the EWOULDBLOCK equivalent */
         *written = 0;
         return CURLE_OK;
+      case SSL_ERROR_SYSCALL:
+        failf(conn->data, "SSL_write() returned SYSCALL, errno = %d\n", errno);
+        return CURLE_SEND_ERROR;
       }
       /* a true error */
       failf(conn->data, "SSL_write() return error %d\n", err);
@@ -328,36 +341,29 @@ int Curl_read(struct connectdata *conn,
               ssize_t *n)
 {
   ssize_t nread;
+  *n=0; /* reset amount to zero */
 
 #ifdef USE_SSLEAY
   if (conn->ssl.use) {
-    bool loop=TRUE;
-    int err;
-    do {
-      nread = SSL_read(conn->ssl.handle, buf, buffersize);
+    nread = SSL_read(conn->ssl.handle, buf, buffersize);
 
-      if(nread >= 0)
-        /* successful read */
-        break;
-
-      err = SSL_get_error(conn->ssl.handle, nread);
+    if(nread < 0) {
+      /* failed SSL_read */
+      int err = SSL_get_error(conn->ssl.handle, nread);
 
       switch(err) {
       case SSL_ERROR_NONE: /* this is not an error */
       case SSL_ERROR_ZERO_RETURN: /* no more data */
-        loop=0; /* get out of loop */
         break;
       case SSL_ERROR_WANT_READ:
       case SSL_ERROR_WANT_WRITE:
-        /* if there's data pending, then we re-invoke SSL_read() */
-        break;
+        /* there's data pending, re-invoke SSL_read() */
+        return -1; /* basicly EWOULDBLOCK */
       default:
         failf(conn->data, "SSL read error: %d", err);
         return CURLE_RECV_ERROR;
       }
-    } while(loop);
-    if(loop && SSL_pending(conn->ssl.handle))
-      return -1; /* basicly EWOULDBLOCK */
+    }
   }
   else {
 #endif
diff --git a/Source/CTest/Curl/sendf.h b/Source/CTest/Curl/sendf.h
index 665a4c8..97e2fa9 100644
--- a/Source/CTest/Curl/sendf.h
+++ b/Source/CTest/Curl/sendf.h
@@ -30,13 +30,6 @@ void Curl_failf(struct SessionHandle *, const char *fmt, ...);
 #define infof Curl_infof
 #define failf Curl_failf
 
-struct send_buffer {
-  char *buffer;
-  size_t size_max;
-  size_t size_used;
-};
-typedef struct send_buffer send_buffer;
-
 #define CLIENTWRITE_BODY   1
 #define CLIENTWRITE_HEADER 2
 #define CLIENTWRITE_BOTH   (CLIENTWRITE_BODY|CLIENTWRITE_HEADER)
diff --git a/Source/CTest/Curl/setup.h b/Source/CTest/Curl/setup.h
index 783fb83..0612df4 100644
--- a/Source/CTest/Curl/setup.h
+++ b/Source/CTest/Curl/setup.h
@@ -35,9 +35,8 @@
 #define CURL_DISABLE_GOPHER
 #endif
 
-#if !defined(WIN32) && defined(_WIN32)
-/* This _might_ be a good Borland fix. Please report whether this works or
-   not! */
+#if !defined(WIN32) && defined(__WIN32__)
+/* This should be a good Borland fix. Alexander J. Oss told us! */
 #define WIN32
 #endif
 
diff --git a/Source/CTest/Curl/share.h b/Source/CTest/Curl/share.h
new file mode 100644
index 0000000..fdd6ec5
--- /dev/null
+++ b/Source/CTest/Curl/share.h
@@ -0,0 +1,52 @@
+#ifndef __CURL_SHARE_H
+#define __CURL_SHARE_H
+
+/***************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ * 
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ ***************************************************************************/
+
+#include "setup.h"
+#include <curl/curl.h>
+
+/* this struct is libcurl-private, don't export details */
+struct Curl_share {
+  unsigned int specifier;
+  unsigned int locked;
+  unsigned int dirty;
+  
+  curl_lock_function lockfunc;
+  curl_unlock_function unlockfunc;
+  void *clientdata;
+};
+
+CURLSHcode Curl_share_aquire_lock (struct SessionHandle *, curl_lock_data);
+CURLSHcode Curl_share_release_lock (struct SessionHandle *, curl_lock_data);
+
+#endif /* __CURL_SHARE_H */
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */
diff --git a/Source/CTest/Curl/ssluse.c b/Source/CTest/Curl/ssluse.c
index d3162f7..07dae8b 100644
--- a/Source/CTest/Curl/ssluse.c
+++ b/Source/CTest/Curl/ssluse.c
@@ -275,7 +275,8 @@ int cert_stuff(struct connectdata *conn,
       if (SSL_CTX_use_PrivateKey_file(conn->ssl.ctx,
                                       key_file,
                                       file_type) != 1) {
-        failf(data, "unable to set private key file\n");
+        failf(data, "unable to set private key file: '%s' type %s\n",
+              key_file, key_type?key_type:"PEM");
         return 0;
       }
       break;
@@ -324,10 +325,15 @@ int cert_stuff(struct connectdata *conn,
 
     ssl=SSL_new(conn->ssl.ctx);
     x509=SSL_get_certificate(ssl);
-    
-    if (x509 != NULL)
-      EVP_PKEY_copy_parameters(X509_get_pubkey(x509),
-                               SSL_get_privatekey(ssl));
+
+    /* This version was provided by Evan Jordan and is supposed to not
+       leak memory as the previous version: */
+    if (x509 != NULL) {
+      EVP_PKEY *pktmp = X509_get_pubkey(x509);
+      EVP_PKEY_copy_parameters(pktmp,SSL_get_privatekey(ssl));
+      EVP_PKEY_free(pktmp);
+    }
+
     SSL_free(ssl);
 
     /* If we are using DSA, we can copy the parameters from
@@ -667,6 +673,44 @@ static int Curl_ASN1_UTCTIME_output(struct connectdata *conn,
 #endif  
 
 /* ====================================================== */
+static int
+cert_hostcheck(const char *certname, const char *hostname)
+{
+  char *tmp;
+  const char *certdomain;
+  
+  if(!certname ||
+     strlen(certname)<3 ||
+     !hostname ||
+     !strlen(hostname)) /* sanity check */
+    return 0;
+
+  if(strequal(certname, hostname)) /* trivial case */
+    return 1;
+
+  certdomain = certname + 1;
+
+  if((certname[0] != '*') || (certdomain[0] != '.'))
+    return 0; /* not a wildcard certificate, check failed */
+  
+  if(!strchr(certdomain+1, '.'))
+    return 0; /* the certificate must have at least another dot in its name */
+
+  /* find 'certdomain' within 'hostname' */
+  tmp = strstr(hostname, certdomain);
+  if(tmp) {
+    /* ok the certname's domain matches the hostname, let's check that it's a
+       tail-match */
+    if(strequal(tmp, certdomain))
+      /* looks like a match. Just check we havent swallowed a '.' */
+      return tmp == strchr(hostname, '.');
+    else
+      return 0;
+  }
+  return 0;
+}
+
+/* ====================================================== */
 CURLcode
 Curl_SSLConnect(struct connectdata *conn)
 {
@@ -904,7 +948,7 @@ Curl_SSLConnect(struct connectdata *conn)
       return CURLE_SSL_PEER_CERTIFICATE;
     }
 
-    if (!strequal(peer_CN, conn->hostname)) {
+    if (!cert_hostcheck(peer_CN, conn->hostname)) {
       if (data->set.ssl.verifyhost > 1) {
         failf(data, "SSL: certificate subject name '%s' does not match "
               "target host name '%s'",
diff --git a/Source/CTest/Curl/transfer.c b/Source/CTest/Curl/transfer.c
index 5e4e4fb..75cdc69 100644
--- a/Source/CTest/Curl/transfer.c
+++ b/Source/CTest/Curl/transfer.c
@@ -114,65 +114,76 @@ enum {
   KEEP_WRITE
 };
 
+/* We keep this static and global since this is read-only and NEVER
+   changed. It should just remain a blanked-out timeout value. */
+static struct timeval notimeout={0,0};
 
 /*
- * compareheader()
- *
- * Returns TRUE if 'headerline' contains the 'header' with given 'content'.
- * Pass headers WITH the colon.
+ * This function will call the read callback to fill our buffer with data
+ * to upload.
  */
-static bool
-compareheader(char *headerline, /* line to check */
-              const char *header,     /* header keyword _with_ colon */
-              const char *content)    /* content string to find */
+static int fillbuffer(struct connectdata *conn,
+                      int bytes)
 {
-  /* RFC2616, section 4.2 says: "Each header field consists of a name followed
-   * by a colon (":") and the field value. Field names are case-insensitive.
-   * The field value MAY be preceded by any amount of LWS, though a single SP
-   * is preferred." */
-
-  size_t hlen = strlen(header);
-  size_t clen;
-  size_t len;
-  char *start;
-  char *end;
-
-  if(!strnequal(headerline, header, hlen))
-    return FALSE; /* doesn't start with header */
-
-  /* pass the header */
-  start = &headerline[hlen];
-
-  /* pass all white spaces */
-  while(*start && isspace((int)*start))
-    start++;
-
-  /* find the end of the header line */
-  end = strchr(start, '\r'); /* lines end with CRLF */
-  if(!end) {
-    /* in case there's a non-standard compliant line here */
-    end = strchr(start, '\n');
-
-    if(!end)
-      /* hm, there's no line ending here, return false and bail out! */
-      return FALSE;
+  int buffersize = bytes;
+  int nread;
+
+  if(conn->bits.upload_chunky) {
+    /* if chunked Transfer-Encoding */
+    buffersize -= (8 + 2 + 2);   /* 32bit hex + CRLF + CRLF */
+    conn->upload_fromhere += 10; /* 32bit hex + CRLF */
+  }
+  
+  nread = conn->fread(conn->upload_fromhere, 1,
+                      buffersize, conn->fread_in);
+          
+  if(!conn->bits.forbidchunk && conn->bits.upload_chunky) {
+    /* if chunked Transfer-Encoding */
+    char hexbuffer[11];
+    int hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
+                          "%x\r\n", nread);
+    /* move buffer pointer */
+    conn->upload_fromhere -= hexlen;
+    nread += hexlen;
+
+    /* copy the prefix to the buffer */
+    memcpy(conn->upload_fromhere, hexbuffer, hexlen);
+    if(nread>hexlen) {
+      /* append CRLF to the data */
+      memcpy(conn->upload_fromhere +
+             nread, "\r\n", 2);
+      nread+=2;
+    }
+    else {
+      /* mark this as done once this chunk is transfered */
+      conn->keep.upload_done = TRUE;
+    }
   }
+  return nread;
+}
 
-  len = end-start; /* length of the content part of the input line */
-  clen = strlen(content); /* length of the word to find */
+/*
+ * checkhttpprefix()
+ *
+ * Returns TRUE if member of the list matches prefix of string
+ */
+static bool
+checkhttpprefix(struct SessionHandle *data,
+                const char *s)
+{
+  struct curl_slist *head = data->set.http200aliases;
 
-  /* find the content string in the rest of the line */
-  for(;len>=clen;len--, start++) {
-    if(strnequal(start, content, clen))
-      return TRUE; /* match! */
+  while (head) {
+    if (checkprefix(head->data, s))
+      return TRUE;
+    head = head->next;
   }
 
-  return FALSE; /* no match */
-}
+  if(checkprefix("HTTP/", s))
+    return TRUE;
 
-/* We keep this static and global since this is read-only and NEVER
-   changed. It should just remain a blanked-out timeout value. */
-static struct timeval notimeout={0,0};
+  return FALSE;
+}
 
 CURLcode Curl_readwrite(struct connectdata *conn,
                         bool *done)
@@ -220,61 +231,111 @@ CURLcode Curl_readwrite(struct connectdata *conn,
     if((k->keepon & KEEP_READ) &&
        (FD_ISSET(conn->sockfd, readfdp))) {
 
-      /* read! */
-      result = Curl_read(conn, conn->sockfd, k->buf,
-                         data->set.buffer_size?
-                         data->set.buffer_size:BUFSIZE -1,
-                         &nread);
+      bool readdone = FALSE;
 
-      if(0>result)
-        break; /* get out of loop */
-      if(result>0)
-        return result;
+      /* This is where we loop until we have read everything there is to
+         read or we get a EWOULDBLOCK */
+      do {
 
-      if ((k->bytecount == 0) && (k->writebytecount == 0))
-        Curl_pgrsTime(data, TIMER_STARTTRANSFER);
+        /* read! */
+        result = Curl_read(conn, conn->sockfd, k->buf,
+                           data->set.buffer_size?
+                           data->set.buffer_size:BUFSIZE -1,
+                           &nread);
 
-      didwhat |= KEEP_READ;
+        if(0>result)
+          break; /* get out of loop */
+        if(result>0)
+          return result;
 
-      /* NULL terminate, allowing string ops to be used */
-      if (0 < nread)
-        k->buf[nread] = 0;
+        if ((k->bytecount == 0) && (k->writebytecount == 0))
+          Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 
-      /* if we receive 0 or less here, the server closed the connection and
-         we bail out from this! */
-      else if (0 >= nread) {
-        k->keepon &= ~KEEP_READ;
-        FD_ZERO(&k->rkeepfd);
-        break;
-      }
+        didwhat |= KEEP_READ;
+
+        /* NULL terminate, allowing string ops to be used */
+        if (0 < nread)
+          k->buf[nread] = 0;
+
+        /* if we receive 0 or less here, the server closed the connection and
+           we bail out from this! */
+        else if (0 >= nread) {
+          k->keepon &= ~KEEP_READ;
+          FD_ZERO(&k->rkeepfd);
+          readdone = TRUE;
+          break;
+        }
 
-      /* Default buffer to use when we write the buffer, it may be changed
-         in the flow below before the actual storing is done. */
-      k->str = k->buf;
+        /* Default buffer to use when we write the buffer, it may be changed
+           in the flow below before the actual storing is done. */
+        k->str = k->buf;
 
-      /* Since this is a two-state thing, we check if we are parsing
-         headers at the moment or not. */          
-      if (k->header) {
-        /* we are in parse-the-header-mode */
-        bool stop_reading = FALSE;
+        /* Since this is a two-state thing, we check if we are parsing
+           headers at the moment or not. */          
+        if (k->header) {
+          /* we are in parse-the-header-mode */
+          bool stop_reading = FALSE;
 
-        /* header line within buffer loop */
-        do {
-          int hbufp_index;
+          /* header line within buffer loop */
+          do {
+            int hbufp_index;
               
-          /* str_start is start of line within buf */
-          k->str_start = k->str;
+            /* str_start is start of line within buf */
+            k->str_start = k->str;
               
-          k->end_ptr = strchr (k->str_start, '\n');
+            k->end_ptr = strchr (k->str_start, '\n');
               
-          if (!k->end_ptr) {
-            /* Not a complete header line within buffer, append the data to
-               the end of the headerbuff. */
+            if (!k->end_ptr) {
+              /* Not a complete header line within buffer, append the data to
+                 the end of the headerbuff. */
+
+              if (k->hbuflen + nread >= data->state.headersize) {
+                /* We enlarge the header buffer as it is too small */
+                char *newbuff;
+                long newsize=MAX((k->hbuflen+nread)*3/2,
+                                 data->state.headersize*2);
+                hbufp_index = k->hbufp - data->state.headerbuff;
+                newbuff = (char *)realloc(data->state.headerbuff, newsize);
+                if(!newbuff) {
+                  failf (data, "Failed to alloc memory for big header!");
+                  return CURLE_OUT_OF_MEMORY;
+                }
+                data->state.headersize=newsize;
+                data->state.headerbuff = newbuff;
+                k->hbufp = data->state.headerbuff + hbufp_index;
+              }
+              memcpy(k->hbufp, k->str, nread);
+              k->hbufp += nread;
+              k->hbuflen += nread;
+              if (!k->headerline && (k->hbuflen>5)) {
+                /* make a first check that this looks like a HTTP header */
+                if(!checkhttpprefix(data, data->state.headerbuff)) {
+                  /* this is not the beginning of a HTTP first header line */
+                  k->header = FALSE;
+                  k->badheader = HEADER_ALLBAD;
+                  break;
+                }
+              }
+
+              break;            /* read more and try again */
+            }
+
+            /* decrease the size of the remaining buffer */
+            nread -= (k->end_ptr - k->str)+1; 
 
-            if (k->hbuflen + nread >= data->state.headersize) {
-              /* We enlarge the header buffer as it is too small */
+            k->str = k->end_ptr + 1; /* move past new line */
+
+            /*
+             * We're about to copy a chunk of data to the end of the
+             * already received header. We make sure that the full string
+             * fit in the allocated header buffer, or else we enlarge 
+             * it.
+             */
+            if (k->hbuflen + (k->str - k->str_start) >=
+                data->state.headersize) {
               char *newbuff;
-              long newsize=MAX((k->hbuflen+nread)*3/2,
+              long newsize=MAX((k->hbuflen+
+                                (k->str-k->str_start))*3/2,
                                data->state.headersize*2);
               hbufp_index = k->hbufp - data->state.headerbuff;
               newbuff = (char *)realloc(data->state.headerbuff, newsize);
@@ -282,602 +343,576 @@ CURLcode Curl_readwrite(struct connectdata *conn,
                 failf (data, "Failed to alloc memory for big header!");
                 return CURLE_OUT_OF_MEMORY;
               }
-              data->state.headersize=newsize;
+              data->state.headersize= newsize;
               data->state.headerbuff = newbuff;
               k->hbufp = data->state.headerbuff + hbufp_index;
             }
-            memcpy(k->hbufp, k->str, nread);
-            k->hbufp += nread;
-            k->hbuflen += nread;
-            if (!k->headerline && (k->hbuflen>5)) {
-              /* make a first check that this looks like a HTTP header */
-              if(!checkprefix("HTTP/", data->state.headerbuff)) {
+
+            /* copy to end of line */
+            strncpy (k->hbufp, k->str_start, k->str - k->str_start);
+            k->hbufp += k->str - k->str_start;
+            k->hbuflen += k->str - k->str_start;
+            *k->hbufp = 0;
+              
+            k->p = data->state.headerbuff;
+              
+            /****
+             * We now have a FULL header line that p points to
+             *****/
+
+            if(!k->headerline) {
+              /* the first read header */
+              if((k->hbuflen>5) &&
+                 !checkhttpprefix(data, data->state.headerbuff)) {
                 /* this is not the beginning of a HTTP first header line */
                 k->header = FALSE;
-                k->badheader = HEADER_ALLBAD;
+                k->badheader = HEADER_PARTHEADER;
                 break;
               }
             }
 
-            break;              /* read more and try again */
-          }
+            if (('\n' == *k->p) || ('\r' == *k->p)) {
+              int headerlen;
+              /* Zero-length header line means end of headers! */
+
+              if ('\r' == *k->p)
+                k->p++; /* pass the \r byte */
+              if ('\n' == *k->p)
+                k->p++; /* pass the \n byte */
+
+              if(100 == k->httpcode) {
+                /*
+                 * we have made a HTTP PUT or POST and this is 1.1-lingo
+                 * that tells us that the server is OK with this and ready
+                 * to receive our stuff.
+                 * However, we'll get more headers now so we must get
+                 * back into the header-parsing state!
+                 */
+                k->header = TRUE;
+                k->headerline = 0; /* restart the header line counter */
+                /* if we did wait for this do enable write now! */
+                if (k->write_after_100_header) {
+
+                  k->write_after_100_header = FALSE;
+                  FD_SET (conn->writesockfd, &k->writefd); /* write */
+                  k->keepon |= KEEP_WRITE;
+                  k->wkeepfd = k->writefd;
+                }
+              }
+              else
+                k->header = FALSE; /* no more header to parse! */
+
+              if (417 == k->httpcode) {
+                /*
+                 * we got: "417 Expectation Failed" this means:
+                 * we have made a HTTP call and our Expect Header
+                 * seems to cause a problem => abort the write operations
+                 * (or prevent them from starting).
+                 */
+                k->write_after_100_header = FALSE;
+                k->keepon &= ~KEEP_WRITE;
+                FD_ZERO(&k->wkeepfd);
+              }
 
-          /* decrease the size of the remaining buffer */
-          nread -= (k->end_ptr - k->str)+1; 
+              /* now, only output this if the header AND body are requested:
+               */
+              k->writetype = CLIENTWRITE_HEADER;
+              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,
+                                         headerlen);
+              if(result)
+                return result;
+
+              data->info.header_size += headerlen;
+              conn->headerbytecount += headerlen;
+
+              if(!k->header) {
+                /*
+                 * really end-of-headers.
+                 *
+                 * If we requested a "no body", this is a good time to get
+                 * out and return home.
+                 */
+                if(data->set.no_body)
+                  stop_reading = TRUE;
+                else if(!conn->bits.close) {
+                  /* If this is not the last request before a close, we must
+                     set the maximum download size to the size of the
+                     expected document or else, we won't know when to stop
+                     reading! */
+                  if(-1 != conn->size)
+                    conn->maxdownload = conn->size;
+                }
+                /* If max download size is *zero* (nothing) we already
+                   have nothing and can safely return ok now! */
+                if(0 == conn->maxdownload)
+                  stop_reading = TRUE;
+                    
+                if(stop_reading) {
+                  /* we make sure that this socket isn't read more now */
+                  k->keepon &= ~KEEP_READ;
+                  FD_ZERO(&k->rkeepfd);
+                }
 
-          k->str = k->end_ptr + 1; /* move past new line */
+                break;          /* exit header line loop */
+              }
 
-          /*
-           * We're about to copy a chunk of data to the end of the
-           * already received header. We make sure that the full string
-           * fit in the allocated header buffer, or else we enlarge 
-           * it.
-           */
-          if (k->hbuflen + (k->str - k->str_start) >=
-              data->state.headersize) {
-            char *newbuff;
-            long newsize=MAX((k->hbuflen+
-                              (k->str-k->str_start))*3/2,
-                             data->state.headersize*2);
-            hbufp_index = k->hbufp - data->state.headerbuff;
-            newbuff = (char *)realloc(data->state.headerbuff, newsize);
-            if(!newbuff) {
-              failf (data, "Failed to alloc memory for big header!");
-              return CURLE_OUT_OF_MEMORY;
+              /* We continue reading headers, so reset the line-based
+                 header parsing variables hbufp && hbuflen */
+              k->hbufp = data->state.headerbuff;
+              k->hbuflen = 0;
+              continue;
             }
-            data->state.headersize= newsize;
-            data->state.headerbuff = newbuff;
-            k->hbufp = data->state.headerbuff + hbufp_index;
-          }
 
-          /* copy to end of line */
-          strncpy (k->hbufp, k->str_start, k->str - k->str_start);
-          k->hbufp += k->str - k->str_start;
-          k->hbuflen += k->str - k->str_start;
-          *k->hbufp = 0;
-              
-          k->p = data->state.headerbuff;
+            /*
+             * Checks for special headers coming up.
+             */
               
-          /****
-           * We now have a FULL header line that p points to
-           *****/
-
-          if(!k->headerline) {
-            /* the first read header */
-            if((k->hbuflen>5) &&
-               !checkprefix("HTTP/", data->state.headerbuff)) {
-              /* this is not the beginning of a HTTP first header line */
-              k->header = FALSE;
-              k->badheader = HEADER_PARTHEADER;
-              break;
-            }
-          }
-
-          if (('\n' == *k->p) || ('\r' == *k->p)) {
-            int headerlen;
-            /* Zero-length header line means end of headers! */
-
-            if ('\r' == *k->p)
-              k->p++; /* pass the \r byte */
-            if ('\n' == *k->p)
-              k->p++; /* pass the \n byte */
-
-            if(100 == k->httpcode) {
-              /*
-               * we have made a HTTP PUT or POST and this is 1.1-lingo
-               * that tells us that the server is OK with this and ready
-               * to receive our stuff.
-               * However, we'll get more headers now so we must get
-               * back into the header-parsing state!
+            if (!k->headerline++) {
+              /* This is the first header, it MUST be the error code line
+                 or else we consiser this to be the body right away! */
+              int httpversion_major;
+              int nc=sscanf (k->p, " HTTP/%d.%d %3d",
+                             &httpversion_major,
+                             &k->httpversion,
+                             &k->httpcode);
+              if (nc==3) {
+                k->httpversion += 10 * httpversion_major;
+              }
+              else {
+                /* this is the real world, not a Nirvana
+                   NCSA 1.5.x returns this crap when asked for HTTP/1.1
+                */
+                nc=sscanf (k->p, " HTTP %3d", &k->httpcode);
+                k->httpversion = 10;
+               
+               /* If user has set option HTTP200ALIASES,
+                  compare header line against list of aliases
                */
-              k->header = TRUE;
-              k->headerline = 0; /* restart the header line counter */
-              /* if we did wait for this do enable write now! */
-              if (k->write_after_100_header) {
+                if (!nc) {
+                  if (checkhttpprefix(data, k->p)) {
+                    nc = 1;
+                    k->httpcode = 200;
+                    k->httpversion =
+                      (data->set.httpversion==CURL_HTTP_VERSION_1_0)? 10 : 11;
+                  }
+                }
+              }
 
-                k->write_after_100_header = FALSE;
-                FD_SET (conn->writesockfd, &k->writefd); /* write */
-                k->keepon |= KEEP_WRITE;
-                k->wkeepfd = k->writefd;
+              if (nc) {
+                data->info.httpcode = k->httpcode;
+                data->info.httpversion = k->httpversion;
+
+                /* 404 -> URL not found! */
+                if (data->set.http_fail_on_error &&
+                    (k->httpcode >= 400)) {
+                  /* If we have been told to fail hard on HTTP-errors,
+                     here is the check for that: */
+                  /* serious error, go home! */
+                  failf (data, "The requested file was not found");
+                  return CURLE_HTTP_RETURNED_ERROR;
+                }
+
+                if(k->httpversion == 10)
+                  /* Default action for HTTP/1.0 must be to close, unless
+                     we get one of those fancy headers that tell us the
+                     server keeps it open for us! */
+                  conn->bits.close = TRUE;
+
+                switch(k->httpcode) {
+                case 204:
+                  /* (quote from RFC2616, section 10.2.5): The server has
+                   * fulfilled the request but does not need to return an
+                   * entity-body ... The 204 response MUST NOT include a
+                   * message-body, and thus is always terminated by the first
+                   * empty line after the header fields. */
+                  /* FALLTHROUGH */
+                case 304:
+                  /* (quote from RFC2616, section 10.3.5): The 304 response MUST
+                   * NOT contain a message-body, and thus is always terminated
+                   * by the first empty line after the header fields.  */
+                  conn->size=0;
+                  conn->maxdownload=0;
+                  break;
+                default:
+                  /* nothing */
+                  break;
+                }
+              }
+              else {
+                k->header = FALSE;   /* this is not a header line */
+                break;
               }
             }
-            else
-              k->header = FALSE; /* no more header to parse! */
 
-            if (417 == k->httpcode) {
+            /* check for Content-Length: header lines to get size */
+            if (checkprefix("Content-Length:", k->p) &&
+                sscanf (k->p+15, " %ld", &k->contentlength)) {
+              conn->size = k->contentlength;
+              Curl_pgrsSetDownloadSize(data, k->contentlength);
+            }
+            /* check for Content-Type: header lines to get the mime-type */
+            else if (checkprefix("Content-Type:", k->p)) {
+              char *start;
+              char *end;
+              int len;
+              
+              /* Find the first non-space letter */
+              for(start=k->p+14;
+                  *start && isspace((int)*start);
+                  start++);
+
+              /* count all non-space letters following */
+              for(end=start, len=0;
+                  *end && !isspace((int)*end);
+                  end++, len++);
+
+              /* allocate memory of a cloned copy */
+              data->info.contenttype = malloc(len + 1);
+              if (NULL == data->info.contenttype)
+                return CURLE_OUT_OF_MEMORY;
+
+              /* copy the content-type string */
+              memcpy(data->info.contenttype, start, len);
+              data->info.contenttype[len] = 0; /* zero terminate */
+            }
+            else if((k->httpversion == 10) &&
+                    conn->bits.httpproxy &&
+                    Curl_compareheader(k->p,
+                                       "Proxy-Connection:", "keep-alive")) {
               /*
-               * we got: "417 Expectation Failed" this means:
-               * we have made a HTTP call and our Expect Header
-               * seems to cause a problem => abort the write operations
-               * (or prevent them from starting).
+               * When a HTTP/1.0 reply comes when using a proxy, the
+               * 'Proxy-Connection: keep-alive' line tells us the
+               * connection will be kept alive for our pleasure.
+               * Default action for 1.0 is to close.
                */
-              k->write_after_100_header = FALSE;
-              k->keepon &= ~KEEP_WRITE;
-              FD_ZERO(&k->wkeepfd);
+              conn->bits.close = FALSE; /* don't close when done */
+              infof(data, "HTTP/1.0 proxy connection set to keep alive!\n");
             }
-
-            /* now, only output this if the header AND body are requested:
-             */
-            k->writetype = CLIENTWRITE_HEADER;
-            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,
-                                       headerlen);
-            if(result)
-              return result;
-
-            data->info.header_size += headerlen;
-            conn->headerbytecount += headerlen;
-
-            if(!k->header) {
+            else if((k->httpversion == 10) &&
+                    Curl_compareheader(k->p, "Connection:", "keep-alive")) {
               /*
-               * really end-of-headers.
+               * A HTTP/1.0 reply with the 'Connection: keep-alive' line
+               * tells us the connection will be kept alive for our
+               * pleasure.  Default action for 1.0 is to close.
                *
-               * If we requested a "no body", this is a good time to get
-               * out and return home.
+               * [RFC2068, section 19.7.1] */
+              conn->bits.close = FALSE; /* don't close when done */
+              infof(data, "HTTP/1.0 connection set to keep alive!\n");
+            }
+            else if (Curl_compareheader(k->p, "Connection:", "close")) {
+              /*
+               * [RFC 2616, section 8.1.2.1]
+               * "Connection: close" is HTTP/1.1 language and means that
+               * the connection will close when this request has been
+               * served.
                */
-              if(data->set.no_body)
-                stop_reading = TRUE;
-              else if(!conn->bits.close) {
-                /* If this is not the last request before a close, we must
-                   set the maximum download size to the size of the
-                   expected document or else, we won't know when to stop
-                   reading! */
-                if(-1 != conn->size)
-                  conn->maxdownload = conn->size;
-              }
-              /* If max download size is *zero* (nothing) we already
-                 have nothing and can safely return ok now! */
-              if(0 == conn->maxdownload)
-                stop_reading = TRUE;
-                    
-              if(stop_reading) {
-                /* we make sure that this socket isn't read more now */
-                k->keepon &= ~KEEP_READ;
-                FD_ZERO(&k->rkeepfd);
-              }
-
-              break;            /* exit header line loop */
+              conn->bits.close = TRUE; /* close when done */
             }
-
-            /* We continue reading headers, so reset the line-based
-               header parsing variables hbufp && hbuflen */
-            k->hbufp = data->state.headerbuff;
-            k->hbuflen = 0;
-            continue;
-          }
-
-          /*
-           * Checks for special headers coming up.
-           */
-              
-          if (!k->headerline++) {
-            /* This is the first header, it MUST be the error code line
-               or else we consiser this to be the body right away! */
-            int httpversion_major;
-            int nc=sscanf (k->p, " HTTP/%d.%d %3d",
-                           &httpversion_major,
-                           &k->httpversion,
-                           &k->httpcode);
-            if (nc==3) {
-              k->httpversion += 10 * httpversion_major;
+            else if (Curl_compareheader(k->p,
+                                        "Transfer-Encoding:", "chunked")) {
+              /*
+               * [RFC 2616, section 3.6.1] A 'chunked' transfer encoding
+               * means that the server will send a series of "chunks". Each
+               * chunk starts with line with info (including size of the
+               * coming block) (terminated with CRLF), then a block of data
+               * with the previously mentioned size. There can be any amount
+               * of chunks, and a chunk-data set to zero signals the
+               * end-of-chunks. */
+              conn->bits.chunk = TRUE; /* chunks coming our way */
+
+              /* init our chunky engine */
+              Curl_httpchunk_init(conn);
             }
-            else {
-              /* this is the real world, not a Nirvana
-                 NCSA 1.5.x returns this crap when asked for HTTP/1.1
-              */
-              nc=sscanf (k->p, " HTTP %3d", &k->httpcode);
-              k->httpversion = 10;
+            else if (checkprefix("Content-Encoding:", k->p) &&
+                     data->set.encoding) {
+              /*
+               * Process Content-Encoding. Look for the values: identity, gzip,
+               * defalte, compress, x-gzip and x-compress. x-gzip and
+               * x-compress are the same as gzip and compress. (Sec 3.5 RFC
+               * 2616). zlib cannot handle compress, and gzip is not currently
+               * implemented. However, errors are handled further down when the
+               * response body is processed 08/27/02 jhrg */
+              char *start;
+
+              /* Find the first non-space letter */
+              for(start=k->p+17;
+                  *start && isspace((int)*start);
+                  start++);
+
+              /* Record the content-encoding for later use. 08/27/02 jhrg */
+              if (checkprefix("identity", start))
+                k->content_encoding = IDENTITY;
+              else if (checkprefix("deflate", start))
+                k->content_encoding = DEFLATE;
+              else if (checkprefix("gzip", start) 
+                       || checkprefix("x-gzip", start))
+                k->content_encoding = GZIP;
+              else if (checkprefix("compress", start) 
+                       || checkprefix("x-compress", start))
+                k->content_encoding = COMPRESS;
             }
-
-            if (nc) {
-              data->info.httpcode = k->httpcode;
-              data->info.httpversion = k->httpversion;
-
-              /* 404 -> URL not found! */
-              if (data->set.http_fail_on_error &&
-                  (k->httpcode >= 400)) {
-                /* If we have been told to fail hard on HTTP-errors,
-                   here is the check for that: */
-                /* serious error, go home! */
-                failf (data, "The requested file was not found");
-                return CURLE_HTTP_NOT_FOUND;
-              }
-
-              if(k->httpversion == 10)
-                /* Default action for HTTP/1.0 must be to close, unless
-                   we get one of those fancy headers that tell us the
-                   server keeps it open for us! */
-                conn->bits.close = TRUE;
-
-              switch(k->httpcode) {
-              case 204:
-                /* (quote from RFC2616, section 10.2.5): The server has
-                 * fulfilled the request but does not need to return an
-                 * entity-body ... The 204 response MUST NOT include a
-                 * message-body, and thus is always terminated by the first
-                 * empty line after the header fields. */
-                /* FALLTHROUGH */
-              case 304:
-                /* (quote from RFC2616, section 10.3.5): The 304 response MUST
-                 * NOT contain a message-body, and thus is always terminated
-                 * by the first empty line after the header fields.  */
-                conn->size=0;
-                conn->maxdownload=0;
-                break;
-              default:
-                /* nothing */
-                break;
+            else if (checkprefix("Content-Range:", k->p)) {
+              if (sscanf (k->p+14, " bytes %d-", &k->offset) ||
+                  sscanf (k->p+14, " bytes: %d-", &k->offset)) {
+                /* This second format was added August 1st 2000 by Igor
+                   Khristophorov since Sun's webserver JavaWebServer/1.1.1
+                   obviously sends the header this way! :-( */
+                if (conn->resume_from == k->offset) {
+                  /* we asked for a resume and we got it */
+                  k->content_range = TRUE;
+                }
               }
             }
-            else {
-              k->header = FALSE;   /* this is not a header line */
-              break;
+            else if(data->cookies &&
+                    checkprefix("Set-Cookie:", k->p)) {
+              Curl_cookie_add(data->cookies, TRUE, k->p+11, conn->name);
             }
-          }
-
-          /* check for Content-Length: header lines to get size */
-          if (checkprefix("Content-Length:", k->p) &&
-              sscanf (k->p+15, " %ld", &k->contentlength)) {
-            conn->size = k->contentlength;
-            Curl_pgrsSetDownloadSize(data, k->contentlength);
+            else if(checkprefix("Last-Modified:", k->p) &&
+                    (data->set.timecondition || data->set.get_filetime) ) {
+              time_t secs=time(NULL);
+              k->timeofdoc = curl_getdate(k->p+strlen("Last-Modified:"),
+                                          &secs);
+              if(data->set.get_filetime)
+                data->info.filetime = k->timeofdoc;
             }
-          /* check for Content-Type: header lines to get the mime-type */
-          else if (checkprefix("Content-Type:", k->p)) {
-            char *start;
-            char *end;
-            int len;
-              
-            /* Find the first non-space letter */
-            for(start=k->p+14;
-                *start && isspace((int)*start);
-                start++);
-
-            /* count all non-space letters following */
-            for(end=start, len=0;
-                *end && !isspace((int)*end);
-                end++, len++);
-
-            /* allocate memory of a cloned copy */
-            data->info.contenttype = malloc(len + 1);
-            if (NULL == data->info.contenttype)
-              return CURLE_OUT_OF_MEMORY;
-
-            /* copy the content-type string */
-            memcpy(data->info.contenttype, start, len);
-            data->info.contenttype[len] = 0; /* zero terminate */
-          }
-          else if((k->httpversion == 10) &&
-                  conn->bits.httpproxy &&
-                  compareheader(k->p, "Proxy-Connection:", "keep-alive")) {
-            /*
-             * When a HTTP/1.0 reply comes when using a proxy, the
-             * 'Proxy-Connection: keep-alive' line tells us the
-             * connection will be kept alive for our pleasure.
-             * Default action for 1.0 is to close.
-             */
-            conn->bits.close = FALSE; /* don't close when done */
-            infof(data, "HTTP/1.0 proxy connection set to keep alive!\n");
-          }
-          else if((k->httpversion == 10) &&
-                  compareheader(k->p, "Connection:", "keep-alive")) {
-            /*
-             * A HTTP/1.0 reply with the 'Connection: keep-alive' line
-             * tells us the connection will be kept alive for our
-             * pleasure.  Default action for 1.0 is to close.
-             *
-             * [RFC2068, section 19.7.1] */
-            conn->bits.close = FALSE; /* don't close when done */
-            infof(data, "HTTP/1.0 connection set to keep alive!\n");
-          }
-          else if (compareheader(k->p, "Connection:", "close")) {
-            /*
-             * [RFC 2616, section 8.1.2.1]
-             * "Connection: close" is HTTP/1.1 language and means that
-             * the connection will close when this request has been
-             * served.
-             */
-            conn->bits.close = TRUE; /* close when done */
-          }
-          else if (compareheader(k->p, "Transfer-Encoding:", "chunked")) {
-            /*
-             * [RFC 2616, section 3.6.1] A 'chunked' transfer encoding
-             * means that the server will send a series of "chunks". Each
-             * chunk starts with line with info (including size of the
-             * coming block) (terminated with CRLF), then a block of data
-             * with the previously mentioned size. There can be any amount
-             * of chunks, and a chunk-data set to zero signals the
-             * end-of-chunks. */
-            conn->bits.chunk = TRUE; /* chunks coming our way */
-
-            /* init our chunky engine */
-            Curl_httpchunk_init(conn);
-          }
-          else if (checkprefix("Content-Encoding:", k->p) &&
-                   data->set.encoding) {
-            /*
-             * Process Content-Encoding. Look for the values: identity, gzip,
-             * defalte, compress, x-gzip and x-compress. x-gzip and
-             * x-compress are the same as gzip and compress. (Sec 3.5 RFC
-             * 2616). zlib cannot handle compress, and gzip is not currently
-             * implemented. However, errors are handled further down when the
-             * response body is processed 08/27/02 jhrg */
-            char *start;
-
-            /* Find the first non-space letter */
-            for(start=k->p+17;
-                *start && isspace((int)*start);
-                start++);
-
-            /* Record the content-encoding for later use. 08/27/02 jhrg */
-            if (checkprefix("identity", start))
-              k->content_encoding = IDENTITY;
-            else if (checkprefix("deflate", start))
-              k->content_encoding = DEFLATE;
-            else if (checkprefix("gzip", start) 
-                     || checkprefix("x-gzip", start))
-              k->content_encoding = GZIP;
-            else if (checkprefix("compress", start) 
-                     || checkprefix("x-compress", start))
-              k->content_encoding = COMPRESS;
-          }
-          else if (checkprefix("Content-Range:", k->p)) {
-            if (sscanf (k->p+14, " bytes %d-", &k->offset) ||
-                sscanf (k->p+14, " bytes: %d-", &k->offset)) {
-              /* This second format was added August 1st 2000 by Igor
-                 Khristophorov since Sun's webserver JavaWebServer/1.1.1
-                 obviously sends the header this way! :-( */
-              if (conn->resume_from == k->offset) {
-                /* we asked for a resume and we got it */
-                k->content_range = TRUE;
+            else if ((k->httpcode >= 300 && k->httpcode < 400) &&
+                     (data->set.http_follow_location) &&
+                     checkprefix("Location:", k->p)) {
+              /* this is the URL that the server advices us to get instead */
+              char *ptr;
+              char *start=k->p;
+              char backup;
+
+              start += 9; /* pass "Location:" */
+
+              /* Skip spaces and tabs. We do this to support multiple
+                 white spaces after the "Location:" keyword. */
+              while(*start && isspace((int)*start ))
+                start++;
+              ptr = start; /* start scanning here */
+
+              /* scan through the string to find the end */
+              while(*ptr && !isspace((int)*ptr))
+                ptr++;
+              backup = *ptr; /* store the ending letter */
+              if(ptr != start) {
+                *ptr = '\0';   /* zero terminate */
+                conn->newurl = strdup(start); /* clone string */
+                *ptr = backup; /* restore ending letter */
               }
             }
-          }
-          else if(data->cookies &&
-                  checkprefix("Set-Cookie:", k->p)) {
-            Curl_cookie_add(data->cookies, TRUE, k->p+11, conn->name);
-          }
-          else if(checkprefix("Last-Modified:", k->p) &&
-                  (data->set.timecondition || data->set.get_filetime) ) {
-            time_t secs=time(NULL);
-            k->timeofdoc = curl_getdate(k->p+strlen("Last-Modified:"),
-                                        &secs);
-            if(data->set.get_filetime)
-              data->info.filetime = k->timeofdoc;
-          }
-          else if ((k->httpcode >= 300 && k->httpcode < 400) &&
-                   (data->set.http_follow_location) &&
-                   checkprefix("Location:", k->p)) {
-            /* this is the URL that the server advices us to get instead */
-            char *ptr;
-            char *start=k->p;
-            char backup;
-
-            start += 9; /* pass "Location:" */
-
-            /* Skip spaces and tabs. We do this to support multiple
-               white spaces after the "Location:" keyword. */
-            while(*start && isspace((int)*start ))
-              start++;
-            ptr = start; /* start scanning here */
-
-            /* scan through the string to find the end */
-            while(*ptr && !isspace((int)*ptr))
-              ptr++;
-            backup = *ptr; /* store the ending letter */
-            if(ptr != start) {
-              *ptr = '\0';   /* zero terminate */
-              conn->newurl = strdup(start); /* clone string */
-              *ptr = backup; /* restore ending letter */
-            }
-          }
 
-          /*
-           * End of header-checks. Write them to the client.
-           */
+            /*
+             * End of header-checks. Write them to the client.
+             */
 
-          k->writetype = CLIENTWRITE_HEADER;
-          if (data->set.http_include_header)
-            k->writetype |= CLIENTWRITE_BODY;
+            k->writetype = CLIENTWRITE_HEADER;
+            if (data->set.http_include_header)
+              k->writetype |= CLIENTWRITE_BODY;
 
-          if(data->set.verbose)
-            Curl_debug(data, CURLINFO_HEADER_IN,
-                       k->p, k->hbuflen);
+            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)
-            return result;
+            result = Curl_client_write(data, k->writetype, k->p,
+                                       k->hbuflen);
+            if(result)
+              return result;
 
-          data->info.header_size += k->hbuflen;
-          conn->headerbytecount += k->hbuflen;
+            data->info.header_size += k->hbuflen;
+            conn->headerbytecount += k->hbuflen;
               
-          /* reset hbufp pointer && hbuflen */
-          k->hbufp = data->state.headerbuff;
-          k->hbuflen = 0;
-        }
-        while (!stop_reading && *k->str); /* header line within buffer */
+            /* reset hbufp pointer && hbuflen */
+            k->hbufp = data->state.headerbuff;
+            k->hbuflen = 0;
+          }
+          while (!stop_reading && *k->str); /* header line within buffer */
 
-        if(stop_reading)
-          /* We've stopped dealing with input, get out of the do-while loop */
-          break;
+          if(stop_reading)
+            /* We've stopped dealing with input, get out of the do-while loop */
+            break;
 
-        /* We might have reached the end of the header part here, but
-           there might be a non-header part left in the end of the read
-           buffer. */
+          /* We might have reached the end of the header part here, but
+             there might be a non-header part left in the end of the read
+             buffer. */
 
-      }                 /* end if header mode */
+        }                       /* end if header mode */
 
-      /* This is not an 'else if' since it may be a rest from the header
-         parsing, where the beginning of the buffer is headers and the end
-         is non-headers. */
-      if (k->str && !k->header && (nread > 0)) {
+        /* This is not an 'else if' since it may be a rest from the header
+           parsing, where the beginning of the buffer is headers and the end
+           is non-headers. */
+        if (k->str && !k->header && (nread > 0)) {
             
-        if(0 == k->bodywrites) {
-          /* These checks are only made the first time we are about to
-             write a piece of the body */
-          if(conn->protocol&PROT_HTTP) {
-            /* HTTP-only checks */
-            if (conn->newurl) {
-              /* abort after the headers if "follow Location" is set */
-              infof (data, "Follow to new URL: %s\n", conn->newurl);
-              k->keepon &= ~KEEP_READ;
-              FD_ZERO(&k->rkeepfd);
-              *done = TRUE;
-              return CURLE_OK;
-            }
-            else if (conn->resume_from &&
-                     !k->content_range &&
-                     (data->set.httpreq==HTTPREQ_GET)) {
-              /* we wanted to resume a download, although the server
-                 doesn't seem to support this and we did this with a GET
-                 (if it wasn't a GET we did a POST or PUT resume) */
-              failf (data, "HTTP server doesn't seem to support "
-                     "byte ranges. Cannot resume.");
-              return CURLE_HTTP_RANGE_ERROR;
+          if(0 == k->bodywrites) {
+            /* These checks are only made the first time we are about to
+               write a piece of the body */
+            if(conn->protocol&PROT_HTTP) {
+              /* HTTP-only checks */
+              if (conn->newurl) {
+                /* abort after the headers if "follow Location" is set */
+                infof (data, "Follow to new URL: %s\n", conn->newurl);
+                k->keepon &= ~KEEP_READ;
+                FD_ZERO(&k->rkeepfd);
+                *done = TRUE;
+                return CURLE_OK;
+              }
+              else if (conn->resume_from &&
+                       !k->content_range &&
+                       (data->set.httpreq==HTTPREQ_GET)) {
+                /* we wanted to resume a download, although the server
+                   doesn't seem to support this and we did this with a GET
+                   (if it wasn't a GET we did a POST or PUT resume) */
+                failf (data, "HTTP server doesn't seem to support "
+                       "byte ranges. Cannot resume.");
+                return CURLE_HTTP_RANGE_ERROR;
+              }
+              else if(data->set.timecondition && !conn->range) {
+                /* A time condition has been set AND no ranges have been
+                   requested. This seems to be what chapter 13.3.4 of
+                   RFC 2616 defines to be the correct action for a
+                   HTTP/1.1 client */
+                if((k->timeofdoc > 0) && (data->set.timevalue > 0)) {
+                  switch(data->set.timecondition) {
+                  case TIMECOND_IFMODSINCE:
+                  default:
+                    if(k->timeofdoc < data->set.timevalue) {
+                      infof(data,
+                            "The requested document is not new enough\n");
+                      *done = TRUE;
+                      return CURLE_OK;
+                    }
+                    break;
+                  case TIMECOND_IFUNMODSINCE:
+                    if(k->timeofdoc > data->set.timevalue) {
+                      infof(data,
+                            "The requested document is not old enough\n");
+                      *done = TRUE;
+                      return CURLE_OK;
+                    }
+                    break;
+                  } /* switch */
+                } /* two valid time strings */
+              } /* we have a time condition */
+
+            } /* this is HTTP */
+          } /* 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) {
+            if(k->badheader) {
+              Curl_debug(data, CURLINFO_DATA_IN, data->state.headerbuff,
+                         k->hbuflen);
+              if(k->badheader == HEADER_PARTHEADER)
+                Curl_debug(data, CURLINFO_DATA_IN, k->str, nread);
             }
-            else if(data->set.timecondition && !conn->range) {
-              /* A time condition has been set AND no ranges have been
-                 requested. This seems to be what chapter 13.3.4 of
-                 RFC 2616 defines to be the correct action for a
-                 HTTP/1.1 client */
-              if((k->timeofdoc > 0) && (data->set.timevalue > 0)) {
-                switch(data->set.timecondition) {
-                case TIMECOND_IFMODSINCE:
-                default:
-                  if(k->timeofdoc < data->set.timevalue) {
-                    infof(data,
-                          "The requested document is not new enough\n");
-                    *done = TRUE;
-                    return CURLE_OK;
-                  }
-                  break;
-                case TIMECOND_IFUNMODSINCE:
-                  if(k->timeofdoc > data->set.timevalue) {
-                    infof(data,
-                          "The requested document is not old enough\n");
-                    *done = TRUE;
-                    return CURLE_OK;
-                  }
-                  break;
-                } /* switch */
-              } /* two valid time strings */
-            } /* we have a time condition */
-
-          } /* this is HTTP */
-        } /* 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) {
-          if(k->badheader) {
-            Curl_debug(data, CURLINFO_DATA_IN, data->state.headerbuff,
-                       k->hbuflen);
-            if(k->badheader == HEADER_PARTHEADER)
+            else
               Curl_debug(data, CURLINFO_DATA_IN, k->str, nread);
           }
-          else
-            Curl_debug(data, CURLINFO_DATA_IN, k->str, nread);
-        }
 
-        if(conn->bits.chunk) {
-          /*
-           * Bless me father for I have sinned. Here comes a chunked
-           * transfer flying and we need to decode this properly.  While
-           * the name says read, this function both reads and writes away
-           * the data. The returned 'nread' holds the number of actual
-           * data it wrote to the client.  */
-          CHUNKcode res =
-            Curl_httpchunk_read(conn, k->str, nread, &nread);
-
-          if(CHUNKE_OK < res) {
-            if(CHUNKE_WRITE_ERROR == res) {
-              failf(data, "Failed writing data");
-              return CURLE_WRITE_ERROR;
+          if(conn->bits.chunk) {
+            /*
+             * Bless me father for I have sinned. Here comes a chunked
+             * transfer flying and we need to decode this properly.  While
+             * the name says read, this function both reads and writes away
+             * the data. The returned 'nread' holds the number of actual
+             * data it wrote to the client.  */
+            CHUNKcode res =
+              Curl_httpchunk_read(conn, k->str, nread, &nread);
+
+            if(CHUNKE_OK < res) {
+              if(CHUNKE_WRITE_ERROR == res) {
+                failf(data, "Failed writing data");
+                return CURLE_WRITE_ERROR;
+              }
+              failf(data, "Received problem in the chunky parser");
+              return CURLE_RECV_ERROR;
             }
-            failf(data, "Received problem in the chunky parser");
-            return CURLE_RECV_ERROR;
-          }
-          else if(CHUNKE_STOP == res) {
-            /* we're done reading chunks! */
-            k->keepon &= ~KEEP_READ; /* read no more */
-            FD_ZERO(&k->rkeepfd);
+            else if(CHUNKE_STOP == res) {
+              /* we're done reading chunks! */
+              k->keepon &= ~KEEP_READ; /* read no more */
+              FD_ZERO(&k->rkeepfd);
 
-            /* There are now possibly N number of bytes at the end of the
-               str buffer that weren't written to the client, but we don't
-               care about them right now. */
+              /* There are now possibly N number of bytes at the end of the
+                 str buffer that weren't written to the client, but we don't
+                 care about them right now. */
+            }
+            /* If it returned OK, we just keep going */
           }
-          /* If it returned OK, we just keep going */
-        }
 
-        if((-1 != conn->maxdownload) &&
-           (k->bytecount + nread >= conn->maxdownload)) {
-          nread = conn->maxdownload - k->bytecount;
-          if(nread < 0 ) /* this should be unusual */
-            nread = 0;
+          if((-1 != conn->maxdownload) &&
+             (k->bytecount + nread >= conn->maxdownload)) {
+            nread = conn->maxdownload - k->bytecount;
+            if(nread < 0 ) /* this should be unusual */
+              nread = 0;
 
-          k->keepon &= ~KEEP_READ; /* we're done reading */
-          FD_ZERO(&k->rkeepfd);
-        }
+            k->keepon &= ~KEEP_READ; /* we're done reading */
+            FD_ZERO(&k->rkeepfd);
+          }
 
-        k->bytecount += nread;
+          k->bytecount += nread;
 
-        Curl_pgrsSetDownloadCounter(data, (double)k->bytecount);
+          Curl_pgrsSetDownloadCounter(data, (double)k->bytecount);
             
-        if(!conn->bits.chunk && (nread || k->badheader)) {
-          /* If this is chunky transfer, it was already written */
-
-          if(k->badheader) {
-            /* we parsed a piece of data wrongly assuming it was a header
-               and now we output it as body instead */
-            result = Curl_client_write(data, CLIENTWRITE_BODY,
-                                       data->state.headerbuff,
-                                       k->hbuflen);
-          }
-          if(k->badheader < HEADER_ALLBAD) {
-            /* This switch handles various content encodings. If there's an
-               error here, be sure to check over the almost identical code in
-               http_chunk.c. 08/29/02 jhrg */
+          if(!conn->bits.chunk && (nread || k->badheader)) {
+            /* If this is chunky transfer, it was already written */
+
+            if(k->badheader) {
+              /* we parsed a piece of data wrongly assuming it was a header
+                 and now we output it as body instead */
+              result = Curl_client_write(data, CLIENTWRITE_BODY,
+                                         data->state.headerbuff,
+                                         k->hbuflen);
+            }
+            if(k->badheader < HEADER_ALLBAD) {
+              /* This switch handles various content encodings. If there's an
+                 error here, be sure to check over the almost identical code
+                 in http_chunk.c. 08/29/02 jhrg */
 #ifdef HAVE_LIBZ
-            switch (k->content_encoding) {
-            case IDENTITY:
+              switch (k->content_encoding) {
+              case IDENTITY:
 #endif
-              /* This is the default when the server sends no
-                 Content-Encoding header. See Curl_readwrite_init; the
-                 memset() call initializes k->content_encoding to zero.
-                 08/28/02 jhrg */
-              result = Curl_client_write(data, CLIENTWRITE_BODY, k->str, 
-                                         nread);
+                /* This is the default when the server sends no
+                   Content-Encoding header. See Curl_readwrite_init; the
+                   memset() call initializes k->content_encoding to zero.
+                   08/28/02 jhrg */
+                result = Curl_client_write(data, CLIENTWRITE_BODY, k->str, 
+                                           nread);
 #ifdef HAVE_LIBZ
-              break;
-
-            case DEFLATE: 
-              /* Assume CLIENTWRITE_BODY; headers are not encoded. */
-              result = Curl_unencode_deflate_write(data, k, nread);
-              break;
-
-            case GZIP:          /* FIXME 08/27/02 jhrg */
-            case COMPRESS:
-            default:
-              failf (data, "Unrecognized content encoding type. "
-                     "libcurl understands `identity' and `deflate' "
-                     "content encodings.");
-              result = CURLE_BAD_CONTENT_ENCODING;
-              break;
-            }
+                break;
+
+              case DEFLATE: 
+                /* Assume CLIENTWRITE_BODY; headers are not encoded. */
+                result = Curl_unencode_deflate_write(data, k, nread);
+                break;
+
+              case GZIP:          /* FIXME 08/27/02 jhrg */
+              case COMPRESS:
+              default:
+                failf (data, "Unrecognized content encoding type. "
+                       "libcurl understands `identity' and `deflate' "
+                       "content encodings.");
+                result = CURLE_BAD_CONTENT_ENCODING;
+                break;
+              }
 #endif
+            }
+            k->badheader = HEADER_NORMAL; /* taken care of now */
+
+            if(result)
+              return result;
           }
-          k->badheader = HEADER_NORMAL; /* taken care of now */
 
-          if(result)
-            return result;
-        }
+        } /* if (! header and data to read ) */
+
+      } while(!readdone);
 
-      } /* if (! header and data to read ) */
     } /* if( read from socket ) */
 
     /* If we still have writing to do, we check if we have a writable
@@ -890,134 +925,114 @@ CURLcode Curl_readwrite(struct connectdata *conn,
 
       int i, si;
       ssize_t bytes_written;
+      bool writedone=FALSE;
 
       if ((k->bytecount == 0) && (k->writebytecount == 0))
         Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 
       didwhat |= KEEP_WRITE;
 
-      /* only read more data if there's no upload data already
-         present in the upload buffer */
-      if(0 == conn->upload_present) {
-        size_t buffersize = BUFSIZE;
-        /* init the "upload from here" pointer */
-        conn->upload_fromhere = k->uploadbuf;
-
-        if(!k->upload_done) {
-
-          if(conn->bits.upload_chunky) {
-            /* if chunked Transfer-Encoding */
-            buffersize -= (8 + 2 + 2);   /* 32bit hex + CRLF + CRLF */
-            conn->upload_fromhere += 10; /* 32bit hex + CRLF */
-          }
-
-          nread = data->set.fread(conn->upload_fromhere, 1,
-                                  buffersize, data->set.in);
-          
-          if(conn->bits.upload_chunky) {
-            /* if chunked Transfer-Encoding */
-            char hexbuffer[9];
-            int hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
-                                  "%x\r\n", nread);
-            /* move buffer pointer */
-            conn->upload_fromhere -= hexlen;
-            nread += hexlen;
-
-            /* copy the prefix to the buffer */
-            memcpy(conn->upload_fromhere, hexbuffer, hexlen);
-            if(nread>0) {
-              /* append CRLF to the data */
-              memcpy(conn->upload_fromhere +
-                     nread, "\r\n", 2);
-              nread+=2;
-            }
-            else {
-              /* mark this as done once this chunk is transfered */
-              k->upload_done = TRUE;
-            }
+      /*
+       * We loop here to do the READ and SEND loop until we run out of
+       * data to send or until we get EWOULDBLOCK back
+       */
+      do {
+        
+        /* only read more data if there's no upload data already
+           present in the upload buffer */
+        if(0 == conn->upload_present) {
+          /* init the "upload from here" pointer */
+          conn->upload_fromhere = k->uploadbuf;
+
+          if(!k->upload_done)
+            nread = fillbuffer(conn, BUFSIZE);
+          else
+            nread = 0; /* we're done uploading/reading */
+
+          /* the signed int typecase of nread of for systems that has
+             unsigned size_t */
+          if (nread<=0) {
+            /* done */
+            k->keepon &= ~KEEP_WRITE; /* we're done writing */
+            FD_ZERO(&k->wkeepfd);
+            writedone = TRUE;
+            break;
           }
-        }
-        else
-          nread = 0; /* we're done uploading/reading */
-
-        /* the signed int typecase of nread of for systems that has
-           unsigned size_t */
-        if (nread<=0) {
-          /* done */
-          k->keepon &= ~KEEP_WRITE; /* we're done writing */
-          FD_ZERO(&k->wkeepfd);
-          break;
-        }
 
-        /* store number of bytes available for upload */
-        conn->upload_present = nread;
+          /* store number of bytes available for upload */
+          conn->upload_present = nread;
 
-        /* convert LF to CRLF if so asked */
-        if (data->set.crlf) {
-          for(i = 0, si = 0; i < nread; i++, si++) {
-            if (conn->upload_fromhere[i] == 0x0a) {
-              data->state.scratch[si++] = 0x0d;
-              data->state.scratch[si] = 0x0a;
+          /* convert LF to CRLF if so asked */
+          if (data->set.crlf) {
+            for(i = 0, si = 0; i < nread; i++, si++) {
+              if (conn->upload_fromhere[i] == 0x0a) {
+                data->state.scratch[si++] = 0x0d;
+                data->state.scratch[si] = 0x0a;
+              }
+              else
+                data->state.scratch[si] = conn->upload_fromhere[i];
             }
-            else
-              data->state.scratch[si] = conn->upload_fromhere[i];
-          }
-          if(si != nread) {
-            /* only perform the special operation if we really did replace
-               anything */
-            nread = si;
+            if(si != nread) {
+              /* only perform the special operation if we really did replace
+                 anything */
+              nread = si;
 
-            /* upload from the new (replaced) buffer instead */
-            conn->upload_fromhere = data->state.scratch;
+              /* upload from the new (replaced) buffer instead */
+              conn->upload_fromhere = data->state.scratch;
 
-            /* set the new amount too */
-            conn->upload_present = nread;
+              /* set the new amount too */
+              conn->upload_present = nread;
+            }
           }
         }
-      }
-      else {
-        /* We have a partial buffer left from a previous "round". Use
-           that instead of reading more data */
-      }
+        else {
+          /* We have a partial buffer left from a previous "round". Use
+             that instead of reading more data */
+        }
 
-      /* write to socket */
-      result = Curl_write(conn,
-                          conn->writesockfd,
-                          conn->upload_fromhere,
-                          conn->upload_present,
-                          &bytes_written);
-      if(result)
-        return result;
-      else if(conn->upload_present != bytes_written) {
-        /* we only wrote a part of the buffer (if anything), deal with it! */
-
-        /* store the amount of bytes left in the buffer to write */
-        conn->upload_present -= bytes_written;
-
-        /* advance the pointer where to find the buffer when the next send
-           is to happen */
-        conn->upload_fromhere += bytes_written;
-      }
-      else {
-        /* we've uploaded that buffer now */
-        conn->upload_fromhere = k->uploadbuf;
-        conn->upload_present = 0; /* no more bytes left */
-
-        if(k->upload_done) {
-          /* switch off writing, we're done! */
-          k->keepon &= ~KEEP_WRITE; /* we're done writing */
-          FD_ZERO(&k->wkeepfd);
+        /* write to socket (send away data) */
+        result = Curl_write(conn,
+                            conn->writesockfd,     /* socket to send to */
+                            conn->upload_fromhere, /* buffer pointer */
+                            conn->upload_present,  /* buffer size */
+                            &bytes_written);       /* actually send away */
+        if(result)
+          return result;
+        else if(conn->upload_present != bytes_written) {
+          /* we only wrote a part of the buffer (if anything), deal with it! */
+
+          /* store the amount of bytes left in the buffer to write */
+          conn->upload_present -= bytes_written;
+
+          /* advance the pointer where to find the buffer when the next send
+             is to happen */
+          conn->upload_fromhere += bytes_written;
+
+          writedone = TRUE; /* we are done, stop the loop */
+        }
+        else {
+          /* we've uploaded that buffer now */
+          conn->upload_fromhere = k->uploadbuf;
+          conn->upload_present = 0; /* no more bytes left */
+
+          if(k->upload_done) {
+            /* switch off writing, we're done! */
+            k->keepon &= ~KEEP_WRITE; /* we're done writing */
+            FD_ZERO(&k->wkeepfd);
+            writedone = TRUE;
+          }
         }
-      }
 
-      if(data->set.verbose)
-        Curl_debug(data, CURLINFO_DATA_OUT, conn->upload_fromhere,
-                   bytes_written);
+        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);
+        k->writebytecount += bytes_written;
+        Curl_pgrsSetUploadCounter(data, (double)k->writebytecount);
 
+      } while(!writedone); /* loop until we're done writing! */
+      
     }
 
   } while(0); /* just to break out from! */
diff --git a/Source/CTest/Curl/url.c b/Source/CTest/Curl/url.c
index 7771752..db5c277 100644
--- a/Source/CTest/Curl/url.c
+++ b/Source/CTest/Curl/url.c
@@ -101,6 +101,7 @@
 #include "strequal.h"
 #include "escape.h"
 #include "strtok.h"
+#include "share.h"
 
 /* And now for the protocols */
 #include "ftp.h"
@@ -1071,8 +1072,8 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
 
   case CURLOPT_SHARE:
     {
-      curl_share *set;
-      set = va_arg(param, curl_share *);
+      struct Curl_share *set;
+      set = va_arg(param, struct Curl_share *);
       if(data->share)
         data->share->dirty--;
 
@@ -1088,6 +1089,20 @@ CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
     data->set.proxytype = va_arg(param, long);
     break;
 
+  case CURLOPT_PRIVATE:
+    /*
+     * Set private data pointer.
+     */
+    data->set.private = va_arg(param, char *);
+    break;
+
+  case CURLOPT_HTTP200ALIASES:
+    /*
+     * Set a list of aliases for HTTP 200 in response header
+     */
+    data->set.http200aliases = va_arg(param, struct curl_slist *);
+    break;
+      
   default:
     /* unknown tag and its companion, just ignore: */
     return CURLE_FAILED_INIT; /* correct this */
@@ -1603,6 +1618,9 @@ static CURLcode ConnectPlease(struct connectdata *conn,
   return result;
 }
 
+/*
+ * ALERT! The 'dns' pointer being passed in here might be NULL at times.
+ */
 static void verboseconnect(struct connectdata *conn,
                            struct Curl_dns_entry *dns)
 {
@@ -1667,6 +1685,12 @@ CURLcode Curl_protocol_connect(struct connectdata *conn,
   struct SessionHandle *data = conn->data;
   CURLcode result=CURLE_OK;
   
+  if(conn->bits.tcpconnect)
+    /* We already are connected, get back. This may happen when the connect
+       worked fine in the first call, like when we connect to a local server
+       or proxy. */
+    return CURLE_OK;
+
   Curl_pgrsTime(data, TIMER_CONNECT); /* connect done */
 
   if(data->set.verbose)
@@ -1779,6 +1803,9 @@ static CURLcode CreateConnection(struct SessionHandle *data,
   /* else, no chunky upload */
   FALSE;
 
+  conn->fread = data->set.fread;
+  conn->fread_in = data->set.in;
+
   /***********************************************************
    * We need to allocate memory to store the path in. We get the size of the
    * full URL to be sure, and we need to make it at least 256 bytes since
@@ -2286,6 +2313,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
 
     /* Setup a "faked" transfer that'll do nothing */
     if(CURLE_OK == result) {
+      conn->bits.tcpconnect = TRUE; /* we are "connected */
       result = Curl_Transfer(conn, -1, -1, FALSE, NULL, /* no download */
                              -1, NULL); /* no upload */
     }
@@ -2463,6 +2491,9 @@ static CURLcode CreateConnection(struct SessionHandle *data,
           /* no name given, get the password only */
           sscanf(userpass, ":%127[^@]", data->state.passwd);
 
+        /* we have set the password */
+        data->state.passwdgiven = TRUE;
+
         if(data->state.user[0]) {
           char *newname=curl_unescape(data->state.user, 0);
           if(strlen(newname) < sizeof(data->state.user)) {
@@ -2498,14 +2529,17 @@ static CURLcode CreateConnection(struct SessionHandle *data,
       /* the name is given, get user+password */
       sscanf(data->set.userpwd, "%127[^:]:%127[^\n]",
              data->state.user, data->state.passwd);
+      if(strchr(data->set.userpwd, ':'))
+        /* a colon means the password was given, even if blank */
+        data->state.passwdgiven = TRUE;
     }
     else
-      /* no name given, get the password only */
+      /* no name given, starts with a colon, get the password only */
       sscanf(data->set.userpwd+1, "%127[^\n]", data->state.passwd);
   }
 
   if (data->set.use_netrc != CURL_NETRC_IGNORED &&
-      data->state.passwd[0] == '\0' ) {  /* need passwd */
+      !data->state.passwdgiven) {  /* need passwd */
     if(Curl_parsenetrc(conn->hostname,
                        data->state.user,
                        data->state.passwd)) {
@@ -2516,8 +2550,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
   }
 
   /* if we have a user but no password, ask for one */
-  if(conn->bits.user_passwd &&
-     !data->state.passwd[0] ) {
+  if(conn->bits.user_passwd && !data->state.passwdgiven ) {
     if(data->set.fpasswd(data->set.passwd_client,
                          "password:", data->state.passwd,
                          sizeof(data->state.passwd)))
@@ -2528,9 +2561,12 @@ static CURLcode CreateConnection(struct SessionHandle *data,
 
   /* If our protocol needs a password and we have none, use the defaults */
   if ( (conn->protocol & (PROT_FTP|PROT_HTTP)) &&
-       !conn->bits.user_passwd) {
+       !conn->bits.user_passwd &&
+       !data->state.passwdgiven) {
+
     strcpy(data->state.user, CURL_DEFAULT_USER);
     strcpy(data->state.passwd, CURL_DEFAULT_PASSWORD);
+
     /* This is the default password, so DON'T set conn->bits.user_passwd */
   }
 
@@ -2782,14 +2818,21 @@ static CURLcode CreateConnection(struct SessionHandle *data,
     /* Connect only if not already connected! */
     result = ConnectPlease(conn, hostaddr, &connected);
 
-    if(connected)
+    if(connected) {
       result = Curl_protocol_connect(conn, hostaddr);
+      if(CURLE_OK == result)
+        conn->bits.tcpconnect = TRUE;
+    }
+    else
+      conn->bits.tcpconnect = FALSE;
+
 
     if(CURLE_OK != result)
       return result;
   }
   else {
     Curl_pgrsTime(data, TIMER_CONNECT); /* we're connected already */
+    conn->bits.tcpconnect = TRUE;
     if(data->set.verbose)
       verboseconnect(conn, hostaddr);
   }
diff --git a/Source/CTest/Curl/urldata.h b/Source/CTest/Curl/urldata.h
index c4cab1a..923da5c 100644
--- a/Source/CTest/Curl/urldata.h
+++ b/Source/CTest/Curl/urldata.h
@@ -157,6 +157,8 @@ struct ssl_config_data {
 struct HTTP {
   struct FormData *sendit;
   int postsize;
+  char *postdata;
+
   const char *p_pragma;      /* Pragma: string */
   const char *p_accept;      /* Accept: string */
   long readbytecount; 
@@ -164,10 +166,24 @@ struct HTTP {
 
   /* For FORM posting */
   struct Form form;
-  curl_read_callback storefread;
-  FILE *in;
-
   struct Curl_chunker chunk;
+
+  struct back {
+    curl_read_callback fread; /* backup storage for fread pointer */
+    void *fread_in;           /* backup storage for fread_in pointer */
+    char *postdata;
+    int postsize;
+  } backup;
+
+  enum {
+    HTTPSEND_NADA,    /* init */
+    HTTPSEND_REQUEST, /* sending a request */
+    HTTPSEND_BODY,    /* sending body */
+    HTTPSEND_LAST     /* never use this */
+  } sending;
+
+  void *send_buffer; /* used if the request couldn't be sent in one chunk,
+                        points to an allocated send_buffer struct */
 };
 
 /****************************************************************************
@@ -190,7 +206,9 @@ struct FTP {
                        read the line, just ignore the result. */
   bool no_transfer; /* nothing was transfered, (possibly because a resumed
                        transfer already was complete) */
-
+  long response_time; /* When no timeout is given, this is the amount of
+                         seconds we await for an FTP response. Initialized
+                         in Curl_ftp_connect() */
 };
 
 /****************************************************************************
@@ -220,8 +238,14 @@ struct ConnectBits {
 
   bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding
                          on upload */
-
-  bool getheader;        /* TRUE if header parsing is wanted */
+  bool getheader;     /* TRUE if header parsing is wanted */
+
+  bool forbidchunk;   /* used only to explicitly forbid chunk-upload for
+                         specific upload buffers. See readmoredata() in
+                         http.c for details. */
+  bool tcpconnect;    /* the tcp stream (or simimlar) is connected, this
+                         is set the first time on the first connect function
+                         call */
 };
 
 /*
@@ -456,6 +480,9 @@ struct connectdata {
       and the 'upload_present' contains the number of bytes available at this
       position */
   char *upload_fromhere;
+
+  curl_read_callback fread; /* function that reads the input */
+  void *fread_in;           /* pointer to pass to the fread() above */
 };
 
 /* The end of connectdata. 08/27/02 jhrg */
@@ -543,6 +570,9 @@ struct UrlState {
   char proxyuser[MAX_CURL_USER_LENGTH];
   char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
 
+  bool passwdgiven; /* set TRUE if an application-provided password has been
+                       set */
+
   struct timeval keeps_speed; /* for the progress meter really */
 
   /* 'connects' will be an allocated array with pointers. If the pointer is
@@ -631,7 +661,7 @@ struct UserDefined {
   bool free_referer; /* set TRUE if 'referer' points to a string we
                         allocated */
   char *useragent;   /* User-Agent string */
-  char *encoding;    /* Accept-Encoding string 08/28/02 jhrg */
+  char *encoding;    /* Accept-Encoding string */
   char *postfields;  /* if POST, set the fields' values here */
   size_t postfieldsize; /* if POST, this might have a size to use instead of
                            strlen(), and then the data *may* be binary (contain
@@ -686,6 +716,10 @@ struct UserDefined {
 
   int dns_cache_timeout; /* DNS cache timeout */
   long buffer_size;      /* size of receive buffer to use */
+
+  char *private; /* Private data */
+
+  struct curl_slist *http200aliases; /* linked list of aliases for http200 */
   
 /* Here follows boolean settings that define how to behave during
    this session. They are STATIC, set by libcurl users or at least initially
@@ -734,7 +768,7 @@ struct UserDefined {
 
 struct SessionHandle {
   curl_hash *hostcache;
-  curl_share *share;           /* Share, handles global variable mutexing */
+  struct Curl_share *share;    /* Share, handles global variable mutexing */
   struct UserDefined set;      /* values set by the libcurl user */
   struct DynamicStatic change; /* possibly modified userdefined data */