Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 193 insertions, 193 deletions

diff --git a/contrib/libs/curl/lib/openldap.c b/contrib/libs/curl/lib/openldap.c
index 999f919e756..f8e31503089 100644
--- a/contrib/libs/curl/lib/openldap.c
+++ b/contrib/libs/curl/lib/openldap.c
@@ -41,34 +41,34 @@
 #include "urldata.h"
 #include <curl/curl.h>
 #include "sendf.h"
-#include "vtls/vtls.h" 
+#include "vtls/vtls.h"
 #include "transfer.h"
 #include "curl_ldap.h"
-#include "curl_base64.h" 
-#include "connect.h" 
-/* The last 3 #include files should be in this order */ 
-#include "curl_printf.h" 
+#include "curl_base64.h"
+#include "connect.h"
+/* The last 3 #include files should be in this order */
+#include "curl_printf.h"
 #include "curl_memory.h"
-#include "memdebug.h" 
-
-/* 
- * Uncommenting this will enable the built-in debug logging of the openldap 
- * library. The debug log level can be set using the CURL_OPENLDAP_TRACE 
- * environment variable. The debug output is written to stderr. 
- * 
- * The library supports the following debug flags: 
- * LDAP_DEBUG_NONE         0x0000 
- * LDAP_DEBUG_TRACE        0x0001 
- * LDAP_DEBUG_CONSTRUCT    0x0002 
- * LDAP_DEBUG_DESTROY      0x0004 
- * LDAP_DEBUG_PARAMETER    0x0008 
- * LDAP_DEBUG_ANY          0xffff 
- * 
- * For example, use CURL_OPENLDAP_TRACE=0 for no debug, 
- * CURL_OPENLDAP_TRACE=2 for LDAP_DEBUG_CONSTRUCT messages only, 
- * CURL_OPENLDAP_TRACE=65535 for all debug message levels. 
- */ 
-/* #define CURL_OPENLDAP_DEBUG */ 
+#include "memdebug.h"
+
+/*
+ * Uncommenting this will enable the built-in debug logging of the openldap
+ * library. The debug log level can be set using the CURL_OPENLDAP_TRACE
+ * environment variable. The debug output is written to stderr.
+ *
+ * The library supports the following debug flags:
+ * LDAP_DEBUG_NONE         0x0000
+ * LDAP_DEBUG_TRACE        0x0001
+ * LDAP_DEBUG_CONSTRUCT    0x0002
+ * LDAP_DEBUG_DESTROY      0x0004
+ * LDAP_DEBUG_PARAMETER    0x0008
+ * LDAP_DEBUG_ANY          0xffff
+ *
+ * For example, use CURL_OPENLDAP_TRACE=0 for no debug,
+ * CURL_OPENLDAP_TRACE=2 for LDAP_DEBUG_CONSTRUCT messages only,
+ * CURL_OPENLDAP_TRACE=65535 for all debug message levels.
+ */
+/* #define CURL_OPENLDAP_DEBUG */
 
 #ifndef _LDAP_PVT_H
 extern int ldap_pvt_url_scheme2proto(const char *);
@@ -76,7 +76,7 @@ extern int ldap_init_fd(ber_socket_t fd, int proto, const char *url,
                         LDAP **ld);
 #endif
 
-static CURLcode ldap_setup_connection(struct connectdata *conn); 
+static CURLcode ldap_setup_connection(struct connectdata *conn);
 static CURLcode ldap_do(struct connectdata *conn, bool *done);
 static CURLcode ldap_done(struct connectdata *conn, CURLcode, bool);
 static CURLcode ldap_connect(struct connectdata *conn, bool *done);
@@ -91,7 +91,7 @@ static Curl_recv ldap_recv;
 
 const struct Curl_handler Curl_handler_ldap = {
   "LDAP",                               /* scheme */
-  ldap_setup_connection,                /* setup_connection */ 
+  ldap_setup_connection,                /* setup_connection */
   ldap_do,                              /* do_it */
   ldap_done,                            /* done */
   ZERO_NULL,                            /* do_more */
@@ -104,7 +104,7 @@ const struct Curl_handler Curl_handler_ldap = {
   ZERO_NULL,                            /* perform_getsock */
   ldap_disconnect,                      /* disconnect */
   ZERO_NULL,                            /* readwrite */
-  ZERO_NULL,                            /* connection_check */ 
+  ZERO_NULL,                            /* connection_check */
   PORT_LDAP,                            /* defport */
   CURLPROTO_LDAP,                       /* protocol */
   CURLPROTO_LDAP,                       /* family */
@@ -118,7 +118,7 @@ const struct Curl_handler Curl_handler_ldap = {
 
 const struct Curl_handler Curl_handler_ldaps = {
   "LDAPS",                              /* scheme */
-  ldap_setup_connection,                /* setup_connection */ 
+  ldap_setup_connection,                /* setup_connection */
   ldap_do,                              /* do_it */
   ldap_done,                            /* done */
   ZERO_NULL,                            /* do_more */
@@ -131,7 +131,7 @@ const struct Curl_handler Curl_handler_ldaps = {
   ZERO_NULL,                            /* perform_getsock */
   ldap_disconnect,                      /* disconnect */
   ZERO_NULL,                            /* readwrite */
-  ZERO_NULL,                            /* connection_check */ 
+  ZERO_NULL,                            /* connection_check */
   PORT_LDAPS,                           /* defport */
   CURLPROTO_LDAPS,                      /* protocol */
   CURLPROTO_LDAP,                       /* family */
@@ -169,11 +169,11 @@ struct ldapreqinfo {
   int nument;
 };
 
-static CURLcode ldap_setup_connection(struct connectdata *conn) 
+static CURLcode ldap_setup_connection(struct connectdata *conn)
 {
   struct ldapconninfo *li;
   LDAPURLDesc *lud;
-  struct Curl_easy *data = conn->data; 
+  struct Curl_easy *data = conn->data;
   int rc, proto;
   CURLcode status;
 
@@ -197,7 +197,7 @@ static CURLcode ldap_setup_connection(struct connectdata *conn)
     return CURLE_OUT_OF_MEMORY;
   li->proto = proto;
   conn->proto.ldapc = li;
-  connkeep(conn, "OpenLDAP default"); 
+  connkeep(conn, "OpenLDAP default");
   return CURLE_OK;
 }
 
@@ -208,29 +208,29 @@ static Sockbuf_IO ldapsb_tls;
 static CURLcode ldap_connect(struct connectdata *conn, bool *done)
 {
   struct ldapconninfo *li = conn->proto.ldapc;
-  struct Curl_easy *data = conn->data; 
+  struct Curl_easy *data = conn->data;
   int rc, proto = LDAP_VERSION3;
-  char hosturl[1024]; 
-  char *ptr; 
- 
+  char hosturl[1024];
+  char *ptr;
+
   (void)done;
 
   strcpy(hosturl, "ldap");
-  ptr = hosturl + 4; 
+  ptr = hosturl + 4;
   if(conn->handler->flags & PROTOPT_SSL)
     *ptr++ = 's';
-  msnprintf(ptr, sizeof(hosturl)-(ptr-hosturl), "://%s:%d", 
-            conn->host.name, conn->remote_port); 
-
-#ifdef CURL_OPENLDAP_DEBUG 
-  static int do_trace = 0; 
-  const char *env = getenv("CURL_OPENLDAP_TRACE"); 
-  do_trace = (env && strtol(env, NULL, 10) > 0); 
-  if(do_trace) { 
-    ldap_set_option(li->ld, LDAP_OPT_DEBUG_LEVEL, &do_trace); 
-  } 
-#endif 
- 
+  msnprintf(ptr, sizeof(hosturl)-(ptr-hosturl), "://%s:%d",
+            conn->host.name, conn->remote_port);
+
+#ifdef CURL_OPENLDAP_DEBUG
+  static int do_trace = 0;
+  const char *env = getenv("CURL_OPENLDAP_TRACE");
+  do_trace = (env && strtol(env, NULL, 10) > 0);
+  if(do_trace) {
+    ldap_set_option(li->ld, LDAP_OPT_DEBUG_LEVEL, &do_trace);
+  }
+#endif
+
   rc = ldap_init_fd(conn->sock[FIRSTSOCKET], li->proto, hosturl, &li->ld);
   if(rc) {
     failf(data, "LDAP local: Cannot connect to %s, %s",
@@ -242,10 +242,10 @@ static CURLcode ldap_connect(struct connectdata *conn, bool *done)
 
 #ifdef USE_SSL
   if(conn->handler->flags & PROTOPT_SSL) {
-    CURLcode result; 
-    result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &li->ssldone); 
-    if(result) 
-      return result; 
+    CURLcode result;
+    result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &li->ssldone);
+    if(result)
+      return result;
   }
 #endif
 
@@ -255,9 +255,9 @@ static CURLcode ldap_connect(struct connectdata *conn, bool *done)
 static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
 {
   struct ldapconninfo *li = conn->proto.ldapc;
-  struct Curl_easy *data = conn->data; 
-  LDAPMessage *msg = NULL; 
-  struct timeval tv = {0, 1}, *tvp; 
+  struct Curl_easy *data = conn->data;
+  LDAPMessage *msg = NULL;
+  struct timeval tv = {0, 1}, *tvp;
   int rc, err;
   char *info = NULL;
 
@@ -265,12 +265,12 @@ static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
   if(conn->handler->flags & PROTOPT_SSL) {
     /* Is the SSL handshake complete yet? */
     if(!li->ssldone) {
-      CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, 
-                                                     &li->ssldone); 
-      if(result || !li->ssldone) 
-        return result; 
+      CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
+                                                     &li->ssldone);
+      if(result || !li->ssldone)
+        return result;
     }
- 
+
     /* Have we installed the libcurl SSL handlers into the sockbuf yet? */
     if(!li->sslinst) {
       Sockbuf *sb;
@@ -285,7 +285,7 @@ static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
 
   tvp = &tv;
 
-  retry: 
+  retry:
   if(!li->didbind) {
     char *binddn;
     struct berval passwd;
@@ -309,7 +309,7 @@ static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
       return CURLE_OK;
   }
 
-  rc = ldap_result(li->ld, li->msgid, LDAP_MSG_ONE, tvp, &msg); 
+  rc = ldap_result(li->ld, li->msgid, LDAP_MSG_ONE, tvp, &msg);
   if(rc < 0) {
     failf(data, "LDAP local: bind ldap_result %s", ldap_err2string(rc));
     return CURLE_LDAP_CANNOT_BIND;
@@ -318,13 +318,13 @@ static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
     /* timed out */
     return CURLE_OK;
   }
- 
-  rc = ldap_parse_result(li->ld, msg, &err, NULL, &info, NULL, NULL, 1); 
+
+  rc = ldap_parse_result(li->ld, msg, &err, NULL, &info, NULL, NULL, 1);
   if(rc) {
     failf(data, "LDAP local: bind ldap_parse_result %s", ldap_err2string(rc));
     return CURLE_LDAP_CANNOT_BIND;
   }
- 
+
   /* Try to fallback to LDAPv2? */
   if(err == LDAP_PROTOCOL_ERROR) {
     int proto;
@@ -353,7 +353,7 @@ static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
     ldap_memfree(info);
   conn->recv[FIRSTSOCKET] = ldap_recv;
   *done = TRUE;
- 
+
   return CURLE_OK;
 }
 
@@ -381,9 +381,9 @@ static CURLcode ldap_do(struct connectdata *conn, bool *done)
   int rc = 0;
   LDAPURLDesc *ludp = NULL;
   int msgid;
-  struct Curl_easy *data = conn->data; 
+  struct Curl_easy *data = conn->data;
 
-  connkeep(conn, "OpenLDAP do"); 
+  connkeep(conn, "OpenLDAP do");
 
   infof(data, "LDAP local: %s\n", data->change.url);
 
@@ -422,7 +422,7 @@ static CURLcode ldap_done(struct connectdata *conn, CURLcode res,
                           bool premature)
 {
   struct ldapreqinfo *lr = conn->data->req.p.ldap;
- 
+
   (void)res;
   (void)premature;
 
@@ -436,7 +436,7 @@ static CURLcode ldap_done(struct connectdata *conn, CURLcode res,
     conn->data->req.p.ldap = NULL;
     free(lr);
   }
- 
+
   return CURLE_OK;
 }
 
@@ -444,19 +444,19 @@ static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
                          size_t len, CURLcode *err)
 {
   struct ldapconninfo *li = conn->proto.ldapc;
-  struct Curl_easy *data = conn->data; 
+  struct Curl_easy *data = conn->data;
   struct ldapreqinfo *lr = data->req.p.ldap;
   int rc, ret;
-  LDAPMessage *msg = NULL; 
+  LDAPMessage *msg = NULL;
   LDAPMessage *ent;
   BerElement *ber = NULL;
-  struct timeval tv = {0, 1}; 
- 
+  struct timeval tv = {0, 1};
+
   (void)len;
   (void)buf;
   (void)sockindex;
 
-  rc = ldap_result(li->ld, lr->msgid, LDAP_MSG_RECEIVED, &tv, &msg); 
+  rc = ldap_result(li->ld, lr->msgid, LDAP_MSG_RECEIVED, &tv, &msg);
   if(rc < 0) {
     failf(data, "LDAP local: search ldap_result %s", ldap_err2string(rc));
     *err = CURLE_RECV_ERROR;
@@ -467,14 +467,14 @@ static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
   ret = -1;
 
   /* timed out */
-  if(!msg) 
+  if(!msg)
     return ret;
 
-  for(ent = ldap_first_message(li->ld, msg); ent; 
-      ent = ldap_next_message(li->ld, ent)) { 
-    struct berval bv, *bvals; 
+  for(ent = ldap_first_message(li->ld, msg); ent;
+      ent = ldap_next_message(li->ld, ent)) {
+    struct berval bv, *bvals;
     int binary = 0, msgtype;
-    CURLcode writeerr; 
+    CURLcode writeerr;
 
     msgtype = ldap_msgtype(ent);
     if(msgtype == LDAP_RES_SEARCH_RESULT) {
@@ -512,91 +512,91 @@ static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
       *err = CURLE_RECV_ERROR;
       return -1;
     }
-    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"DN: ", 4); 
-    if(writeerr) { 
-      *err = writeerr; 
-      return -1; 
-    } 
- 
-    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val, 
-                                 bv.bv_len); 
-    if(writeerr) { 
-      *err = writeerr; 
-      return -1; 
-    } 
- 
-    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1); 
-    if(writeerr) { 
-      *err = writeerr; 
-      return -1; 
-    } 
+    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"DN: ", 4);
+    if(writeerr) {
+      *err = writeerr;
+      return -1;
+    }
+
+    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val,
+                                 bv.bv_len);
+    if(writeerr) {
+      *err = writeerr;
+      return -1;
+    }
+
+    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1);
+    if(writeerr) {
+      *err = writeerr;
+      return -1;
+    }
     data->req.bytecount += bv.bv_len + 5;
 
-    for(rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, &bvals); 
-        rc == LDAP_SUCCESS; 
-        rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, &bvals)) { 
+    for(rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, &bvals);
+        rc == LDAP_SUCCESS;
+        rc = ldap_get_attribute_ber(li->ld, ent, ber, &bv, &bvals)) {
       int i;
 
-      if(bv.bv_val == NULL) 
-        break; 
+      if(bv.bv_val == NULL)
+        break;
 
       if(bv.bv_len > 7 && !strncmp(bv.bv_val + bv.bv_len - 7, ";binary", 7))
         binary = 1;
       else
         binary = 0;
 
-      if(bvals == NULL) { 
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val, 
-                                     bv.bv_len); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":\n", 2); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
-        data->req.bytecount += bv.bv_len + 3; 
-        continue; 
-      } 
- 
-      for(i = 0; bvals[i].bv_val != NULL; i++) { 
+      if(bvals == NULL) {
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val,
+                                     bv.bv_len);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":\n", 2);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+        data->req.bytecount += bv.bv_len + 3;
+        continue;
+      }
+
+      for(i = 0; bvals[i].bv_val != NULL; i++) {
         int binval = 0;
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
- 
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val, 
-                                     bv.bv_len); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
- 
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":", 1); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)bv.bv_val,
+                                     bv.bv_len);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)":", 1);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
         data->req.bytecount += bv.bv_len + 2;
 
         if(!binary) {
           /* check for leading or trailing whitespace */
           if(ISSPACE(bvals[i].bv_val[0]) ||
-             ISSPACE(bvals[i].bv_val[bvals[i].bv_len-1])) 
+             ISSPACE(bvals[i].bv_val[bvals[i].bv_len-1]))
             binval = 1;
           else {
             /* check for unprintable characters */
             unsigned int j;
-            for(j = 0; j<bvals[i].bv_len; j++) 
+            for(j = 0; j<bvals[i].bv_len; j++)
               if(!ISPRINT(bvals[i].bv_val[j])) {
                 binval = 1;
                 break;
@@ -615,70 +615,70 @@ static ssize_t ldap_recv(struct connectdata *conn, int sockindex, char *buf,
           if(error) {
             ber_memfree(bvals);
             ber_free(ber, 0);
-            ldap_msgfree(msg); 
+            ldap_msgfree(msg);
             *err = error;
             return -1;
           }
-          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, 
-                                       (char *)": ", 2); 
-          if(writeerr) { 
-            *err = writeerr; 
-            return -1; 
-          } 
- 
+          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY,
+                                       (char *)": ", 2);
+          if(writeerr) {
+            *err = writeerr;
+            return -1;
+          }
+
           data->req.bytecount += 2;
           if(val_b64_sz > 0) {
-            writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, val_b64, 
-                                         val_b64_sz); 
-            if(writeerr) { 
-              *err = writeerr; 
-              return -1; 
-            } 
+            writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, val_b64,
+                                         val_b64_sz);
+            if(writeerr) {
+              *err = writeerr;
+              return -1;
+            }
             free(val_b64);
             data->req.bytecount += val_b64_sz;
           }
         }
         else {
-          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)" ", 1); 
-          if(writeerr) { 
-            *err = writeerr; 
-            return -1; 
-          } 
- 
-          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, bvals[i].bv_val, 
-                                       bvals[i].bv_len); 
-          if(writeerr) { 
-            *err = writeerr; 
-            return -1; 
-          } 
- 
+          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)" ", 1);
+          if(writeerr) {
+            *err = writeerr;
+            return -1;
+          }
+
+          writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, bvals[i].bv_val,
+                                       bvals[i].bv_len);
+          if(writeerr) {
+            *err = writeerr;
+            return -1;
+          }
+
           data->req.bytecount += bvals[i].bv_len + 1;
         }
-        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0); 
-        if(writeerr) { 
-          *err = writeerr; 
-          return -1; 
-        } 
- 
+        writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
+        if(writeerr) {
+          *err = writeerr;
+          return -1;
+        }
+
         data->req.bytecount++;
       }
       ber_memfree(bvals);
-      writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0); 
-      if(writeerr) { 
-        *err = writeerr; 
-        return -1; 
-      } 
+      writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
+      if(writeerr) {
+        *err = writeerr;
+        return -1;
+      }
       data->req.bytecount++;
     }
-    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0); 
-    if(writeerr) { 
-      *err = writeerr; 
-      return -1; 
-    } 
+    writeerr = Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
+    if(writeerr) {
+      *err = writeerr;
+      return -1;
+    }
     data->req.bytecount++;
     ber_free(ber, 0);
   }
-  ldap_msgfree(msg); 
+  ldap_msgfree(msg);
   return ret;
 }
 
@@ -724,7 +724,7 @@ ldapsb_tls_read(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
   ber_slen_t ret;
   CURLcode err = CURLE_RECV_ERROR;
 
-  ret = (li->recv)(conn, FIRSTSOCKET, buf, len, &err); 
+  ret = (li->recv)(conn, FIRSTSOCKET, buf, len, &err);
   if(ret < 0 && err == CURLE_AGAIN) {
     SET_SOCKERRNO(EWOULDBLOCK);
   }
@@ -739,7 +739,7 @@ ldapsb_tls_write(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
   ber_slen_t ret;
   CURLcode err = CURLE_SEND_ERROR;
 
-  ret = (li->send)(conn, FIRSTSOCKET, buf, len, &err); 
+  ret = (li->send)(conn, FIRSTSOCKET, buf, len, &err);
   if(ret < 0 && err == CURLE_AGAIN) {
     SET_SOCKERRNO(EWOULDBLOCK);
   }