Restoring authorship annotation for <deshevoy@yandex-team.ru>. Commit 1 of 2.

1 files changed, 463 insertions, 463 deletions

diff --git a/contrib/libs/curl/lib/imap.c b/contrib/libs/curl/lib/imap.c
index c6dd7a23230..c9bdf2d3cdb 100644
--- a/contrib/libs/curl/lib/imap.c
+++ b/contrib/libs/curl/lib/imap.c
@@ -24,12 +24,12 @@
  * RFC3501 IMAPv4 protocol
  * RFC4422 Simple Authentication and Security Layer (SASL)
  * RFC4616 PLAIN authentication
- * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism
+ * RFC4752 The Kerberos V5 ("GSSAPI") SASL Mechanism 
  * RFC4959 IMAP Extension for SASL Initial Client Response
  * RFC5092 IMAP URL Scheme
  * RFC6749 OAuth 2.0 Authorization Framework
  * RFC8314 Use of TLS for Email Submission and Access
- * Draft   LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
+ * Draft   LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt> 
  *
  ***************************************************************************/
 
@@ -69,21 +69,21 @@
 #include "http.h" /* for HTTP proxy tunnel stuff */
 #include "socks.h"
 #include "imap.h"
-#include "mime.h"
+#include "mime.h" 
 #include "strtoofft.h"
-#include "strcase.h"
-#include "vtls/vtls.h"
+#include "strcase.h" 
+#include "vtls/vtls.h" 
 #include "connect.h"
 #include "strerror.h"
 #include "select.h"
 #include "multiif.h"
 #include "url.h"
-#include "strcase.h"
+#include "strcase.h" 
 #include "curl_sasl.h"
 #include "warnless.h"
 
-/* The last 3 #include files should be in this order */
-#include "curl_printf.h"
+/* The last 3 #include files should be in this order */ 
+#include "curl_printf.h" 
 #include "curl_memory.h"
 #include "memdebug.h"
 
@@ -98,17 +98,17 @@ static CURLcode imap_multi_statemach(struct connectdata *conn, bool *done);
 static int imap_getsock(struct connectdata *conn, curl_socket_t *socks);
 static CURLcode imap_doing(struct connectdata *conn, bool *dophase_done);
 static CURLcode imap_setup_connection(struct connectdata *conn);
-static char *imap_atom(const char *str, bool escape_only);
+static char *imap_atom(const char *str, bool escape_only); 
 static CURLcode imap_sendf(struct connectdata *conn, const char *fmt, ...);
 static CURLcode imap_parse_url_options(struct connectdata *conn);
 static CURLcode imap_parse_url_path(struct connectdata *conn);
 static CURLcode imap_parse_custom_request(struct connectdata *conn);
-static CURLcode imap_perform_authenticate(struct connectdata *conn,
-                                          const char *mech,
-                                          const char *initresp);
-static CURLcode imap_continue_authenticate(struct connectdata *conn,
-                                           const char *resp);
-static void imap_get_message(char *buffer, char **outptr);
+static CURLcode imap_perform_authenticate(struct connectdata *conn, 
+                                          const char *mech, 
+                                          const char *initresp); 
+static CURLcode imap_continue_authenticate(struct connectdata *conn, 
+                                           const char *resp); 
+static void imap_get_message(char *buffer, char **outptr); 
 
 /*
  * IMAP protocol handler.
@@ -129,12 +129,12 @@ const struct Curl_handler Curl_handler_imap = {
   ZERO_NULL,                        /* perform_getsock */
   imap_disconnect,                  /* disconnect */
   ZERO_NULL,                        /* readwrite */
-  ZERO_NULL,                        /* connection_check */
+  ZERO_NULL,                        /* connection_check */ 
   PORT_IMAP,                        /* defport */
   CURLPROTO_IMAP,                   /* protocol */
   CURLPROTO_IMAP,                   /* family */
-  PROTOPT_CLOSEACTION|              /* flags */
-  PROTOPT_URLOPTIONS
+  PROTOPT_CLOSEACTION|              /* flags */ 
+  PROTOPT_URLOPTIONS 
 };
 
 #ifdef USE_SSL
@@ -157,38 +157,38 @@ const struct Curl_handler Curl_handler_imaps = {
   ZERO_NULL,                        /* perform_getsock */
   imap_disconnect,                  /* disconnect */
   ZERO_NULL,                        /* readwrite */
-  ZERO_NULL,                        /* connection_check */
+  ZERO_NULL,                        /* connection_check */ 
   PORT_IMAPS,                       /* defport */
-  CURLPROTO_IMAPS,                  /* protocol */
+  CURLPROTO_IMAPS,                  /* protocol */ 
   CURLPROTO_IMAP,                   /* family */
-  PROTOPT_CLOSEACTION | PROTOPT_SSL | /* flags */
-  PROTOPT_URLOPTIONS
+  PROTOPT_CLOSEACTION | PROTOPT_SSL | /* flags */ 
+  PROTOPT_URLOPTIONS 
 };
 #endif
 
-#define IMAP_RESP_OK       1
-#define IMAP_RESP_NOT_OK   2
-#define IMAP_RESP_PREAUTH  3
-
-/* SASL parameters for the imap protocol */
-static const struct SASLproto saslimap = {
-  "imap",                     /* The service name */
-  '+',                        /* Code received when continuation is expected */
-  IMAP_RESP_OK,               /* Code to receive upon authentication success */
-  0,                          /* Maximum initial response length (no max) */
-  imap_perform_authenticate,  /* Send authentication command */
-  imap_continue_authenticate, /* Send authentication continuation */
-  imap_get_message            /* Get SASL response message */
+#define IMAP_RESP_OK       1 
+#define IMAP_RESP_NOT_OK   2 
+#define IMAP_RESP_PREAUTH  3 
+
+/* SASL parameters for the imap protocol */ 
+static const struct SASLproto saslimap = { 
+  "imap",                     /* The service name */ 
+  '+',                        /* Code received when continuation is expected */ 
+  IMAP_RESP_OK,               /* Code to receive upon authentication success */ 
+  0,                          /* Maximum initial response length (no max) */ 
+  imap_perform_authenticate,  /* Send authentication command */ 
+  imap_continue_authenticate, /* Send authentication continuation */ 
+  imap_get_message            /* Get SASL response message */ 
 };
 
 
 #ifdef USE_SSL
 static void imap_to_imaps(struct connectdata *conn)
 {
-  /* Change the connection handler */
+  /* Change the connection handler */ 
   conn->handler = &Curl_handler_imaps;
-
-  /* Set the connection's upgraded to TLS flag */
+ 
+  /* Set the connection's upgraded to TLS flag */ 
   conn->bits.tls_upgraded = TRUE;
 }
 #else
@@ -229,8 +229,8 @@ static bool imap_matchresp(const char *line, size_t len, const char *cmd)
 
   /* Does the command name match and is it followed by a space character or at
      the end of line? */
-  if(line + cmd_len <= end && strncasecompare(line, cmd, cmd_len) &&
-     (line[cmd_len] == ' ' || line + cmd_len + 2 == end))
+  if(line + cmd_len <= end && strncasecompare(line, cmd, cmd_len) && 
+     (line[cmd_len] == ' ' || line + cmd_len + 2 == end)) 
     return TRUE;
 
   return FALSE;
@@ -257,11 +257,11 @@ static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
     len -= id_len + 1;
 
     if(len >= 2 && !memcmp(line, "OK", 2))
-      *resp = IMAP_RESP_OK;
-    else if(len >= 7 && !memcmp(line, "PREAUTH", 7))
-      *resp = IMAP_RESP_PREAUTH;
-    else
-      *resp = IMAP_RESP_NOT_OK;
+      *resp = IMAP_RESP_OK; 
+    else if(len >= 7 && !memcmp(line, "PREAUTH", 7)) 
+      *resp = IMAP_RESP_PREAUTH; 
+    else 
+      *resp = IMAP_RESP_NOT_OK; 
 
     return TRUE;
   }
@@ -278,15 +278,15 @@ static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
       case IMAP_LIST:
         if((!imap->custom && !imap_matchresp(line, len, "LIST")) ||
           (imap->custom && !imap_matchresp(line, len, imap->custom) &&
-           (!strcasecompare(imap->custom, "STORE") ||
+           (!strcasecompare(imap->custom, "STORE") || 
             !imap_matchresp(line, len, "FETCH")) &&
-           !strcasecompare(imap->custom, "SELECT") &&
-           !strcasecompare(imap->custom, "EXAMINE") &&
-           !strcasecompare(imap->custom, "SEARCH") &&
-           !strcasecompare(imap->custom, "EXPUNGE") &&
-           !strcasecompare(imap->custom, "LSUB") &&
-           !strcasecompare(imap->custom, "UID") &&
-           !strcasecompare(imap->custom, "NOOP")))
+           !strcasecompare(imap->custom, "SELECT") && 
+           !strcasecompare(imap->custom, "EXAMINE") && 
+           !strcasecompare(imap->custom, "SEARCH") && 
+           !strcasecompare(imap->custom, "EXPUNGE") && 
+           !strcasecompare(imap->custom, "LSUB") && 
+           !strcasecompare(imap->custom, "UID") && 
+           !strcasecompare(imap->custom, "NOOP"))) 
           return FALSE;
         break;
 
@@ -300,11 +300,11 @@ static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
           return FALSE;
         break;
 
-      case IMAP_SEARCH:
-        if(!imap_matchresp(line, len, "SEARCH"))
-          return FALSE;
-        break;
-
+      case IMAP_SEARCH: 
+        if(!imap_matchresp(line, len, "SEARCH")) 
+          return FALSE; 
+        break; 
+ 
       /* Ignore other untagged responses */
       default:
         return FALSE;
@@ -319,10 +319,10 @@ static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
      APPEND commands and as outlined in Section 4. Examples of RFC-4959 but
      some e-mail servers ignore this and only send a single + instead. */
   if(imap && !imap->custom && ((len == 3 && line[0] == '+') ||
-     (len >= 2 && !memcmp("+ ", line, 2)))) {
+     (len >= 2 && !memcmp("+ ", line, 2)))) { 
     switch(imapc->state) {
       /* States which are interested in continuation responses */
-      case IMAP_AUTHENTICATE:
+      case IMAP_AUTHENTICATE: 
       case IMAP_APPEND:
         *resp = '+';
         break;
@@ -341,42 +341,42 @@ static bool imap_endofresp(struct connectdata *conn, char *line, size_t len,
 
 /***********************************************************************
  *
- * imap_get_message()
- *
- * Gets the authentication message from the response buffer.
- */
-static void imap_get_message(char *buffer, char **outptr)
-{
-  size_t len = strlen(buffer);
-  char *message = NULL;
-
-  if(len > 2) {
-    /* Find the start of the message */
-    len -= 2;
-    for(message = buffer + 2; *message == ' ' || *message == '\t';
-        message++, len--)
-      ;
-
-    /* Find the end of the message */
-    for(; len--;)
-      if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' &&
-         message[len] != '\t')
-        break;
-
-    /* Terminate the message */
-    if(++len) {
-      message[len] = '\0';
-    }
-  }
-  else
-    /* junk input => zero length output */
-    message = &buffer[len];
-
-  *outptr = message;
-}
-
-/***********************************************************************
- *
+ * imap_get_message() 
+ * 
+ * Gets the authentication message from the response buffer. 
+ */ 
+static void imap_get_message(char *buffer, char **outptr) 
+{ 
+  size_t len = strlen(buffer); 
+  char *message = NULL; 
+ 
+  if(len > 2) { 
+    /* Find the start of the message */ 
+    len -= 2; 
+    for(message = buffer + 2; *message == ' ' || *message == '\t'; 
+        message++, len--) 
+      ; 
+ 
+    /* Find the end of the message */ 
+    for(; len--;) 
+      if(message[len] != '\r' && message[len] != '\n' && message[len] != ' ' && 
+         message[len] != '\t') 
+        break; 
+ 
+    /* Terminate the message */ 
+    if(++len) { 
+      message[len] = '\0'; 
+    } 
+  } 
+  else 
+    /* junk input => zero length output */ 
+    message = &buffer[len]; 
+ 
+  *outptr = message; 
+} 
+ 
+/*********************************************************************** 
+ * 
  * state()
  *
  * This is the ONLY way to change IMAP state!
@@ -392,7 +392,7 @@ static void state(struct connectdata *conn, imapstate newstate)
     "CAPABILITY",
     "STARTTLS",
     "UPGRADETLS",
-    "AUTHENTICATE",
+    "AUTHENTICATE", 
     "LOGIN",
     "LIST",
     "SELECT",
@@ -400,7 +400,7 @@ static void state(struct connectdata *conn, imapstate newstate)
     "FETCH_FINAL",
     "APPEND",
     "APPEND_FINAL",
-    "SEARCH",
+    "SEARCH", 
     "LOGOUT",
     /* LAST */
   };
@@ -424,9 +424,9 @@ static CURLcode imap_perform_capability(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
   struct imap_conn *imapc = &conn->proto.imapc;
-  imapc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */
-  imapc->sasl.authused = SASL_AUTH_NONE;  /* Clear the auth. mechanism used */
-  imapc->tls_supported = FALSE;           /* Clear the TLS capability */
+  imapc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanisms yet */ 
+  imapc->sasl.authused = SASL_AUTH_NONE;  /* Clear the auth. mechanism used */ 
+  imapc->tls_supported = FALSE;           /* Clear the TLS capability */ 
 
   /* Send the CAPABILITY command */
   result = imap_sendf(conn, "CAPABILITY");
@@ -501,15 +501,15 @@ static CURLcode imap_perform_login(struct connectdata *conn)
   }
 
   /* Make sure the username and password are in the correct atom format */
-  user = imap_atom(conn->user, false);
-  passwd = imap_atom(conn->passwd, false);
+  user = imap_atom(conn->user, false); 
+  passwd = imap_atom(conn->passwd, false); 
 
   /* Send the LOGIN command */
   result = imap_sendf(conn, "LOGIN %s %s", user ? user : "",
                       passwd ? passwd : "");
 
-  free(user);
-  free(passwd);
+  free(user); 
+  free(passwd); 
 
   if(!result)
     state(conn, IMAP_LOGIN);
@@ -521,70 +521,70 @@ static CURLcode imap_perform_login(struct connectdata *conn)
  *
  * imap_perform_authenticate()
  *
- * Sends an AUTHENTICATE command allowing the client to login with the given
- * SASL authentication mechanism.
+ * Sends an AUTHENTICATE command allowing the client to login with the given 
+ * SASL authentication mechanism. 
  */
-static CURLcode imap_perform_authenticate(struct connectdata *conn,
-                                          const char *mech,
-                                          const char *initresp)
+static CURLcode imap_perform_authenticate(struct connectdata *conn, 
+                                          const char *mech, 
+                                          const char *initresp) 
 {
   CURLcode result = CURLE_OK;
 
-  if(initresp) {
-    /* Send the AUTHENTICATE command with the initial response */
-    result = imap_sendf(conn, "AUTHENTICATE %s %s", mech, initresp);
+  if(initresp) { 
+    /* Send the AUTHENTICATE command with the initial response */ 
+    result = imap_sendf(conn, "AUTHENTICATE %s %s", mech, initresp); 
   }
-  else {
-    /* Send the AUTHENTICATE command */
-    result = imap_sendf(conn, "AUTHENTICATE %s", mech);
+  else { 
+    /* Send the AUTHENTICATE command */ 
+    result = imap_sendf(conn, "AUTHENTICATE %s", mech); 
   }
 
-  return result;
-}
-
-/***********************************************************************
- *
- * imap_continue_authenticate()
- *
- * Sends SASL continuation data or cancellation.
- */
-static CURLcode imap_continue_authenticate(struct connectdata *conn,
-                                           const char *resp)
-{
-  struct imap_conn *imapc = &conn->proto.imapc;
-
-  return Curl_pp_sendf(&imapc->pp, "%s", resp);
-}
-
-/***********************************************************************
- *
- * imap_perform_authentication()
- *
- * Initiates the authentication sequence, with the appropriate SASL
- * authentication mechanism, falling back to clear text should a common
- * mechanism not be available between the client and server.
- */
-static CURLcode imap_perform_authentication(struct connectdata *conn)
-{
-  CURLcode result = CURLE_OK;
-  struct imap_conn *imapc = &conn->proto.imapc;
-  saslprogress progress;
-
-  /* Check if already authenticated OR if there is enough data to authenticate
-     with and end the connect phase if we don't */
-  if(imapc->preauth ||
-     !Curl_sasl_can_authenticate(&imapc->sasl, conn)) {
-    state(conn, IMAP_STOP);
-    return result;
+  return result; 
+} 
+
+/*********************************************************************** 
+ * 
+ * imap_continue_authenticate() 
+ * 
+ * Sends SASL continuation data or cancellation. 
+ */ 
+static CURLcode imap_continue_authenticate(struct connectdata *conn, 
+                                           const char *resp) 
+{ 
+  struct imap_conn *imapc = &conn->proto.imapc; 
+
+  return Curl_pp_sendf(&imapc->pp, "%s", resp); 
+} 
+
+/*********************************************************************** 
+ * 
+ * imap_perform_authentication() 
+ * 
+ * Initiates the authentication sequence, with the appropriate SASL 
+ * authentication mechanism, falling back to clear text should a common 
+ * mechanism not be available between the client and server. 
+ */ 
+static CURLcode imap_perform_authentication(struct connectdata *conn) 
+{ 
+  CURLcode result = CURLE_OK; 
+  struct imap_conn *imapc = &conn->proto.imapc; 
+  saslprogress progress; 
+ 
+  /* Check if already authenticated OR if there is enough data to authenticate 
+     with and end the connect phase if we don't */ 
+  if(imapc->preauth || 
+     !Curl_sasl_can_authenticate(&imapc->sasl, conn)) { 
+    state(conn, IMAP_STOP); 
+    return result; 
   }
 
-  /* Calculate the SASL login details */
-  result = Curl_sasl_start(&imapc->sasl, conn, imapc->ir_supported, &progress);
-
+  /* Calculate the SASL login details */ 
+  result = Curl_sasl_start(&imapc->sasl, conn, imapc->ir_supported, &progress); 
+ 
   if(!result) {
-    if(progress == SASL_INPROGRESS)
-      state(conn, IMAP_AUTHENTICATE);
-    else if(!imapc->login_disabled && (imapc->preftype & IMAP_TYPE_CLEARTEXT))
+    if(progress == SASL_INPROGRESS) 
+      state(conn, IMAP_AUTHENTICATE); 
+    else if(!imapc->login_disabled && (imapc->preftype & IMAP_TYPE_CLEARTEXT)) 
       /* Perform clear text authentication */
       result = imap_perform_login(conn);
     else {
@@ -606,7 +606,7 @@ static CURLcode imap_perform_authentication(struct connectdata *conn)
 static CURLcode imap_perform_list(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
 
   if(imap->custom)
@@ -614,16 +614,16 @@ static CURLcode imap_perform_list(struct connectdata *conn)
     result = imap_sendf(conn, "%s%s", imap->custom,
                         imap->custom_params ? imap->custom_params : "");
   else {
-    /* Make sure the mailbox is in the correct atom format if necessary */
-    char *mailbox = imap->mailbox ? imap_atom(imap->mailbox, true)
-                                  : strdup("");
+    /* Make sure the mailbox is in the correct atom format if necessary */ 
+    char *mailbox = imap->mailbox ? imap_atom(imap->mailbox, true) 
+                                  : strdup(""); 
     if(!mailbox)
       return CURLE_OUT_OF_MEMORY;
 
     /* Send the LIST command */
     result = imap_sendf(conn, "LIST \"%s\" *", mailbox);
 
-    free(mailbox);
+    free(mailbox); 
   }
 
   if(!result)
@@ -641,7 +641,7 @@ static CURLcode imap_perform_list(struct connectdata *conn)
 static CURLcode imap_perform_select(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
   struct imap_conn *imapc = &conn->proto.imapc;
   char *mailbox;
@@ -657,14 +657,14 @@ static CURLcode imap_perform_select(struct connectdata *conn)
   }
 
   /* Make sure the mailbox is in the correct atom format */
-  mailbox = imap_atom(imap->mailbox, false);
+  mailbox = imap_atom(imap->mailbox, false); 
   if(!mailbox)
     return CURLE_OUT_OF_MEMORY;
 
   /* Send the SELECT command */
   result = imap_sendf(conn, "SELECT %s", mailbox);
 
-  free(mailbox);
+  free(mailbox); 
 
   if(!result)
     state(conn, IMAP_SELECT);
@@ -682,37 +682,37 @@ static CURLcode imap_perform_fetch(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
   struct IMAP *imap = conn->data->req.p.imap;
-  /* Check we have a UID */
-  if(imap->uid) {
-
-    /* Send the FETCH command */
-    if(imap->partial)
-      result = imap_sendf(conn, "UID FETCH %s BODY[%s]<%s>",
-                            imap->uid,
-                            imap->section ? imap->section : "",
-                            imap->partial);
-    else
-      result = imap_sendf(conn, "UID FETCH %s BODY[%s]",
-                            imap->uid,
-                            imap->section ? imap->section : "");
-  }
-  else if(imap->mindex) {
-
-    /* Send the FETCH command */
-    if(imap->partial)
-      result = imap_sendf(conn, "FETCH %s BODY[%s]<%s>",
-                            imap->mindex,
-                            imap->section ? imap->section : "",
-                            imap->partial);
-    else
-      result = imap_sendf(conn, "FETCH %s BODY[%s]",
-                            imap->mindex,
-                            imap->section ? imap->section : "");
-  }
-  else {
-        failf(conn->data, "Cannot FETCH without a UID.");
-        return CURLE_URL_MALFORMAT;
+  /* Check we have a UID */ 
+  if(imap->uid) { 
+
+    /* Send the FETCH command */ 
+    if(imap->partial) 
+      result = imap_sendf(conn, "UID FETCH %s BODY[%s]<%s>", 
+                            imap->uid, 
+                            imap->section ? imap->section : "", 
+                            imap->partial); 
+    else 
+      result = imap_sendf(conn, "UID FETCH %s BODY[%s]", 
+                            imap->uid, 
+                            imap->section ? imap->section : ""); 
   }
+  else if(imap->mindex) { 
+
+    /* Send the FETCH command */ 
+    if(imap->partial) 
+      result = imap_sendf(conn, "FETCH %s BODY[%s]<%s>", 
+                            imap->mindex, 
+                            imap->section ? imap->section : "", 
+                            imap->partial); 
+    else 
+      result = imap_sendf(conn, "FETCH %s BODY[%s]", 
+                            imap->mindex, 
+                            imap->section ? imap->section : ""); 
+  } 
+  else { 
+        failf(conn->data, "Cannot FETCH without a UID."); 
+        return CURLE_URL_MALFORMAT; 
+  } 
   if(!result)
     state(conn, IMAP_FETCH);
 
@@ -728,61 +728,61 @@ static CURLcode imap_perform_fetch(struct connectdata *conn)
 static CURLcode imap_perform_append(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
   char *mailbox;
 
   /* Check we have a mailbox */
   if(!imap->mailbox) {
-    failf(data, "Cannot APPEND without a mailbox.");
+    failf(data, "Cannot APPEND without a mailbox."); 
     return CURLE_URL_MALFORMAT;
   }
 
-  /* Prepare the mime data if some. */
-  if(data->set.mimepost.kind != MIMEKIND_NONE) {
-    /* Use the whole structure as data. */
-    data->set.mimepost.flags &= ~MIME_BODY_ONLY;
-
-    /* Add external headers and mime version. */
-    curl_mime_headers(&data->set.mimepost, data->set.headers, 0);
-    result = Curl_mime_prepare_headers(&data->set.mimepost, NULL,
-                                       NULL, MIMESTRATEGY_MAIL);
-
-    if(!result)
-      if(!Curl_checkheaders(conn, "Mime-Version"))
-        result = Curl_mime_add_header(&data->set.mimepost.curlheaders,
-                                      "Mime-Version: 1.0");
-
-    /* Make sure we will read the entire mime structure. */
-    if(!result)
-      result = Curl_mime_rewind(&data->set.mimepost);
-
-    if(result)
-      return result;
-
-    data->state.infilesize = Curl_mime_size(&data->set.mimepost);
-
-    /* Read from mime structure. */
-    data->state.fread_func = (curl_read_callback) Curl_mime_read;
-    data->state.in = (void *) &data->set.mimepost;
-  }
-
+  /* Prepare the mime data if some. */ 
+  if(data->set.mimepost.kind != MIMEKIND_NONE) { 
+    /* Use the whole structure as data. */ 
+    data->set.mimepost.flags &= ~MIME_BODY_ONLY; 
+ 
+    /* Add external headers and mime version. */ 
+    curl_mime_headers(&data->set.mimepost, data->set.headers, 0); 
+    result = Curl_mime_prepare_headers(&data->set.mimepost, NULL, 
+                                       NULL, MIMESTRATEGY_MAIL); 
+ 
+    if(!result) 
+      if(!Curl_checkheaders(conn, "Mime-Version")) 
+        result = Curl_mime_add_header(&data->set.mimepost.curlheaders, 
+                                      "Mime-Version: 1.0"); 
+ 
+    /* Make sure we will read the entire mime structure. */ 
+    if(!result) 
+      result = Curl_mime_rewind(&data->set.mimepost); 
+ 
+    if(result) 
+      return result; 
+ 
+    data->state.infilesize = Curl_mime_size(&data->set.mimepost); 
+ 
+    /* Read from mime structure. */ 
+    data->state.fread_func = (curl_read_callback) Curl_mime_read; 
+    data->state.in = (void *) &data->set.mimepost; 
+  } 
+ 
   /* Check we know the size of the upload */
-  if(data->state.infilesize < 0) {
-    failf(data, "Cannot APPEND with unknown input file size\n");
+  if(data->state.infilesize < 0) { 
+    failf(data, "Cannot APPEND with unknown input file size\n"); 
     return CURLE_UPLOAD_FAILED;
   }
 
   /* Make sure the mailbox is in the correct atom format */
-  mailbox = imap_atom(imap->mailbox, false);
+  mailbox = imap_atom(imap->mailbox, false); 
   if(!mailbox)
     return CURLE_OUT_OF_MEMORY;
 
   /* Send the APPEND command */
-  result = imap_sendf(conn, "APPEND %s (\\Seen) {%" CURL_FORMAT_CURL_OFF_T "}",
-                      mailbox, data->state.infilesize);
+  result = imap_sendf(conn, "APPEND %s (\\Seen) {%" CURL_FORMAT_CURL_OFF_T "}", 
+                      mailbox, data->state.infilesize); 
 
-  free(mailbox);
+  free(mailbox); 
 
   if(!result)
     state(conn, IMAP_APPEND);
@@ -792,32 +792,32 @@ static CURLcode imap_perform_append(struct connectdata *conn)
 
 /***********************************************************************
  *
- * imap_perform_search()
- *
- * Sends a SEARCH command.
- */
-static CURLcode imap_perform_search(struct connectdata *conn)
-{
-  CURLcode result = CURLE_OK;
+ * imap_perform_search() 
+ * 
+ * Sends a SEARCH command. 
+ */ 
+static CURLcode imap_perform_search(struct connectdata *conn) 
+{ 
+  CURLcode result = CURLE_OK; 
   struct IMAP *imap = conn->data->req.p.imap;
-
-  /* Check we have a query string */
-  if(!imap->query) {
-    failf(conn->data, "Cannot SEARCH without a query string.");
-    return CURLE_URL_MALFORMAT;
-  }
-
-  /* Send the SEARCH command */
-  result = imap_sendf(conn, "SEARCH %s", imap->query);
-
-  if(!result)
-    state(conn, IMAP_SEARCH);
-
-  return result;
-}
-
-/***********************************************************************
- *
+ 
+  /* Check we have a query string */ 
+  if(!imap->query) { 
+    failf(conn->data, "Cannot SEARCH without a query string."); 
+    return CURLE_URL_MALFORMAT; 
+  } 
+ 
+  /* Send the SEARCH command */ 
+  result = imap_sendf(conn, "SEARCH %s", imap->query); 
+ 
+  if(!result) 
+    state(conn, IMAP_SEARCH); 
+ 
+  return result; 
+} 
+ 
+/*********************************************************************** 
+ * 
  * imap_perform_logout()
  *
  * Performs the logout action prior to sclose() being called.
@@ -838,21 +838,21 @@ static CURLcode imap_state_servergreet_resp(struct connectdata *conn,
                                             int imapcode,
                                             imapstate instate)
 {
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   (void)instate; /* no use for this yet */
 
-  if(imapcode == IMAP_RESP_PREAUTH) {
-    /* PREAUTH */
-    struct imap_conn *imapc = &conn->proto.imapc;
-    imapc->preauth = TRUE;
-    infof(data, "PREAUTH connection, already authenticated!\n");
-  }
-  else if(imapcode != IMAP_RESP_OK) {
+  if(imapcode == IMAP_RESP_PREAUTH) { 
+    /* PREAUTH */ 
+    struct imap_conn *imapc = &conn->proto.imapc; 
+    imapc->preauth = TRUE; 
+    infof(data, "PREAUTH connection, already authenticated!\n"); 
+  } 
+  else if(imapcode != IMAP_RESP_OK) { 
     failf(data, "Got unexpected imap-server response");
-    return CURLE_WEIRD_SERVER_REPLY;
+    return CURLE_WEIRD_SERVER_REPLY; 
   }
 
-  return imap_perform_capability(conn);
+  return imap_perform_capability(conn); 
 }
 
 /* For CAPABILITY responses */
@@ -861,7 +861,7 @@ static CURLcode imap_state_capability_resp(struct connectdata *conn,
                                            imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct imap_conn *imapc = &conn->proto.imapc;
   const char *line = data->state.buffer;
 
@@ -873,7 +873,7 @@ static CURLcode imap_state_capability_resp(struct connectdata *conn,
 
     /* Loop through the data line */
     for(;;) {
-      size_t wordlen;
+      size_t wordlen; 
       while(*line &&
             (*line == ' ' || *line == '\t' ||
               *line == '\r' || *line == '\n')) {
@@ -904,22 +904,22 @@ static CURLcode imap_state_capability_resp(struct connectdata *conn,
 
       /* Do we have a SASL based authentication mechanism? */
       else if(wordlen > 5 && !memcmp(line, "AUTH=", 5)) {
-        size_t llen;
-        unsigned int mechbit;
-
+        size_t llen; 
+        unsigned int mechbit; 
+ 
         line += 5;
         wordlen -= 5;
 
         /* Test the word for a matching authentication mechanism */
-        mechbit = Curl_sasl_decode_mech(line, wordlen, &llen);
-        if(mechbit && llen == wordlen)
-          imapc->sasl.authmechs |= mechbit;
+        mechbit = Curl_sasl_decode_mech(line, wordlen, &llen); 
+        if(mechbit && llen == wordlen) 
+          imapc->sasl.authmechs |= mechbit; 
       }
 
       line += wordlen;
     }
   }
-  else if(imapcode == IMAP_RESP_OK) {
+  else if(imapcode == IMAP_RESP_OK) { 
     if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
       /* We don't have a SSL/TLS connection yet, but SSL is requested */
       if(imapc->tls_supported)
@@ -927,17 +927,17 @@ static CURLcode imap_state_capability_resp(struct connectdata *conn,
         result = imap_perform_starttls(conn);
       else if(data->set.use_ssl == CURLUSESSL_TRY)
         /* Fallback and carry on with authentication */
-        result = imap_perform_authentication(conn);
+        result = imap_perform_authentication(conn); 
       else {
         failf(data, "STARTTLS not supported.");
         result = CURLE_USE_SSL_FAILED;
       }
     }
     else
-      result = imap_perform_authentication(conn);
+      result = imap_perform_authentication(conn); 
   }
   else
-    result = imap_perform_authentication(conn);
+    result = imap_perform_authentication(conn); 
 
   return result;
 }
@@ -948,17 +948,17 @@ static CURLcode imap_state_starttls_resp(struct connectdata *conn,
                                          imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
 
   (void)instate; /* no use for this yet */
 
-  if(imapcode != IMAP_RESP_OK) {
+  if(imapcode != IMAP_RESP_OK) { 
     if(data->set.use_ssl != CURLUSESSL_TRY) {
-      failf(data, "STARTTLS denied");
+      failf(data, "STARTTLS denied"); 
       result = CURLE_USE_SSL_FAILED;
     }
     else
-      result = imap_perform_authentication(conn);
+      result = imap_perform_authentication(conn); 
   }
   else
     result = imap_perform_upgrade_tls(conn);
@@ -966,35 +966,35 @@ static CURLcode imap_state_starttls_resp(struct connectdata *conn,
   return result;
 }
 
-/* For SASL authentication responses */
-static CURLcode imap_state_auth_resp(struct connectdata *conn,
-                                     int imapcode,
-                                     imapstate instate)
+/* For SASL authentication responses */ 
+static CURLcode imap_state_auth_resp(struct connectdata *conn, 
+                                     int imapcode, 
+                                     imapstate instate) 
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
-  struct imap_conn *imapc = &conn->proto.imapc;
-  saslprogress progress;
+  struct Curl_easy *data = conn->data; 
+  struct imap_conn *imapc = &conn->proto.imapc; 
+  saslprogress progress; 
 
   (void)instate; /* no use for this yet */
 
-  result = Curl_sasl_continue(&imapc->sasl, conn, imapcode, &progress);
-  if(!result)
-    switch(progress) {
-    case SASL_DONE:
-      state(conn, IMAP_STOP);  /* Authenticated */
-      break;
-    case SASL_IDLE:            /* No mechanism left after cancellation */
-      if((!imapc->login_disabled) && (imapc->preftype & IMAP_TYPE_CLEARTEXT))
-        /* Perform clear text authentication */
-        result = imap_perform_login(conn);
-      else {
-        failf(data, "Authentication cancelled");
-        result = CURLE_LOGIN_DENIED;
+  result = Curl_sasl_continue(&imapc->sasl, conn, imapcode, &progress); 
+  if(!result) 
+    switch(progress) { 
+    case SASL_DONE: 
+      state(conn, IMAP_STOP);  /* Authenticated */ 
+      break; 
+    case SASL_IDLE:            /* No mechanism left after cancellation */ 
+      if((!imapc->login_disabled) && (imapc->preftype & IMAP_TYPE_CLEARTEXT)) 
+        /* Perform clear text authentication */ 
+        result = imap_perform_login(conn); 
+      else { 
+        failf(data, "Authentication cancelled"); 
+        result = CURLE_LOGIN_DENIED; 
       }
-      break;
-    default:
-      break;
+      break; 
+    default: 
+      break; 
     }
 
   return result;
@@ -1006,11 +1006,11 @@ static CURLcode imap_state_login_resp(struct connectdata *conn,
                                       imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
 
   (void)instate; /* no use for this yet */
 
-  if(imapcode != IMAP_RESP_OK) {
+  if(imapcode != IMAP_RESP_OK) { 
     failf(data, "Access denied. %c", imapcode);
     result = CURLE_LOGIN_DENIED;
   }
@@ -1021,10 +1021,10 @@ static CURLcode imap_state_login_resp(struct connectdata *conn,
   return result;
 }
 
-/* For LIST and SEARCH responses */
-static CURLcode imap_state_listsearch_resp(struct connectdata *conn,
-                                           int imapcode,
-                                           imapstate instate)
+/* For LIST and SEARCH responses */ 
+static CURLcode imap_state_listsearch_resp(struct connectdata *conn, 
+                                           int imapcode, 
+                                           imapstate instate) 
 {
   CURLcode result = CURLE_OK;
   char *line = conn->data->state.buffer;
@@ -1038,7 +1038,7 @@ static CURLcode imap_state_listsearch_resp(struct connectdata *conn,
     result = Curl_client_write(conn, CLIENTWRITE_BODY, line, len + 1);
     line[len] = '\0';
   }
-  else if(imapcode != IMAP_RESP_OK)
+  else if(imapcode != IMAP_RESP_OK) 
     result = CURLE_QUOTE_ERROR;
   else
     /* End of DO phase */
@@ -1052,7 +1052,7 @@ static CURLcode imap_state_select_resp(struct connectdata *conn, int imapcode,
                                        imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = conn->data->req.p.imap;
   struct imap_conn *imapc = &conn->proto.imapc;
   const char *line = data->state.buffer;
@@ -1061,16 +1061,16 @@ static CURLcode imap_state_select_resp(struct connectdata *conn, int imapcode,
 
   if(imapcode == '*') {
     /* See if this is an UIDVALIDITY response */
-    char tmp[20];
+    char tmp[20]; 
     if(sscanf(line + 2, "OK [UIDVALIDITY %19[0123456789]]", tmp) == 1) {
       Curl_safefree(imapc->mailbox_uidvalidity);
       imapc->mailbox_uidvalidity = strdup(tmp);
     }
   }
-  else if(imapcode == IMAP_RESP_OK) {
+  else if(imapcode == IMAP_RESP_OK) { 
     /* Check if the UIDVALIDITY has been specified and matches */
     if(imap->uidvalidity && imapc->mailbox_uidvalidity &&
-       !strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)) {
+       !strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)) { 
       failf(conn->data, "Mailbox UIDVALIDITY has changed");
       result = CURLE_REMOTE_FILE_NOT_FOUND;
     }
@@ -1080,8 +1080,8 @@ static CURLcode imap_state_select_resp(struct connectdata *conn, int imapcode,
 
       if(imap->custom)
         result = imap_perform_list(conn);
-      else if(imap->query)
-        result = imap_perform_search(conn);
+      else if(imap->query) 
+        result = imap_perform_search(conn); 
       else
         result = imap_perform_fetch(conn);
     }
@@ -1099,17 +1099,17 @@ static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
                                       imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct imap_conn *imapc = &conn->proto.imapc;
   struct pingpong *pp = &imapc->pp;
   const char *ptr = data->state.buffer;
   bool parsed = FALSE;
-  curl_off_t size = 0;
+  curl_off_t size = 0; 
 
   (void)instate; /* no use for this yet */
 
   if(imapcode != '*') {
-    Curl_pgrsSetDownloadSize(data, -1);
+    Curl_pgrsSetDownloadSize(data, -1); 
     state(conn, IMAP_STOP);
     return CURLE_REMOTE_FILE_NOT_FOUND;
   }
@@ -1121,16 +1121,16 @@ static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
 
   if(*ptr == '{') {
     char *endptr;
-    if(!curlx_strtoofft(ptr + 1, &endptr, 10, &size)) {
-      if(endptr - ptr > 1 && endptr[0] == '}' &&
-         endptr[1] == '\r' && endptr[2] == '\0')
-        parsed = TRUE;
-    }
+    if(!curlx_strtoofft(ptr + 1, &endptr, 10, &size)) { 
+      if(endptr - ptr > 1 && endptr[0] == '}' && 
+         endptr[1] == '\r' && endptr[2] == '\0') 
+        parsed = TRUE; 
+    } 
   }
 
   if(parsed) {
-    infof(data, "Found %" CURL_FORMAT_CURL_OFF_T " bytes to download\n",
-          size);
+    infof(data, "Found %" CURL_FORMAT_CURL_OFF_T " bytes to download\n", 
+          size); 
     Curl_pgrsSetDownloadSize(data, size);
 
     if(pp->cache) {
@@ -1143,19 +1143,19 @@ static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
         /* The conversion from curl_off_t to size_t is always fine here */
         chunk = (size_t)size;
 
-      if(!chunk) {
-        /* no size, we're done with the data */
-        state(conn, IMAP_STOP);
-        return CURLE_OK;
-      }
+      if(!chunk) { 
+        /* no size, we're done with the data */ 
+        state(conn, IMAP_STOP); 
+        return CURLE_OK; 
+      } 
       result = Curl_client_write(conn, CLIENTWRITE_BODY, pp->cache, chunk);
       if(result)
         return result;
 
       data->req.bytecount += chunk;
 
-      infof(data, "Written %zu bytes, %" CURL_FORMAT_CURL_OFF_TU
-            " bytes are left for transfer\n", chunk, size - chunk);
+      infof(data, "Written %zu bytes, %" CURL_FORMAT_CURL_OFF_TU 
+            " bytes are left for transfer\n", chunk, size - chunk); 
 
       /* Have we used the entire cache or just part of it?*/
       if(pp->cache_size > chunk) {
@@ -1187,7 +1187,7 @@ static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
   else {
     /* We don't know how to parse this line */
     failf(pp->conn->data, "Failed to parse FETCH response.");
-    result = CURLE_WEIRD_SERVER_REPLY;
+    result = CURLE_WEIRD_SERVER_REPLY; 
   }
 
   /* End of DO phase */
@@ -1205,8 +1205,8 @@ static CURLcode imap_state_fetch_final_resp(struct connectdata *conn,
 
   (void)instate; /* No use for this yet */
 
-  if(imapcode != IMAP_RESP_OK)
-    result = CURLE_WEIRD_SERVER_REPLY;
+  if(imapcode != IMAP_RESP_OK) 
+    result = CURLE_WEIRD_SERVER_REPLY; 
   else
     /* End of DONE phase */
     state(conn, IMAP_STOP);
@@ -1219,7 +1219,7 @@ static CURLcode imap_state_append_resp(struct connectdata *conn, int imapcode,
                                        imapstate instate)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
 
   (void)instate; /* No use for this yet */
 
@@ -1228,7 +1228,7 @@ static CURLcode imap_state_append_resp(struct connectdata *conn, int imapcode,
   }
   else {
     /* Set the progress upload size */
-    Curl_pgrsSetUploadSize(data, data->state.infilesize);
+    Curl_pgrsSetUploadSize(data, data->state.infilesize); 
 
     /* IMAP upload */
     Curl_setup_transfer(data, -1, -1, FALSE, FIRSTSOCKET);
@@ -1249,7 +1249,7 @@ static CURLcode imap_state_append_final_resp(struct connectdata *conn,
 
   (void)instate; /* No use for this yet */
 
-  if(imapcode != IMAP_RESP_OK)
+  if(imapcode != IMAP_RESP_OK) 
     result = CURLE_UPLOAD_FAILED;
   else
     /* End of DONE phase */
@@ -1283,7 +1283,7 @@ static CURLcode imap_statemach_act(struct connectdata *conn)
 
     /* Was there an error parsing the response line? */
     if(imapcode == -1)
-      return CURLE_WEIRD_SERVER_REPLY;
+      return CURLE_WEIRD_SERVER_REPLY; 
 
     if(!imapcode)
       break;
@@ -1302,8 +1302,8 @@ static CURLcode imap_statemach_act(struct connectdata *conn)
       result = imap_state_starttls_resp(conn, imapcode, imapc->state);
       break;
 
-    case IMAP_AUTHENTICATE:
-      result = imap_state_auth_resp(conn, imapcode, imapc->state);
+    case IMAP_AUTHENTICATE: 
+      result = imap_state_auth_resp(conn, imapcode, imapc->state); 
       break;
 
     case IMAP_LOGIN:
@@ -1312,7 +1312,7 @@ static CURLcode imap_statemach_act(struct connectdata *conn)
 
     case IMAP_LIST:
     case IMAP_SEARCH:
-      result = imap_state_listsearch_resp(conn, imapcode, imapc->state);
+      result = imap_state_listsearch_resp(conn, imapcode, imapc->state); 
       break;
 
     case IMAP_SELECT:
@@ -1377,12 +1377,12 @@ static CURLcode imap_block_statemach(struct connectdata *conn,
   return result;
 }
 
-/* Allocate and initialize the struct IMAP for the current Curl_easy if
+/* Allocate and initialize the struct IMAP for the current Curl_easy if 
    required */
 static CURLcode imap_init(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap;
 
   imap = data->req.p.imap = calloc(sizeof(struct IMAP), 1);
@@ -1417,7 +1417,7 @@ static CURLcode imap_connect(struct connectdata *conn, bool *done)
   *done = FALSE; /* default to not done yet */
 
   /* We always support persistent connections in IMAP */
-  connkeep(conn, "IMAP default");
+  connkeep(conn, "IMAP default"); 
 
   /* Set the default response time-out */
   pp->response_time = RESP_TIMEOUT;
@@ -1425,9 +1425,9 @@ static CURLcode imap_connect(struct connectdata *conn, bool *done)
   pp->endofresp = imap_endofresp;
   pp->conn = conn;
 
-  /* Set the default preferred authentication type and mechanism */
-  imapc->preftype = IMAP_TYPE_ANY;
-  Curl_sasl_init(&imapc->sasl, &saslimap);
+  /* Set the default preferred authentication type and mechanism */ 
+  imapc->preftype = IMAP_TYPE_ANY; 
+  Curl_sasl_init(&imapc->sasl, &saslimap); 
 
   Curl_dyn_init(&imapc->dyn, DYN_IMAP_CMD);
   /* Initialise the pingpong layer */
@@ -1463,7 +1463,7 @@ static CURLcode imap_done(struct connectdata *conn, CURLcode status,
                           bool premature)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
 
   (void)premature;
@@ -1472,15 +1472,15 @@ static CURLcode imap_done(struct connectdata *conn, CURLcode status,
     return CURLE_OK;
 
   if(status) {
-    connclose(conn, "IMAP done with bad status"); /* marked for closure */
+    connclose(conn, "IMAP done with bad status"); /* marked for closure */ 
     result = status;         /* use the already set error code */
   }
   else if(!data->set.connect_only && !imap->custom &&
-          (imap->uid || imap->mindex || data->set.upload ||
-          data->set.mimepost.kind != MIMEKIND_NONE)) {
+          (imap->uid || imap->mindex || data->set.upload || 
+          data->set.mimepost.kind != MIMEKIND_NONE)) { 
     /* Handle responses after FETCH or APPEND transfer has finished */
-
-    if(!data->set.upload && data->set.mimepost.kind == MIMEKIND_NONE)
+ 
+    if(!data->set.upload && data->set.mimepost.kind == MIMEKIND_NONE) 
       state(conn, IMAP_FETCH_FINAL);
     else {
       /* End the APPEND command first by sending an empty line */
@@ -1498,10 +1498,10 @@ static CURLcode imap_done(struct connectdata *conn, CURLcode status,
   Curl_safefree(imap->mailbox);
   Curl_safefree(imap->uidvalidity);
   Curl_safefree(imap->uid);
-  Curl_safefree(imap->mindex);
+  Curl_safefree(imap->mindex); 
   Curl_safefree(imap->section);
-  Curl_safefree(imap->partial);
-  Curl_safefree(imap->query);
+  Curl_safefree(imap->partial); 
+  Curl_safefree(imap->query); 
   Curl_safefree(imap->custom);
   Curl_safefree(imap->custom_params);
 
@@ -1523,7 +1523,7 @@ static CURLcode imap_perform(struct connectdata *conn, bool *connected,
 {
   /* This is IMAP and no proxy */
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
   struct imap_conn *imapc = &conn->proto.imapc;
   bool selected = FALSE;
@@ -1540,26 +1540,26 @@ static CURLcode imap_perform(struct connectdata *conn, bool *connected,
   /* Determine if the requested mailbox (with the same UIDVALIDITY if set)
      has already been selected on this connection */
   if(imap->mailbox && imapc->mailbox &&
-     strcasecompare(imap->mailbox, imapc->mailbox) &&
+     strcasecompare(imap->mailbox, imapc->mailbox) && 
      (!imap->uidvalidity || !imapc->mailbox_uidvalidity ||
-      strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)))
+      strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity))) 
     selected = TRUE;
 
   /* Start the first command in the DO phase */
-  if(conn->data->set.upload || data->set.mimepost.kind != MIMEKIND_NONE)
+  if(conn->data->set.upload || data->set.mimepost.kind != MIMEKIND_NONE) 
     /* APPEND can be executed directly */
     result = imap_perform_append(conn);
   else if(imap->custom && (selected || !imap->mailbox))
     /* Custom command using the same mailbox or no mailbox */
     result = imap_perform_list(conn);
-  else if(!imap->custom && selected && (imap->uid || imap->mindex))
+  else if(!imap->custom && selected && (imap->uid || imap->mindex)) 
     /* FETCH from the same mailbox */
     result = imap_perform_fetch(conn);
-  else if(!imap->custom && selected && imap->query)
-    /* SEARCH the current mailbox */
-    result = imap_perform_search(conn);
-  else if(imap->mailbox && !selected &&
-         (imap->custom || imap->uid || imap->mindex || imap->query))
+  else if(!imap->custom && selected && imap->query) 
+    /* SEARCH the current mailbox */ 
+    result = imap_perform_search(conn); 
+  else if(imap->mailbox && !selected && 
+         (imap->custom || imap->uid || imap->mindex || imap->query)) 
     /* SELECT the mailbox */
     result = imap_perform_select(conn);
   else
@@ -1627,7 +1627,7 @@ static CURLcode imap_disconnect(struct connectdata *conn, bool dead_connection)
 
   /* The IMAP session may or may not have been allocated/setup at this
      point! */
-  if(!dead_connection && imapc->pp.conn && imapc->pp.conn->bits.protoconnstart)
+  if(!dead_connection && imapc->pp.conn && imapc->pp.conn->bits.protoconnstart) 
     if(!imap_perform_logout(conn))
       (void)imap_block_statemach(conn, TRUE); /* ignore errors on LOGOUT */
 
@@ -1636,7 +1636,7 @@ static CURLcode imap_disconnect(struct connectdata *conn, bool dead_connection)
   Curl_dyn_free(&imapc->dyn);
 
   /* Cleanup the SASL module */
-  Curl_sasl_cleanup(conn, imapc->sasl.authused);
+  Curl_sasl_cleanup(conn, imapc->sasl.authused); 
 
   /* Cleanup our connection based variables */
   Curl_safefree(imapc->mailbox);
@@ -1689,7 +1689,7 @@ static CURLcode imap_regular_transfer(struct connectdata *conn,
 {
   CURLcode result = CURLE_OK;
   bool connected = FALSE;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
 
   /* Make sure size is unknown at this point */
   data->req.size = -1;
@@ -1697,8 +1697,8 @@ static CURLcode imap_regular_transfer(struct connectdata *conn,
   /* Set the progress data */
   Curl_pgrsSetUploadCounter(data, 0);
   Curl_pgrsSetDownloadCounter(data, 0);
-  Curl_pgrsSetUploadSize(data, -1);
-  Curl_pgrsSetDownloadSize(data, -1);
+  Curl_pgrsSetUploadSize(data, -1); 
+  Curl_pgrsSetDownloadSize(data, -1); 
 
   /* Carry out the perform */
   result = imap_perform(conn, &connected, dophase_done);
@@ -1717,7 +1717,7 @@ static CURLcode imap_setup_connection(struct connectdata *conn)
   if(result)
     return result;
 
-  /* Clear the TLS upgraded flag */
+  /* Clear the TLS upgraded flag */ 
   conn->bits.tls_upgraded = FALSE;
 
   return CURLE_OK;
@@ -1727,7 +1727,7 @@ static CURLcode imap_setup_connection(struct connectdata *conn)
  *
  * imap_sendf()
  *
- * Sends the formatted string as an IMAP command to the server.
+ * Sends the formatted string as an IMAP command to the server. 
  *
  * Designed to never block.
  */
@@ -1739,7 +1739,7 @@ static CURLcode imap_sendf(struct connectdata *conn, const char *fmt, ...)
   DEBUGASSERT(fmt);
 
   /* Calculate the tag based on the connection ID and command ID */
-  msnprintf(imapc->resptag, sizeof(imapc->resptag), "%c%03d",
+  msnprintf(imapc->resptag, sizeof(imapc->resptag), "%c%03d", 
             'A' + curlx_sltosi(conn->connection_id % 26),
             (++imapc->cmdid)%1000);
 
@@ -1767,22 +1767,22 @@ static CURLcode imap_sendf(struct connectdata *conn, const char *fmt, ...)
  * The returned string needs to be freed.
  *
  */
-static char *imap_atom(const char *str, bool escape_only)
+static char *imap_atom(const char *str, bool escape_only) 
 {
-  /* !checksrc! disable PARENBRACE 1 */
-  const char atom_specials[] = "(){ %*]";
+  /* !checksrc! disable PARENBRACE 1 */ 
+  const char atom_specials[] = "(){ %*]"; 
   const char *p1;
   char *p2;
   size_t backsp_count = 0;
   size_t quote_count = 0;
-  bool others_exists = FALSE;
+  bool others_exists = FALSE; 
   size_t newlen = 0;
   char *newstr = NULL;
 
   if(!str)
     return NULL;
 
-  /* Look for "atom-specials", counting the backslash and quote characters as
+  /* Look for "atom-specials", counting the backslash and quote characters as 
      these will need escaping */
   p1 = str;
   while(*p1) {
@@ -1790,26 +1790,26 @@ static char *imap_atom(const char *str, bool escape_only)
       backsp_count++;
     else if(*p1 == '"')
       quote_count++;
-    else if(!escape_only) {
-      const char *p3 = atom_specials;
-
-      while(*p3 && !others_exists) {
-        if(*p1 == *p3)
-          others_exists = TRUE;
-
-        p3++;
-      }
-    }
-
+    else if(!escape_only) { 
+      const char *p3 = atom_specials; 
+
+      while(*p3 && !others_exists) { 
+        if(*p1 == *p3) 
+          others_exists = TRUE; 
+ 
+        p3++; 
+      } 
+    } 
+ 
     p1++;
   }
 
-  /* Does the input contain any "atom-special" characters? */
-  if(!backsp_count && !quote_count && !others_exists)
+  /* Does the input contain any "atom-special" characters? */ 
+  if(!backsp_count && !quote_count && !others_exists) 
     return strdup(str);
 
   /* Calculate the new string length */
-  newlen = strlen(str) + backsp_count + quote_count + (escape_only ? 0 : 2);
+  newlen = strlen(str) + backsp_count + quote_count + (escape_only ? 0 : 2); 
 
   /* Allocate the new string */
   newstr = (char *) malloc((newlen + 1) * sizeof(char));
@@ -1818,7 +1818,7 @@ static char *imap_atom(const char *str, bool escape_only)
 
   /* Surround the string in quotes if necessary */
   p2 = newstr;
-  if(!escape_only) {
+  if(!escape_only) { 
     newstr[0] = '"';
     newstr[newlen - 1] = '"';
     p2++;
@@ -1892,44 +1892,44 @@ static CURLcode imap_parse_url_options(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
   struct imap_conn *imapc = &conn->proto.imapc;
-  const char *ptr = conn->options;
+  const char *ptr = conn->options; 
 
-  imapc->sasl.resetprefs = TRUE;
-
-  while(!result && ptr && *ptr) {
+  imapc->sasl.resetprefs = TRUE; 
+ 
+  while(!result && ptr && *ptr) { 
     const char *key = ptr;
-    const char *value;
+    const char *value; 
 
     while(*ptr && *ptr != '=')
         ptr++;
 
-    value = ptr + 1;
+    value = ptr + 1; 
 
-    while(*ptr && *ptr != ';')
-      ptr++;
-
-    if(strncasecompare(key, "AUTH=", 5))
-      result = Curl_sasl_parse_url_auth_option(&imapc->sasl,
-                                               value, ptr - value);
+    while(*ptr && *ptr != ';') 
+      ptr++; 
+ 
+    if(strncasecompare(key, "AUTH=", 5)) 
+      result = Curl_sasl_parse_url_auth_option(&imapc->sasl, 
+                                               value, ptr - value); 
     else
       result = CURLE_URL_MALFORMAT;
-
-    if(*ptr == ';')
-      ptr++;
-  }
-
-  switch(imapc->sasl.prefmech) {
-  case SASL_AUTH_NONE:
-    imapc->preftype = IMAP_TYPE_NONE;
-    break;
-  case SASL_AUTH_DEFAULT:
-    imapc->preftype = IMAP_TYPE_ANY;
-    break;
-  default:
-    imapc->preftype = IMAP_TYPE_SASL;
-    break;
+ 
+    if(*ptr == ';') 
+      ptr++; 
   }
 
+  switch(imapc->sasl.prefmech) { 
+  case SASL_AUTH_NONE: 
+    imapc->preftype = IMAP_TYPE_NONE; 
+    break; 
+  case SASL_AUTH_DEFAULT: 
+    imapc->preftype = IMAP_TYPE_ANY; 
+    break; 
+  default: 
+    imapc->preftype = IMAP_TYPE_SASL; 
+    break; 
+  } 
+ 
   return result;
 }
 
@@ -1944,9 +1944,9 @@ static CURLcode imap_parse_url_path(struct connectdata *conn)
 {
   /* The imap struct is already initialised in imap_connect() */
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
-  const char *begin = &data->state.up.path[1]; /* skip leading slash */
+  const char *begin = &data->state.up.path[1]; /* skip leading slash */ 
   const char *ptr = begin;
 
   /* See how much of the URL is a valid path and decode it */
@@ -1996,70 +1996,70 @@ static CURLcode imap_parse_url_path(struct connectdata *conn)
     result = Curl_urldecode(data, begin, ptr - begin, &value, &valuelen,
                             REJECT_CTRL);
     if(result) {
-      free(name);
+      free(name); 
       return result;
     }
 
     DEBUGF(infof(conn->data, "IMAP URL parameter '%s' = '%s'\n", name, value));
 
-    /* Process the known hierarchical parameters (UIDVALIDITY, UID, SECTION and
-       PARTIAL) stripping of the trailing slash character if it is present.
+    /* Process the known hierarchical parameters (UIDVALIDITY, UID, SECTION and 
+       PARTIAL) stripping of the trailing slash character if it is present. 
 
        Note: Unknown parameters trigger a URL_MALFORMAT error. */
-    if(strcasecompare(name, "UIDVALIDITY") && !imap->uidvalidity) {
+    if(strcasecompare(name, "UIDVALIDITY") && !imap->uidvalidity) { 
       if(valuelen > 0 && value[valuelen - 1] == '/')
         value[valuelen - 1] = '\0';
 
       imap->uidvalidity = value;
       value = NULL;
     }
-    else if(strcasecompare(name, "UID") && !imap->uid) {
+    else if(strcasecompare(name, "UID") && !imap->uid) { 
       if(valuelen > 0 && value[valuelen - 1] == '/')
         value[valuelen - 1] = '\0';
 
       imap->uid = value;
       value = NULL;
     }
-    else if(strcasecompare(name, "MAILINDEX") && !imap->mindex) {
-      if(valuelen > 0 && value[valuelen - 1] == '/')
-        value[valuelen - 1] = '\0';
-
-      imap->mindex = value;
-      value = NULL;
-    }
-    else if(strcasecompare(name, "SECTION") && !imap->section) {
+    else if(strcasecompare(name, "MAILINDEX") && !imap->mindex) { 
       if(valuelen > 0 && value[valuelen - 1] == '/')
         value[valuelen - 1] = '\0';
 
+      imap->mindex = value; 
+      value = NULL; 
+    } 
+    else if(strcasecompare(name, "SECTION") && !imap->section) { 
+      if(valuelen > 0 && value[valuelen - 1] == '/') 
+        value[valuelen - 1] = '\0'; 
+ 
       imap->section = value;
       value = NULL;
     }
-    else if(strcasecompare(name, "PARTIAL") && !imap->partial) {
-      if(valuelen > 0 && value[valuelen - 1] == '/')
-        value[valuelen - 1] = '\0';
-
-      imap->partial = value;
-      value = NULL;
-    }
+    else if(strcasecompare(name, "PARTIAL") && !imap->partial) { 
+      if(valuelen > 0 && value[valuelen - 1] == '/') 
+        value[valuelen - 1] = '\0'; 
+ 
+      imap->partial = value; 
+      value = NULL; 
+    } 
     else {
-      free(name);
-      free(value);
+      free(name); 
+      free(value); 
 
       return CURLE_URL_MALFORMAT;
     }
 
-    free(name);
-    free(value);
-  }
-
-  /* Does the URL contain a query parameter? Only valid when we have a mailbox
-     and no UID as per RFC-5092 */
-  if(imap->mailbox && !imap->uid && !imap->mindex) {
-    /* Get the query parameter, URL decoded */
-    (void)curl_url_get(data->state.uh, CURLUPART_QUERY, &imap->query,
-                       CURLU_URLDECODE);
+    free(name); 
+    free(value); 
   }
 
+  /* Does the URL contain a query parameter? Only valid when we have a mailbox 
+     and no UID as per RFC-5092 */ 
+  if(imap->mailbox && !imap->uid && !imap->mindex) { 
+    /* Get the query parameter, URL decoded */ 
+    (void)curl_url_get(data->state.uh, CURLUPART_QUERY, &imap->query, 
+                       CURLU_URLDECODE); 
+  } 
+ 
   /* Any extra stuff at the end of the URL is an error */
   if(*ptr)
     return CURLE_URL_MALFORMAT;
@@ -2076,7 +2076,7 @@ static CURLcode imap_parse_url_path(struct connectdata *conn)
 static CURLcode imap_parse_custom_request(struct connectdata *conn)
 {
   CURLcode result = CURLE_OK;
-  struct Curl_easy *data = conn->data;
+  struct Curl_easy *data = conn->data; 
   struct IMAP *imap = data->req.p.imap;
   const char *custom = data->set.str[STRING_CUSTOMREQUEST];