From 965f26c806a87fbf9ae803d12d57b1e5f91e0754 Mon Sep 17 00:00:00 2001

From: Steve Holme <steve_holme@hotmail.com>

Date: Sat, 13 Apr 2013 10:49:42 +0100

Subject: [PATCH 01/28] url: Added support for parsing login options from the

 URL

As well as parsing the username and password from the URL, added support

for parsing the optional options part from the login details, to allow

the following supported URL format:

schema://username:password;options@example.com/path?q=foobar

This will only be used by IMAP, POP3 and SMTP at present but any

protocol that may be given login options in the URL will be able to

add support for them.

Upstream-commit: 73aa95592f47d461f0246eef1187f5d569aa6afa

Signed-off-by: Kamil Dudka <kdudka@redhat.com>

---

 lib/url.c     | 79 ++++++++++++++++++++++++++++++++++++++++++++---------------

 lib/urldata.h |  3 +++

 2 files changed, 62 insertions(+), 20 deletions(-)

diff --git a/lib/url.c b/lib/url.c

index 2dc56ae..fdf6bca 100644

--- a/lib/url.c

+++ b/lib/url.c

@@ -2461,6 +2461,7 @@ static void conn_free(struct connectdata *conn)

   Curl_safefree(conn->user);

   Curl_safefree(conn->passwd);

+  Curl_safefree(conn->options);

   Curl_safefree(conn->proxyuser);

   Curl_safefree(conn->proxypasswd);

   Curl_safefree(conn->allocptr.proxyuserpwd);

@@ -4283,24 +4284,27 @@ static CURLcode parse_url_userpass(struct SessionHandle *data,

                                    struct connectdata *conn,

                                    char *user, char *passwd)

 {

+  char options[MAX_CURL_OPTIONS_LENGTH];

+

   /* At this point, we're hoping all the other special cases have

    * been taken care of, so conn->host.name is at most

-   *    [user[:password]]@]hostname

+   *    [user[:password][;options]]@]hostname

    *

    * We need somewhere to put the embedded details, so do that first.

    */

-  char *ptr=strchr(conn->host.name, '@');

+  char *ptr = strchr(conn->host.name, '@');

   char *userpass = conn->host.name;

-  user[0] =0;   /* to make everything well-defined */

-  passwd[0]=0;

+  user[0] = 0;   /* to make everything well-defined */

+  passwd[0] = 0;

+  options[0] = 0;

   /* We will now try to extract the

-   * possible user+password pair in a string like:

+   * possible login information in a string like:

    * ftp://user:password@ftp.my.site:8021/README */

   if(ptr != NULL) {

-    /* there's a user+password given here, to the left of the @ */

+    /* There's login information to the left of the @ */

     conn->host.name = ++ptr;

@@ -4310,26 +4314,46 @@ static CURLcode parse_url_userpass(struct SessionHandle *data,

      * set user/passwd, but doing that first adds more cases here :-(

      */

-    conn->bits.userpwd_in_url = TRUE;

     if(data->set.use_netrc != CURL_NETRC_REQUIRED) {

-      /* We could use the one in the URL */

-

-      conn->bits.user_passwd = TRUE; /* enable user+password */

-

+      /* We could use the information in the URL so extract it */

       if(*userpass != ':') {

-        /* the name is given, get user+password */

-        sscanf(userpass, "%" MAX_CURL_USER_LENGTH_TXT "[^:@]:"

-               "%" MAX_CURL_PASSWORD_LENGTH_TXT "[^@]",

-               user, passwd);

+        if(*userpass != ';') {

+          /* The user is given so extract the user, password and options */

+          int result = sscanf(userpass,

+                              "%" MAX_CURL_USER_LENGTH_TXT "[^:;@]:"

+                              "%" MAX_CURL_PASSWORD_LENGTH_TXT "[^;@];"

+                              "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

+                              user, passwd, options);

+

+          /* The extract failed so extract the user and options instead */

+          if(result == 1)

+            sscanf(userpass, "%" MAX_CURL_USER_LENGTH_TXT "[^:;@];"

+                             "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

+                              user, options);

+        }

+        else {

+          /* No name or password are given so extract the options only */

+        sscanf(userpass, ";%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]", options);

+        }

       }

       else

-        /* no name given, get the password only */

-        sscanf(userpass, ":%" MAX_CURL_PASSWORD_LENGTH_TXT "[^@]", passwd);

+        /* No name is given so extract the password and options */

+        sscanf(userpass, ":%" MAX_CURL_PASSWORD_LENGTH_TXT "[^;@];"

+               "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

+               passwd, options);

       if(user[0]) {

-        char *newname=curl_easy_unescape(data, user, 0, NULL);

+        char *newname;

+

+        /* We have a user in the URL */

+        conn->bits.userpwd_in_url = TRUE;

+        conn->bits.user_passwd = TRUE; /* enable user+password */

+

+        /* Decode the user */

+        newname = curl_easy_unescape(data, user, 0, NULL);

         if(!newname)

           return CURLE_OUT_OF_MEMORY;

+

         if(strlen(newname) < MAX_CURL_USER_LENGTH)

           strcpy(user, newname);

@@ -4337,18 +4361,33 @@ static CURLcode parse_url_userpass(struct SessionHandle *data,

            the unconverted name, it'll be wrong but what the heck */

         free(newname);

       }

+

       if(passwd[0]) {

-        /* we have a password found in the URL, decode it! */

-        char *newpasswd=curl_easy_unescape(data, passwd, 0, NULL);

+        /* We have a password in the URL so decode it */

+        char *newpasswd = curl_easy_unescape(data, passwd, 0, NULL);

         if(!newpasswd)

           return CURLE_OUT_OF_MEMORY;

+

         if(strlen(newpasswd) < MAX_CURL_PASSWORD_LENGTH)

           strcpy(passwd, newpasswd);

         free(newpasswd);

       }

+

+      if(options[0]) {

+        /* We have an options list in the URL so decode it */

+        char *newoptions = curl_easy_unescape(data, options, 0, NULL);

+        if(!newoptions)

+          return CURLE_OUT_OF_MEMORY;

+

+        if(strlen(newoptions) < MAX_CURL_OPTIONS_LENGTH)

+          conn->options = newoptions;

+        else

+          free(newoptions);

+      }

     }

   }

+

   return CURLE_OK;

 }

diff --git a/lib/urldata.h b/lib/urldata.h

index 26bc89f..46ef5d5 100644

--- a/lib/urldata.h

+++ b/lib/urldata.h

@@ -847,6 +847,7 @@ struct connectdata {

   char *user;    /* user name string, allocated */

   char *passwd;  /* password string, allocated */

+  char *options; /* options string, allocated */

   char *proxyuser;    /* proxy user name string, allocated */

   char *proxypasswd;  /* proxy password string, allocated */

@@ -1132,8 +1133,10 @@ typedef enum {

  * Session-data MUST be put in the connectdata struct and here.  */

 #define MAX_CURL_USER_LENGTH 256

 #define MAX_CURL_PASSWORD_LENGTH 256

+#define MAX_CURL_OPTIONS_LENGTH 256

 #define MAX_CURL_USER_LENGTH_TXT "255"

 #define MAX_CURL_PASSWORD_LENGTH_TXT "255"

+#define MAX_CURL_OPTIONS_LENGTH_TXT "255"

 struct auth {

   unsigned long want;  /* Bitmask set to the authentication methods wanted by

-- 

2.4.6

From 8e092594b858dd049e3f4f6660325f703e0a1c44 Mon Sep 17 00:00:00 2001

From: Steve Holme <steve_holme@hotmail.com>

Date: Thu, 18 Apr 2013 17:02:28 +0100

Subject: [PATCH 02/28] url: Reworked URL parsing to allow overriding by

 CURLOPT_USERPWD

Upstream-commit: 90c87f311eb087840008bfe89b19e6e0b808a246

Signed-off-by: Kamil Dudka <kdudka@redhat.com>

---

 lib/url.c | 50 +++++++++++++++++++++++++++++++-------------------

 1 file changed, 31 insertions(+), 19 deletions(-)

diff --git a/lib/url.c b/lib/url.c

index fdf6bca..4a9df84 100644

--- a/lib/url.c

+++ b/lib/url.c

@@ -140,7 +140,7 @@ static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke);

 static CURLcode do_init(struct connectdata *conn);

 static CURLcode parse_url_userpass(struct SessionHandle *data,

                                    struct connectdata *conn,

-                                   char *user, char *passwd);

+                                   char *user, char *passwd, char *options);

 /*

  * Protocol table.

  */

@@ -3585,8 +3585,7 @@ static CURLcode findprotocol(struct SessionHandle *data,

 static CURLcode parseurlandfillconn(struct SessionHandle *data,

                                     struct connectdata *conn,

                                     bool *prot_missing,

-                                    char *user,

-                                    char *passwd)

+                                    char *user, char *passwd, char *options)

 {

   char *at;

   char *fragment;

@@ -3811,7 +3810,7 @@ static CURLcode parseurlandfillconn(struct SessionHandle *data,

    * Parse a user name and password in the URL and strip it out

    * of the host name

    *************************************************************/

-  result = parse_url_userpass(data, conn, user, passwd);

+  result = parse_url_userpass(data, conn, user, passwd, options);

   if(result != CURLE_OK)

     return result;

@@ -4282,10 +4281,8 @@ static CURLcode parse_proxy_auth(struct SessionHandle *data,

  */

 static CURLcode parse_url_userpass(struct SessionHandle *data,

                                    struct connectdata *conn,

-                                   char *user, char *passwd)

+                                   char *user, char *passwd, char *options)

 {

-  char options[MAX_CURL_OPTIONS_LENGTH];

-

   /* At this point, we're hoping all the other special cases have

    * been taken care of, so conn->host.name is at most

    *    [user[:password][;options]]@]hostname

@@ -4381,9 +4378,9 @@ static CURLcode parse_url_userpass(struct SessionHandle *data,

           return CURLE_OUT_OF_MEMORY;

         if(strlen(newoptions) < MAX_CURL_OPTIONS_LENGTH)

-          conn->options = newoptions;

-        else

-          free(newoptions);

+          strcpy(options, newoptions);

+

+        free(newoptions);

       }

     }

   }

@@ -4551,11 +4548,13 @@ static void override_userpass(struct SessionHandle *data,

  * Set password so it's available in the connection.

  */

 static CURLcode set_userpass(struct connectdata *conn,

-                             const char *user, const char *passwd)

+                             const char *user, const char *passwd,

+                             const char *options)

 {

+  CURLcode result = CURLE_OK;

+

   /* If our protocol needs a password and we have none, use the defaults */

-  if((conn->handler->flags & PROTOPT_NEEDSPWD) &&

-     !conn->bits.user_passwd) {

+  if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) {

     conn->user = strdup(CURL_DEFAULT_USER);

     if(conn->user)

@@ -4565,17 +4564,28 @@ static CURLcode set_userpass(struct connectdata *conn,

     /* This is the default password, so DON'T set conn->bits.user_passwd */

   }

   else {

-    /* store user + password, zero-length if not set */

+    /* Store the user, zero-length if not set */

     conn->user = strdup(user);

+

+    /* Store the password (only if user is present), zero-length if not set */

     if(conn->user)

       conn->passwd = strdup(passwd);

     else

       conn->passwd = NULL;

   }

+

   if(!conn->user || !conn->passwd)

-    return CURLE_OUT_OF_MEMORY;

+    result = CURLE_OUT_OF_MEMORY;

-  return CURLE_OK;

+  /* Store the options, null if not set */

+  if(!result && options[0]) {

+    conn->options = strdup(options);

+

+    if(!conn->options)

+      result = CURLE_OUT_OF_MEMORY;

+  }

+

+  return result;

 }

 /*************************************************************

@@ -4745,12 +4755,13 @@ static CURLcode create_conn(struct SessionHandle *data,

                             struct connectdata **in_connect,

                             bool *async)

 {

-  CURLcode result=CURLE_OK;

+  CURLcode result = CURLE_OK;

   struct connectdata *conn;

   struct connectdata *conn_temp = NULL;

   size_t urllen;

   char user[MAX_CURL_USER_LENGTH];

   char passwd[MAX_CURL_PASSWORD_LENGTH];

+  char options[MAX_CURL_OPTIONS_LENGTH];

   bool reuse;

   char *proxy = NULL;

   bool prot_missing = FALSE;

@@ -4815,7 +4826,8 @@ static CURLcode create_conn(struct SessionHandle *data,

   conn->host.name = conn->host.rawalloc;

   conn->host.name[0] = 0;

-  result = parseurlandfillconn(data, conn, &prot_missing, user, passwd);

+  result = parseurlandfillconn(data, conn, &prot_missing, user, passwd,

+                               options);

   if(result != CURLE_OK)

     return result;

@@ -5016,7 +5028,7 @@ static CURLcode create_conn(struct SessionHandle *data,

    * for use

    *************************************************************/

   override_userpass(data, conn, user, passwd);

-  result = set_userpass(conn, user, passwd);

+  result = set_userpass(conn, user, passwd, options);

   if(result != CURLE_OK)

     return result;

-- 

2.4.6

From c9099e450c8eebbc3318f827a8532448f6a8631f Mon Sep 17 00:00:00 2001

From: Steve Holme <steve_holme@hotmail.com>

Date: Thu, 18 Apr 2013 17:09:40 +0100

Subject: [PATCH 03/28] url: Re-factored set_userpass() and

 parse_url_userpass()

Re-factored these functions to reflect their new behaviour following the

addition of login options.

Upstream-commit: 0d49e408a48246b9a27448473e78ce3fd237b19e

Signed-off-by: Kamil Dudka <kdudka@redhat.com>

---

 lib/url.c | 41 +++++++++++++++++++++++------------------

 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/lib/url.c b/lib/url.c

index 4a9df84..f03ca0f 100644

--- a/lib/url.c

+++ b/lib/url.c

@@ -138,9 +138,9 @@ find_oldest_idle_connection(struct SessionHandle *data);

 static void conn_free(struct connectdata *conn);

 static void signalPipeClose(struct curl_llist *pipeline, bool pipe_broke);

 static CURLcode do_init(struct connectdata *conn);

-static CURLcode parse_url_userpass(struct SessionHandle *data,

-                                   struct connectdata *conn,

-                                   char *user, char *passwd, char *options);

+static CURLcode parse_url_login(struct SessionHandle *data,

+                                struct connectdata *conn,

+                                char *user, char *passwd, char *options);

 /*

  * Protocol table.

  */

@@ -3806,11 +3806,11 @@ static CURLcode parseurlandfillconn(struct SessionHandle *data,

     data->change.url_alloc = TRUE; /* free this later */

   }

-  /*************************************************************

-   * Parse a user name and password in the URL and strip it out

-   * of the host name

-   *************************************************************/

-  result = parse_url_userpass(data, conn, user, passwd, options);

+  /*

+   * Parse the login details from the URL and strip them out of

+   * the host name

+   */

+  result = parse_url_login(data, conn, user, passwd, options);

   if(result != CURLE_OK)

     return result;

@@ -4268,7 +4268,8 @@ static CURLcode parse_proxy_auth(struct SessionHandle *data,

 /*

  *

- * Parse a user name and password in the URL and strip it out of the host name

+ * Parse the login details (user name, password and options) from the URL and

+ * strip them out of the host name

  *

  * Inputs: data->set.use_netrc (CURLOPT_NETRC)

  *         conn->host.name

@@ -4276,12 +4277,13 @@ static CURLcode parse_proxy_auth(struct SessionHandle *data,

  * Outputs: (almost :- all currently undefined)

  *          conn->bits.user_passwd  - non-zero if non-default passwords exist

  *          user                    - non-zero length if defined

- *          passwd                  -   ditto

+ *          passwd                  - non-zero length if defined

+ *          options                 - non-zero length if defined

  *          conn->host.name         - remove user name and password

  */

-static CURLcode parse_url_userpass(struct SessionHandle *data,

-                                   struct connectdata *conn,

-                                   char *user, char *passwd, char *options)

+static CURLcode parse_url_login(struct SessionHandle *data,

+                                struct connectdata *conn,

+                                char *user, char *passwd, char *options)

 {

   /* At this point, we're hoping all the other special cases have

    * been taken care of, so conn->host.name is at most

@@ -4547,20 +4549,23 @@ static void override_userpass(struct SessionHandle *data,

 /*

  * Set password so it's available in the connection.

  */

-static CURLcode set_userpass(struct connectdata *conn,

-                             const char *user, const char *passwd,

-                             const char *options)

+static CURLcode set_login(struct connectdata *conn,

+                          const char *user, const char *passwd,

+                          const char *options)

 {

   CURLcode result = CURLE_OK;

   /* If our protocol needs a password and we have none, use the defaults */

   if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) {

-

+    /* Store the default user */

     conn->user = strdup(CURL_DEFAULT_USER);

+

+    /* Store the default password */

     if(conn->user)

       conn->passwd = strdup(CURL_DEFAULT_PASSWORD);

     else

       conn->passwd = NULL;

+

     /* This is the default password, so DON'T set conn->bits.user_passwd */

   }

   else {

@@ -5028,7 +5033,7 @@ static CURLcode create_conn(struct SessionHandle *data,

    * for use

    *************************************************************/

   override_userpass(data, conn, user, passwd);

-  result = set_userpass(conn, user, passwd, options);

+  result = set_login(conn, user, passwd, options);

   if(result != CURLE_OK)

     return result;

-- 

2.4.6

From a66a0feefcb037ffcfaf2dbd3dcd9f17a416ad13 Mon Sep 17 00:00:00 2001

From: Steve Holme <steve_holme@hotmail.com>

Date: Thu, 18 Apr 2013 17:52:05 +0100

Subject: [PATCH 04/28] url: Moved parsing of login details out of

 parse_url_login()

Separated the parsing of login details from the processing of them in

parse_url_login() ready for use by setstropt_userpwd().

Upstream-commit: bb20989a6384f95a73fd68b0e109fc860e0c7a57

Signed-off-by: Kamil Dudka <kdudka@redhat.com>

---

 lib/url.c | 221 +++++++++++++++++++++++++++++++++++++++++++++-----------------

 1 file changed, 161 insertions(+), 60 deletions(-)

diff --git a/lib/url.c b/lib/url.c

index f03ca0f..3396944 100644

--- a/lib/url.c

+++ b/lib/url.c

@@ -141,6 +141,9 @@ static CURLcode do_init(struct connectdata *conn);

 static CURLcode parse_url_login(struct SessionHandle *data,

                                 struct connectdata *conn,

                                 char *user, char *passwd, char *options);

+static CURLcode parse_login_details(const char *login, const size_t len,

+                                    char **userptr, char **passwdptr,

+                                    char **optionsptr);

 /*

  * Protocol table.

  */

@@ -4267,6 +4270,7 @@ static CURLcode parse_proxy_auth(struct SessionHandle *data,

 #endif /* CURL_DISABLE_PROXY */

 /*

+ * parse_url_login()

  *

  * Parse the login details (user name, password and options) from the URL and

  * strip them out of the host name

@@ -4285,6 +4289,11 @@ static CURLcode parse_url_login(struct SessionHandle *data,

                                 struct connectdata *conn,

                                 char *user, char *passwd, char *options)

 {

+  CURLcode result = CURLE_OK;

+  char *userp = NULL;

+  char *passwdp = NULL;

+  char *optionsp = NULL;

+

   /* At this point, we're hoping all the other special cases have

    * been taken care of, so conn->host.name is at most

    *    [user[:password][;options]]@]hostname

@@ -4293,7 +4302,7 @@ static CURLcode parse_url_login(struct SessionHandle *data,

    */

   char *ptr = strchr(conn->host.name, '@');

-  char *userpass = conn->host.name;

+  char *login = conn->host.name;

   user[0] = 0;   /* to make everything well-defined */

   passwd[0] = 0;

@@ -4302,7 +4311,7 @@ static CURLcode parse_url_login(struct SessionHandle *data,

   /* We will now try to extract the

    * possible login information in a string like:

    * ftp://user:password@ftp.my.site:8021/README */

-  if(ptr != NULL) {

+  if(ptr) {

     /* There's login information to the left of the @ */

     conn->host.name = ++ptr;

@@ -4314,80 +4323,172 @@ static CURLcode parse_url_login(struct SessionHandle *data,

      */

     if(data->set.use_netrc != CURL_NETRC_REQUIRED) {

-      /* We could use the information in the URL so extract it */

-      if(*userpass != ':') {

-        if(*userpass != ';') {

-          /* The user is given so extract the user, password and options */

-          int result = sscanf(userpass,

-                              "%" MAX_CURL_USER_LENGTH_TXT "[^:;@]:"

-                              "%" MAX_CURL_PASSWORD_LENGTH_TXT "[^;@];"

-                              "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

-                              user, passwd, options);

-

-          /* The extract failed so extract the user and options instead */

-          if(result == 1)

-            sscanf(userpass, "%" MAX_CURL_USER_LENGTH_TXT "[^:;@];"

-                             "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

-                              user, options);

-        }

-        else {

-          /* No name or password are given so extract the options only */

-        sscanf(userpass, ";%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]", options);

+      /* We could use the login information in the URL so extract it */

+      result = parse_login_details(login, ptr - login - 1,

+                                   &userp, &passwdp, &optionsp);

+      if(!result) {

+        if(userp) {

+          char *newname;

+

+          /* We have a user in the URL */

+          conn->bits.userpwd_in_url = TRUE;

+          conn->bits.user_passwd = TRUE; /* enable user+password */

+

+          /* Decode the user */

+          newname = curl_easy_unescape(data, userp, 0, NULL);

+          if(!newname)

+            return CURLE_OUT_OF_MEMORY;

+

+          if(strlen(newname) < MAX_CURL_USER_LENGTH)

+            strcpy(user, newname);

+

+          free(newname);

         }

-      }

-      else

-        /* No name is given so extract the password and options */

-        sscanf(userpass, ":%" MAX_CURL_PASSWORD_LENGTH_TXT "[^;@];"

-               "%" MAX_CURL_OPTIONS_LENGTH_TXT "[^@]",

-               passwd, options);

-      if(user[0]) {

-        char *newname;

+        if(passwdp) {

+          /* We have a password in the URL so decode it */

+          char *newpasswd = curl_easy_unescape(data, passwdp, 0, NULL);

+          if(!newpasswd)

+            return CURLE_OUT_OF_MEMORY;

-        /* We have a user in the URL */

-        conn->bits.userpwd_in_url = TRUE;

-        conn->bits.user_passwd = TRUE; /* enable user+password */

+          if(strlen(newpasswd) < MAX_CURL_PASSWORD_LENGTH)

+            strcpy(passwd, newpasswd);

-        /* Decode the user */

-        newname = curl_easy_unescape(data, user, 0, NULL);

-        if(!newname)

-          return CURLE_OUT_OF_MEMORY;

+          free(newpasswd);

+        }

+

+        if(optionsp) {

+          /* We have an options list in the URL so decode it */

+          char *newoptions = curl_easy_unescape(data, optionsp, 0, NULL);

+          if(!newoptions)

+            return CURLE_OUT_OF_MEMORY;

-        if(strlen(newname) < MAX_CURL_USER_LENGTH)

-          strcpy(user, newname);

+          if(strlen(newoptions) < MAX_CURL_OPTIONS_LENGTH)

+            strcpy(options, newoptions);

-        /* if the new name is longer than accepted, then just use

-           the unconverted name, it'll be wrong but what the heck */

-        free(newname);

+          free(newoptions);

+        }

       }

-      if(passwd[0]) {

-        /* We have a password in the URL so decode it */

-        char *newpasswd = curl_easy_unescape(data, passwd, 0, NULL);

-        if(!newpasswd)

-          return CURLE_OUT_OF_MEMORY;

+      Curl_safefree(userp);

+      Curl_safefree(passwdp);

+      Curl_safefree(optionsp);

+    }

+  }

-        if(strlen(newpasswd) < MAX_CURL_PASSWORD_LENGTH)

-          strcpy(passwd, newpasswd);

+  return result;

+}

-        free(newpasswd);

-      }

+/*

+ * parse_login_details()

+ *

+ * This is used to parse a login string for user name, password and options in

+ * the following formats:

+ *

+ *   user

+ *   user:password

+ *   user:password;options

+ *   user;options

+ *   user;options:password

+ *   :password

+ *   :password;options

+ *   ;options

+ *   ;options:password

+ *

+ * Parameters:

+ *

+ * login    [in]     - The login string.

+ * len      [in]     - The length of the login string.

+ * userp    [in/out] - The address where a pointer to newly allocated memory

+ *                     holding the user will be stored upon completion.

+ * passdwp  [in/out] - The address where a pointer to newly allocated memory

+ *                     holding the password will be stored upon completion.

+ * optionsp [in/out] - The address where a pointer to newly allocated memory

+ *                     holding the options will be stored upon completion.

+ *

+ * Returns CURLE_OK on success.

+ */

+static CURLcode parse_login_details(const char *login, const size_t len,

+                                    char **userp, char **passwdp,

+                                    char **optionsp)

+{

+  CURLcode result = CURLE_OK;

+  char *utemp = NULL;

+  char *ptemp = NULL;

+  char *otemp = NULL;

+  const char *psep = NULL;

+  const char *osep = NULL;

+  size_t ulen;

+  size_t plen;

+  size_t olen;

+

+  /* Attempt to find the password separator */

+  if(passwdp)

+    psep = strchr(login, ':');

+

+  /* Attempt to find the options separator */

+  if(optionsp)

+    osep = strchr(login, ';');

+

+  /* Calculate the portion lengths */

+  ulen = (psep ?

+          (size_t)(osep && psep > osep ? osep - login : psep - login) :

+          (osep ? (size_t)(osep - login) : len));

+  plen = (psep ?

+          (osep && osep > psep ? (size_t)(osep - psep) :

+                                 (size_t)(login + len - psep)) - 1 : 0);

+  olen = (osep ?

+          (psep && psep > osep ? (size_t)(psep - osep) :

+                                 (size_t)(login + len - osep)) - 1 : 0);

+

+  /* Allocate the user portion temporary buffer */

+  if(userp && ulen) {

+    utemp = malloc(ulen + 1);

+    if(!utemp)

+      result = CURLE_OUT_OF_MEMORY;

+  }

+

+  /* Allocate the password portion temporary buffer */

+  if(!result && passwdp && plen) {

+    ptemp = malloc(plen + 1);

+    if(!ptemp)

+      result = CURLE_OUT_OF_MEMORY;

+  }

+

+  /* Allocate the options  portion temporary buffer */

+  if(!result && optionsp && olen) {

+    otemp = malloc(olen + 1);