diff --git a/include/libssh2.h b/include/libssh2.h
index 85dcb6d3..63c3fbbf 100644
--- a/include/libssh2.h
+++ b/include/libssh2.h
@@ -968,7 +968,7 @@ libssh2_knownhost_init(LIBSSH2_SESSION *session);
 #define LIBSSH2_KNOWNHOST_KEY_RSA1     (1<<18)
 #define LIBSSH2_KNOWNHOST_KEY_SSHRSA   (2<<18)
 #define LIBSSH2_KNOWNHOST_KEY_SSHDSS   (3<<18)
-#define LIBSSH2_KNOWNHOST_KEY_ECDSA	   (4<<18)
+#define LIBSSH2_KNOWNHOST_KEY_ECDSA    (4<<18)
 #define LIBSSH2_KNOWNHOST_KEY_UNKNOWN  (7<<18)
 
 LIBSSH2_API int
diff --git a/src/agent.c b/src/agent.c
index c2ba422b..b7bd7594 100644
--- a/src/agent.c
+++ b/src/agent.c
@@ -148,21 +148,21 @@ agent_connect_unix(LIBSSH2_AGENT *agent)
     struct sockaddr_un s_un;
 
     path = getenv("SSH_AUTH_SOCK");
-    if (!path)
+    if(!path)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
                               "no auth sock variable");
 
     agent->fd = socket(PF_UNIX, SOCK_STREAM, 0);
-    if (agent->fd < 0)
+    if(agent->fd < 0)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_SOCKET,
                               "failed creating socket");
 
     s_un.sun_family = AF_UNIX;
-    strncpy (s_un.sun_path, path, sizeof s_un.sun_path);
-    s_un.sun_path[sizeof(s_un.sun_path)-1]=0; /* make sure there's a trailing
-                                                 zero */
-    if (connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
-        close (agent->fd);
+    strncpy(s_un.sun_path, path, sizeof s_un.sun_path);
+    s_un.sun_path[sizeof(s_un.sun_path)-1] = 0; /* make sure there's a trailing
+                                                   zero */
+    if(connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
+        close(agent->fd);
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed connecting with agent");
     }
@@ -177,34 +177,34 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     int rc;
 
     /* Send the length of the request */
-    if (transctx->state == agent_NB_state_request_created) {
+    if(transctx->state == agent_NB_state_request_created) {
         _libssh2_htonu32(buf, transctx->request_len);
         rc = LIBSSH2_SEND_FD(agent->session, agent->fd, buf, sizeof buf, 0);
-        if (rc == -EAGAIN)
+        if(rc == -EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
-        else if (rc < 0)
+        else if(rc < 0)
             return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "agent send failed");
         transctx->state = agent_NB_state_request_length_sent;
     }
 
     /* Send the request body */
-    if (transctx->state == agent_NB_state_request_length_sent) {
+    if(transctx->state == agent_NB_state_request_length_sent) {
         rc = LIBSSH2_SEND_FD(agent->session, agent->fd, transctx->request,
                            transctx->request_len, 0);
-        if (rc == -EAGAIN)
+        if(rc == -EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
-        else if (rc < 0)
+        else if(rc < 0)
             return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "agent send failed");
         transctx->state = agent_NB_state_request_sent;
     }
 
     /* Receive the length of a response */
-    if (transctx->state == agent_NB_state_request_sent) {
+    if(transctx->state == agent_NB_state_request_sent) {
         rc = LIBSSH2_RECV_FD(agent->session, agent->fd, buf, sizeof buf, 0);
-        if (rc < 0) {
-            if (rc == -EAGAIN)
+        if(rc < 0) {
+            if(rc == -EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
             return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_RECV,
                                   "agent recv failed");
@@ -212,18 +212,18 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         transctx->response_len = _libssh2_ntohu32(buf);
         transctx->response = LIBSSH2_ALLOC(agent->session,
                                            transctx->response_len);
-        if (!transctx->response)
+        if(!transctx->response)
             return LIBSSH2_ERROR_ALLOC;
 
         transctx->state = agent_NB_state_response_length_received;
     }
 
     /* Receive the response body */
-    if (transctx->state == agent_NB_state_response_length_received) {
+    if(transctx->state == agent_NB_state_response_length_received) {
         rc = LIBSSH2_RECV_FD(agent->session, agent->fd, transctx->response,
                            transctx->response_len, 0);
-        if (rc < 0) {
-            if (rc == -EAGAIN)
+        if(rc < 0) {
+            if(rc == -EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
             return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "agent recv failed");
@@ -270,7 +270,7 @@ agent_connect_pageant(LIBSSH2_AGENT *agent)
 {
     HWND hwnd;
     hwnd = FindWindow("Pageant", "Pageant");
-    if (!hwnd)
+    if(!hwnd)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed connecting agent");
     agent->fd = 0;         /* Mark as the connection has been established */
@@ -288,12 +288,12 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     int id;
     COPYDATASTRUCT cds;
 
-    if (!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
+    if(!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_INVAL,
                               "illegal input");
 
     hwnd = FindWindow("Pageant", "Pageant");
-    if (!hwnd)
+    if(!hwnd)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "found no pageant");
 
@@ -301,12 +301,12 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     filemap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
                                 0, PAGEANT_MAX_MSGLEN, mapname);
 
-    if (filemap == NULL || filemap == INVALID_HANDLE_VALUE)
+    if(filemap == NULL || filemap == INVALID_HANDLE_VALUE)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed setting up pageant filemap");
 
     p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
-    if (p == NULL || p2 == NULL) {
+    if(p == NULL || p2 == NULL) {
         CloseHandle(filemap);
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed to open pageant filemap for writing");
@@ -320,9 +320,9 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     cds.lpData = mapname;
 
     id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds);
-    if (id > 0) {
+    if(id > 0) {
         transctx->response_len = _libssh2_ntohu32(p);
-        if (transctx->response_len > PAGEANT_MAX_MSGLEN) {
+        if(transctx->response_len > PAGEANT_MAX_MSGLEN) {
             UnmapViewOfFile(p);
             CloseHandle(filemap);
             return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
@@ -330,7 +330,7 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         }
         transctx->response = LIBSSH2_ALLOC(agent->session,
                                            transctx->response_len);
-        if (!transctx->response) {
+        if(!transctx->response) {
             UnmapViewOfFile(p);
             CloseHandle(filemap);
             return _libssh2_error(agent->session, LIBSSH2_ERROR_ALLOC,
@@ -384,9 +384,9 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     int rc;
 
     /* Create a request to sign the data */
-    if (transctx->state == agent_NB_state_init) {
+    if(transctx->state == agent_NB_state_init) {
         s = transctx->request = LIBSSH2_ALLOC(session, len);
-        if (!transctx->request)
+        if(!transctx->request)
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "out of memory");
 
@@ -405,17 +405,17 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     }
 
     /* Make sure to be re-called as a result of EAGAIN. */
-    if (*transctx->request != SSH2_AGENTC_SIGN_REQUEST)
+    if(*transctx->request != SSH2_AGENTC_SIGN_REQUEST)
         return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
                               "illegal request");
 
-    if (!agent->ops)
+    if(!agent->ops)
         /* if no agent has been connected, bail out */
         return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
                               "agent not connected");
 
     rc = agent->ops->transact(agent, transctx);
-    if (rc) {
+    if(rc) {
         goto error;
     }
     LIBSSH2_FREE(session, transctx->request);
@@ -424,11 +424,11 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     len = transctx->response_len;
     s = transctx->response;
     len--;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
-    if (*s != SSH2_AGENT_SIGN_RESPONSE) {
+    if(*s != SSH2_AGENT_SIGN_RESPONSE) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
@@ -436,7 +436,7 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
 
     /* Skip the entire length of the signature */
     len -= 4;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
@@ -444,14 +444,14 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
 
     /* Skip signing method */
     len -= 4;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
     method_len = _libssh2_ntohu32(s);
     s += 4;
     len -= method_len;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
@@ -459,20 +459,20 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
 
     /* Read the signature */
     len -= 4;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
     *sig_len = _libssh2_ntohu32(s);
     s += 4;
     len -= *sig_len;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
 
     *sig = LIBSSH2_ALLOC(session, *sig_len);
-    if (!*sig) {
+    if(!*sig) {
         rc = LIBSSH2_ERROR_ALLOC;
         goto error;
     }
@@ -498,24 +498,24 @@ agent_list_identities(LIBSSH2_AGENT *agent)
     unsigned char c = SSH2_AGENTC_REQUEST_IDENTITIES;
 
     /* Create a request to list identities */
-    if (transctx->state == agent_NB_state_init) {
+    if(transctx->state == agent_NB_state_init) {
         transctx->request = &c;
         transctx->request_len = 1;
         transctx->state = agent_NB_state_request_created;
     }
 
     /* Make sure to be re-called as a result of EAGAIN. */
-    if (*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES)
+    if(*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
                               "illegal agent request");
 
-    if (!agent->ops)
+    if(!agent->ops)
         /* if no agent has been connected, bail out */
         return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
                               "agent not connected");
 
     rc = agent->ops->transact(agent, transctx);
-    if (rc) {
+    if(rc) {
         goto error;
     }
     transctx->request = NULL;
@@ -523,11 +523,11 @@ agent_list_identities(LIBSSH2_AGENT *agent)
     len = transctx->response_len;
     s = transctx->response;
     len--;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
-    if (*s != SSH2_AGENT_IDENTITIES_ANSWER) {
+    if(*s != SSH2_AGENT_IDENTITIES_ANSWER) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
@@ -535,25 +535,25 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
     /* Read the length of identities */
     len -= 4;
-    if (len < 0) {
+    if(len < 0) {
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
     num_identities = _libssh2_ntohu32(s);
     s += 4;
 
-    while (num_identities--) {
+    while(num_identities--) {
         struct agent_publickey *identity;
         ssize_t comment_len;
 
         /* Read the length of the blob */
         len -= 4;
-        if (len < 0) {
+        if(len < 0) {
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             goto error;
         }
         identity = LIBSSH2_ALLOC(agent->session, sizeof *identity);
-        if (!identity) {
+        if(!identity) {
             rc = LIBSSH2_ERROR_ALLOC;
             goto error;
         }
@@ -562,7 +562,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         /* Read the blob */
         len -= identity->external.blob_len;
-        if (len < 0) {
+        if(len < 0) {
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             LIBSSH2_FREE(agent->session, identity);
             goto error;
@@ -570,7 +570,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         identity->external.blob = LIBSSH2_ALLOC(agent->session,
                                                 identity->external.blob_len);
-        if (!identity->external.blob) {
+        if(!identity->external.blob) {
             rc = LIBSSH2_ERROR_ALLOC;
             LIBSSH2_FREE(agent->session, identity);
             goto error;
@@ -580,7 +580,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         /* Read the length of the comment */
         len -= 4;
-        if (len < 0) {
+        if(len < 0) {
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             LIBSSH2_FREE(agent->session, identity->external.blob);
             LIBSSH2_FREE(agent->session, identity);
@@ -591,7 +591,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         /* Read the comment */
         len -= comment_len;
-        if (len < 0) {
+        if(len < 0) {
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             LIBSSH2_FREE(agent->session, identity->external.blob);
             LIBSSH2_FREE(agent->session, identity);
@@ -600,7 +600,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         identity->external.comment = LIBSSH2_ALLOC(agent->session,
                                                    comment_len + 1);
-        if (!identity->external.comment) {
+        if(!identity->external.comment) {
             rc = LIBSSH2_ERROR_ALLOC;
             LIBSSH2_FREE(agent->session, identity->external.blob);
             LIBSSH2_FREE(agent->session, identity);
@@ -621,11 +621,12 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 }
 
 static void
-agent_free_identities(LIBSSH2_AGENT *agent) {
+agent_free_identities(LIBSSH2_AGENT *agent)
+{
     struct agent_publickey *node;
     struct agent_publickey *next;
 
-    for (node = _libssh2_list_first(&agent->head); node; node = next) {
+    for(node = _libssh2_list_first(&agent->head); node; node = next) {
         next = _libssh2_list_next(&node->node);
         LIBSSH2_FREE(agent->session, node->external.blob);
         LIBSSH2_FREE(agent->session, node->external.comment);
@@ -664,7 +665,7 @@ libssh2_agent_init(LIBSSH2_SESSION *session)
     LIBSSH2_AGENT *agent;
 
     agent = LIBSSH2_CALLOC(session, sizeof *agent);
-    if (!agent) {
+    if(!agent) {
         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                        "Unable to allocate space for agent connection");
         return NULL;
@@ -687,10 +688,10 @@ LIBSSH2_API int
 libssh2_agent_connect(LIBSSH2_AGENT *agent)
 {
     int i, rc = -1;
-    for (i = 0; supported_backends[i].name; i++) {
+    for(i = 0; supported_backends[i].name; i++) {
         agent->ops = supported_backends[i].ops;
         rc = (agent->ops->connect)(agent);
-        if (!rc)
+        if(!rc)
             return 0;
     }
     return rc;
@@ -707,7 +708,7 @@ LIBSSH2_API int
 libssh2_agent_list_identities(LIBSSH2_AGENT *agent)
 {
     memset(&agent->transctx, 0, sizeof agent->transctx);
-    /* Abondon the last fetched identities */
+    /* Abandon the last fetched identities */
     agent_free_identities(agent);
     return agent_list_identities(agent);
 }
@@ -730,7 +731,7 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
                            struct libssh2_agent_publickey *oprev)
 {
     struct agent_publickey *node;
-    if (oprev && oprev->node) {
+    if(oprev && oprev->node) {
         /* we have a starting point */
         struct agent_publickey *prev = oprev->node;
 
@@ -740,7 +741,7 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
     else
         node = _libssh2_list_first(&agent->head);
 
-    if (!node)
+    if(!node)
         /* no (more) node */
         return 1;
 
@@ -764,7 +765,7 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
     void *abstract = agent;
     int rc;
 
-    if (agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
+    if(agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
         memset(&agent->transctx, 0, sizeof agent->transctx);
         agent->identity = identity->node;
     }
@@ -789,7 +790,7 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
 LIBSSH2_API int
 libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
 {
-    if (agent->ops && agent->fd != LIBSSH2_INVALID_SOCKET)
+    if(agent->ops && agent->fd != LIBSSH2_INVALID_SOCKET)
         return agent->ops->disconnect(agent);
     return 0;
 }
@@ -801,9 +802,10 @@ libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
  * collection of public keys.
  */
 LIBSSH2_API void
-libssh2_agent_free(LIBSSH2_AGENT *agent) {
+libssh2_agent_free(LIBSSH2_AGENT *agent)
+{
     /* Allow connection freeing when the socket has lost its connection */
-    if (agent->fd != LIBSSH2_INVALID_SOCKET) {
+    if(agent->fd != LIBSSH2_INVALID_SOCKET) {
         libssh2_agent_disconnect(agent);
     }
     agent_free_identities(agent);
diff --git a/src/channel.c b/src/channel.c
index b708dd43..d9208e43 100644
--- a/src/channel.c
+++ b/src/channel.c
@@ -66,8 +66,8 @@ _libssh2_channel_nextid(LIBSSH2_SESSION * session)
 
     channel = _libssh2_list_first(&session->channels);
 
-    while (channel) {
-        if (channel->local.id > id) {
+    while(channel) {
+        if(channel->local.id > id) {
             id = channel->local.id;
         }
         channel = _libssh2_list_next(&channel->node);
@@ -100,7 +100,7 @@ _libssh2_channel_locate(LIBSSH2_SESSION *session, uint32_t channel_id)
     for(channel = _libssh2_list_first(&session->channels);
         channel;
         channel = _libssh2_list_next(&channel->node)) {
-        if (channel->local.id == channel_id)
+        if(channel->local.id == channel_id)
             return channel;
     }
 
@@ -112,7 +112,7 @@ _libssh2_channel_locate(LIBSSH2_SESSION *session, uint32_t channel_id)
         for(channel = _libssh2_list_first(&l->queue);
             channel;
             channel = _libssh2_list_next(&channel->node)) {
-            if (channel->local.id == channel_id)
+            if(channel->local.id == channel_id)
                 return channel;
         }
     }
@@ -141,7 +141,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
     unsigned char *s;
     int rc;
 
-    if (session->open_state == libssh2_NB_state_idle) {
+    if(session->open_state == libssh2_NB_state_idle) {
         session->open_channel = NULL;
         session->open_packet = NULL;
         session->open_data = NULL;
@@ -159,7 +159,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
                        packet_size);
         session->open_channel =
             LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-        if (!session->open_channel) {
+        if(!session->open_channel) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate space for channel data");
             return NULL;
@@ -167,7 +167,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         session->open_channel->channel_type_len = channel_type_len;
         session->open_channel->channel_type =
             LIBSSH2_ALLOC(session, channel_type_len);
-        if (!session->open_channel->channel_type) {
+        if(!session->open_channel->channel_type) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Failed allocating memory for channel type name");
             LIBSSH2_FREE(session, session->open_channel);
@@ -189,7 +189,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
 
         s = session->open_packet =
             LIBSSH2_ALLOC(session, session->open_packet_len);
-        if (!session->open_packet) {
+        if(!session->open_packet) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate temporary space for packet");
             goto channel_error;
@@ -205,17 +205,17 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         session->open_state = libssh2_NB_state_created;
     }
 
-    if (session->open_state == libssh2_NB_state_created) {
+    if(session->open_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session,
                                      session->open_packet,
                                      session->open_packet_len,
                                      message, message_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending channel-open request");
             return NULL;
         }
-        else if (rc) {
+        else if(rc) {
             _libssh2_error(session, rc,
                            "Unable to send channel-open request");
             goto channel_error;
@@ -224,21 +224,22 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         session->open_state = libssh2_NB_state_sent;
     }
 
-    if (session->open_state == libssh2_NB_state_sent) {
+    if(session->open_state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_requirev(session, reply_codes,
                                       &session->open_data,
                                       &session->open_data_len, 1,
                                       session->open_packet + 5 +
                                       channel_type_len, 4,
                                       &session->open_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
             return NULL;
-        } else if (rc) {
+        }
+        else if(rc) {
             goto channel_error;
         }
 
-        if (session->open_data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
+        if(session->open_data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
             session->open_channel->remote.id =
                 _libssh2_ntohu32(session->open_data + 5);
             session->open_channel->local.window_size =
@@ -265,9 +266,9 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
             return session->open_channel;
         }
 
-        if (session->open_data[0] == SSH_MSG_CHANNEL_OPEN_FAILURE) {
+        if(session->open_data[0] == SSH_MSG_CHANNEL_OPEN_FAILURE) {
             unsigned int reason_code = _libssh2_ntohu32(session->open_data + 5);
-            switch (reason_code) {
+            switch(reason_code) {
             case SSH_OPEN_ADMINISTRATIVELY_PROHIBITED:
                 _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
                                "Channel open failure (administratively prohibited)");
@@ -293,15 +294,15 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
 
   channel_error:
 
-    if (session->open_data) {
+    if(session->open_data) {
         LIBSSH2_FREE(session, session->open_data);
         session->open_data = NULL;
     }
-    if (session->open_packet) {
+    if(session->open_packet) {
         LIBSSH2_FREE(session, session->open_packet);
         session->open_packet = NULL;
     }
-    if (session->open_channel) {
+    if(session->open_channel) {
         unsigned char channel_id[4];
         LIBSSH2_FREE(session, session->open_channel->channel_type);
 
@@ -309,7 +310,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
 
         /* Clear out packets meant for this channel */
         _libssh2_htonu32(channel_id, session->open_channel->local.id);
-        while ((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA,
+        while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA,
                                     &session->open_data,
                                     &session->open_data_len, 1,
                                     channel_id, 4) >= 0)
@@ -366,7 +367,7 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
     LIBSSH2_CHANNEL *channel;
     unsigned char *s;
 
-    if (session->direct_state == libssh2_NB_state_idle) {
+    if(session->direct_state == libssh2_NB_state_idle) {
         session->direct_host_len = strlen(host);
         session->direct_shost_len = strlen(shost);
         /* host_len(4) + port(4) + shost_len(4) + sport(4) */
@@ -379,7 +380,7 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
 
         s = session->direct_message =
             LIBSSH2_ALLOC(session, session->direct_message_len);
-        if (!session->direct_message) {
+        if(!session->direct_message) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for direct-tcpip connection");
             return NULL;
@@ -398,7 +399,7 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
                               session->direct_message,
                               session->direct_message_len);
 
-    if (!channel &&
+    if(!channel &&
         libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
         /* The error code is still set to LIBSSH2_ERROR_EAGAIN, set our state
            to created to avoid re-creating the package on next invoke */
@@ -450,7 +451,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
     if(!host)
         host = "0.0.0.0";
 
-    if (session->fwdLstn_state == libssh2_NB_state_idle) {
+    if(session->fwdLstn_state == libssh2_NB_state_idle) {
         session->fwdLstn_host_len = strlen(host);
         /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4)
            + port(4) */
@@ -467,7 +468,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
 
         s = session->fwdLstn_packet =
             LIBSSH2_ALLOC(session, session->fwdLstn_packet_len);
-        if (!session->fwdLstn_packet) {
+        if(!session->fwdLstn_packet) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for setenv packet");
             return NULL;
@@ -483,18 +484,18 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
         session->fwdLstn_state = libssh2_NB_state_created;
     }
 
-    if (session->fwdLstn_state == libssh2_NB_state_created) {
+    if(session->fwdLstn_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session,
                                      session->fwdLstn_packet,
                                      session->fwdLstn_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending global-request packet for "
                            "forward listen request");
             return NULL;
         }
-        else if (rc) {
+        else if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                            "Unable to send global-request packet for forward "
                            "listen request");
@@ -509,32 +510,33 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
         session->fwdLstn_state = libssh2_NB_state_sent;
     }
 
-    if (session->fwdLstn_state == libssh2_NB_state_sent) {
+    if(session->fwdLstn_state == libssh2_NB_state_sent) {
         unsigned char *data;
         size_t data_len;
         rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
                                       0, NULL, 0,
                                       &session->fwdLstn_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
             return NULL;
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_PROTO, "Unknown");
             session->fwdLstn_state = libssh2_NB_state_idle;
             return NULL;
         }
 
-        if (data[0] == SSH_MSG_REQUEST_SUCCESS) {
+        if(data[0] == SSH_MSG_REQUEST_SUCCESS) {
             LIBSSH2_LISTENER *listener;
 
             listener = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_LISTENER));
-            if (!listener)
+            if(!listener)
                 _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                "Unable to allocate memory for listener queue");
             else {
                 listener->host =
                     LIBSSH2_ALLOC(session, session->fwdLstn_host_len + 1);
-                if (!listener->host) {
+                if(!listener->host) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for listener queue");
                     LIBSSH2_FREE(session, listener);
@@ -544,7 +546,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
                     listener->session = session;
                     memcpy(listener->host, host, session->fwdLstn_host_len);
                     listener->host[session->fwdLstn_host_len] = 0;
-                    if (data_len >= 5 && !port) {
+                    if(data_len >= 5 && !port) {
                         listener->port = _libssh2_ntohu32(data + 1);
                         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                                        "Dynamic tcpip-forward port allocated: %d",
@@ -559,7 +561,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
                     /* append this to the parent's list of listeners */
                     _libssh2_list_add(&session->listeners, &listener->node);
 
-                    if (bound_port) {
+                    if(bound_port) {
                         *bound_port = listener->port;
                     }
                 }
@@ -569,7 +571,7 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
             session->fwdLstn_state = libssh2_NB_state_idle;
             return listener;
         }
-        else if (data[0] == SSH_MSG_REQUEST_FAILURE) {
+        else if(data[0] == SSH_MSG_REQUEST_FAILURE) {
             LIBSSH2_FREE(session, data);
             _libssh2_error(session, LIBSSH2_ERROR_REQUEST_DENIED,
                            "Unable to complete request for forward-listen");
@@ -624,13 +626,13 @@ int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
     int rc;
     int retcode = 0;
 
-    if (listener->chanFwdCncl_state == libssh2_NB_state_idle) {
+    if(listener->chanFwdCncl_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "Cancelling tcpip-forward session for %s:%d",
                        listener->host, listener->port);
 
         s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!packet) {
+        if(!packet) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for setenv packet");
             return LIBSSH2_ERROR_ALLOC;
@@ -645,19 +647,20 @@ int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
         _libssh2_store_u32(&s, listener->port);
 
         listener->chanFwdCncl_state = libssh2_NB_state_created;
-    } else {
+    }
+    else {
         packet = listener->chanFwdCncl_data;
     }
 
-    if (listener->chanFwdCncl_state == libssh2_NB_state_created) {
+    if(listener->chanFwdCncl_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, packet, packet_len, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending forward request");
             listener->chanFwdCncl_data = packet;
             return rc;
         }
-        else if (rc) {
+        else if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                            "Unable to send global-request packet for forward "
                            "listen request");
@@ -673,11 +676,11 @@ int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
     }
 
     queued = _libssh2_list_first(&listener->queue);
-    while (queued) {
+    while(queued) {
         LIBSSH2_CHANNEL *next = _libssh2_list_next(&queued->node);
 
         rc = _libssh2_channel_free(queued);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
         queued = next;
@@ -725,9 +728,9 @@ channel_forward_accept(LIBSSH2_LISTENER *listener)
 
     do {
         rc = _libssh2_transport_read(listener->session);
-    } while (rc > 0);
+    } while(rc > 0);
 
-    if (_libssh2_list_first(&listener->queue)) {
+    if(_libssh2_list_first(&listener->queue)) {
         LIBSSH2_CHANNEL *channel = _libssh2_list_first(&listener->queue);
 
         /* detach channel from listener's queue */
@@ -741,7 +744,7 @@ channel_forward_accept(LIBSSH2_LISTENER *listener)
         return channel;
     }
 
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         _libssh2_error(listener->session, LIBSSH2_ERROR_EAGAIN,
                        "Would block waiting for packet");
     }
@@ -786,7 +789,7 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
     size_t data_len;
     int rc;
 
-    if (channel->setenv_state == libssh2_NB_state_idle) {
+    if(channel->setenv_state == libssh2_NB_state_idle) {
         /* 21 = packet_type(1) + channel_id(4) + request_len(4) +
          * request(3)"env" + want_reply(1) + varname_len(4) + value_len(4) */
         channel->setenv_packet_len = varname_len + value_len + 21;
@@ -802,7 +805,7 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
 
         s = channel->setenv_packet =
             LIBSSH2_ALLOC(session, channel->setenv_packet_len);
-        if (!channel->setenv_packet) {
+        if(!channel->setenv_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory "
                                   "for setenv packet");
@@ -818,16 +821,17 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
         channel->setenv_state = libssh2_NB_state_created;
     }
 
-    if (channel->setenv_state == libssh2_NB_state_created) {
+    if(channel->setenv_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session,
                                      channel->setenv_packet,
                                      channel->setenv_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending setenv request");
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             LIBSSH2_FREE(session, channel->setenv_packet);
             channel->setenv_packet = NULL;
             channel->setenv_state = libssh2_NB_state_idle;
@@ -843,20 +847,20 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
         channel->setenv_state = libssh2_NB_state_sent;
     }
 
-    if (channel->setenv_state == libssh2_NB_state_sent) {
+    if(channel->setenv_state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
                                       1, channel->setenv_local_channel, 4,
                                       &channel->
                                       setenv_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
-        if (rc) {
+        if(rc) {
             channel->setenv_state = libssh2_NB_state_idle;
             return rc;
         }
 
-        if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
+        if(data[0] == SSH_MSG_CHANNEL_SUCCESS) {
             LIBSSH2_FREE(session, data);
             channel->setenv_state = libssh2_NB_state_idle;
             return 0;
@@ -907,7 +911,7 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
         { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
     int rc;
 
-    if (channel->reqPTY_state == libssh2_NB_state_idle) {
+    if(channel->reqPTY_state == libssh2_NB_state_idle) {
         /* 41 = packet_type(1) + channel(4) + pty_req_len(4) + "pty_req"(7) +
          * want_reply(1) + term_len(4) + width(4) + height(4) + width_px(4) +
          * height_px(4) + modes_len(4) */
@@ -944,15 +948,16 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
         channel->reqPTY_state = libssh2_NB_state_created;
     }
 
-    if (channel->reqPTY_state == libssh2_NB_state_created) {
+    if(channel->reqPTY_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, channel->reqPTY_packet,
                                      channel->reqPTY_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending pty request");
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             channel->reqPTY_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
                                   "Unable to send pty-request packet");
@@ -962,16 +967,17 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
         channel->reqPTY_state = libssh2_NB_state_sent;
     }
 
-    if (channel->reqPTY_state == libssh2_NB_state_sent) {
+    if(channel->reqPTY_state == libssh2_NB_state_sent) {
         unsigned char *data;
         size_t data_len;
         unsigned char code;
         rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
                                       1, channel->reqPTY_local_channel, 4,
                                       &channel->reqPTY_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             channel->reqPTY_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                                   "Failed to require the PTY package");
@@ -982,7 +988,7 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
         LIBSSH2_FREE(session, data);
         channel->reqPTY_state = libssh2_NB_state_idle;
 
-        if (code == SSH_MSG_CHANNEL_SUCCESS)
+        if(code == SSH_MSG_CHANNEL_SUCCESS)
             return 0;
     }
 
@@ -1021,7 +1027,7 @@ channel_request_pty_size(LIBSSH2_CHANNEL * channel, int width,
     int rc;
     int retcode = LIBSSH2_ERROR_PROTO;
 
-    if (channel->reqPTY_state == libssh2_NB_state_idle) {
+    if(channel->reqPTY_state == libssh2_NB_state_idle) {
         channel->reqPTY_packet_len = 39;
 
         /* Zero the whole thing out */
@@ -1048,15 +1054,16 @@ channel_request_pty_size(LIBSSH2_CHANNEL * channel, int width,
         channel->reqPTY_state = libssh2_NB_state_created;
     }
 
-    if (channel->reqPTY_state == libssh2_NB_state_created) {
+    if(channel->reqPTY_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, channel->reqPTY_packet,
                                      channel->reqPTY_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending window-change request");
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             channel->reqPTY_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
                                   "Unable to send window-change packet");
@@ -1106,7 +1113,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         auth_cookie ? strlen(auth_cookie) : LIBSSH2_X11_RANDOM_COOKIE_LEN;
     int rc;
 
-    if (channel->reqX11_state == libssh2_NB_state_idle) {
+    if(channel->reqX11_state == libssh2_NB_state_idle) {
         /* 30 = packet_type(1) + channel(4) + x11_req_len(4) + "x11-req"(7) +
          * want_reply(1) + single_cnx(1) + proto_len(4) + cookie_len(4) +
          * screen_num(4) */
@@ -1126,7 +1133,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
 
         s = channel->reqX11_packet =
             LIBSSH2_ALLOC(session, channel->reqX11_packet_len);
-        if (!channel->reqX11_packet) {
+        if(!channel->reqX11_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for pty-request");
         }
@@ -1138,19 +1145,20 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         *(s++) = 0x01;          /* want_reply */
         *(s++) = single_connection ? 0x01 : 0x00;
 
-        _libssh2_store_str(&s, auth_proto?auth_proto:"MIT-MAGIC-COOKIE-1",
+        _libssh2_store_str(&s, auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
                            proto_len);
 
         _libssh2_store_u32(&s, cookie_len);
-        if (auth_cookie) {
+        if(auth_cookie) {
             memcpy(s, auth_cookie, cookie_len);
-        } else {
+        }
+        else {
             int i;
             /* note: the extra +1 below is necessary since the sprintf()
                loop will always write 3 bytes so the last one will write
                the trailing zero at the LIBSSH2_X11_RANDOM_COOKIE_LEN/2
                border */
-            unsigned char buffer[(LIBSSH2_X11_RANDOM_COOKIE_LEN / 2) +1];
+            unsigned char buffer[(LIBSSH2_X11_RANDOM_COOKIE_LEN / 2) + 1];
 
             _libssh2_random(buffer, LIBSSH2_X11_RANDOM_COOKIE_LEN / 2);
             for(i = 0; i < (LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); i++) {
@@ -1163,16 +1171,16 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         channel->reqX11_state = libssh2_NB_state_created;
     }
 
-    if (channel->reqX11_state == libssh2_NB_state_created) {
+    if(channel->reqX11_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, channel->reqX11_packet,
                                      channel->reqX11_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending X11-req packet");
             return rc;
         }
-        if (rc) {
+        if(rc) {
             LIBSSH2_FREE(session, channel->reqX11_packet);
             channel->reqX11_packet = NULL;
             channel->reqX11_state = libssh2_NB_state_idle;
@@ -1187,7 +1195,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         channel->reqX11_state = libssh2_NB_state_sent;
     }
 
-    if (channel->reqX11_state == libssh2_NB_state_sent) {
+    if(channel->reqX11_state == libssh2_NB_state_sent) {
         size_t data_len;
         unsigned char *data;
         unsigned char code;
@@ -1195,9 +1203,10 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
                                       1, channel->reqX11_local_channel, 4,
                                       &channel->reqX11_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             channel->reqX11_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
                                   "waiting for x11-req response packet");
@@ -1207,7 +1216,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         LIBSSH2_FREE(session, data);
         channel->reqX11_state = libssh2_NB_state_idle;
 
-        if (code == SSH_MSG_CHANNEL_SUCCESS)
+        if(code == SSH_MSG_CHANNEL_SUCCESS)
             return 0;
     }
 
@@ -1252,12 +1261,12 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
     int rc;
 
-    if (channel->process_state == libssh2_NB_state_end) {
+    if(channel->process_state == libssh2_NB_state_end) {
         return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
                               "Channel can not be reused");
     }
 
-    if (channel->process_state == libssh2_NB_state_idle) {
+    if(channel->process_state == libssh2_NB_state_idle) {
         /* 10 = packet_type(1) + channel(4) + request_len(4) + want_reply(1) */
         channel->process_packet_len = request_len + 10;
 
@@ -1265,16 +1274,16 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         memset(&channel->process_packet_requirev_state, 0,
                sizeof(channel->process_packet_requirev_state));
 
-        if (message)
+        if(message)
             channel->process_packet_len += + 4;
 
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "starting request(%s) on channel %lu/%lu, message=%s",
                        request, channel->local.id, channel->remote.id,
-                       message?message:"<null>");
+                       message ? message : "<null>");
         s = channel->process_packet =
             LIBSSH2_ALLOC(session, channel->process_packet_len);
-        if (!channel->process_packet)
+        if(!channel->process_packet)
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory "
                                   "for channel-process request");
@@ -1284,23 +1293,23 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         _libssh2_store_str(&s, request, request_len);
         *(s++) = 0x01;
 
-        if (message)
+        if(message)
             _libssh2_store_u32(&s, message_len);
 
         channel->process_state = libssh2_NB_state_created;
     }
 
-    if (channel->process_state == libssh2_NB_state_created) {
+    if(channel->process_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session,
                                      channel->process_packet,
                                      channel->process_packet_len,
                                      (unsigned char *)message, message_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending channel request");
             return rc;
         }
-        else if (rc) {
+        else if(rc) {
             LIBSSH2_FREE(session, channel->process_packet);
             channel->process_packet = NULL;
             channel->process_state = libssh2_NB_state_end;
@@ -1315,16 +1324,17 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         channel->process_state = libssh2_NB_state_sent;
     }
 
-    if (channel->process_state == libssh2_NB_state_sent) {
+    if(channel->process_state == libssh2_NB_state_sent) {
         unsigned char *data;
         size_t data_len;
         unsigned char code;
         rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
                                       1, channel->process_local_channel, 4,
                                       &channel->process_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             channel->process_state = libssh2_NB_state_end;
             return _libssh2_error(session, rc,
                                   "Failed waiting for channel success");
@@ -1334,7 +1344,7 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         LIBSSH2_FREE(session, data);
         channel->process_state = libssh2_NB_state_end;
 
-        if (code == SSH_MSG_CHANNEL_SUCCESS)
+        if(code == SSH_MSG_CHANNEL_SUCCESS)
             return 0;
     }
 
@@ -1387,24 +1397,24 @@ libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking)
 int
 _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
 {
-    if (channel->flush_state == libssh2_NB_state_idle) {
+    if(channel->flush_state == libssh2_NB_state_idle) {
         LIBSSH2_PACKET *packet =
             _libssh2_list_first(&channel->session->packets);
         channel->flush_refund_bytes = 0;
         channel->flush_flush_bytes = 0;
 
-        while (packet) {
+        while(packet) {
             LIBSSH2_PACKET *next = _libssh2_list_next(&packet->node);
             unsigned char packet_type = packet->data[0];
 
-            if (((packet_type == SSH_MSG_CHANNEL_DATA)
+            if(((packet_type == SSH_MSG_CHANNEL_DATA)
                  || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
                 && (_libssh2_ntohu32(packet->data + 1) == channel->local.id)) {
                 /* It's our channel at least */
                 long packet_stream_id =
                     (packet_type == SSH_MSG_CHANNEL_DATA) ? 0 :
                     _libssh2_ntohu32(packet->data + 5);
-                if ((streamid == LIBSSH2_CHANNEL_FLUSH_ALL)
+                if((streamid == LIBSSH2_CHANNEL_FLUSH_ALL)
                     || ((packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA)
                         && ((streamid == LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA)
                             || (streamid == packet_stream_id)))
@@ -1438,13 +1448,13 @@ _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
     channel->read_avail -= channel->flush_flush_bytes;
     channel->remote.window_size -= channel->flush_flush_bytes;
 
-    if (channel->flush_refund_bytes) {
+    if(channel->flush_refund_bytes) {
         int rc;
 
         rc = _libssh2_channel_receive_window_adjust(channel,
                                                     channel->flush_refund_bytes,
                                                     1, NULL);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
     }
 
@@ -1510,41 +1520,42 @@ libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel,
 {
     size_t namelen = 0;
 
-    if (channel) {
+    if(channel) {
         LIBSSH2_SESSION *session = channel->session;
 
-        if (channel->exit_signal) {
+        if(channel->exit_signal) {
             namelen = strlen(channel->exit_signal);
-            if (exitsignal) {
-               *exitsignal = LIBSSH2_ALLOC(session, namelen + 1);
-                if (!*exitsignal) {
+            if(exitsignal) {
+                *exitsignal = LIBSSH2_ALLOC(session, namelen + 1);
+                if(!*exitsignal) {
                     return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                         "Unable to allocate memory for signal name");
                 }
                 memcpy(*exitsignal, channel->exit_signal, namelen);
                 (*exitsignal)[namelen] = '\0';
             }
-            if (exitsignal_len)
+            if(exitsignal_len)
                 *exitsignal_len = namelen;
-        } else {
-            if (exitsignal)
+        }
+        else {
+            if(exitsignal)
                 *exitsignal = NULL;
-            if (exitsignal_len)
+            if(exitsignal_len)
                 *exitsignal_len = 0;
         }
 
         /* TODO: set error message and language tag */
 
-        if (errmsg)
+        if(errmsg)
             *errmsg = NULL;
 
-        if (errmsg_len)
+        if(errmsg_len)
             *errmsg_len = 0;
 
-        if (langtag)
+        if(langtag)
             *langtag = NULL;
 
-        if (langtag_len)
+        if(langtag_len)
             *langtag_len = 0;
     }
 
@@ -1571,8 +1582,8 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
     if(store)
         *store = channel->remote.window_size;
 
-    if (channel->adjust_state == libssh2_NB_state_idle) {
-        if (!force
+    if(channel->adjust_state == libssh2_NB_state_idle) {
+        if(!force
             && (adjustment + channel->adjust_queue <
                 LIBSSH2_CHANNEL_MINADJUST)) {
             _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
@@ -1583,7 +1594,7 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
             return 0;
         }
 
-        if (!adjustment && !channel->adjust_queue) {
+        if(!adjustment && !channel->adjust_queue) {
             return 0;
         }
 
@@ -1604,12 +1615,12 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
 
     rc = _libssh2_transport_send(channel->session, channel->adjust_adjust, 9,
                                  NULL, 0);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         _libssh2_error(channel->session, rc,
                        "Would block sending window adjust");
         return rc;
     }
-    else if (rc) {
+    else if(rc) {
         channel->adjust_queue = adjustment;
         return _libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND,
                               "Unable to send transfer-window adjustment "
@@ -1654,7 +1665,7 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
 
     /* stupid - but this is how it was made to work before and this is just
        kept for backwards compatibility */
-    return rc?(unsigned long)rc:window;
+    return rc ? (unsigned long)rc : window;
 }
 
 /*
@@ -1688,7 +1699,7 @@ libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
 int
 _libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
 {
-    if (channel->extData2_state == libssh2_NB_state_idle) {
+    if(channel->extData2_state == libssh2_NB_state_idle) {
         _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
                        "Setting channel %lu/%lu handle_extended_data"
                        " mode to %d",
@@ -1698,8 +1709,8 @@ _libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
         channel->extData2_state = libssh2_NB_state_created;
     }
 
-    if (channel->extData2_state == libssh2_NB_state_idle) {
-        if (ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) {
+    if(channel->extData2_state == libssh2_NB_state_idle) {
+        if(ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) {
             int rc =
                 _libssh2_channel_flush(channel,
                                        LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA);
@@ -1779,11 +1790,11 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
                    stream_id);
 
     /* expand the receiving window first if it has become too narrow */
-    if( (channel->read_state == libssh2_NB_state_jump1) ||
-        (channel->remote.window_size < channel->remote.window_size_initial / 4 * 3 + buflen) ) {
+    if((channel->read_state == libssh2_NB_state_jump1) ||
+       (channel->remote.window_size < channel->remote.window_size_initial / 4 * 3 + buflen) ) {
 
         uint32_t adjustment = channel->remote.window_size_initial + buflen - channel->remote.window_size;
-        if (adjustment < LIBSSH2_CHANNEL_MINADJUST)
+        if(adjustment < LIBSSH2_CHANNEL_MINADJUST)
             adjustment = LIBSSH2_CHANNEL_MINADJUST;
 
         /* the actual window adjusting may not finish so we need to deal with
@@ -1791,7 +1802,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
         channel->read_state = libssh2_NB_state_jump1;
         rc = _libssh2_channel_receive_window_adjust(channel, adjustment,
                                                     0, NULL);
-        if (rc)
+        if(rc)
             return rc;
 
         channel->read_state = libssh2_NB_state_idle;
@@ -1801,13 +1812,13 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
        produces faster transfers. */
     do {
         rc = _libssh2_transport_read(session);
-    } while (rc > 0);
+    } while(rc > 0);
 
-    if ((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN))
+    if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN))
         return _libssh2_error(session, rc, "transport read");
 
     read_packet = _libssh2_list_first(&session->packets);
-    while (read_packet && (bytes_read < (int) buflen)) {
+    while(read_packet && (bytes_read < (int) buflen)) {
         /* previously this loop condition also checked for
            !channel->remote.close but we cannot let it do this:
 
@@ -1831,7 +1842,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
          * or the standard stream with extended_data_merge
          * enabled and data was available
          */
-        if ((stream_id
+        if((stream_id
              && (readpkt->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
              && (channel->local.id == channel->read_local_id)
              && (stream_id == (int) _libssh2_ntohu32(readpkt->data + 5)))
@@ -1847,7 +1858,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
             bytes_want = buflen - bytes_read;
             unlink_packet = FALSE;
 
-            if (bytes_want >= (int) (readpkt->data_len - readpkt->data_head)) {
+            if(bytes_want >= (int) (readpkt->data_len - readpkt->data_head)) {
                 /* we want more than this node keeps, so adjust the number and
                    delete this node after the copy */
                 bytes_want = readpkt->data_len - readpkt->data_head;
@@ -1869,7 +1880,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
             bytes_read += bytes_want;
 
             /* if drained, remove from list */
-            if (unlink_packet) {
+            if(unlink_packet) {
                 /* detach readpkt from session->packets list */
                 _libssh2_list_remove(&readpkt->node);
 
@@ -1882,7 +1893,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
         read_packet = read_next;
     }
 
-    if (!bytes_read) {
+    if(!bytes_read) {
         /* If the channel is already at EOF or even closed, we need to signal
            that back. We may have gotten that info while draining the incoming
            transport layer until EAGAIN so we must not be fooled by that
@@ -1953,10 +1964,10 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
     uint32_t read_local_id;
 
     read_packet = _libssh2_list_first(&session->packets);
-    if (read_packet == NULL)
+    if(read_packet == NULL)
         return 0;
 
-    while (read_packet) {
+    while(read_packet) {
         read_local_id = _libssh2_ntohu32(read_packet->data + 1);
 
         /*
@@ -1966,7 +1977,7 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
          * or the standard stream with extended_data_merge
          * enabled and data was available
          */
-        if ((stream_id
+        if((stream_id
              && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
              && (channel->local.id == read_local_id)
              && (stream_id == (int) _libssh2_ntohu32(read_packet->data + 5)))
@@ -1979,8 +1990,7 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
              && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
              && (channel->local.id == read_local_id)
              && (channel->remote.extended_data_ignore_mode
-                 == LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE)))
-        {
+                 == LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
             return (read_packet->data_len - read_packet->data_head);
         }
         read_packet = _libssh2_list_next(&read_packet->node);
@@ -2017,7 +2027,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
     if(buflen > 32700)
         buflen = 32700;
 
-    if (channel->write_state == libssh2_NB_state_idle) {
+    if(channel->write_state == libssh2_NB_state_idle) {
         unsigned char *s = channel->write_packet;
 
         _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
@@ -2025,11 +2035,11 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
                        (int) buflen, channel->local.id, channel->remote.id,
                        stream_id);
 
-        if (channel->local.close)
+        if(channel->local.close)
             return _libssh2_error(channel->session,
                                   LIBSSH2_ERROR_CHANNEL_CLOSED,
                                   "We've already closed this channel");
-        else if (channel->local.eof)
+        else if(channel->local.eof)
             return _libssh2_error(channel->session,
                                   LIBSSH2_ERROR_CHANNEL_EOF_SENT,
                                   "EOF has already been received, "
@@ -2039,7 +2049,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
          * pending window adjust packets */
         do
             rc = _libssh2_transport_read(session);
-        while (rc > 0);
+        while(rc > 0);
 
         if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {
             return _libssh2_error(channel->session, rc,
@@ -2055,7 +2065,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
              */
             session->socket_block_directions = LIBSSH2_SESSION_BLOCK_INBOUND;
 
-            return (rc==LIBSSH2_ERROR_EAGAIN?rc:0);
+            return (rc == LIBSSH2_ERROR_EAGAIN?rc:0);
         }
 
         channel->write_bufwrite = buflen;
@@ -2063,12 +2073,12 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
         *(s++) = stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA :
             SSH_MSG_CHANNEL_DATA;
         _libssh2_store_u32(&s, channel->remote.id);
-        if (stream_id)
+        if(stream_id)
             _libssh2_store_u32(&s, stream_id);
 
         /* Don't exceed the remote end's limits */
         /* REMEMBER local means local as the SOURCE of the data */
-        if (channel->write_bufwrite > channel->local.window_size) {
+        if(channel->write_bufwrite > channel->local.window_size) {
             _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                            "Splitting write block due to %lu byte "
                            "window_size on %lu/%lu/%d",
@@ -2076,7 +2086,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
                            channel->remote.id, stream_id);
             channel->write_bufwrite = channel->local.window_size;
         }
-        if (channel->write_bufwrite > channel->local.packet_size) {
+        if(channel->write_bufwrite > channel->local.packet_size) {
             _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                            "Splitting write block due to %lu byte "
                            "packet_size on %lu/%lu/%d",
@@ -2097,15 +2107,15 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
         channel->write_state = libssh2_NB_state_created;
     }
 
-    if (channel->write_state == libssh2_NB_state_created) {
+    if(channel->write_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, channel->write_packet,
                                      channel->write_packet_len,
                                      buf, channel->write_bufwrite);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, rc,
                                   "Unable to send channel data");
         }
-        else if (rc) {
+        else if(rc) {
             channel->write_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
                                   "Unable to send channel data");
@@ -2169,12 +2179,12 @@ static int channel_send_eof(LIBSSH2_CHANNEL *channel)
     packet[0] = SSH_MSG_CHANNEL_EOF;
     _libssh2_htonu32(packet + 1, channel->remote.id);
     rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         _libssh2_error(session, rc,
                        "Would block sending EOF");
         return rc;
     }
-    else if (rc) {
+    else if(rc) {
         return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                               "Unable to send EOF on channel");
     }
@@ -2217,8 +2227,8 @@ libssh2_channel_eof(LIBSSH2_CHANNEL * channel)
     session = channel->session;
     packet = _libssh2_list_first(&session->packets);
 
-    while (packet) {
-        if (((packet->data[0] == SSH_MSG_CHANNEL_DATA)
+    while(packet) {
+        if(((packet->data[0] == SSH_MSG_CHANNEL_DATA)
              || (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA))
             && (channel->local.id == _libssh2_ntohu32(packet->data + 1))) {
             /* There's data waiting to be read yet, mask the EOF status */
@@ -2240,7 +2250,7 @@ static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
     LIBSSH2_SESSION *session = channel->session;
     int rc;
 
-    if (channel->wait_eof_state == libssh2_NB_state_idle) {
+    if(channel->wait_eof_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "Awaiting EOF for channel %lu/%lu", channel->local.id,
                        channel->remote.id);
@@ -2253,25 +2263,25 @@ static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
      * Either the EOF will be set or network timeout will occur.
      */
     do {
-        if (channel->remote.eof) {
+        if(channel->remote.eof) {
             break;
         }
 
-        if ((channel->remote.window_size == channel->read_avail) &&
+        if((channel->remote.window_size == channel->read_avail) &&
             session->api_block_mode)
             return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_WINDOW_FULL,
                                   "Receiving channel window has been exhausted");
 
         rc = _libssh2_transport_read(session);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
-        else if (rc < 0) {
+        else if(rc < 0) {
             channel->wait_eof_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
                                   "_libssh2_transport_read() bailed out!");
         }
-    } while (1);
+    } while(1);
 
     channel->wait_eof_state = libssh2_NB_state_idle;
 
@@ -2300,16 +2310,17 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
     LIBSSH2_SESSION *session = channel->session;
     int rc = 0;
 
-    if (channel->local.close) {
+    if(channel->local.close) {
         /* Already closed, act like we sent another close,
          * even though we didn't... shhhhhh */
         channel->close_state = libssh2_NB_state_idle;
         return 0;
     }
 
-    if (!channel->local.eof) {
-        if ((rc = channel_send_eof(channel))) {
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(!channel->local.eof) {
+        rc = channel_send_eof(channel);
+        if(rc) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 return rc;
             }
             _libssh2_error(session, rc,
@@ -2320,7 +2331,7 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
     /* ignore if we have received a remote eof or not, as it is now too
        late for us to wait for it. Continue closing! */
 
-    if (channel->close_state == libssh2_NB_state_idle) {
+    if(channel->close_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Closing channel %lu/%lu",
                        channel->local.id, channel->remote.id);
 
@@ -2330,29 +2341,31 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
         channel->close_state = libssh2_NB_state_created;
     }
 
-    if (channel->close_state == libssh2_NB_state_created) {
+    if(channel->close_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, channel->close_packet, 5,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending close-channel");
             return rc;
 
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, rc,
                            "Unable to send close-channel request, "
                            "but closing anyway");
             /* skip waiting for the response and fall through to
                LIBSSH2_CHANNEL_CLOSE below */
 
-        } else
+        }
+        else
             channel->close_state = libssh2_NB_state_sent;
     }
 
-    if (channel->close_state == libssh2_NB_state_sent) {
+    if(channel->close_state == libssh2_NB_state_sent) {
         /* We must wait for the remote SSH_MSG_CHANNEL_CLOSE message */
 
-        while (!channel->remote.close && !rc &&
+        while(!channel->remote.close && !rc &&
                (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED))
             rc = _libssh2_transport_read(session);
     }
@@ -2364,7 +2377,7 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
 
         /* We call the callback last in this function to make it keep the local
            data as long as EAGAIN is returned. */
-        if (channel->close_cb) {
+        if(channel->close_cb) {
             LIBSSH2_CHANNEL_CLOSE(session, channel);
         }
 
@@ -2372,7 +2385,7 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
     }
 
     /* return 0 or an error */
-    return rc>=0?0:rc;
+    return rc >= 0 ? 0 : rc;
 }
 
 /*
@@ -2402,13 +2415,13 @@ static int channel_wait_closed(LIBSSH2_CHANNEL *channel)
     LIBSSH2_SESSION *session = channel->session;
     int rc;
 
-    if (!channel->remote.eof) {
+    if(!channel->remote.eof) {
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "libssh2_channel_wait_closed() invoked when "
                               "channel is not in EOF state");
     }
 
-    if (channel->wait_closed_state == libssh2_NB_state_idle) {
+    if(channel->wait_closed_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "Awaiting close of channel %lu/%lu", channel->local.id,
                        channel->remote.id);
@@ -2420,13 +2433,13 @@ static int channel_wait_closed(LIBSSH2_CHANNEL *channel)
      * While channel is not closed, read more packets from the network.
      * Either the channel will be closed or network timeout will occur.
      */
-    if (!channel->remote.close) {
+    if(!channel->remote.close) {
         do {
             rc = _libssh2_transport_read(session);
-            if (channel->remote.close)
+            if(channel->remote.close)
                 /* it is now closed, move on! */
                 break;
-        } while (rc > 0);
+        } while(rc > 0);
         if(rc < 0)
             return rc;
     }
@@ -2471,7 +2484,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 
     assert(session);
 
-    if (channel->free_state == libssh2_NB_state_idle) {
+    if(channel->free_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "Freeing channel %lu/%lu resources", channel->local.id,
                        channel->remote.id);
@@ -2480,7 +2493,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
     }
 
     /* Allow channel freeing even when the socket has lost its connection */
-    if (!channel->local.close
+    if(!channel->local.close
         && (session->socket_state == LIBSSH2_SOCKET_CONNECTED)) {
         rc = _libssh2_channel_close(channel);
 
@@ -2493,7 +2506,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 
     channel->free_state = libssh2_NB_state_idle;
 
-    if (channel->exit_signal) {
+    if(channel->exit_signal) {
         LIBSSH2_FREE(session, channel->exit_signal);
     }
 
@@ -2505,7 +2518,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 
     /* Clear out packets meant for this channel */
     _libssh2_htonu32(channel_id, channel->local.id);
-    while ((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data,
+    while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data,
                                 &data_len, 1, channel_id, 4) >= 0)
            ||
            (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data,
@@ -2514,7 +2527,7 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
     }
 
     /* free "channel_type" */
-    if (channel->channel_type) {
+    if(channel->channel_type) {
         LIBSSH2_FREE(session, channel->channel_type);
     }
 
@@ -2524,13 +2537,13 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
     /*
      * Make sure all memory used in the state variables are free
      */
-    if (channel->setenv_packet) {
+    if(channel->setenv_packet) {
         LIBSSH2_FREE(session, channel->setenv_packet);
     }
-    if (channel->reqX11_packet) {
+    if(channel->reqX11_packet) {
         LIBSSH2_FREE(session, channel->reqX11_packet);
     }
-    if (channel->process_packet) {
+    if(channel->process_packet) {
         LIBSSH2_FREE(session, channel->process_packet);
     }
 
@@ -2575,19 +2588,19 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
     if(!channel)
         return 0; /* no channel, no window! */
 
-    if (window_size_initial) {
+    if(window_size_initial) {
         *window_size_initial = channel->remote.window_size_initial;
     }
 
-    if (read_avail) {
+    if(read_avail) {
         size_t bytes_queued = 0;
         LIBSSH2_PACKET *packet =
             _libssh2_list_first(&channel->session->packets);
 
-        while (packet) {
+        while(packet) {
             unsigned char packet_type = packet->data[0];
 
-            if (((packet_type == SSH_MSG_CHANNEL_DATA)
+            if(((packet_type == SSH_MSG_CHANNEL_DATA)
                  || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
                 && (_libssh2_ntohu32(packet->data + 1) == channel->local.id)) {
                 bytes_queued += packet->data_len - packet->data_head;
@@ -2617,7 +2630,7 @@ libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
     if(!channel)
         return 0; /* no channel, no window! */
 
-    if (window_size_initial) {
+    if(window_size_initial) {
         /* For locally initiated channels this is very often 0, so it's not
          * *that* useful as information goes */
         *window_size_initial = channel->local.window_size_initial;
diff --git a/src/comp.c b/src/comp.c
index 4560188b..47e896a5 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -142,7 +142,7 @@ comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
     int status;
 
     strm = LIBSSH2_CALLOC(session, sizeof(z_stream));
-    if (!strm) {
+    if(!strm) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for "
                               "zlib compression/decompression");
@@ -151,15 +151,16 @@ comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
     strm->opaque = (voidpf) session;
     strm->zalloc = (alloc_func) comp_method_zlib_alloc;
     strm->zfree = (free_func) comp_method_zlib_free;
-    if (compr) {
+    if(compr) {
         /* deflate */
         status = deflateInit(strm, Z_DEFAULT_COMPRESSION);
-    } else {
+    }
+    else {
         /* inflate */
         status = inflateInit(strm);
     }
 
-    if (status != Z_OK) {
+    if(status != Z_OK) {
         LIBSSH2_FREE(session, strm);
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                        "unhandled zlib error %d", status);
@@ -197,7 +198,7 @@ comp_method_zlib_comp(LIBSSH2_SESSION *session,
 
     status = deflate(strm, Z_PARTIAL_FLUSH);
 
-    if ((status == Z_OK) && (strm->avail_out > 0)) {
+    if((status == Z_OK) && (strm->avail_out > 0)) {
         *dest_len = out_maxlen - strm->avail_out;
         return 0;
     }
@@ -227,15 +228,15 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
     int out_maxlen = 4 * src_len;
 
     /* If strm is null, then we have not yet been initialized. */
-    if (strm == NULL)
+    if(strm == NULL)
         return _libssh2_error(session, LIBSSH2_ERROR_COMPRESS,
                               "decompression uninitialized");;
 
     /* In practice they never come smaller than this */
-    if (out_maxlen < 25)
+    if(out_maxlen < 25)
         out_maxlen = 25;
 
-    if (out_maxlen > (int) payload_limit)
+    if(out_maxlen > (int) payload_limit)
         out_maxlen = payload_limit;
 
     strm->next_in = (unsigned char *) src;
@@ -243,26 +244,28 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
     strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen);
     out = (char *) strm->next_out;
     strm->avail_out = out_maxlen;
-    if (!strm->next_out)
+    if(!strm->next_out)
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate decompression buffer");
 
     /* Loop until it's all inflated or hit error */
-    for (;;) {
+    for(;;) {
         int status;
         size_t out_ofs;
         char *newout;
 
         status = inflate(strm, Z_PARTIAL_FLUSH);
 
-        if (status == Z_OK) {
-            if (strm->avail_out > 0)
+        if(status == Z_OK) {
+            if(strm->avail_out > 0)
                 /* status is OK and the output buffer has not been exhausted so we're done */
                 break;
-        } else if (status == Z_BUF_ERROR) {
+        }
+        else if(status == Z_BUF_ERROR) {
             /* the input data has been exhausted so we are done */
             break;
-        } else {
+        }
+        else {
             /* error state */
             LIBSSH2_FREE(session, out);
             _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
@@ -271,7 +274,7 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
                                   "decompression failure");
         }
 
-        if (out_maxlen >= (int) payload_limit) {
+        if(out_maxlen >= (int) payload_limit) {
             LIBSSH2_FREE(session, out);
             return _libssh2_error(session, LIBSSH2_ERROR_ZLIB,
                                   "Excessive growth in decompression phase");
@@ -281,7 +284,7 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
         out_ofs = out_maxlen - strm->avail_out;
         out_maxlen *= 2;
         newout = LIBSSH2_REALLOC(session, out, out_maxlen);
-        if (!newout) {
+        if(!newout) {
             LIBSSH2_FREE(session, out);
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to expand decompression buffer");
@@ -306,8 +309,8 @@ comp_method_zlib_dtor(LIBSSH2_SESSION *session, int compr, void **abstract)
 {
     z_stream *strm = *abstract;
 
-    if (strm) {
-        if (compr)
+    if(strm) {
+        if(compr)
             deflateEnd(strm);
         else
             inflateEnd(strm);
diff --git a/src/crypt.c b/src/crypt.c
index b0d8a35a..4beb0aa2 100644
--- a/src/crypt.c
+++ b/src/crypt.c
@@ -80,12 +80,12 @@ crypt_init(LIBSSH2_SESSION * session,
 {
     struct crypt_ctx *ctx = LIBSSH2_ALLOC(session,
                                           sizeof(struct crypt_ctx));
-    if (!ctx)
+    if(!ctx)
         return LIBSSH2_ERROR_ALLOC;
 
     ctx->encrypt = encrypt;
     ctx->algo = method->algo;
-    if (_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) {
+    if(_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) {
         LIBSSH2_FREE(session, ctx);
         return -1;
     }
@@ -109,7 +109,7 @@ static int
 crypt_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
     struct crypt_ctx **cctx = (struct crypt_ctx **) abstract;
-    if (cctx && *cctx) {
+    if(cctx && *cctx) {
         _libssh2_cipher_dtor(&(*cctx)->h);
         LIBSSH2_FREE(session, *cctx);
         *abstract = NULL;
@@ -252,13 +252,13 @@ crypt_init_arcfour128(LIBSSH2_SESSION * session,
 {
     int rc;
 
-    rc = crypt_init (session, method, iv, free_iv, secret, free_secret,
-                     encrypt, abstract);
-    if (rc == 0) {
+    rc = crypt_init(session, method, iv, free_iv, secret, free_secret,
+                    encrypt, abstract);
+    if(rc == 0) {
         struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
         unsigned char block[8];
         size_t discard = 1536;
-        for (; discard; discard -= 8)
+        for(; discard; discard -= 8)
             _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
                                   method->blocksize);
     }
diff --git a/src/global.c b/src/global.c
index 353ffce6..5f57daca 100644
--- a/src/global.c
+++ b/src/global.c
@@ -44,7 +44,7 @@ static int _libssh2_init_flags = 0;
 LIBSSH2_API int
 libssh2_init(int flags)
 {
-    if (_libssh2_initialized == 0 && !(flags & LIBSSH2_INIT_NO_CRYPTO)) {
+    if(_libssh2_initialized == 0 && !(flags & LIBSSH2_INIT_NO_CRYPTO)) {
         libssh2_crypto_init();
 #if LIBSSH2_AES_CTR
         _libssh2_init_aes_ctr();
@@ -60,12 +60,12 @@ libssh2_init(int flags)
 LIBSSH2_API void
 libssh2_exit(void)
 {
-    if (_libssh2_initialized == 0)
+    if(_libssh2_initialized == 0)
         return;
 
     _libssh2_initialized--;
 
-    if (!(_libssh2_init_flags & LIBSSH2_INIT_NO_CRYPTO)) {
+    if(!(_libssh2_init_flags & LIBSSH2_INIT_NO_CRYPTO)) {
         libssh2_crypto_exit();
     }
 
@@ -75,6 +75,6 @@ libssh2_exit(void)
 void
 _libssh2_init_if_needed(void)
 {
-    if (_libssh2_initialized == 0)
+    if(_libssh2_initialized == 0)
         (void)libssh2_init (0);
 }
diff --git a/src/hostkey.c b/src/hostkey.c
index 4e833e93..e25eb83f 100644
--- a/src/hostkey.c
+++ b/src/hostkey.c
@@ -70,7 +70,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
 
     (void) hostkey_data_len;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_rsa_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -79,7 +79,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
     len = _libssh2_ntohu32(s);
     s += 4;
 
-    if (len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) {
+    if(len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) {
         return -1;
     }
     s += 7;
@@ -95,7 +95,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
 
     ret = _libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0,
                            NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -118,13 +118,13 @@ hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session,
     libssh2_rsa_ctx *rsactx;
     int ret;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_rsa_dtor(session, abstract);
         *abstract = NULL;
     }
 
     ret = _libssh2_rsa_new_private(&rsactx, session, privkeyfile, passphrase);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -148,7 +148,7 @@ hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
     libssh2_rsa_ctx *rsactx;
     int ret;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_rsa_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -156,7 +156,7 @@ hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
     ret = _libssh2_rsa_new_private_frommemory(&rsactx, session,
                                               privkeyfiledata,
                                               privkeyfiledata_len, passphrase);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -218,7 +218,7 @@ hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
 
     ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH,
                                  signature, signature_len);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -287,7 +287,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
 
     (void) hostkey_data_len;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_dss_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -295,7 +295,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
     s = hostkey_data;
     len = _libssh2_ntohu32(s);
     s += 4;
-    if (len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) {
+    if(len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) {
         return -1;
     }
     s += 7;
@@ -319,7 +319,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
 
     ret = _libssh2_dsa_new(&dsactx, p, p_len, q, q_len,
                            g, g_len, y, y_len, NULL, 0);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -342,13 +342,13 @@ hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session,
     libssh2_dsa_ctx *dsactx;
     int ret;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_dss_dtor(session, abstract);
         *abstract = NULL;
     }
 
     ret = _libssh2_dsa_new_private(&dsactx, session, privkeyfile, passphrase);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -372,7 +372,7 @@ hostkey_method_ssh_dss_initPEMFromMemory(LIBSSH2_SESSION * session,
     libssh2_dsa_ctx *dsactx;
     int ret;
 
-    if (*abstract) {
+    if(*abstract) {
         hostkey_method_ssh_dss_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -380,7 +380,7 @@ hostkey_method_ssh_dss_initPEMFromMemory(LIBSSH2_SESSION * session,
     ret = _libssh2_dsa_new_private_frommemory(&dsactx, session,
                                               privkeyfiledata,
                                               privkeyfiledata_len, passphrase);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -406,7 +406,7 @@ hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session,
     /* Skip past keyname_len(4) + keyname(7){"ssh-dss"} + signature_len(4) */
     sig += 15;
     sig_len -= 15;
-    if (sig_len != 40) {
+    if(sig_len != 40) {
         return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                               "Invalid DSS signature length");
     }
@@ -432,7 +432,7 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
     int i;
 
     *signature = LIBSSH2_CALLOC(session, 2 * SHA_DIGEST_LENGTH);
-    if (!*signature) {
+    if(!*signature) {
         return -1;
     }
 
@@ -444,7 +444,7 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
     }
     libssh2_sha1_final(ctx, hash);
 
-    if (_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
+    if(_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
         LIBSSH2_FREE(session, *signature);
         return -1;
     }
@@ -509,28 +509,31 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
     size_t len, key_len, n_len;
     libssh2_curve_type type;
 
-    if (abstract != NULL && *abstract) {
+    if(abstract != NULL && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
 
-    if ( hostkey_data_len < 23 )
+    if(hostkey_data_len < 23)
         return -1;
 
     s = hostkey_data;
     len = _libssh2_ntohu32(s);
     s += 4;
 
-    if (len != 19 )
+    if(len != 19)
         return -1;
 
-    if (strncmp((char*) s, "ecdsa-sha2-nistp256", 19) == 0 ) {
+    if(strncmp((char *) s, "ecdsa-sha2-nistp256", 19) == 0) {
         type = LIBSSH2_EC_CURVE_NISTP256;
-    } else if(strncmp((char*) s, "ecdsa-sha2-nistp384", 19) == 0 ) {
+    }
+    else if(strncmp((char *) s, "ecdsa-sha2-nistp384", 19) == 0) {
         type = LIBSSH2_EC_CURVE_NISTP384;
-    } else if(strncmp((char*) s, "ecdsa-sha2-nistp521", 19) == 0 ) {
+    }
+    else if(strncmp((char *) s, "ecdsa-sha2-nistp521", 19) == 0) {
         type = LIBSSH2_EC_CURVE_NISTP521;
-    } else {
+    }
+    else {
         return -1;
     }
     s += 19;
@@ -539,14 +542,16 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
     n_len = _libssh2_ntohu32(s);
     s += 4;
 
-    if (n_len != 8)
+    if(n_len != 8)
         return -1;
 
-    if ( type == LIBSSH2_EC_CURVE_NISTP256 && strncmp((char*)s, "nistp256", 8) != 0) {
+    if(type == LIBSSH2_EC_CURVE_NISTP256 && strncmp((char *)s, "nistp256", 8) != 0) {
         return -1;
-    } else if ( type == LIBSSH2_EC_CURVE_NISTP384 && strncmp((char*)s, "nistp384", 8) != 0) {
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP384 && strncmp((char *)s, "nistp384", 8) != 0) {
         return -1;
-    } else if ( type == LIBSSH2_EC_CURVE_NISTP521 && strncmp((char*)s, "nistp521", 8) != 0) {
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP521 && strncmp((char *)s, "nistp521", 8) != 0) {
         return -1;
     }
 
@@ -558,10 +563,10 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
 
     k = s;
 
-    if (_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, k, key_len, type) )
+    if(_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, k, key_len, type) )
         return -1;
 
-    if ( abstract != NULL )
+    if(abstract != NULL)
         *abstract = ecdsactx;
 
     return 0;
@@ -581,14 +586,14 @@ hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
     libssh2_ecdsa_ctx *ec_ctx = NULL;
     int ret;
 
-    if (abstract != NULL && *abstract) {
+    if(abstract != NULL && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
 
     ret = _libssh2_ecdsa_new_private(&ec_ctx, session, privkeyfile, passphrase);
 
-    if ( abstract != NULL )
+    if(abstract != NULL)
         *abstract = ec_ctx;
 
     return ret;
@@ -609,7 +614,7 @@ hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
     libssh2_ecdsa_ctx *ec_ctx = NULL;
     int ret;
 
-    if (abstract != NULL && *abstract) {
+    if(abstract != NULL && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -617,11 +622,11 @@ hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
     ret = _libssh2_ecdsa_new_private_frommemory(&ec_ctx, session,
                                                 privkeyfiledata,
                                                 privkeyfiledata_len, passphrase);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
-    if (abstract != NULL)
+    if(abstract != NULL)
         *abstract = ec_ctx;
 
     return 0;
@@ -645,7 +650,7 @@ hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
 
     (void) session;
 
-    if ( sig_len < 35 )
+    if(sig_len < 35)
         return -1;
 
     /* Skip past keyname_len(4) + keyname(19){"ecdsa-sha2-nistp256"} + signature_len(4) */
@@ -697,13 +702,16 @@ hostkey_method_ssh_ecdsa_signv(LIBSSH2_SESSION * session,
     libssh2_curve_type type = _libssh2_ecdsa_key_get_curve_type(ec_ctx);
     int ret = 0;
 
-    if ( type == LIBSSH2_EC_CURVE_NISTP256 ) {
+    if(type == LIBSSH2_EC_CURVE_NISTP256) {
         LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(256);
-    }else if ( type == LIBSSH2_EC_CURVE_NISTP384 ) {
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
         LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(384);
-    }else if ( type == LIBSSH2_EC_CURVE_NISTP521 ){
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
         LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(512);
-    }else{
+    }
+    else {
         return -1;
     }
 
@@ -721,7 +729,7 @@ hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session, void **abstract)
     libssh2_ecdsa_ctx *keyctx = (libssh2_ecdsa_ctx *) (*abstract);
     (void) session;
 
-    if (keyctx != NULL)
+    if(keyctx != NULL)
         _libssh2_ecdsa_free(keyctx);
 
     *abstract = NULL;
@@ -799,7 +807,7 @@ libssh2_hostkey_methods(void)
 LIBSSH2_API const char *
 libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type)
 {
-    switch (hash_type) {
+    switch(hash_type) {
 #if LIBSSH2_MD5
     case LIBSSH2_HOSTKEY_HASH_MD5:
         return (session->server_hostkey_md5_valid)
@@ -840,28 +848,28 @@ static int hostkey_type(const unsigned char *hostkey, size_t len)
         0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-', 'n', 'i', 's', 't', 'p', '5', '2', '1'
     };
 
-    if (len < 11)
+    if(len < 11)
         return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
 
-    if (!memcmp(rsa, hostkey, 11))
+    if(!memcmp(rsa, hostkey, 11))
         return LIBSSH2_HOSTKEY_TYPE_RSA;
 
-    if (!memcmp(dss, hostkey, 11))
+    if(!memcmp(dss, hostkey, 11))
         return LIBSSH2_HOSTKEY_TYPE_DSS;
 
-    if ( len < 15 )
+    if(len < 15)
         return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
 
-    if ( len < 23 )
+    if(len < 23)
         return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
 
-    if (!memcmp(ecdsa_256, hostkey, 23))
+    if(!memcmp(ecdsa_256, hostkey, 23))
         return LIBSSH2_HOSTKEY_TYPE_ECDSA;
 
-    if (!memcmp(ecdsa_384, hostkey, 23))
+    if(!memcmp(ecdsa_384, hostkey, 23))
         return LIBSSH2_HOSTKEY_TYPE_ECDSA;
 
-    if (!memcmp(ecdsa_521, hostkey, 23))
+    if(!memcmp(ecdsa_521, hostkey, 23))
         return LIBSSH2_HOSTKEY_TYPE_ECDSA;
 
     return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
@@ -879,7 +887,7 @@ libssh2_session_hostkey(LIBSSH2_SESSION *session, size_t *len, int *type)
     if(session->server_hostkey_len) {
         if(len)
             *len = session->server_hostkey_len;
-        if (type)
+        if(type)
             *type = hostkey_type(session->server_hostkey,
                                  session->server_hostkey_len);
         return (char *) session->server_hostkey;
diff --git a/src/keepalive.c b/src/keepalive.c
index fd749dd2..2151b171 100644
--- a/src/keepalive.c
+++ b/src/keepalive.c
@@ -46,7 +46,7 @@ libssh2_keepalive_config (LIBSSH2_SESSION *session,
                           int want_reply,
                           unsigned interval)
 {
-    if (interval == 1)
+    if(interval == 1)
         session->keepalive_interval = 2;
     else
         session->keepalive_interval = interval;
@@ -59,20 +59,20 @@ libssh2_keepalive_send (LIBSSH2_SESSION *session,
 {
     time_t now;
 
-    if (!session->keepalive_interval) {
-        if (seconds_to_next)
+    if(!session->keepalive_interval) {
+        if(seconds_to_next)
             *seconds_to_next = 0;
         return 0;
     }
 
-    now = time (NULL);
+    now = time(NULL);
 
-    if (session->keepalive_last_sent + session->keepalive_interval <= now) {
+    if(session->keepalive_last_sent + session->keepalive_interval <= now) {
         /* Format is
            "SSH_MSG_GLOBAL_REQUEST || 4-byte len || str || want-reply". */
         unsigned char keepalive_data[]
             = "\x50\x00\x00\x00\x15keepalive@libssh2.orgW";
-        size_t len = sizeof (keepalive_data) - 1;
+        size_t len = sizeof(keepalive_data) - 1;
         int rc;
 
         keepalive_data[len - 1] =
@@ -81,16 +81,17 @@ libssh2_keepalive_send (LIBSSH2_SESSION *session,
         rc = _libssh2_transport_send(session, keepalive_data, len, NULL, 0);
         /* Silently ignore PACKET_EAGAIN here: if the write buffer is
            already full, sending another keepalive is not useful. */
-        if (rc && rc != LIBSSH2_ERROR_EAGAIN) {
+        if(rc && rc != LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                            "Unable to send keepalive message");
             return rc;
         }
 
         session->keepalive_last_sent = now;
-        if (seconds_to_next)
+        if(seconds_to_next)
             *seconds_to_next = session->keepalive_interval;
-    } else if (seconds_to_next) {
+    }
+    else if(seconds_to_next) {
         *seconds_to_next = (int) (session->keepalive_last_sent - now)
             + session->keepalive_interval;
     }
diff --git a/src/kex.c b/src/kex.c
index d806c731..b034480e 100644
--- a/src/kex.c
+++ b/src/kex.c
@@ -48,19 +48,20 @@
     {                                                                   \
         libssh2_sha1_ctx hash;                                          \
         unsigned long len = 0;                                          \
-        if (!(value)) {                                                 \
+        if(!(value)) {                                                  \
             value = LIBSSH2_ALLOC(session, reqlen + SHA_DIGEST_LENGTH); \
         }                                                               \
-        if (value)                                                      \
-            while (len < (unsigned long)reqlen) {                       \
+        if(value)                                                       \
+            while(len < (unsigned long)reqlen) {                        \
                 libssh2_sha1_init(&hash);                               \
                 libssh2_sha1_update(hash, exchange_state->k_value,      \
                                     exchange_state->k_value_len);       \
                 libssh2_sha1_update(hash, exchange_state->h_sig_comp,   \
                                     SHA_DIGEST_LENGTH);                 \
-                if (len > 0) {                                          \
+                if(len > 0) {                                           \
                     libssh2_sha1_update(hash, value, len);              \
-                } else {                                                \
+                }                                                       \
+                else {                                                  \
                     libssh2_sha1_update(hash, (version), 1);            \
                     libssh2_sha1_update(hash, session->session_id,      \
                                         session->session_id_len);       \
@@ -73,13 +74,13 @@
 
 #define LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(value, reqlen, version)                \
     {                                                                               \
-        if (type == LIBSSH2_EC_CURVE_NISTP256) {                                    \
+        if(type == LIBSSH2_EC_CURVE_NISTP256) {                                     \
             LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, value, reqlen, version);         \
         }                                                                           \
-        else if (type == LIBSSH2_EC_CURVE_NISTP384 ) {                              \
+        else if(type == LIBSSH2_EC_CURVE_NISTP384) {                                \
             LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(384, value, reqlen, version);         \
         }                                                                           \
-        else if (type == LIBSSH2_EC_CURVE_NISTP521 ) {                              \
+        else if(type == LIBSSH2_EC_CURVE_NISTP521) {                                \
             LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(512, value, reqlen, version);         \
         }                                                                           \
 }                                                                                   \
@@ -89,19 +90,20 @@
     {                                                                                   \
         libssh2_sha##digest_type##_ctx hash;                                            \
         unsigned long len = 0;                                                          \
-        if (!(value)) {                                                                 \
+        if(!(value)) {                                                                  \
             value = LIBSSH2_ALLOC(session, reqlen + SHA##digest_type##_DIGEST_LENGTH);  \
         }                                                                               \
-        if (value)                                                                      \
-            while (len < (unsigned long)reqlen) {                                       \
+        if(value)                                                                       \
+            while(len < (unsigned long)reqlen) {                                        \
                 libssh2_sha##digest_type##_init(&hash);                                 \
                 libssh2_sha##digest_type##_update(hash, exchange_state->k_value,        \
                                     exchange_state->k_value_len);                       \
                 libssh2_sha##digest_type##_update(hash, exchange_state->h_sig_comp,     \
                                     SHA##digest_type##_DIGEST_LENGTH);                  \
-                if (len > 0) {                                                          \
+                if(len > 0) {                                                           \
                     libssh2_sha##digest_type##_update(hash, value, len);                \
-                }    else {                                                             \
+                }                                                                       \
+                else {                                                                  \
                     libssh2_sha##digest_type##_update(hash, (version), 1);              \
                     libssh2_sha##digest_type##_update(hash, session->session_id,        \
                                         session->session_id_len);                       \
@@ -131,7 +133,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
     int rc;
     libssh2_sha1_ctx exchange_hash_ctx;
 
-    if (exchange_state->state == libssh2_NB_state_idle) {
+    if(exchange_state->state == libssh2_NB_state_idle) {
         /* Setup initial values */
         exchange_state->e_packet = NULL;
         exchange_state->s_packet = NULL;
@@ -148,21 +150,21 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         /* Generate x and e */
         rc = libssh2_dh_key_pair(&exchange_state->x, exchange_state->e, g, p,
                                  group_order, exchange_state->ctx);
-        if (rc)
+        if(rc)
             goto clean_exit;
 
         /* Send KEX init */
         /* packet_type(1) + String Length(4) + leading 0(1) */
         exchange_state->e_packet_len =
             _libssh2_bn_bytes(exchange_state->e) + 6;
-        if (_libssh2_bn_bits(exchange_state->e) % 8) {
+        if(_libssh2_bn_bits(exchange_state->e) % 8) {
             /* Leading 00 not needed */
             exchange_state->e_packet_len--;
         }
 
         exchange_state->e_packet =
             LIBSSH2_ALLOC(session, exchange_state->e_packet_len);
-        if (!exchange_state->e_packet) {
+        if(!exchange_state->e_packet) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Out of memory error");
             goto clean_exit;
@@ -170,10 +172,11 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->e_packet[0] = packet_type_init;
         _libssh2_htonu32(exchange_state->e_packet + 1,
                          exchange_state->e_packet_len - 5);
-        if (_libssh2_bn_bits(exchange_state->e) % 8) {
+        if(_libssh2_bn_bits(exchange_state->e) % 8) {
             _libssh2_bn_to_bin(exchange_state->e,
                                exchange_state->e_packet + 5);
-        } else {
+        }
+        else {
             exchange_state->e_packet[5] = 0;
             _libssh2_bn_to_bin(exchange_state->e,
                                exchange_state->e_packet + 6);
@@ -184,13 +187,14 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_created;
     }
 
-    if (exchange_state->state == libssh2_NB_state_created) {
+    if(exchange_state->state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, exchange_state->e_packet,
                                      exchange_state->e_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to send KEX init message");
             goto clean_exit;
@@ -198,8 +202,8 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent) {
-        if (session->burn_optimistic_kexinit) {
+    if(exchange_state->state == libssh2_NB_state_sent) {
+        if(session->burn_optimistic_kexinit) {
             /* The first KEX packet to come along will be the guess initially
              * sent by the server.  That guess turned out to be wrong so we
              * need to silently ignore it */
@@ -209,9 +213,10 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                            "Waiting for badly guessed KEX packet (to be ignored)");
             burn_type =
                 _libssh2_packet_burn(session, &exchange_state->burn_state);
-            if (burn_type == LIBSSH2_ERROR_EAGAIN) {
+            if(burn_type == LIBSSH2_ERROR_EAGAIN) {
                 return burn_type;
-            } else if (burn_type <= 0) {
+            }
+            else if(burn_type <= 0) {
                 /* Failed to receive a packet */
                 ret = burn_type;
                 goto clean_exit;
@@ -226,16 +231,16 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent1;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent1) {
+    if(exchange_state->state == libssh2_NB_state_sent1) {
         /* Wait for KEX reply */
         rc = _libssh2_packet_require(session, packet_type_reply,
                                      &exchange_state->s_packet,
                                      &exchange_state->s_packet_len, 0, NULL,
                                      0, &exchange_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
-        if (rc) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
                                  "Timed out waiting for KEX reply");
             goto clean_exit;
@@ -247,12 +252,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         session->server_hostkey_len = _libssh2_ntohu32(exchange_state->s);
         exchange_state->s += 4;
 
-        if (session->server_hostkey)
+        if(session->server_hostkey)
             LIBSSH2_FREE(session, session->server_hostkey);
 
         session->server_hostkey =
             LIBSSH2_ALLOC(session, session->server_hostkey_len);
-        if (!session->server_hostkey) {
+        if(!session->server_hostkey) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate memory for a copy "
                                  "of the host key");
@@ -266,7 +271,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if (libssh2_md5_init(&fingerprint_ctx)) {
+            if(libssh2_md5_init(&fingerprint_ctx)) {
                 libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
                                    session->server_hostkey_len);
                 libssh2_md5_final(fingerprint_ctx,
@@ -294,7 +299,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if (libssh2_sha1_init(&fingerprint_ctx)) {
+            if(libssh2_sha1_init(&fingerprint_ctx)) {
                 libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
                                     session->server_hostkey_len);
                 libssh2_sha1_final(fingerprint_ctx,
@@ -322,7 +327,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if (libssh2_sha256_init(&fingerprint_ctx)) {
+            if(libssh2_sha256_init(&fingerprint_ctx)) {
                 libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
                                     session->server_hostkey_len);
                 libssh2_sha256_final(fingerprint_ctx,
@@ -336,9 +341,9 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
 #ifdef LIBSSH2DEBUG
         {
             char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session, (const char*)session->server_hostkey_sha256,
+            _libssh2_base64_encode(session, (const char *)session->server_hostkey_sha256,
                                    SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if (base64Fingerprint != NULL) {
+            if(base64Fingerprint != NULL) {
                 _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s", base64Fingerprint);
                 LIBSSH2_FREE(session, base64Fingerprint);
@@ -347,7 +352,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
 #endif /* LIBSSH2DEBUG */
 
 
-        if (session->hostkey->init(session, session->server_hostkey,
+        if(session->hostkey->init(session, session->server_hostkey,
                                    session->server_hostkey_len,
                                    &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
@@ -370,30 +375,31 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         libssh2_dh_secret(&exchange_state->x, exchange_state->k,
                           exchange_state->f, p, exchange_state->ctx);
         exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             /* don't need leading 00 */
             exchange_state->k_value_len--;
         }
         exchange_state->k_value =
             LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if (!exchange_state->k_value) {
+        if(!exchange_state->k_value) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate buffer for K");
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
                          exchange_state->k_value_len - 4);
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        } else {
+        }
+        else {
             exchange_state->k_value[4] = 0;
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
         }
 
-        exchange_state->exchange_hash = (void*)&exchange_hash_ctx;
+        exchange_state->exchange_hash = (void *)&exchange_hash_ctx;
         libssh2_sha1_init(&exchange_hash_ctx);
 
-        if (session->local.banner) {
+        if(session->local.banner) {
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              strlen((char *) session->local.banner) - 2);
             libssh2_sha1_update(exchange_hash_ctx,
@@ -401,7 +407,8 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
             libssh2_sha1_update(exchange_hash_ctx,
                                 session->local.banner,
                                 strlen((char *) session->local.banner) - 2);
-        } else {
+        }
+        else {
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
             libssh2_sha1_update(exchange_hash_ctx,
@@ -443,7 +450,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                             session->server_hostkey,
                             session->server_hostkey_len);
 
-        if (packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
+        if(packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
             /* diffie-hellman-group-exchange hashes additional fields */
 #ifdef LIBSSH2_DH_GEX_NEW
             _libssh2_htonu32(exchange_state->h_sig_comp,
@@ -462,7 +469,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
 #endif
         }
 
-        if (midhash) {
+        if(midhash) {
             libssh2_sha1_update(exchange_hash_ctx, midhash,
                                 midhash_len);
         }
@@ -486,7 +493,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         libssh2_sha1_final(exchange_hash_ctx,
                            exchange_state->h_sig_comp);
 
-        if (session->hostkey->
+        if(session->hostkey->
             sig_verify(session, exchange_state->h_sig,
                        exchange_state->h_sig_len, exchange_state->h_sig_comp,
                        20, &session->server_hostkey_abstract)) {
@@ -501,11 +508,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent2;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent2) {
+    if(exchange_state->state == libssh2_NB_state_sent2) {
         rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Unable to send NEWKEYS message");
             goto clean_exit;
         }
@@ -513,14 +521,15 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent3;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent3) {
+    if(exchange_state->state == libssh2_NB_state_sent3) {
         rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
                                      &exchange_state->tmp,
                                      &exchange_state->tmp_len, 0, NULL, 0,
                                      &exchange_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
             goto clean_exit;
         }
@@ -533,9 +542,9 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
            for this packet type anyway */
         LIBSSH2_FREE(session, exchange_state->tmp);
 
-        if (!session->session_id) {
+        if(!session->session_id) {
             session->session_id = LIBSSH2_ALLOC(session, SHA_DIGEST_LENGTH);
-            if (!session->session_id) {
+            if(!session->session_id) {
                 ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                      "Unable to allocate buffer for SHA digest");
                 goto clean_exit;
@@ -547,13 +556,13 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         }
 
         /* Cleanup any existing cipher */
-        if (session->local.crypt->dtor) {
+        if(session->local.crypt->dtor) {
             session->local.crypt->dtor(session,
                                        &session->local.crypt_abstract);
         }
 
         /* Calculate IV/Secret/Key for each direction */
-        if (session->local.crypt->init) {
+        if(session->local.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
@@ -561,7 +570,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->local.crypt->
                                                         iv_len,
                                                         (const unsigned char *)"A");
-            if (!iv) {
+            if(!iv) {
                 ret = -1;
                 goto clean_exit;
             }
@@ -569,12 +578,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->local.crypt->
                                                         secret_len,
                                                         (const unsigned char *)"C");
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->local.crypt->
+            if(session->local.crypt->
                 init(session, session->local.crypt, iv, &free_iv, secret,
                      &free_secret, 1, &session->local.crypt_abstract)) {
                 LIBSSH2_FREE(session, iv);
@@ -583,12 +592,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                 goto clean_exit;
             }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->local.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->local.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -596,13 +605,13 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server IV and Key calculated");
 
-        if (session->remote.crypt->dtor) {
+        if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
             session->remote.crypt->dtor(session,
                                         &session->remote.crypt_abstract);
         }
 
-        if (session->remote.crypt->init) {
+        if(session->remote.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
@@ -610,7 +619,7 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->remote.crypt->
                                                         iv_len,
                                                         (const unsigned char *)"B");
-            if (!iv) {
+            if(!iv) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
@@ -618,12 +627,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->remote.crypt->
                                                         secret_len,
                                                         (const unsigned char *)"D");
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->remote.crypt->
+            if(session->remote.crypt->
                 init(session, session->remote.crypt, iv, &free_iv, secret,
                      &free_secret, 0, &session->remote.crypt_abstract)) {
                 LIBSSH2_FREE(session, iv);
@@ -632,12 +641,12 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                 goto clean_exit;
             }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->remote.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->remote.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -645,11 +654,11 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Server to Client IV and Key calculated");
 
-        if (session->local.mac->dtor) {
+        if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
         }
 
-        if (session->local.mac->init) {
+        if(session->local.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -657,14 +666,14 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->local.mac->
                                                         key_len,
                                                         (const unsigned char *)"E");
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->local.mac->init(session, key, &free_key,
                                      &session->local.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->local.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -672,11 +681,11 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server HMAC Key calculated");
 
-        if (session->remote.mac->dtor) {
+        if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
         }
 
-        if (session->remote.mac->init) {
+        if(session->remote.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -684,14 +693,14 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
                                                         session->remote.mac->
                                                         key_len,
                                                         (const unsigned char *)"F");
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->remote.mac->init(session, key, &free_key,
                                       &session->remote.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->remote.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -702,13 +711,13 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         /* Initialize compression for each direction */
 
         /* Cleanup any existing compression */
-        if (session->local.comp && session->local.comp->dtor) {
+        if(session->local.comp && session->local.comp->dtor) {
             session->local.comp->dtor(session, 1,
                                       &session->local.comp_abstract);
         }
 
-        if (session->local.comp && session->local.comp->init) {
-            if (session->local.comp->init(session, 1,
+        if(session->local.comp && session->local.comp->init) {
+            if(session->local.comp->init(session, 1,
                                           &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -717,13 +726,13 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server compression initialized");
 
-        if (session->remote.comp && session->remote.comp->dtor) {
+        if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
                                        &session->remote.comp_abstract);
         }
 
-        if (session->remote.comp && session->remote.comp->init) {
-            if (session->remote.comp->init(session, 0,
+        if(session->remote.comp && session->remote.comp->init) {
+            if(session->remote.comp->init(session, 0,
                                            &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -745,17 +754,17 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
     _libssh2_bn_ctx_free(exchange_state->ctx);
     exchange_state->ctx = NULL;
 
-    if (exchange_state->e_packet) {
+    if(exchange_state->e_packet) {
         LIBSSH2_FREE(session, exchange_state->e_packet);
         exchange_state->e_packet = NULL;
     }
 
-    if (exchange_state->s_packet) {
+    if(exchange_state->s_packet) {
         LIBSSH2_FREE(session, exchange_state->s_packet);
         exchange_state->s_packet = NULL;
     }
 
-    if (exchange_state->k_value) {
+    if(exchange_state->k_value) {
         LIBSSH2_FREE(session, exchange_state->k_value);
         exchange_state->k_value = NULL;
     }
@@ -785,7 +794,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
     int rc;
     libssh2_sha256_ctx exchange_hash_ctx;
 
-    if (exchange_state->state == libssh2_NB_state_idle) {
+    if(exchange_state->state == libssh2_NB_state_idle) {
         /* Setup initial values */
         exchange_state->e_packet = NULL;
         exchange_state->s_packet = NULL;
@@ -802,21 +811,21 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         /* Generate x and e */
         rc = libssh2_dh_key_pair(&exchange_state->x, exchange_state->e, g, p,
                                  group_order, exchange_state->ctx);
-        if (rc)
+        if(rc)
             goto clean_exit;
 
         /* Send KEX init */
         /* packet_type(1) + String Length(4) + leading 0(1) */
         exchange_state->e_packet_len =
             _libssh2_bn_bytes(exchange_state->e) + 6;
-        if (_libssh2_bn_bits(exchange_state->e) % 8) {
+        if(_libssh2_bn_bits(exchange_state->e) % 8) {
             /* Leading 00 not needed */
             exchange_state->e_packet_len--;
         }
 
         exchange_state->e_packet =
             LIBSSH2_ALLOC(session, exchange_state->e_packet_len);
-        if (!exchange_state->e_packet) {
+        if(!exchange_state->e_packet) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Out of memory error");
             goto clean_exit;
@@ -824,10 +833,11 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->e_packet[0] = packet_type_init;
         _libssh2_htonu32(exchange_state->e_packet + 1,
                          exchange_state->e_packet_len - 5);
-        if (_libssh2_bn_bits(exchange_state->e) % 8) {
+        if(_libssh2_bn_bits(exchange_state->e) % 8) {
             _libssh2_bn_to_bin(exchange_state->e,
                                exchange_state->e_packet + 5);
-        } else {
+        }
+        else {
             exchange_state->e_packet[5] = 0;
             _libssh2_bn_to_bin(exchange_state->e,
                                exchange_state->e_packet + 6);
@@ -838,13 +848,14 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_created;
     }
 
-    if (exchange_state->state == libssh2_NB_state_created) {
+    if(exchange_state->state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, exchange_state->e_packet,
                                      exchange_state->e_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to send KEX init message");
             goto clean_exit;
@@ -852,8 +863,8 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent) {
-        if (session->burn_optimistic_kexinit) {
+    if(exchange_state->state == libssh2_NB_state_sent) {
+        if(session->burn_optimistic_kexinit) {
             /* The first KEX packet to come along will be the guess initially
              * sent by the server.  That guess turned out to be wrong so we
              * need to silently ignore it */
@@ -863,9 +874,10 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                            "Waiting for badly guessed KEX packet (to be ignored)");
             burn_type =
                 _libssh2_packet_burn(session, &exchange_state->burn_state);
-            if (burn_type == LIBSSH2_ERROR_EAGAIN) {
+            if(burn_type == LIBSSH2_ERROR_EAGAIN) {
                 return burn_type;
-            } else if (burn_type <= 0) {
+            }
+            else if(burn_type <= 0) {
                 /* Failed to receive a packet */
                 ret = burn_type;
                 goto clean_exit;
@@ -880,16 +892,16 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent1;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent1) {
+    if(exchange_state->state == libssh2_NB_state_sent1) {
         /* Wait for KEX reply */
         rc = _libssh2_packet_require(session, packet_type_reply,
                                      &exchange_state->s_packet,
                                      &exchange_state->s_packet_len, 0, NULL,
                                      0, &exchange_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
-        if (rc) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
                                  "Timed out waiting for KEX reply");
             goto clean_exit;
@@ -901,12 +913,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         session->server_hostkey_len = _libssh2_ntohu32(exchange_state->s);
         exchange_state->s += 4;
 
-        if (session->server_hostkey)
+        if(session->server_hostkey)
             LIBSSH2_FREE(session, session->server_hostkey);
 
         session->server_hostkey =
             LIBSSH2_ALLOC(session, session->server_hostkey_len);
-        if (!session->server_hostkey) {
+        if(!session->server_hostkey) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate memory for a copy "
                                  "of the host key");
@@ -920,7 +932,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if (libssh2_md5_init(&fingerprint_ctx)) {
+            if(libssh2_md5_init(&fingerprint_ctx)) {
                 libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
                                    session->server_hostkey_len);
                 libssh2_md5_final(fingerprint_ctx,
@@ -948,7 +960,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if (libssh2_sha1_init(&fingerprint_ctx)) {
+            if(libssh2_sha1_init(&fingerprint_ctx)) {
                 libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
                                     session->server_hostkey_len);
                 libssh2_sha1_final(fingerprint_ctx,
@@ -976,7 +988,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if (libssh2_sha256_init(&fingerprint_ctx)) {
+            if(libssh2_sha256_init(&fingerprint_ctx)) {
                 libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
                                       session->server_hostkey_len);
                 libssh2_sha256_final(fingerprint_ctx,
@@ -990,9 +1002,9 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
 #ifdef LIBSSH2DEBUG
         {
             char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session, (const char*)session->server_hostkey_sha256,
+            _libssh2_base64_encode(session, (const char *)session->server_hostkey_sha256,
                                    SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if (base64Fingerprint != NULL) {
+            if(base64Fingerprint != NULL) {
                 _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s", base64Fingerprint);
                 LIBSSH2_FREE(session, base64Fingerprint);
@@ -1000,7 +1012,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         }
 #endif /* LIBSSH2DEBUG */
 
-        if (session->hostkey->init(session, session->server_hostkey,
+        if(session->hostkey->init(session, session->server_hostkey,
                                    session->server_hostkey_len,
                                    &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
@@ -1023,30 +1035,31 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         libssh2_dh_secret(&exchange_state->x, exchange_state->k,
                           exchange_state->f, p, exchange_state->ctx);
         exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             /* don't need leading 00 */
             exchange_state->k_value_len--;
         }
         exchange_state->k_value =
             LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if (!exchange_state->k_value) {
+        if(!exchange_state->k_value) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate buffer for K");
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
                          exchange_state->k_value_len - 4);
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        } else {
+        }
+        else {
             exchange_state->k_value[4] = 0;
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
         }
 
-        exchange_state->exchange_hash = (void*)&exchange_hash_ctx;
+        exchange_state->exchange_hash = (void *)&exchange_hash_ctx;
         libssh2_sha256_init(&exchange_hash_ctx);
 
-        if (session->local.banner) {
+        if(session->local.banner) {
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              strlen((char *) session->local.banner) - 2);
             libssh2_sha256_update(exchange_hash_ctx,
@@ -1054,7 +1067,8 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
             libssh2_sha256_update(exchange_hash_ctx,
                                   session->local.banner,
                                   strlen((char *) session->local.banner) - 2);
-        } else {
+        }
+        else {
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
             libssh2_sha256_update(exchange_hash_ctx,
@@ -1096,7 +1110,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                               session->server_hostkey,
                               session->server_hostkey_len);
 
-        if (packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
+        if(packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
             /* diffie-hellman-group-exchange hashes additional fields */
 #ifdef LIBSSH2_DH_GEX_NEW
             _libssh2_htonu32(exchange_state->h_sig_comp,
@@ -1115,7 +1129,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
 #endif
         }
 
-        if (midhash) {
+        if(midhash) {
             libssh2_sha256_update(exchange_hash_ctx, midhash,
                                   midhash_len);
         }
@@ -1139,7 +1153,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         libssh2_sha256_final(exchange_hash_ctx,
                              exchange_state->h_sig_comp);
 
-        if (session->hostkey->
+        if(session->hostkey->
             sig_verify(session, exchange_state->h_sig,
                        exchange_state->h_sig_len, exchange_state->h_sig_comp,
                        SHA256_DIGEST_LENGTH, &session->server_hostkey_abstract)) {
@@ -1156,11 +1170,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent2;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent2) {
+    if(exchange_state->state == libssh2_NB_state_sent2) {
         rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Unable to send NEWKEYS message");
             goto clean_exit;
         }
@@ -1168,14 +1183,15 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         exchange_state->state = libssh2_NB_state_sent3;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent3) {
+    if(exchange_state->state == libssh2_NB_state_sent3) {
         rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
                                      &exchange_state->tmp,
                                      &exchange_state->tmp_len, 0, NULL, 0,
                                      &exchange_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
             goto clean_exit;
         }
@@ -1188,9 +1204,9 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
            for this packet type anyway */
         LIBSSH2_FREE(session, exchange_state->tmp);
 
-        if (!session->session_id) {
+        if(!session->session_id) {
             session->session_id = LIBSSH2_ALLOC(session, SHA256_DIGEST_LENGTH);
-            if (!session->session_id) {
+            if(!session->session_id) {
                 ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                      "Unable to allocate buffer for SHA digest");
                 goto clean_exit;
@@ -1202,13 +1218,13 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         }
 
         /* Cleanup any existing cipher */
-        if (session->local.crypt->dtor) {
+        if(session->local.crypt->dtor) {
             session->local.crypt->dtor(session,
                                        &session->local.crypt_abstract);
         }
 
         /* Calculate IV/Secret/Key for each direction */
-        if (session->local.crypt->init) {
+        if(session->local.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
@@ -1216,7 +1232,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->local.crypt->
                                               iv_len,
                                               (const unsigned char *)"A");
-            if (!iv) {
+            if(!iv) {
                 ret = -1;
                 goto clean_exit;
             }
@@ -1224,12 +1240,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->local.crypt->
                                               secret_len,
                                               (const unsigned char *)"C");
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->local.crypt->
+            if(session->local.crypt->
                 init(session, session->local.crypt, iv, &free_iv, secret,
                      &free_secret, 1, &session->local.crypt_abstract)) {
                 LIBSSH2_FREE(session, iv);
@@ -1238,12 +1254,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                 goto clean_exit;
             }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->local.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->local.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -1251,13 +1267,13 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server IV and Key calculated");
 
-        if (session->remote.crypt->dtor) {
+        if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
             session->remote.crypt->dtor(session,
                                         &session->remote.crypt_abstract);
         }
 
-        if (session->remote.crypt->init) {
+        if(session->remote.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
@@ -1265,7 +1281,7 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->remote.crypt->
                                               iv_len,
                                               (const unsigned char *)"B");
-            if (!iv) {
+            if(!iv) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
@@ -1273,12 +1289,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->remote.crypt->
                                               secret_len,
                                               (const unsigned char *)"D");
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->remote.crypt->
+            if(session->remote.crypt->
                 init(session, session->remote.crypt, iv, &free_iv, secret,
                      &free_secret, 0, &session->remote.crypt_abstract)) {
                 LIBSSH2_FREE(session, iv);
@@ -1287,12 +1303,12 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                 goto clean_exit;
             }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->remote.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->remote.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -1300,11 +1316,11 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Server to Client IV and Key calculated");
 
-        if (session->local.mac->dtor) {
+        if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
         }
 
-        if (session->local.mac->init) {
+        if(session->local.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -1312,14 +1328,14 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->local.mac->
                                               key_len,
                                               (const unsigned char *)"E");
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->local.mac->init(session, key, &free_key,
                                      &session->local.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->local.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -1327,11 +1343,11 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server HMAC Key calculated");
 
-        if (session->remote.mac->dtor) {
+        if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
         }
 
-        if (session->remote.mac->init) {
+        if(session->remote.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -1339,14 +1355,14 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
                                               session->remote.mac->
                                               key_len,
                                               (const unsigned char *)"F");
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->remote.mac->init(session, key, &free_key,
                                       &session->remote.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->remote.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -1357,13 +1373,13 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         /* Initialize compression for each direction */
 
         /* Cleanup any existing compression */
-        if (session->local.comp && session->local.comp->dtor) {
+        if(session->local.comp && session->local.comp->dtor) {
             session->local.comp->dtor(session, 1,
                                       &session->local.comp_abstract);
         }
 
-        if (session->local.comp && session->local.comp->init) {
-            if (session->local.comp->init(session, 1,
+        if(session->local.comp && session->local.comp->init) {
+            if(session->local.comp->init(session, 1,
                                           &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -1372,13 +1388,13 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server compression initialized");
 
-        if (session->remote.comp && session->remote.comp->dtor) {
+        if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
                                        &session->remote.comp_abstract);
         }
 
-        if (session->remote.comp && session->remote.comp->init) {
-            if (session->remote.comp->init(session, 0,
+        if(session->remote.comp && session->remote.comp->init) {
+            if(session->remote.comp->init(session, 0,
                                            &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -1400,17 +1416,17 @@ static int diffie_hellman_sha256(LIBSSH2_SESSION *session,
     _libssh2_bn_ctx_free(exchange_state->ctx);
     exchange_state->ctx = NULL;
 
-    if (exchange_state->e_packet) {
+    if(exchange_state->e_packet) {
         LIBSSH2_FREE(session, exchange_state->e_packet);
         exchange_state->e_packet = NULL;
     }
 
-    if (exchange_state->s_packet) {
+    if(exchange_state->s_packet) {
         LIBSSH2_FREE(session, exchange_state->s_packet);
         exchange_state->s_packet = NULL;
     }
 
-    if (exchange_state->k_value) {
+    if(exchange_state->k_value) {
         LIBSSH2_FREE(session, exchange_state->k_value);
         exchange_state->k_value = NULL;
     }
@@ -1451,7 +1467,7 @@ kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
 
     int ret;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
         /* g == 2 */
         key_state->p = _libssh2_bn_init_from_bin();      /* SSH2 defined value (p_value) */
         key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
@@ -1468,7 +1484,7 @@ kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
     ret = diffie_hellman_sha1(session, key_state->g, key_state->p, 128,
                               SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY,
                               NULL, 0, &key_state->exchange_state);
-    if (ret == LIBSSH2_ERROR_EAGAIN) {
+    if(ret == LIBSSH2_ERROR_EAGAIN) {
         return ret;
     }
 
@@ -1527,7 +1543,7 @@ kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session,
     };
     int ret;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
         key_state->p = _libssh2_bn_init_from_bin();      /* SSH2 defined value (p_value) */
         key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
 
@@ -1544,7 +1560,7 @@ kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session,
     ret = diffie_hellman_sha1(session, key_state->g, key_state->p,
                               256, SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY,
                               NULL, 0, &key_state->exchange_state);
-    if (ret == LIBSSH2_ERROR_EAGAIN) {
+    if(ret == LIBSSH2_ERROR_EAGAIN) {
         return ret;
     }
 
@@ -1571,7 +1587,7 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
     int ret = 0;
     int rc;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
         key_state->p = _libssh2_bn_init_from_bin();
         key_state->g = _libssh2_bn_init_from_bin();
         /* Ask for a P and G pair */
@@ -1594,12 +1610,13 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
         key_state->state = libssh2_NB_state_created;
     }
 
-    if (key_state->state == libssh2_NB_state_created) {
+    if(key_state->state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, key_state->request,
                                      key_state->request_len, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to send Group Exchange Request");
             goto dh_gex_clean_exit;
@@ -1608,13 +1625,14 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
         key_state->state = libssh2_NB_state_sent;
     }
 
-    if (key_state->state == libssh2_NB_state_sent) {
+    if(key_state->state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP,
                                      &key_state->data, &key_state->data_len,
                                      0, NULL, 0, &key_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Timeout waiting for GEX_GROUP reply");
             goto dh_gex_clean_exit;
@@ -1623,7 +1641,7 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
         key_state->state = libssh2_NB_state_sent1;
     }
 
-    if (key_state->state == libssh2_NB_state_sent1) {
+    if(key_state->state == libssh2_NB_state_sent1) {
         unsigned char *s = key_state->data + 1;
         p_len = _libssh2_ntohu32(s);
         s += 4;
@@ -1640,7 +1658,7 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
                                   key_state->data + 1,
                                   key_state->data_len - 1,
                                   &key_state->exchange_state);
-        if (ret == LIBSSH2_ERROR_EAGAIN) {
+        if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
 
@@ -1671,7 +1689,7 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
     int ret = 0;
     int rc;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
         key_state->p = _libssh2_bn_init();
         key_state->g = _libssh2_bn_init();
         /* Ask for a P and G pair */
@@ -1694,12 +1712,13 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
         key_state->state = libssh2_NB_state_created;
     }
 
-    if (key_state->state == libssh2_NB_state_created) {
+    if(key_state->state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, key_state->request,
                                      key_state->request_len, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to send Group Exchange Request SHA256");
             goto dh_gex_clean_exit;
@@ -1708,13 +1727,14 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
         key_state->state = libssh2_NB_state_sent;
     }
 
-    if (key_state->state == libssh2_NB_state_sent) {
+    if(key_state->state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP,
                                      &key_state->data, &key_state->data_len,
                                      0, NULL, 0, &key_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Timeout waiting for GEX_GROUP reply SHA256");
             goto dh_gex_clean_exit;
@@ -1723,7 +1743,7 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
         key_state->state = libssh2_NB_state_sent1;
     }
 
-    if (key_state->state == libssh2_NB_state_sent1) {
+    if(key_state->state == libssh2_NB_state_sent1) {
         unsigned char *s = key_state->data + 1;
         p_len = _libssh2_ntohu32(s);
         s += 4;
@@ -1740,7 +1760,7 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
                                     key_state->data + 1,
                                     key_state->data_len - 1,
                                     &key_state->exchange_state);
-        if (ret == LIBSSH2_ERROR_EAGAIN) {
+        if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
 
@@ -1770,20 +1790,20 @@ kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
     int ret = 0;
     libssh2_curve_type type;
 
-    if ( name == NULL )
+    if(name == NULL)
         return -1;
 
-    if ( strcmp(name, "ecdh-sha2-nistp256") == 0)
+    if(strcmp(name, "ecdh-sha2-nistp256") == 0)
         type = LIBSSH2_EC_CURVE_NISTP256;
-    else if ( strcmp(name, "ecdh-sha2-nistp384") == 0)
+    else if(strcmp(name, "ecdh-sha2-nistp384") == 0)
         type = LIBSSH2_EC_CURVE_NISTP384;
-    else if ( strcmp(name, "ecdh-sha2-nistp521") == 0)
+    else if(strcmp(name, "ecdh-sha2-nistp521") == 0)
         type = LIBSSH2_EC_CURVE_NISTP521;
     else {
         ret = -1;
     }
 
-    if (ret == 0 && out_type) {
+    if(ret == 0 && out_type) {
         *out_type = type;
     }
 
@@ -1812,10 +1832,10 @@ kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
     {                                                                               \
                                                                                     \
         libssh2_sha##digest_type##_ctx ctx;                                         \
-        exchange_state->exchange_hash = (void*)&ctx;                                \
+        exchange_state->exchange_hash = (void *)&ctx;                               \
                                                                                     \
         libssh2_sha##digest_type##_init(&ctx);                                      \
-        if (session->local.banner) {                                                \
+        if(session->local.banner) {                                                 \
             _libssh2_htonu32(exchange_state->h_sig_comp,                            \
             strlen((char *) session->local.banner) - 2);                            \
             libssh2_sha##digest_type##_update(ctx,                                  \
@@ -1823,7 +1843,8 @@ kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
             libssh2_sha##digest_type##_update(ctx,                                  \
               (char *) session->local.banner,                                       \
               strlen((char *) session->local.banner) - 2);                          \
-        } else {                                                                    \
+        }                                                                           \
+        else {                                                                      \
             _libssh2_htonu32(exchange_state->h_sig_comp,                            \
              sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);                               \
             libssh2_sha##digest_type##_update(ctx,                                  \
@@ -1887,7 +1908,7 @@ kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
                                                                                     \
         libssh2_sha##digest_type##_final(ctx, exchange_state->h_sig_comp);          \
                                                                                     \
-        if (session->hostkey->                                                      \
+        if(session->hostkey->                                                      \
         sig_verify(session, exchange_state->h_sig,                                  \
            exchange_state->h_sig_len, exchange_state->h_sig_comp,                   \
            SHA##digest_type##_DIGEST_LENGTH, &session->server_hostkey_abstract)) {  \
@@ -1908,7 +1929,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
     int ret = 0;
     int rc;
 
-    if (exchange_state->state == libssh2_NB_state_idle) {
+    if(exchange_state->state == libssh2_NB_state_idle) {
 
         /* Setup initial values */
         exchange_state->k = _libssh2_bn_init();
@@ -1916,8 +1937,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         exchange_state->state = libssh2_NB_state_created;
     }
 
-    if ( exchange_state->state == libssh2_NB_state_created )
-    {
+    if(exchange_state->state == libssh2_NB_state_created) {
         /* parse INIT reply data */
 
         /* host key K_S */
@@ -1926,11 +1946,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         size_t server_public_key_len;
         size_t host_sig_len;
 
-        session->server_hostkey_len = _libssh2_ntohu32((const unsigned char*)s);
+        session->server_hostkey_len = _libssh2_ntohu32((const unsigned char *)s);
         s += 4;
 
         session->server_hostkey = LIBSSH2_ALLOC(session, session->server_hostkey_len);
-        if (!session->server_hostkey) {
+        if(!session->server_hostkey) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate memory for a copy "
                                  "of the host key");
@@ -1944,7 +1964,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if (libssh2_md5_init(&fingerprint_ctx)) {
+            if(libssh2_md5_init(&fingerprint_ctx)) {
                 libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
                                    session->server_hostkey_len);
                 libssh2_md5_final(fingerprint_ctx, session->server_hostkey_md5);
@@ -1971,7 +1991,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if (libssh2_sha1_init(&fingerprint_ctx)) {
+            if(libssh2_sha1_init(&fingerprint_ctx)) {
                 libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
                                     session->server_hostkey_len);
                 libssh2_sha1_final(fingerprint_ctx, session->server_hostkey_sha1);
@@ -1999,7 +2019,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if (libssh2_sha256_init(&fingerprint_ctx)) {
+            if(libssh2_sha256_init(&fingerprint_ctx)) {
                 libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
                                       session->server_hostkey_len);
                 libssh2_sha256_final(fingerprint_ctx, session->server_hostkey_sha256);
@@ -2012,8 +2032,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 #ifdef LIBSSH2DEBUG
         {
             char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session, (const char*)session->server_hostkey_sha256, SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if ( base64Fingerprint != NULL ) {
+            _libssh2_base64_encode(session, (const char *)session->server_hostkey_sha256, SHA256_DIGEST_LENGTH, &base64Fingerprint);
+            if(base64Fingerprint != NULL) {
                 _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s", base64Fingerprint);
                 LIBSSH2_FREE(session, base64Fingerprint);
@@ -2021,7 +2041,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         }
 #endif /* LIBSSH2DEBUG */
 
-        if (session->hostkey->init(session, session->server_hostkey,
+        if(session->hostkey->init(session, session->server_hostkey,
                                    session->server_hostkey_len,
                                    &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
@@ -2030,14 +2050,14 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         }
 
         /* server public key Q_S */
-        server_public_key_len = _libssh2_ntohu32((const unsigned char*)s);
+        server_public_key_len = _libssh2_ntohu32((const unsigned char *)s);
         s += 4;
 
         server_public_key = s;
         s += server_public_key_len;
 
         /* server signature */
-        host_sig_len = _libssh2_ntohu32((const unsigned char*)s);
+        host_sig_len = _libssh2_ntohu32((const unsigned char *)s);
         s += 4;
 
         exchange_state->h_sig = s;
@@ -2046,36 +2066,37 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 
         /* Compute the shared secret K */
         rc = _libssh2_ecdh_gen_k(&exchange_state->k, private_key, server_public_key, server_public_key_len);
-        if ( rc != 0 ) {
+        if(rc != 0) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
                                  "Unable to create ECDH shared secret");
             goto clean_exit;
         }
 
         exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             /* don't need leading 00 */
             exchange_state->k_value_len--;
         }
         exchange_state->k_value =
         LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if (!exchange_state->k_value) {
+        if(!exchange_state->k_value) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate buffer for K");
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
                          exchange_state->k_value_len - 4);
-        if (_libssh2_bn_bits(exchange_state->k) % 8) {
+        if(_libssh2_bn_bits(exchange_state->k) % 8) {
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        } else {
+        }
+        else {
             exchange_state->k_value[4] = 0;
             _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
         }
 
         /* verify hash */
 
-        switch ( type ) {
+        switch(type) {
             case LIBSSH2_EC_CURVE_NISTP256:
                 LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(256);
                 break;
@@ -2088,7 +2109,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 break;
         }
 
-        if ( rc != 0 ) {
+        if(rc != 0) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
                                  "Unable to verify hostkey signature");
             goto clean_exit;
@@ -2098,11 +2119,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         exchange_state->state = libssh2_NB_state_sent;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent) {
+    if(exchange_state->state == libssh2_NB_state_sent) {
         rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Unable to send NEWKEYS message");
             goto clean_exit;
         }
@@ -2110,14 +2132,15 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         exchange_state->state = libssh2_NB_state_sent2;
     }
 
-    if (exchange_state->state == libssh2_NB_state_sent2) {
+    if(exchange_state->state == libssh2_NB_state_sent2) {
         rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
                                      &exchange_state->tmp,
                                      &exchange_state->tmp_len, 0, NULL, 0,
                                      &exchange_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
             goto clean_exit;
         }
@@ -2131,15 +2154,15 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
          for this packet type anyway */
         LIBSSH2_FREE(session, exchange_state->tmp);
 
-        if (!session->session_id) {
+        if(!session->session_id) {
 
             size_t digest_length = 0;
 
-            if ( type == LIBSSH2_EC_CURVE_NISTP256 )
+            if(type == LIBSSH2_EC_CURVE_NISTP256)
                 digest_length = SHA256_DIGEST_LENGTH;
-            else if ( type == LIBSSH2_EC_CURVE_NISTP384 )
+            else if(type == LIBSSH2_EC_CURVE_NISTP384)
                 digest_length = SHA384_DIGEST_LENGTH;
-            else if ( type == LIBSSH2_EC_CURVE_NISTP521 )
+            else if(type == LIBSSH2_EC_CURVE_NISTP521)
                 digest_length = SHA512_DIGEST_LENGTH;
             else{
                 ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
@@ -2148,7 +2171,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 
             }
             session->session_id = LIBSSH2_ALLOC(session, digest_length);
-            if (!session->session_id) {
+            if(!session->session_id) {
                 ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                      "Unable to allocate buffer for SHA digest");
                 goto clean_exit;
@@ -2160,20 +2183,20 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         }
 
         /* Cleanup any existing cipher */
-        if (session->local.crypt->dtor) {
+        if(session->local.crypt->dtor) {
             session->local.crypt->dtor(session,
                                        &session->local.crypt_abstract);
         }
 
         /* Calculate IV/Secret/Key for each direction */
-        if (session->local.crypt->init) {
+        if(session->local.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
             LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(iv,
                                                  session->local.crypt->
                                                  iv_len, "A");
-            if (!iv) {
+            if(!iv) {
                 ret = -1;
                 goto clean_exit;
             }
@@ -2182,12 +2205,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                                 session->local.crypt->
                                                 secret_len, "C");
 
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->local.crypt->
+            if(session->local.crypt->
                 init(session, session->local.crypt, iv, &free_iv, secret,
                      &free_secret, 1, &session->local.crypt_abstract)) {
                     LIBSSH2_FREE(session, iv);
@@ -2196,12 +2219,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                     goto clean_exit;
                 }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->local.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->local.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -2209,13 +2232,13 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server IV and Key calculated");
 
-        if (session->remote.crypt->dtor) {
+        if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
             session->remote.crypt->dtor(session,
                                         &session->remote.crypt_abstract);
         }
 
-        if (session->remote.crypt->init) {
+        if(session->remote.crypt->init) {
             unsigned char *iv = NULL, *secret = NULL;
             int free_iv = 0, free_secret = 0;
 
@@ -2223,7 +2246,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                                  session->remote.crypt->
                                                  iv_len, "B");
 
-            if (!iv) {
+            if(!iv) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
@@ -2231,12 +2254,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                                  session->remote.crypt->
                                                  secret_len, "D");
 
-            if (!secret) {
+            if(!secret) {
                 LIBSSH2_FREE(session, iv);
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
-            if (session->remote.crypt->
+            if(session->remote.crypt->
                 init(session, session->remote.crypt, iv, &free_iv, secret,
                      &free_secret, 0, &session->remote.crypt_abstract)) {
                     LIBSSH2_FREE(session, iv);
@@ -2245,12 +2268,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                     goto clean_exit;
                 }
 
-            if (free_iv) {
+            if(free_iv) {
                 memset(iv, 0, session->remote.crypt->iv_len);
                 LIBSSH2_FREE(session, iv);
             }
 
-            if (free_secret) {
+            if(free_secret) {
                 memset(secret, 0, session->remote.crypt->secret_len);
                 LIBSSH2_FREE(session, secret);
             }
@@ -2258,11 +2281,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Server to Client IV and Key calculated");
 
-        if (session->local.mac->dtor) {
+        if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
         }
 
-        if (session->local.mac->init) {
+        if(session->local.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -2270,14 +2293,14 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                                  session->local.mac->
                                                  key_len, "E");
 
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->local.mac->init(session, key, &free_key,
                                      &session->local.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->local.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -2285,11 +2308,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server HMAC Key calculated");
 
-        if (session->remote.mac->dtor) {
+        if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
         }
 
-        if (session->remote.mac->init) {
+        if(session->remote.mac->init) {
             unsigned char *key = NULL;
             int free_key = 0;
 
@@ -2297,14 +2320,14 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                                  session->remote.mac->
                                                  key_len, "F");
 
-            if (!key) {
+            if(!key) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
             session->remote.mac->init(session, key, &free_key,
                                       &session->remote.mac_abstract);
 
-            if (free_key) {
+            if(free_key) {
                 memset(key, 0, session->remote.mac->key_len);
                 LIBSSH2_FREE(session, key);
             }
@@ -2315,13 +2338,13 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         /* Initialize compression for each direction */
 
         /* Cleanup any existing compression */
-        if (session->local.comp && session->local.comp->dtor) {
+        if(session->local.comp && session->local.comp->dtor) {
             session->local.comp->dtor(session, 1,
                                       &session->local.comp_abstract);
         }
 
-        if (session->local.comp && session->local.comp->init) {
-            if (session->local.comp->init(session, 1,
+        if(session->local.comp && session->local.comp->init) {
+            if(session->local.comp->init(session, 1,
                                           &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -2330,13 +2353,13 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Client to Server compression initialized");
 
-        if (session->remote.comp && session->remote.comp->dtor) {
+        if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
                                        &session->remote.comp_abstract);
         }
 
-        if (session->remote.comp && session->remote.comp->init) {
-            if (session->remote.comp->init(session, 0,
+        if(session->remote.comp && session->remote.comp->init) {
+            if(session->remote.comp->init(session, 0,
                                            &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
@@ -2351,7 +2374,7 @@ clean_exit:
     _libssh2_bn_free(exchange_state->k);
     exchange_state->k = NULL;
 
-    if (exchange_state->k_value) {
+    if(exchange_state->k_value) {
         LIBSSH2_FREE(session, exchange_state->k_value);
         exchange_state->k_value = NULL;
     }
@@ -2377,17 +2400,16 @@ kex_method_ecdh_key_exchange
     unsigned char *s;
     libssh2_curve_type type;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
 
         key_state->public_key_oct = NULL;
         key_state->state = libssh2_NB_state_created;
     }
 
-    if ( key_state->state == libssh2_NB_state_created )
-    {
+    if(key_state->state == libssh2_NB_state_created) {
         rc = kex_session_ecdh_curve_type(session->kex->name, &type);
 
-        if ( rc != 0 ) {
+        if(rc != 0) {
             ret = _libssh2_error(session, -1,
                                  "Unknown KEX nistp curve type");
             goto ecdh_clean_exit;
@@ -2396,8 +2418,7 @@ kex_method_ecdh_key_exchange
         rc = _libssh2_ecdsa_create_key(&key_state->private_key, &key_state->public_key_oct,
                                        &key_state->public_key_oct_len, type);
 
-        if ( rc != 0 )
-        {
+        if(rc != 0) {
             ret = _libssh2_error(session, rc,
                                  "Unable to create private key");
             goto ecdh_clean_exit;
@@ -2405,7 +2426,7 @@ kex_method_ecdh_key_exchange
 
         key_state->request[0] = SSH2_MSG_KEX_ECDH_INIT;
         s = key_state->request + 1;
-        _libssh2_store_str(&s, (const char*)key_state->public_key_oct, key_state->public_key_oct_len);
+        _libssh2_store_str(&s, (const char *)key_state->public_key_oct, key_state->public_key_oct_len);
         key_state->request_len = key_state->public_key_oct_len + 5;
 
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
@@ -2414,12 +2435,13 @@ kex_method_ecdh_key_exchange
         key_state->state = libssh2_NB_state_sent;
     }
 
-    if ( key_state->state == libssh2_NB_state_sent ) {
+    if(key_state->state == libssh2_NB_state_sent) {
         rc = _libssh2_transport_send(session, key_state->request,
                                      key_state->request_len, NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to send ECDH_INIT");
             goto ecdh_clean_exit;
@@ -2428,13 +2450,14 @@ kex_method_ecdh_key_exchange
         key_state->state = libssh2_NB_state_sent1;
     }
 
-    if ( key_state->state == libssh2_NB_state_sent1 ) {
+    if(key_state->state == libssh2_NB_state_sent1) {
         rc = _libssh2_packet_require(session, SSH2_MSG_KEX_ECDH_REPLY,
                                      &key_state->data, &key_state->data_len,
                                      0, NULL, 0, &key_state->req_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Timeout waiting for ECDH_REPLY reply");
             goto ecdh_clean_exit;
@@ -2443,14 +2466,14 @@ kex_method_ecdh_key_exchange
         key_state->state = libssh2_NB_state_sent2;
     }
 
-    if ( key_state->state == libssh2_NB_state_sent2 ) {
+    if(key_state->state == libssh2_NB_state_sent2) {
 
         (void)kex_session_ecdh_curve_type(session->kex->name, &type);
 
-        ret = ecdh_sha2_nistp(session, type, key_state->data, key_state->data_len, (unsigned char*)key_state->public_key_oct,
+        ret = ecdh_sha2_nistp(session, type, key_state->data, key_state->data_len, (unsigned char *)key_state->public_key_oct,
                              key_state->public_key_oct_len, key_state->private_key, &key_state->exchange_state);
 
-        if (ret == LIBSSH2_ERROR_EAGAIN) {
+        if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
 
@@ -2459,12 +2482,12 @@ kex_method_ecdh_key_exchange
 
 ecdh_clean_exit:
 
-    if (key_state->public_key_oct) {
+    if(key_state->public_key_oct) {
         free(key_state->public_key_oct);
         key_state->public_key_oct = NULL;
     }
 
-    if (key_state->private_key) {
+    if(key_state->private_key) {
         _libssh2_ecdsa_free(key_state->private_key);
         key_state->private_key = NULL;
     }
@@ -2557,11 +2580,11 @@ kex_method_strlen(LIBSSH2_COMMON_METHOD ** method)
 {
     size_t len = 0;
 
-    if (!method || !*method) {
+    if(!method || !*method) {
         return 0;
     }
 
-    while (*method && (*method)->name) {
+    while(*method && (*method)->name) {
         len += strlen((*method)->name) + 1;
         method++;
     }
@@ -2581,11 +2604,11 @@ kex_method_list(unsigned char *buf, size_t list_strlen,
     _libssh2_htonu32(buf, list_strlen);
     buf += 4;
 
-    if (!method || !*method) {
+    if(!method || !*method) {
         return 4;
     }
 
-    while (*method && (*method)->name) {
+    while(*method && (*method)->name) {
         int mlen = strlen((*method)->name);
         memcpy(buf, (*method)->name, mlen);
         buf += mlen;
@@ -2603,12 +2626,13 @@ kex_method_list(unsigned char *buf, size_t list_strlen,
      kex_method_strlen((LIBSSH2_COMMON_METHOD**)(defaultvar)))
 
 #define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar)  \
-    if (prefvar) {                                                      \
+    if(prefvar) {                                                       \
         _libssh2_htonu32((buf), (prefvarlen));                          \
         buf += 4;                                                       \
         memcpy((buf), (prefvar), (prefvarlen));                         \
         buf += (prefvarlen);                                            \
-    } else {                                                            \
+    }                                                                   \
+    else {                                                              \
         buf += kex_method_list((buf), (prefvarlen),                     \
                                (LIBSSH2_COMMON_METHOD**)(defaultvar));  \
     }
@@ -2629,7 +2653,7 @@ static int kexinit(LIBSSH2_SESSION * session)
     unsigned char *data, *s;
     int rc;
 
-    if (session->kexinit_state == libssh2_NB_state_idle) {
+    if(session->kexinit_state == libssh2_NB_state_idle) {
         kex_len =
             LIBSSH2_METHOD_PREFS_LEN(session->kex_prefs, libssh2_kex_methods);
         hostkey_len =
@@ -2663,7 +2687,7 @@ static int kexinit(LIBSSH2_SESSION * session)
             lang_cs_len + lang_sc_len;
 
         s = data = LIBSSH2_ALLOC(session, data_len);
-        if (!data) {
+        if(!data) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory");
         }
@@ -2736,7 +2760,8 @@ static int kexinit(LIBSSH2_SESSION * session)
 #endif /* LIBSSH2DEBUG */
 
         session->kexinit_state = libssh2_NB_state_created;
-    } else {
+    }
+    else {
         data = session->kexinit_data;
         data_len = session->kexinit_data_len;
         /* zap the variables to ensure there is NOT a double free later */
@@ -2745,12 +2770,12 @@ static int kexinit(LIBSSH2_SESSION * session)
     }
 
     rc = _libssh2_transport_send(session, data, data_len, NULL, 0);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         session->kexinit_data = data;
         session->kexinit_data_len = data_len;
         return rc;
     }
-    else if (rc) {
+    else if(rc) {
         LIBSSH2_FREE(session, data);
         session->kexinit_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
@@ -2758,7 +2783,7 @@ static int kexinit(LIBSSH2_SESSION * session)
 
     }
 
-    if (session->local.kexinit) {
+    if(session->local.kexinit) {
         LIBSSH2_FREE(session, session->local.kexinit);
     }
 
@@ -2772,7 +2797,7 @@ static int kexinit(LIBSSH2_SESSION * session)
 
 /* kex_agree_instr
  * Kex specific variant of strstr()
- * Needle must be preceed by BOL or ',', and followed by ',' or EOL
+ * Needle must be precede by BOL or ',', and followed by ',' or EOL
  */
 static unsigned char *
 kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
@@ -2781,12 +2806,12 @@ kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
     unsigned char *s;
 
     /* Haystack too short to bother trying */
-    if (haystack_len < needle_len) {
+    if(haystack_len < needle_len) {
         return NULL;
     }
 
     /* Needle at start of haystack */
-    if ((strncmp((char *) haystack, (char *) needle, needle_len) == 0) &&
+    if((strncmp((char *) haystack, (char *) needle, needle_len) == 0) &&
         (needle_len == haystack_len || haystack[needle_len] == ',')) {
         return haystack;
     }
@@ -2794,11 +2819,11 @@ kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
     s = haystack;
     /* Search until we run out of comas or we run out of haystack,
        whichever comes first */
-    while ((s = (unsigned char *) strchr((char *) s, ','))
+    while((s = (unsigned char *) strchr((char *) s, ','))
            && ((haystack_len - (s - haystack)) > needle_len)) {
         s++;
         /* Needle at X position */
-        if ((strncmp((char *) s, (char *) needle, needle_len) == 0) &&
+        if((strncmp((char *) s, (char *) needle, needle_len) == 0) &&
             (((s - haystack) + needle_len) == haystack_len
              || s[needle_len] == ',')) {
             return s;
@@ -2816,8 +2841,8 @@ static const LIBSSH2_COMMON_METHOD *
 kex_get_method_by_name(const char *name, size_t name_len,
                        const LIBSSH2_COMMON_METHOD ** methodlist)
 {
-    while (*methodlist) {
-        if ((strlen((*methodlist)->name) == name_len) &&
+    while(*methodlist) {
+        if((strlen((*methodlist)->name) == name_len) &&
             (strncmp((*methodlist)->name, name, name_len) == 0)) {
             return *methodlist;
         }
@@ -2838,31 +2863,31 @@ static int kex_agree_hostkey(LIBSSH2_SESSION * session,
     const LIBSSH2_HOSTKEY_METHOD **hostkeyp = libssh2_hostkey_methods();
     unsigned char *s;
 
-    if (session->hostkey_prefs) {
+    if(session->hostkey_prefs) {
         s = (unsigned char *) session->hostkey_prefs;
 
-        while (s && *s) {
+        while(s && *s) {
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            if (kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
+            if(kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
                 const LIBSSH2_HOSTKEY_METHOD *method =
                     (const LIBSSH2_HOSTKEY_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
                                            hostkeyp);
 
-                if (!method) {
+                if(!method) {
                     /* Invalid method -- Should never be reached */
                     return -1;
                 }
 
                 /* So far so good, but does it suit our purposes? (Encrypting
                    vs Signing) */
-                if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) ==
+                if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) ==
                      0) || (method->encrypt)) {
                     /* Either this hostkey can do encryption or this kex just
                        doesn't require it */
-                    if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY)
+                    if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY)
                          == 0) || (method->sig_verify)) {
                         /* Either this hostkey can do signing or this kex just
                            doesn't require it */
@@ -2877,18 +2902,18 @@ static int kex_agree_hostkey(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    while (hostkeyp && (*hostkeyp) && (*hostkeyp)->name) {
+    while(hostkeyp && (*hostkeyp) && (*hostkeyp)->name) {
         s = kex_agree_instr(hostkey, hostkey_len,
                             (unsigned char *) (*hostkeyp)->name,
                             strlen((*hostkeyp)->name));
-        if (s) {
+        if(s) {
             /* So far so good, but does it suit our purposes? (Encrypting vs
                Signing) */
-            if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) == 0) ||
+            if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) == 0) ||
                 ((*hostkeyp)->encrypt)) {
                 /* Either this hostkey can do encryption or this kex just
                    doesn't require it */
-                if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY) ==
+                if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY) ==
                      0) || ((*hostkeyp)->sig_verify)) {
                     /* Either this hostkey can do signing or this kex just
                        doesn't require it */
@@ -2915,19 +2940,20 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
     const LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
     unsigned char *s;
 
-    if (session->kex_prefs) {
+    if(session->kex_prefs) {
         s = (unsigned char *) session->kex_prefs;
 
-        while (s && *s) {
+        while(s && *s) {
             unsigned char *q, *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            if ((q = kex_agree_instr(kex, kex_len, s, method_len))) {
+            q = kex_agree_instr(kex, kex_len, s, method_len);
+            if(q) {
                 const LIBSSH2_KEX_METHOD *method = (const LIBSSH2_KEX_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
                                            kexp);
 
-                if (!method) {
+                if(!method) {
                     /* Invalid method -- Should never be reached */
                     return -1;
                 }
@@ -2935,10 +2961,10 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
                 /* We've agreed on a key exchange method,
                  * Can we agree on a hostkey that works with this kex?
                  */
-                if (kex_agree_hostkey(session, method->flags, hostkey,
+                if(kex_agree_hostkey(session, method->flags, hostkey,
                                       hostkey_len) == 0) {
                     session->kex = method;
-                    if (session->burn_optimistic_kexinit && (kex == q)) {
+                    if(session->burn_optimistic_kexinit && (kex == q)) {
                         /* Server sent an optimistic packet,
                          * and client agrees with preference
                          * cancel burning the first KEX_INIT packet that comes in */
@@ -2953,18 +2979,18 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
         return -1;
     }
 
-    while (*kexp && (*kexp)->name) {
+    while(*kexp && (*kexp)->name) {
         s = kex_agree_instr(kex, kex_len,
                             (unsigned char *) (*kexp)->name,
                             strlen((*kexp)->name));
-        if (s) {
+        if(s) {
             /* We've agreed on a key exchange method,
              * Can we agree on a hostkey that works with this kex?
              */
-            if (kex_agree_hostkey(session, (*kexp)->flags, hostkey,
+            if(kex_agree_hostkey(session, (*kexp)->flags, hostkey,
                                   hostkey_len) == 0) {
                 session->kex = *kexp;
-                if (session->burn_optimistic_kexinit && (kex == s)) {
+                if(session->burn_optimistic_kexinit && (kex == s)) {
                     /* Server sent an optimistic packet,
                      * and client agrees with preference
                      * cancel burning the first KEX_INIT packet that comes in */
@@ -2993,21 +3019,21 @@ static int kex_agree_crypt(LIBSSH2_SESSION * session,
 
     (void) session;
 
-    if (endpoint->crypt_prefs) {
+    if(endpoint->crypt_prefs) {
         s = (unsigned char *) endpoint->crypt_prefs;
 
-        while (s && *s) {
+        while(s && *s) {
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if (kex_agree_instr(crypt, crypt_len, s, method_len)) {
+            if(kex_agree_instr(crypt, crypt_len, s, method_len)) {
                 const LIBSSH2_CRYPT_METHOD *method =
                     (const LIBSSH2_CRYPT_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
                                            cryptp);
 
-                if (!method) {
+                if(!method) {
                     /* Invalid method -- Should never be reached */
                     return -1;
                 }
@@ -3021,11 +3047,11 @@ static int kex_agree_crypt(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    while (*cryptp && (*cryptp)->name) {
+    while(*cryptp && (*cryptp)->name) {
         s = kex_agree_instr(crypt, crypt_len,
                             (unsigned char *) (*cryptp)->name,
                             strlen((*cryptp)->name));
-        if (s) {
+        if(s) {
             endpoint->crypt = *cryptp;
             return 0;
         }
@@ -3048,20 +3074,20 @@ static int kex_agree_mac(LIBSSH2_SESSION * session,
     unsigned char *s;
     (void) session;
 
-    if (endpoint->mac_prefs) {
+    if(endpoint->mac_prefs) {
         s = (unsigned char *) endpoint->mac_prefs;
 
-        while (s && *s) {
+        while(s && *s) {
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if (kex_agree_instr(mac, mac_len, s, method_len)) {
+            if(kex_agree_instr(mac, mac_len, s, method_len)) {
                 const LIBSSH2_MAC_METHOD *method = (const LIBSSH2_MAC_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
                                            macp);
 
-                if (!method) {
+                if(!method) {
                     /* Invalid method -- Should never be reached */
                     return -1;
                 }
@@ -3075,10 +3101,10 @@ static int kex_agree_mac(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    while (*macp && (*macp)->name) {
+    while(*macp && (*macp)->name) {
         s = kex_agree_instr(mac, mac_len, (unsigned char *) (*macp)->name,
                             strlen((*macp)->name));
-        if (s) {
+        if(s) {
             endpoint->mac = *macp;
             return 0;
         }
@@ -3101,21 +3127,21 @@ static int kex_agree_comp(LIBSSH2_SESSION *session,
     unsigned char *s;
     (void) session;
 
-    if (endpoint->comp_prefs) {
+    if(endpoint->comp_prefs) {
         s = (unsigned char *) endpoint->comp_prefs;
 
-        while (s && *s) {
+        while(s && *s) {
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if (kex_agree_instr(comp, comp_len, s, method_len)) {
+            if(kex_agree_instr(comp, comp_len, s, method_len)) {
                 const LIBSSH2_COMP_METHOD *method =
                     (const LIBSSH2_COMP_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
                                            compp);
 
-                if (!method) {
+                if(!method) {
                     /* Invalid method -- Should never be reached */
                     return -1;
                 }
@@ -3129,10 +3155,10 @@ static int kex_agree_comp(LIBSSH2_SESSION *session,
         return -1;
     }
 
-    while (*compp && (*compp)->name) {
+    while(*compp && (*compp)->name) {
         s = kex_agree_instr(comp, comp_len, (unsigned char *) (*compp)->name,
                             strlen((*compp)->name));
-        if (s) {
+        if(s) {
             endpoint->comp = *compp;
             return 0;
         }
@@ -3163,7 +3189,7 @@ static int kex_string_pair(unsigned char **sp,   /* parsing position */
 
     /* the length of the string must fit within the current pointer and the
        end of the packet */
-    if (*lenp > (data_len - (s - data) -4))
+    if(*lenp > (data_len - (s - data) -4))
         return 1;
     *strp = s + 4;
     s += 4 + *lenp;
@@ -3214,30 +3240,30 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
     session->burn_optimistic_kexinit = *(s++);
     /* Next uint32 in packet is all zeros (reserved) */
 
-    if (data_len < (unsigned) (s - data))
+    if(data_len < (unsigned) (s - data))
         return -1;              /* short packet */
 
-    if (kex_agree_kex_hostkey(session, kex, kex_len, hostkey, hostkey_len)) {
+    if(kex_agree_kex_hostkey(session, kex, kex_len, hostkey, hostkey_len)) {
         return -1;
     }
 
-    if (kex_agree_crypt(session, &session->local, crypt_cs, crypt_cs_len)
+    if(kex_agree_crypt(session, &session->local, crypt_cs, crypt_cs_len)
         || kex_agree_crypt(session, &session->remote, crypt_sc, crypt_sc_len)) {
         return -1;
     }
 
-    if (kex_agree_mac(session, &session->local, mac_cs, mac_cs_len) ||
+    if(kex_agree_mac(session, &session->local, mac_cs, mac_cs_len) ||
         kex_agree_mac(session, &session->remote, mac_sc, mac_sc_len)) {
         return -1;
     }
 
-    if (kex_agree_comp(session, &session->local, comp_cs, comp_cs_len) ||
+    if(kex_agree_comp(session, &session->local, comp_cs, comp_cs_len) ||
         kex_agree_comp(session, &session->remote, comp_sc, comp_sc_len)) {
         return -1;
     }
 
 #if 0
-    if (libssh2_kex_agree_lang(session, &session->local, lang_cs, lang_cs_len)
+    if(libssh2_kex_agree_lang(session, &session->local, lang_cs, lang_cs_len)
         || libssh2_kex_agree_lang(session, &session->remote, lang_sc,
                                   lang_sc_len)) {
         return -1;
@@ -3281,14 +3307,14 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
 
     session->state |= LIBSSH2_STATE_KEX_ACTIVE;
 
-    if (key_state->state == libssh2_NB_state_idle) {
+    if(key_state->state == libssh2_NB_state_idle) {
         /* Prevent loop in packet_add() */
         session->state |= LIBSSH2_STATE_EXCHANGING_KEYS;
 
-        if (reexchange) {
+        if(reexchange) {
             session->kex = NULL;
 
-            if (session->hostkey && session->hostkey->dtor) {
+            if(session->hostkey && session->hostkey->dtor) {
                 session->hostkey->dtor(session,
                                        &session->server_hostkey_abstract);
             }
@@ -3298,8 +3324,8 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
         key_state->state = libssh2_NB_state_created;
     }
 
-    if (!session->kex || !session->hostkey) {
-        if (key_state->state == libssh2_NB_state_created) {
+    if(!session->kex || !session->hostkey) {
+        if(key_state->state == libssh2_NB_state_created) {
             /* Preserve in case of failure */
             key_state->oldlocal = session->local.kexinit;
             key_state->oldlocal_len = session->local.kexinit_len;
@@ -3309,12 +3335,13 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
             key_state->state = libssh2_NB_state_sent;
         }
 
-        if (key_state->state == libssh2_NB_state_sent) {
+        if(key_state->state == libssh2_NB_state_sent) {
             retcode = kexinit(session);
-            if (retcode == LIBSSH2_ERROR_EAGAIN) {
+            if(retcode == LIBSSH2_ERROR_EAGAIN) {
                 session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
                 return retcode;
-            } else if (retcode) {
+            }
+            else if(retcode) {
                 session->local.kexinit = key_state->oldlocal;
                 session->local.kexinit_len = key_state->oldlocal_len;
                 key_state->state = libssh2_NB_state_idle;
@@ -3326,18 +3353,18 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
             key_state->state = libssh2_NB_state_sent1;
         }
 
-        if (key_state->state == libssh2_NB_state_sent1) {
+        if(key_state->state == libssh2_NB_state_sent1) {
             retcode =
                 _libssh2_packet_require(session, SSH_MSG_KEXINIT,
                                         &key_state->data,
                                         &key_state->data_len, 0, NULL, 0,
                                         &key_state->req_state);
-            if (retcode == LIBSSH2_ERROR_EAGAIN) {
+            if(retcode == LIBSSH2_ERROR_EAGAIN) {
                 session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
                 return retcode;
             }
-            else if (retcode) {
-                if (session->local.kexinit) {
+            else if(retcode) {
+                if(session->local.kexinit) {
                     LIBSSH2_FREE(session, session->local.kexinit);
                 }
                 session->local.kexinit = key_state->oldlocal;
@@ -3348,30 +3375,32 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
                 return -1;
             }
 
-            if (session->remote.kexinit) {
+            if(session->remote.kexinit) {
                 LIBSSH2_FREE(session, session->remote.kexinit);
             }
             session->remote.kexinit = key_state->data;
             session->remote.kexinit_len = key_state->data_len;
 
-            if (kex_agree_methods(session, key_state->data,
+            if(kex_agree_methods(session, key_state->data,
                                   key_state->data_len))
                 rc = LIBSSH2_ERROR_KEX_FAILURE;
 
             key_state->state = libssh2_NB_state_sent2;
         }
-    } else {
+    }
+    else {
         key_state->state = libssh2_NB_state_sent2;
     }
 
-    if (rc == 0 && session->kex) {
-        if (key_state->state == libssh2_NB_state_sent2) {
+    if(rc == 0 && session->kex) {
+        if(key_state->state == libssh2_NB_state_sent2) {
             retcode = session->kex->exchange_keys(session,
                                                   &key_state->key_state_low);
-            if (retcode == LIBSSH2_ERROR_EAGAIN) {
+            if(retcode == LIBSSH2_ERROR_EAGAIN) {
                 session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
                 return retcode;
-            } else if (retcode) {
+            }
+            else if(retcode) {
                 rc = _libssh2_error(session, LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE,
                                     "Unrecoverable error exchanging keys");
             }
@@ -3379,11 +3408,11 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
     }
 
     /* Done with kexinit buffers */
-    if (session->local.kexinit) {
+    if(session->local.kexinit) {
         LIBSSH2_FREE(session, session->local.kexinit);
         session->local.kexinit = NULL;
     }
-    if (session->remote.kexinit) {
+    if(session->remote.kexinit) {
         LIBSSH2_FREE(session, session->remote.kexinit);
         session->remote.kexinit = NULL;
     }
@@ -3409,7 +3438,7 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
     int prefs_len = strlen(prefs);
     const LIBSSH2_COMMON_METHOD **mlist;
 
-    switch (method_type) {
+    switch(method_type) {
     case LIBSSH2_METHOD_KEX:
         prefvar = &session->kex_prefs;
         mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
@@ -3468,24 +3497,26 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
     }
 
     s = newprefs = LIBSSH2_ALLOC(session, prefs_len + 1);
-    if (!newprefs) {
+    if(!newprefs) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Error allocated space for method preferences");
     }
     memcpy(s, prefs, prefs_len + 1);
 
-    while (s && *s && mlist) {
+    while(s && *s && mlist) {
         char *p = strchr(s, ',');
         int method_len = p ? (p - s) : (int) strlen(s);
 
-        if (!kex_get_method_by_name(s, method_len, mlist)) {
+        if(!kex_get_method_by_name(s, method_len, mlist)) {
             /* Strip out unsupported method */
-            if (p) {
+            if(p) {
                 memcpy(s, p + 1, strlen(s) - method_len);
-            } else {
-                if (s > newprefs) {
+            }
+            else {
+                if(s > newprefs) {
                     *(--s) = '\0';
-                } else {
+                }
+                else {
                     *s = '\0';
                 }
             }
@@ -3494,14 +3525,14 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
         s = p ? (p + 1) : NULL;
     }
 
-    if (strlen(newprefs) == 0) {
+    if(strlen(newprefs) == 0) {
         LIBSSH2_FREE(session, newprefs);
         return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
                               "The requested method(s) are not currently "
                               "supported");
     }
 
-    if (*prefvar) {
+    if(*prefvar) {
         LIBSSH2_FREE(session, *prefvar);
     }
     *prefvar = newprefs;
@@ -3517,7 +3548,7 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
 
 LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
                                                int method_type,
-                                               const char*** algs)
+                                               const char ***algs)
 {
     unsigned int i;
     unsigned int j;
@@ -3525,11 +3556,11 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     const LIBSSH2_COMMON_METHOD **mlist;
 
     /* to prevent coredumps due to dereferencing of NULL */
-    if (NULL == algs)
+    if(NULL == algs)
         return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
                               "algs must not be NULL");
 
-    switch (method_type) {
+    switch(method_type) {
     case LIBSSH2_METHOD_KEX:
         mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
         break;
@@ -3559,7 +3590,7 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     }  /* switch */
 
     /* weird situation */
-    if (NULL==mlist)
+    if(NULL == mlist)
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "No algorithm found");
 
@@ -3576,28 +3607,28 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     */
 
     /* count the number of supported algorithms */
-    for ( i=0, ialg=0; NULL!=mlist[i]; i++) {
+    for(i = 0, ialg = 0; NULL != mlist[i]; i++) {
         /* do not count fields with NULL name */
-        if (mlist[i]->name)
+        if(mlist[i]->name)
             ialg++;
     }
 
     /* weird situation, no algorithm found */
-    if (0==ialg)
+    if(0 == ialg)
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "No algorithm found");
 
     /* allocate buffer */
-    *algs = (const char**) LIBSSH2_ALLOC(session, ialg*sizeof(const char*));
-    if ( NULL==*algs ) {
+    *algs = (const char **) LIBSSH2_ALLOC(session, ialg*sizeof(const char *));
+    if(NULL == *algs) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Memory allocation failed");
     }
     /* Past this point *algs must be deallocated in case of an error!! */
 
     /* copy non-NULL pointers only */
-    for ( i=0, j=0; NULL!=mlist[i] && j<ialg; i++ ) {
-        if ( NULL==mlist[i]->name ){
+    for(i = 0, j = 0; NULL != mlist[i] && j < ialg; i++) {
+        if(NULL == mlist[i]->name) {
             /* maybe a weird situation but if it occurs, do not include NULL
                pointers */
             continue;
@@ -3608,7 +3639,7 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     }
 
     /* correct number of pointers copied? (test the code above) */
-    if ( j!=ialg ) {
+    if(j != ialg) {
         /* deallocate buffer */
         LIBSSH2_FREE(session, (void *)*algs);
         *algs = NULL;
diff --git a/src/knownhost.c b/src/knownhost.c
index a32dcf87..1edec752 100644
--- a/src/knownhost.c
+++ b/src/knownhost.c
@@ -71,7 +71,7 @@ static void free_host(LIBSSH2_SESSION *session, struct known_host *entry)
     if(entry) {
         if(entry->comment)
             LIBSSH2_FREE(session, entry->comment);
-        if (entry->key_type_name)
+        if(entry->key_type_name)
             LIBSSH2_FREE(session, entry->key_type_name);
         if(entry->key)
             LIBSSH2_FREE(session, entry->key);
@@ -149,7 +149,8 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
         return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL,
                               "No key type set");
 
-    if(!(entry = LIBSSH2_CALLOC(hosts->session, sizeof(struct known_host))))
+    entry = LIBSSH2_CALLOC(hosts->session, sizeof(struct known_host));
+    if(!entry)
         return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for known host "
                               "entry");
@@ -159,13 +160,13 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
     switch(entry->typemask  & LIBSSH2_KNOWNHOST_TYPE_MASK) {
     case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
     case LIBSSH2_KNOWNHOST_TYPE_CUSTOM:
-        entry->name = LIBSSH2_ALLOC(hosts->session, hostlen+1);
+        entry->name = LIBSSH2_ALLOC(hosts->session, hostlen + 1);
         if(!entry->name) {
             rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
                                 "Unable to allocate memory for host name");
             goto error;
         }
-        memcpy(entry->name, host, hostlen+1);
+        memcpy(entry->name, host, hostlen + 1);
         entry->name_len = hostlen;
         break;
     case LIBSSH2_KNOWNHOST_TYPE_SHA1:
@@ -193,14 +194,14 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
         /* the provided key is base64 encoded already */
         if(!keylen)
             keylen = strlen(key);
-        entry->key = LIBSSH2_ALLOC(hosts->session, keylen+1);
+        entry->key = LIBSSH2_ALLOC(hosts->session, keylen + 1);
         if(!entry->key) {
             rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
                                 "Unable to allocate memory for key");
             goto error;
         }
-        memcpy(entry->key, key, keylen+1);
-        entry->key[keylen]=0; /* force a terminating zero trailer */
+        memcpy(entry->key, key, keylen + 1);
+        entry->key[keylen] = 0; /* force a terminating zero trailer */
     }
     else {
         /* key is raw, we base64 encode it and store it as such */
@@ -216,28 +217,28 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
         entry->key = ptr;
     }
 
-    if (key_type_name && ((typemask & LIBSSH2_KNOWNHOST_KEY_MASK) ==
+    if(key_type_name && ((typemask & LIBSSH2_KNOWNHOST_KEY_MASK) ==
                           LIBSSH2_KNOWNHOST_KEY_UNKNOWN)) {
-        entry->key_type_name = LIBSSH2_ALLOC(hosts->session, key_type_len+1);
-        if (!entry->key_type_name) {
+        entry->key_type_name = LIBSSH2_ALLOC(hosts->session, key_type_len + 1);
+        if(!entry->key_type_name) {
             rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
                                 "Unable to allocate memory for key type");
             goto error;
         }
         memcpy(entry->key_type_name, key_type_name, key_type_len);
-        entry->key_type_name[key_type_len]=0;
+        entry->key_type_name[key_type_len] = 0;
         entry->key_type_len = key_type_len;
     }
 
-    if (comment) {
-        entry->comment = LIBSSH2_ALLOC(hosts->session, commentlen+1);
+    if(comment) {
+        entry->comment = LIBSSH2_ALLOC(hosts->session, commentlen + 1);
         if(!entry->comment) {
             rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
                                 "Unable to allocate memory for comment");
             goto error;
         }
-        memcpy(entry->comment, comment, commentlen+1);
-        entry->comment[commentlen]=0; /* force a terminating zero trailer */
+        memcpy(entry->comment, comment, commentlen + 1);
+        entry->comment[commentlen] = 0; /* force a terminating zero trailer */
         entry->comment_len = commentlen;
     }
     else {
@@ -370,7 +371,7 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
        plain 'host' */
     if(port >= 0) {
         int len = snprintf(hostbuff, sizeof(hostbuff), "[%s]:%d", hostp, port);
-        if (len < 0 || len >= (int)sizeof(hostbuff)) {
+        if(len < 0 || len >= (int)sizeof(hostbuff)) {
             _libssh2_error(hosts->session,
                            LIBSSH2_ERROR_BUFFER_TOO_SMALL,
                            "Known-host write buffer too small");
@@ -401,7 +402,7 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
 
     do {
         node = _libssh2_list_first(&hosts->head);
-        while (node) {
+        while(node) {
             switch(node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) {
             case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
                 if(type == LIBSSH2_KNOWNHOST_TYPE_PLAIN)
@@ -450,13 +451,13 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
                    - if key_type is set to zero, ignore it an match always
                    - otherwise match when both key types are equal
                 */
-                if ( (host_key_type != LIBSSH2_KNOWNHOST_KEY_UNKNOWN ) &&
-                     ( (host_key_type == 0) ||
-                       (host_key_type == known_key_type) ) ) {
+                if(host_key_type != LIBSSH2_KNOWNHOST_KEY_UNKNOWN &&
+                     (host_key_type == 0 ||
+                      host_key_type == known_key_type)) {
                     /* host name and key type match, now compare the keys */
                     if(!strcmp(key, node->key)) {
                         /* they match! */
-                        if (ext)
+                        if(ext)
                             *ext = knownhost_to_external(node);
                         badkey = NULL;
                         rc = LIBSSH2_KNOWNHOST_CHECK_MATCH;
@@ -472,14 +473,14 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
                 }
                 match = 0; /* don't count this as a match anymore */
             }
-            node= _libssh2_list_next(&node->node);
+            node = _libssh2_list_next(&node->node);
         }
         host = hostp;
     } while(!match && --numcheck);
 
     if(badkey) {
         /* key mismatch */
-        if (ext)
+        if(ext)
             *ext = knownhost_to_external(badkey);
         rc = LIBSSH2_KNOWNHOST_CHECK_MISMATCH;
     }
@@ -646,7 +647,7 @@ static int oldstyle_hostline(LIBSSH2_KNOWNHOSTS *hosts,
 
             /* copy host name to the temp buffer and zero terminate */
             memcpy(hostbuf, name, namelen);
-            hostbuf[namelen]=0;
+            hostbuf[namelen] = 0;
 
             rc = knownhost_add(hosts, hostbuf, NULL,
                                key_type_name, key_type_len,
@@ -685,7 +686,7 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
     for(p = salt; *p && (*p != '|'); p++)
         ;
 
-    if(*p=='|') {
+    if(*p == '|') {
         const char *hash = NULL;
         size_t saltlen = p - salt;
         if(saltlen >= (sizeof(saltbuf)-1)) /* weird length */
@@ -698,11 +699,11 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
         saltbuf[saltlen] = 0; /* zero terminate */
         salt = saltbuf; /* point to the stack based buffer */
 
-        hash = p+1; /* the host hash is after the separator */
+        hash = p + 1; /* the host hash is after the separator */
 
         /* now make the host point to the hash */
         host = hash;
-        hostlen -= saltlen+1; /* deduct the salt and separator */
+        hostlen -= saltlen + 1; /* deduct the salt and separator */
 
         /* check that the lengths seem sensible */
         if(hostlen >= sizeof(hostbuf)-1)
@@ -712,7 +713,7 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
                                   "(unexpected length)");
 
         memcpy(hostbuf, host, hostlen);
-        hostbuf[hostlen]=0;
+        hostbuf[hostlen] = 0;
 
         return knownhost_add(hosts, hostbuf, salt,
                              key_type_name, key_type_len,
@@ -766,16 +767,16 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
 
     default:
         key_type_name = key;
-        while (keylen && *key &&
+        while(keylen && *key &&
                (*key != ' ') && (*key != '\t')) {
             key++;
             keylen--;
         }
         key_type_len = key - key_type_name;
 
-        if (!strncmp(key_type_name, "ssh-dss", key_type_len))
+        if(!strncmp(key_type_name, "ssh-dss", key_type_len))
             key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
-        else if (!strncmp(key_type_name, "ssh-rsa", key_type_len))
+        else if(!strncmp(key_type_name, "ssh-rsa", key_type_len))
             key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
         else
             key_type = LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
@@ -800,7 +801,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
         keylen -= commentlen;
 
         /* Distinguish empty comment (a space) from no comment (no space) */
-        if (commentlen == 0)
+        if(commentlen == 0)
             comment = NULL;
 
         /* skip whitespaces */
@@ -879,7 +880,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
     cp = line;
 
     /* skip leading whitespaces */
-    while(len && ((*cp==' ') || (*cp == '\t'))) {
+    while(len && ((*cp == ' ') || (*cp == '\t'))) {
         cp++;
         len--;
     }
@@ -892,7 +893,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
     hostp = cp;
 
     /* move over the host to the separator */
-    while(len && *cp && (*cp!=' ') && (*cp != '\t')) {
+    while(len && *cp && (*cp != ' ') && (*cp != '\t')) {
         cp++;
         len--;
     }
@@ -900,7 +901,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
     hostlen = cp - hostp;
 
     /* the key starts after the whitespaces */
-    while(len && *cp && ((*cp==' ') || (*cp == '\t'))) {
+    while(len && *cp && ((*cp == ' ') || (*cp == '\t'))) {
         cp++;
         len--;
     }
@@ -1018,7 +1019,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
         break;
     case LIBSSH2_KNOWNHOST_KEY_UNKNOWN:
         key_type_name = node->key_type_name;
-        if (key_type_name) {
+        if(key_type_name) {
             key_type_len = node->key_type_len;
             break;
         }
@@ -1033,7 +1034,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
        - Hashed (SHA1) or unhashed hostname
        - key name or no key name (RSA1)
        - comment or no comment
-      
+
        This means there are 2^3 different formats:
        ("|1|%s|%s %s %s %s\n", salt, hashed_host, key_name, key, comment)
        ("|1|%s|%s %s %s\n", salt, hashed_host, key_name, key)
@@ -1043,7 +1044,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
        ("%s %s %s\n", host, key_name, key)
        ("%s %s %s\n", host, key, comment)
        ("%s %s\n", host, key)
-      
+
        Even if the buffer is too small, we have to set outlen to the number of
        characters the complete line would have taken.  We also don't write
        anything to the buffer unless we are sure we can write everything to the
@@ -1087,10 +1088,10 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
             if(node->comment && key_type_len)
                 snprintf(buf, buflen, "|1|%s|%s %s %s %s\n", saltalloc,
                          namealloc, key_type_name, node->key, node->comment);
-            else if (node->comment)
+            else if(node->comment)
                 snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
                          node->key, node->comment);
-            else if (key_type_len)
+            else if(key_type_len)
                 snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
                          key_type_name, node->key);
             else
@@ -1109,10 +1110,10 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
             if(node->comment && key_type_len)
                 snprintf(buf, buflen, "%s %s %s %s\n", node->name,
                          key_type_name, node->key, node->comment);
-            else if (node->comment)
+            else if(node->comment)
                 snprintf(buf, buflen, "%s %s %s\n", node->name, node->key,
                          node->comment);
-            else if (key_type_len)
+            else if(key_type_len)
                 snprintf(buf, buflen, "%s %s %s\n", node->name, key_type_name,
                          node->key);
             else
diff --git a/src/libgcrypt.c b/src/libgcrypt.c
index 5429566a..d9860bd2 100644
--- a/src/libgcrypt.c
+++ b/src/libgcrypt.c
@@ -66,17 +66,18 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
     (void) e2data;
     (void) e2len;
 
-    if (ddata) {
+    if(ddata) {
         rc = gcry_sexp_build
             (rsa, NULL,
              "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
              nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
              qlen, qdata, coefflen, coeffdata);
-    } else {
+    }
+    else {
         rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
                              nlen, ndata, elen, edata);
     }
-    if (rc) {
+    if(rc) {
         *rsa = NULL;
         return -1;
     }
@@ -99,12 +100,12 @@ _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
     rc = gcry_sexp_build(&s_hash, NULL,
                          "(data (flags pkcs1) (hash sha1 %b))",
                          SHA_DIGEST_LENGTH, hash);
-    if (rc != 0) {
+    if(rc != 0) {
         return -1;
     }
 
     rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig);
-    if (rc != 0) {
+    if(rc != 0) {
         gcry_sexp_release(s_hash);
         return -1;
     }
@@ -130,18 +131,19 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
 {
     int rc;
 
-    if (x_len) {
+    if(x_len) {
         rc = gcry_sexp_build
             (dsactx, NULL,
              "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
              p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
-    } else {
+    }
+    else {
         rc = gcry_sexp_build(dsactx, NULL,
                              "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
                              p_len, p, q_len, q, g_len, g, y_len, y);
     }
 
-    if (rc) {
+    if(rc) {
         *dsactx = NULL;
         return -1;
     }
@@ -173,7 +175,7 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
     unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;
 
     fp = fopen(filename, "r");
-    if (!fp) {
+    if(!fp) {
         return -1;
     }
 
@@ -183,72 +185,72 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
                              passphrase,
                              fp, &data, &datalen);
     fclose(fp);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
     save_data = data;
 
-    if (_libssh2_pem_decode_sequence(&data, &datalen)) {
+    if(_libssh2_pem_decode_sequence(&data, &datalen)) {
         ret = -1;
         goto fail;
     }
 /* First read Version field (should be 0). */
     ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if (ret != 0 || (nlen != 1 && *n != '\0')) {
+    if(ret != 0 || (nlen != 1 && *n != '\0')) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
-    if (_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
+    if(_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
                          q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
         ret = -1;
         goto fail;
@@ -285,7 +287,7 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
     unsigned int plen, qlen, glen, ylen, xlen;
 
     fp = fopen(filename, "r");
-    if (!fp) {
+    if(!fp) {
         return -1;
     }
 
@@ -295,60 +297,60 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
                              passphrase,
                              fp, &data, &datalen);
     fclose(fp);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
     save_data = data;
 
-    if (_libssh2_pem_decode_sequence(&data, &datalen)) {
+    if(_libssh2_pem_decode_sequence(&data, &datalen)) {
         ret = -1;
         goto fail;
     }
 
 /* First read Version field (should be 0). */
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if (ret != 0 || (plen != 1 && *p != '\0')) {
+    if(ret != 0 || (plen != 1 && *p != '\0')) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen);
-    if (ret != 0) {
+    if(ret != 0) {
         ret = -1;
         goto fail;
     }
 
-    if (datalen != 0) {
+    if(datalen != 0) {
         ret = -1;
         goto fail;
     }
 
-    if (_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) {
+    if(_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) {
         ret = -1;
         goto fail;
     }
@@ -373,11 +375,11 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
     const char *tmp;
     size_t size;
 
-    if (hash_len != SHA_DIGEST_LENGTH) {
+    if(hash_len != SHA_DIGEST_LENGTH) {
         return -1;
     }
 
-    if (gcry_sexp_build(&data, NULL,
+    if(gcry_sexp_build(&data, NULL,
                         "(data (flags pkcs1) (hash sha1 %b))",
                         hash_len, hash)) {
         return -1;
@@ -387,27 +389,27 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
 
     gcry_sexp_release(data);
 
-    if (rc != 0) {
+    if(rc != 0) {
         return -1;
     }
 
     data = gcry_sexp_find_token(sig_sexp, "s", 0);
-    if (!data) {
+    if(!data) {
         return -1;
     }
 
     tmp = gcry_sexp_nth_data(data, 1, &size);
-    if (!tmp) {
+    if(!tmp) {
         return -1;
     }
 
-    if (tmp[0] == '\0') {
+    if(tmp[0] == '\0') {
         tmp++;
         size--;
     }
 
     *signature = LIBSSH2_ALLOC(session, size);
-    if (!*signature) {
+    if(!*signature) {
         return -1;
     }
     memcpy(*signature, tmp, size);
@@ -428,14 +430,14 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     const char *tmp;
     size_t size;
 
-    if (hash_len != SHA_DIGEST_LENGTH) {
+    if(hash_len != SHA_DIGEST_LENGTH) {
         return -1;
     }
 
     memcpy(zhash + 1, hash, hash_len);
     zhash[0] = 0;
 
-    if (gcry_sexp_build(&data, NULL, "(data (value %b))", hash_len + 1, zhash)) {
+    if(gcry_sexp_build(&data, NULL, "(data (value %b))", hash_len + 1, zhash)) {
         return -1;
     }
 
@@ -443,7 +445,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 
     gcry_sexp_release(data);
 
-    if (ret != 0) {
+    if(ret != 0) {
         return -1;
     }
 
@@ -452,19 +454,19 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 /* Extract R. */
 
     data = gcry_sexp_find_token(sig_sexp, "r", 0);
-    if (!data)
+    if(!data)
         goto err;
 
     tmp = gcry_sexp_nth_data(data, 1, &size);
-    if (!tmp)
+    if(!tmp)
         goto err;
 
-    if (tmp[0] == '\0') {
+    if(tmp[0] == '\0') {
         tmp++;
         size--;
     }
 
-    if (size < 1 || size > 20)
+    if(size < 1 || size > 20)
         goto err;
 
     memcpy(sig + (20 - size), tmp, size);
@@ -474,19 +476,19 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 /* Extract S. */
 
     data = gcry_sexp_find_token(sig_sexp, "s", 0);
-    if (!data)
+    if(!data)
         goto err;
 
     tmp = gcry_sexp_nth_data(data, 1, &size);
-    if (!tmp)
+    if(!tmp)
         goto err;
 
-    if (tmp[0] == '\0') {
+    if(tmp[0] == '\0') {
         tmp++;
         size--;
     }
 
-    if (size < 1 || size > 20)
+    if(size < 1 || size > 20)
         goto err;
 
     memcpy(sig + 20 + (20 - size), tmp, size);
@@ -496,10 +498,10 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     ret = -1;
 
   out:
-    if (sig_sexp) {
+    if(sig_sexp) {
         gcry_sexp_release(sig_sexp);
     }
-    if (data) {
+    if(data) {
         gcry_sexp_release(data);
     }
     return ret;
@@ -517,12 +519,12 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
     libssh2_sha1(m, m_len, hash + 1);
     hash[0] = 0;
 
-    if (gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
+    if(gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
                         SHA_DIGEST_LENGTH + 1, hash)) {
         return -1;
     }
 
-    if (gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
+    if(gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
                         20, sig, 20, sig + 20)) {
         gcry_sexp_release(s_hash);
         return -1;
@@ -541,30 +543,30 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
                      unsigned char *iv, unsigned char *secret, int encrypt)
 {
     int ret;
-    int cipher = _libssh2_gcry_cipher (algo);
-    int mode = _libssh2_gcry_mode (algo);
+    int cipher = _libssh2_gcry_cipher(algo);
+    int mode = _libssh2_gcry_mode(algo);
     int keylen = gcry_cipher_get_algo_keylen(cipher);
 
     (void) encrypt;
 
     ret = gcry_cipher_open(h, cipher, mode, 0);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
     ret = gcry_cipher_setkey(*h, secret, keylen);
-    if (ret) {
+    if(ret) {
         gcry_cipher_close(*h);
         return -1;
     }
 
-    if (mode != GCRY_CIPHER_MODE_STREAM) {
+    if(mode != GCRY_CIPHER_MODE_STREAM) {
         int blklen = gcry_cipher_get_algo_blklen(cipher);
-        if (mode == GCRY_CIPHER_MODE_CTR)
+        if(mode == GCRY_CIPHER_MODE_CTR)
             ret = gcry_cipher_setctr(*h, iv, blklen);
         else
             ret = gcry_cipher_setiv(*h, iv, blklen);
-        if (ret) {
+        if(ret) {
             gcry_cipher_close(*h);
             return -1;
         }
@@ -578,12 +580,13 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
                       _libssh2_cipher_type(algo),
                       int encrypt, unsigned char *block, size_t blklen)
 {
-    int cipher = _libssh2_gcry_cipher (algo);
+    int cipher = _libssh2_gcry_cipher(algo);
     int ret;
 
-    if (encrypt) {
+    if(encrypt) {
         ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen);
-    } else {
+    }
+    else {
         ret = gcry_cipher_decrypt(*ctx, block, blklen, block, blklen);
     }
     return ret;
diff --git a/src/libgcrypt.h b/src/libgcrypt.h
index 4070e3a4..85ad3059 100644
--- a/src/libgcrypt.h
+++ b/src/libgcrypt.h
@@ -73,82 +73,82 @@
 
 /* returns 0 in case of failure */
 #define libssh2_sha1_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open (ctx,  GCRY_MD_SHA1, 0))
+  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA1, 0))
 #define libssh2_sha1_update(ctx, data, len) \
-  gcry_md_write (ctx, (unsigned char *) data, len)
+  gcry_md_write(ctx, (unsigned char *) data, len)
 #define libssh2_sha1_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close (ctx)
+  memcpy(out, gcry_md_read(ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close(ctx)
 #define libssh2_sha1(message, len, out) \
-  gcry_md_hash_buffer (GCRY_MD_SHA1, out, message, len)
+  gcry_md_hash_buffer(GCRY_MD_SHA1, out, message, len)
 
 #define libssh2_sha256_ctx gcry_md_hd_t
 
 #define libssh2_sha256_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open (ctx,  GCRY_MD_SHA256, 0))
+  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA256, 0))
 #define libssh2_sha256_update(ctx, data, len) \
-  gcry_md_write (ctx, (unsigned char *) data, len)
+  gcry_md_write(ctx, (unsigned char *) data, len)
 #define libssh2_sha256_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close (ctx)
+  memcpy(out, gcry_md_read(ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close(ctx)
 #define libssh2_sha256(message, len, out) \
-  gcry_md_hash_buffer (GCRY_MD_SHA256, out, message, len)
+  gcry_md_hash_buffer(GCRY_MD_SHA256, out, message, len)
 
 #define libssh2_sha384_ctx gcry_md_hd_t
 
 #define libssh2_sha384_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open (ctx,  GCRY_MD_SHA384, 0))
+  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA384, 0))
 #define libssh2_sha384_update(ctx, data, len) \
-  gcry_md_write (ctx, (unsigned char *) data, len)
+  gcry_md_write(ctx, (unsigned char *) data, len)
 #define libssh2_sha384_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close (ctx)
+  memcpy(out, gcry_md_read(ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close(ctx)
 #define libssh2_sha384(message, len, out) \
-  gcry_md_hash_buffer (GCRY_MD_SHA384, out, message, len)
+  gcry_md_hash_buffer(GCRY_MD_SHA384, out, message, len)
 
 #define libssh2_sha512_ctx gcry_md_hd_t
 
 #define libssh2_sha512_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open (ctx,  GCRY_MD_SHA512, 0))
+  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA512, 0))
 #define libssh2_sha512_update(ctx, data, len) \
-  gcry_md_write (ctx, (unsigned char *) data, len)
+  gcry_md_write(ctx, (unsigned char *) data, len)
 #define libssh2_sha512_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close (ctx)
+  memcpy(out, gcry_md_read(ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close(ctx)
 #define libssh2_sha512(message, len, out) \
-  gcry_md_hash_buffer (GCRY_MD_SHA512, out, message, len)
+  gcry_md_hash_buffer(GCRY_MD_SHA512, out, message, len)
 
 #define libssh2_md5_ctx gcry_md_hd_t
 
 /* returns 0 in case of failure */
 #define libssh2_md5_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open (ctx,  GCRY_MD_MD5, 0))
+  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_MD5, 0))
 
 #define libssh2_md5_update(ctx, data, len) \
-  gcry_md_write (ctx, (unsigned char *) data, len)
+  gcry_md_write(ctx, (unsigned char *) data, len)
 #define libssh2_md5_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close (ctx)
+  memcpy(out, gcry_md_read(ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close(ctx)
 #define libssh2_md5(message, len, out) \
-  gcry_md_hash_buffer (GCRY_MD_MD5, out, message, len)
+  gcry_md_hash_buffer(GCRY_MD_MD5, out, message, len)
 
 #define libssh2_hmac_ctx gcry_md_hd_t
 #define libssh2_hmac_ctx_init(ctx)
 #define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  gcry_md_open (ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey (*ctx, key, keylen)
+  gcry_md_open(ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
+    gcry_md_setkey(*ctx, key, keylen)
 #define libssh2_hmac_md5_init(ctx, key, keylen) \
-  gcry_md_open (ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey (*ctx, key, keylen)
+  gcry_md_open(ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
+    gcry_md_setkey(*ctx, key, keylen)
 #define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  gcry_md_open (ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey (*ctx, key, keylen)
+  gcry_md_open(ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
+    gcry_md_setkey(*ctx, key, keylen)
 #define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  gcry_md_open (ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey (*ctx, key, keylen)
+  gcry_md_open(ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \
+    gcry_md_setkey(*ctx, key, keylen)
 #define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  gcry_md_open (ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey (*ctx, key, keylen)
+  gcry_md_open(ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \
+    gcry_md_setkey(*ctx, key, keylen)
 #define libssh2_hmac_update(ctx, data, datalen) \
-  gcry_md_write (ctx, (unsigned char *) data, datalen)
+  gcry_md_write(ctx, (unsigned char *) data, datalen)
 #define libssh2_hmac_final(ctx, data) \
-  memcpy (data, gcry_md_read (ctx, 0), \
-      gcry_md_get_algo_dlen (gcry_md_get_algo (ctx)))
+  memcpy(data, gcry_md_read(ctx, 0), \
+      gcry_md_get_algo_dlen(gcry_md_get_algo(ctx)))
 #define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx);
 
 #define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM)
diff --git a/src/libssh2_priv.h b/src/libssh2_priv.h
index 5a32b3fd..8fdc3fa8 100644
--- a/src/libssh2_priv.h
+++ b/src/libssh2_priv.h
@@ -118,13 +118,13 @@
 
 struct iovec {
     size_t iov_len;
-    void * iov_base;
+    void *iov_base;
 };
 
 static inline int writev(int sock, struct iovec *iov, int nvecs)
 {
     DWORD ret;
-    if (WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
+    if(WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
         return ret;
     }
     return -1;
@@ -649,7 +649,7 @@ struct _LIBSSH2_SESSION
 #ifdef LIBSSH2DEBUG
     int showmask;               /* what debug/trace messages to display */
     libssh2_trace_handler_func tracehandler; /* callback to display trace messages */
-    void* tracehandler_context; /* context for the trace handler */
+    void *tracehandler_context; /* context for the trace handler */
 #endif
 
     /* State variables used in libssh2_banner_send() */
@@ -1064,13 +1064,13 @@ int _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
                                 unsigned char **i, unsigned int *ilen);
 
 /* global.c */
-void _libssh2_init_if_needed (void);
+void _libssh2_init_if_needed(void);
 
 
 #define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0]))
 
 /* define to output the libssh2_int64_t type in a *printf() */
-#if defined( __BORLANDC__ ) || defined( _MSC_VER ) || defined( __MINGW32__ )
+#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW32__)
 #define LIBSSH2_INT64_T_FORMAT "I64d"
 #else
 #define LIBSSH2_INT64_T_FORMAT "lld"
diff --git a/src/mac.c b/src/mac.c
index 5ec26eb3..5ac71df4 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -86,7 +86,7 @@ mac_method_common_init(LIBSSH2_SESSION * session, unsigned char *key,
 static int
 mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
-    if (*abstract) {
+    if(*abstract) {
         LIBSSH2_FREE(session, *abstract);
     }
     *abstract = NULL;
@@ -118,7 +118,7 @@ mac_method_hmac_sha2_512_hash(LIBSSH2_SESSION * session,
     libssh2_hmac_sha512_init(&ctx, *abstract, 64);
     libssh2_hmac_update(ctx, seqno_buf, 4);
     libssh2_hmac_update(ctx, packet, packet_len);
-    if (addtl && addtl_len) {
+    if(addtl && addtl_len) {
         libssh2_hmac_update(ctx, addtl, addtl_len);
     }
     libssh2_hmac_final(ctx, buf);
@@ -163,7 +163,7 @@ mac_method_hmac_sha2_256_hash(LIBSSH2_SESSION * session,
     libssh2_hmac_sha256_init(&ctx, *abstract, 32);
     libssh2_hmac_update(ctx, seqno_buf, 4);
     libssh2_hmac_update(ctx, packet, packet_len);
-    if (addtl && addtl_len) {
+    if(addtl && addtl_len) {
         libssh2_hmac_update(ctx, addtl, addtl_len);
     }
     libssh2_hmac_final(ctx, buf);
@@ -208,7 +208,7 @@ mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session,
     libssh2_hmac_sha1_init(&ctx, *abstract, 20);
     libssh2_hmac_update(ctx, seqno_buf, 4);
     libssh2_hmac_update(ctx, packet, packet_len);
-    if (addtl && addtl_len) {
+    if(addtl && addtl_len) {
         libssh2_hmac_update(ctx, addtl, addtl_len);
     }
     libssh2_hmac_final(ctx, buf);
@@ -281,7 +281,7 @@ mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf,
     libssh2_hmac_md5_init(&ctx, *abstract, 16);
     libssh2_hmac_update(ctx, seqno_buf, 4);
     libssh2_hmac_update(ctx, packet, packet_len);
-    if (addtl && addtl_len) {
+    if(addtl && addtl_len) {
         libssh2_hmac_update(ctx, addtl, addtl_len);
     }
     libssh2_hmac_final(ctx, buf);
@@ -354,7 +354,7 @@ mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session,
     libssh2_hmac_ripemd160_init(&ctx, *abstract, 20);
     libssh2_hmac_update(ctx, seqno_buf, 4);
     libssh2_hmac_update(ctx, packet, packet_len);
-    if (addtl && addtl_len) {
+    if(addtl && addtl_len) {
         libssh2_hmac_update(ctx, addtl, addtl_len);
     }
     libssh2_hmac_final(ctx, buf);
diff --git a/src/mbedtls.c b/src/mbedtls.c
index c0ecd18e..4df24a83 100644
--- a/src/mbedtls.c
+++ b/src/mbedtls.c
@@ -18,7 +18,7 @@ _libssh2_mbedtls_init(void)
     ret = mbedtls_ctr_drbg_seed(&_libssh2_mbedtls_ctr_drbg,
                                 mbedtls_entropy_func,
                                 &_libssh2_mbedtls_entropy, NULL, 0);
-    if (ret != 0)
+    if(ret != 0)
         mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg);
 }
 
@@ -44,11 +44,11 @@ _libssh2_mbedtls_safe_free(void *buf, int len)
     (void)len;
 #endif
 
-    if (!buf)
+    if(!buf)
         return;
 
 #ifdef LIBSSH2_CLEAR_MEMORY
-    if (len > 0)
+    if(len > 0)
         memset(buf, 0, len);
 #endif
 
@@ -65,7 +65,7 @@ _libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
     const mbedtls_cipher_info_t *cipher_info;
     int ret, op;
 
-    if (!ctx)
+    if(!ctx)
         return -1;
 
     op = encrypt == 0 ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT;
@@ -99,11 +99,10 @@ _libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
     (void) encrypt;
     (void) algo;
 
-    osize = blocklen+mbedtls_cipher_get_block_size(ctx);
+    osize = blocklen + mbedtls_cipher_get_block_size(ctx);
 
     output = (unsigned char *)mbedtls_calloc(osize, sizeof(char));
-    if(output)
-    {
+    if(output) {
         ret = mbedtls_cipher_reset(ctx);
 
         if(!ret)
@@ -112,7 +111,7 @@ _libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
         if(!ret)
             ret = mbedtls_cipher_finish(ctx, output + olen, &finish_olen);
 
-        if (!ret) {
+        if(!ret) {
             olen += finish_olen;
             memcpy(block, output, olen);
         }
@@ -148,8 +147,8 @@ _libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
 
     mbedtls_md_init(ctx);
     ret = mbedtls_md_setup(ctx, md_info, hmac);
-    if (!ret){
-        if (hmac)
+    if(!ret) {
+        if(hmac)
             ret = mbedtls_md_hmac_starts(ctx, key, keylen);
         else
             ret = mbedtls_md_starts(ctx);
@@ -196,7 +195,7 @@ _libssh2_mbedtls_bignum_init(void)
     _libssh2_bn *bignum;
 
     bignum = (_libssh2_bn *)mbedtls_calloc(1, sizeof(_libssh2_bn));
-    if (bignum) {
+    if(bignum) {
         mbedtls_mpi_init(bignum);
     }
 
@@ -210,18 +209,18 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
     int err;
     int i;
 
-    if (!bn || bits <= 0)
+    if(!bn || bits <= 0)
         return -1;
 
     len = (bits + 7) >> 3;
     err = mbedtls_mpi_fill_random(bn, len, mbedtls_ctr_drbg_random, &_libssh2_mbedtls_ctr_drbg);
-    if (err)
+    if(err)
         return -1;
 
     /* Zero unsued bits above the most significant bit*/
-    for(i=len*8-1;bits<=i;--i) {
+    for(i = len*8 - 1; bits <= i; --i) {
         err = mbedtls_mpi_set_bit(bn, i, 0);
-        if (err)
+        if(err)
             return -1;
     }
 
@@ -230,16 +229,16 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
        and if top is 1, the two most significant bits of the number will be set
        to 1, so that the product of two such random numbers will always have 2*bits length.
     */
-    for(i=0;i<=top;++i) {
+    for(i = 0; i <= top; ++i) {
         err = mbedtls_mpi_set_bit(bn, bits-i-1, 1);
-        if (err)
+        if(err)
             return -1;
     }
 
     /* make odd by setting first bit in least significant byte */
-    if (bottom) {
+    if(bottom) {
         err = mbedtls_mpi_set_bit(bn, 0, 1);
-        if (err)
+        if(err)
             return -1;
     }
 
@@ -275,42 +274,37 @@ _libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
     libssh2_rsa_ctx *ctx;
 
     ctx = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
-    if (ctx != NULL) {
+    if(ctx != NULL) {
         mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V15, 0);
     }
     else
         return -1;
 
-    if( (ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 ||
-        (ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0 )
-    {
+    if((ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 ||
+       (ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0) {
         ret = -1;
     }
 
-    if (!ret)
-    {
+    if(!ret) {
         ctx->len = mbedtls_mpi_size(&(ctx->N));
     }
 
-    if (!ret && ddata)
-    {
-        if( (ret = mbedtls_mpi_read_binary(&(ctx->D) , ddata, dlen) ) != 0 ||
-            (ret = mbedtls_mpi_read_binary(&(ctx->P) , pdata, plen) ) != 0 ||
-            (ret = mbedtls_mpi_read_binary(&(ctx->Q) , qdata, qlen) ) != 0 ||
-            (ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 ||
-            (ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 ||
-            (ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) ) != 0 )
-        {
+    if(!ret && ddata) {
+        if((ret = mbedtls_mpi_read_binary(&(ctx->D), ddata, dlen) ) != 0 ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->P), pdata, plen) ) != 0 ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->Q), qdata, qlen) ) != 0 ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) ) != 0) {
             ret = -1;
         }
         ret = mbedtls_rsa_check_privkey(ctx);
     }
-    else if (!ret)
-    {
+    else if(!ret) {
         ret = mbedtls_rsa_check_pubkey(ctx);
     }
 
-    if (ret && ctx) {
+    if(ret && ctx) {
         _libssh2_mbedtls_rsa_free(ctx);
         ctx = NULL;
     }
@@ -328,15 +322,14 @@ _libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
     mbedtls_pk_context pkey;
 
     *rsa = (libssh2_rsa_ctx *) LIBSSH2_ALLOC(session, sizeof(libssh2_rsa_ctx));
-    if (*rsa == NULL)
+    if(*rsa == NULL)
         return -1;
 
     mbedtls_rsa_init(*rsa, MBEDTLS_RSA_PKCS_V15, 0);
     mbedtls_pk_init(&pkey);
 
     ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase);
-    if( ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA)
-    {
+    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
         mbedtls_pk_free(&pkey);
         mbedtls_rsa_free(*rsa);
         LIBSSH2_FREE(session, *rsa);
@@ -361,16 +354,15 @@ _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
     int ret;
     mbedtls_pk_context pkey;
 
-    *rsa = (libssh2_rsa_ctx *) mbedtls_calloc( 1, sizeof( libssh2_rsa_ctx ) );
-    if (*rsa == NULL)
+    *rsa = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
+    if(*rsa == NULL)
         return -1;
 
     mbedtls_pk_init(&pkey);
 
     ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata,
                               filedata_len, NULL, 0);
-    if( ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA)
-    {
+    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
         mbedtls_pk_free(&pkey);
         mbedtls_rsa_free(*rsa);
         LIBSSH2_FREE(session, *rsa);
@@ -421,14 +413,14 @@ _libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
 
     sig_len = rsa->len;
     sig = LIBSSH2_ALLOC(session, sig_len);
-    if (!sig) {
+    if(!sig) {
         return -1;
     }
 
     ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
                                  MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
                                  hash, sig);
-    if (ret) {
+    if(ret) {
         LIBSSH2_FREE(session, sig);
         return -1;
     }
@@ -453,8 +445,8 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
 {
     int            e_bytes, n_bytes;
     unsigned long  len;
-    unsigned char* key;
-    unsigned char* p;
+    unsigned char *key;
+    unsigned char *p;
 
     e_bytes = mbedtls_mpi_size(&rsa->E);
     n_bytes = mbedtls_mpi_size(&rsa->N);
@@ -463,7 +455,7 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
     len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
 
     key = LIBSSH2_ALLOC(session, len);
-    if (!key) {
+    if(!key) {
         return NULL;
     }
 
@@ -499,35 +491,36 @@ _libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
     size_t keylen = 0, mthlen = 0;
     int ret;
 
-    if( mbedtls_pk_get_type(pkey) != MBEDTLS_PK_RSA )
-    {
+    if(mbedtls_pk_get_type(pkey) != MBEDTLS_PK_RSA) {
         mbedtls_pk_free(pkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Key type not supported");
     }
 
-    // write method
+    /* write method */
     mthlen = 7;
     mth = LIBSSH2_ALLOC(session, mthlen);
-    if (mth) {
+    if(mth) {
         memcpy(mth, "ssh-rsa", mthlen);
-    } else {
+    }
+    else {
         ret = -1;
     }
 
     mbedtls_rsa_context *rsa = mbedtls_pk_rsa(*pkey);
     key = gen_publickey_from_rsa(session, rsa, &keylen);
-    if (key == NULL) {
+    if(key == NULL) {
         ret = -1;
     }
 
-    // write output
-    if (ret) {
-        if (mth)
+    /* write output */
+    if(ret) {
+        if(mth)
             LIBSSH2_FREE(session, mth);
-        if (key)
+        if(key)
             LIBSSH2_FREE(session, key);
-    } else {
+    }
+    else {
         *method = mth;
         *method_len = mthlen;
         *pubkeydata = key;
@@ -552,8 +545,7 @@ _libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
 
     mbedtls_pk_init(&pkey);
     ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase);
-    if( ret != 0 )
-    {
+    if(ret != 0) {
         mbedtls_strerror(ret, (char *)buf, sizeof(buf));
         mbedtls_pk_free(&pkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
@@ -584,8 +576,7 @@ _libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     mbedtls_pk_init(&pkey);
     ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)privatekeydata,
                               privatekeydata_len, NULL, 0);
-    if( ret != 0 )
-    {
+    if(ret != 0) {
         mbedtls_strerror(ret, (char *)buf, sizeof(buf));
         mbedtls_pk_free(&pkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
diff --git a/src/misc.c b/src/misc.c
index 52b5fb1c..f6032015 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -51,18 +51,18 @@
 #include <stdio.h>
 #include <errno.h>
 
-int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errmsg, int errflags)
+int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char *errmsg, int errflags)
 {
-    if (session->err_flags & LIBSSH2_ERR_FLAG_DUP)
+    if(session->err_flags & LIBSSH2_ERR_FLAG_DUP)
         LIBSSH2_FREE(session, (char *)session->err_msg);
 
     session->err_code = errcode;
     session->err_flags = 0;
 
-    if ((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
+    if((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
         size_t len = strlen(errmsg);
         char *copy = LIBSSH2_ALLOC(session, len + 1);
-        if (copy) {
+        if(copy) {
             memcpy(copy, errmsg, len + 1);
             session->err_flags = LIBSSH2_ERR_FLAG_DUP;
             session->err_msg = copy;
@@ -86,7 +86,7 @@ int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errm
     return errcode;
 }
 
-int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg)
+int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg)
 {
     return _libssh2_error_flags(session, errcode, errmsg, 0);
 }
@@ -94,7 +94,7 @@ int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg)
 #ifdef WIN32
 static int wsa2errno(void)
 {
-    switch (WSAGetLastError()) {
+    switch(WSAGetLastError()) {
     case WSAEWOULDBLOCK:
         return EAGAIN;
 
@@ -127,20 +127,20 @@ _libssh2_recv(libssh2_socket_t sock, void *buffer, size_t length,
 
     rc = recv(sock, buffer, length, flags);
 #ifdef WIN32
-    if (rc < 0 )
+    if(rc < 0)
         return -wsa2errno();
 #elif defined(__VMS)
-    if (rc < 0 ){
-        if ( errno == EWOULDBLOCK )
+    if(rc < 0) {
+        if(errno == EWOULDBLOCK)
             return -EAGAIN;
         else
             return -errno;
     }
 #else
-    if (rc < 0 ){
+    if(rc < 0) {
         /* Sometimes the first recv() function call sets errno to ENOENT on
            Solaris and HP-UX */
-        if ( errno == ENOENT )
+        if(errno == ENOENT)
             return -EAGAIN;
         else
             return -errno;
@@ -163,17 +163,17 @@ _libssh2_send(libssh2_socket_t sock, const void *buffer, size_t length,
 
     rc = send(sock, buffer, length, flags);
 #ifdef WIN32
-    if (rc < 0 )
+    if(rc < 0)
         return -wsa2errno();
 #elif defined(__VMS)
-    if (rc < 0 ) {
-        if ( errno == EWOULDBLOCK )
+    if(rc < 0) {
+        if(errno == EWOULDBLOCK)
             return -EAGAIN;
         else
             return -errno;
     }
 #else
-    if (rc < 0 )
+    if(rc < 0)
         return -errno;
 #endif
     return rc;
@@ -269,15 +269,16 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
 
     *data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1);
     d = (unsigned char *) *data;
-    if (!d) {
+    if(!d) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for base64 decoding");
     }
 
     for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) {
-        if ((v = base64_reverse_table[*s]) < 0)
+        v = base64_reverse_table[*s];
+        if(v < 0)
             continue;
-        switch (i % 4) {
+        switch(i % 4) {
         case 0:
             d[len] = (unsigned char)(v << 2);
             break;
@@ -295,7 +296,7 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
         }
         i++;
     }
-    if ((i % 4) == 1) {
+    if((i % 4) == 1) {
         /* Invalid -- We have a byte which belongs exclusively to a partial
            octet */
         LIBSSH2_FREE(session, *data);
@@ -322,68 +323,68 @@ static const char table64[]=
 size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
                               const char *inp, size_t insize, char **outptr)
 {
-  unsigned char ibuf[3];
-  unsigned char obuf[4];
-  int i;
-  int inputparts;
-  char *output;
-  char *base64data;
-  const char *indata = inp;
+    unsigned char ibuf[3];
+    unsigned char obuf[4];
+    int i;
+    int inputparts;
+    char *output;
+    char *base64data;
+    const char *indata = inp;
 
-  *outptr = NULL; /* set to NULL in case of failure before we reach the end */
+    *outptr = NULL; /* set to NULL in case of failure before we reach the end */
 
-  if(0 == insize)
-    insize = strlen(indata);
+    if(0 == insize)
+        insize = strlen(indata);
 
-  base64data = output = LIBSSH2_ALLOC(session, insize*4/3+4);
-  if(NULL == output)
-    return 0;
+    base64data = output = LIBSSH2_ALLOC(session, insize * 4 / 3 + 4);
+    if(NULL == output)
+        return 0;
 
-  while(insize > 0) {
-    for (i = inputparts = 0; i < 3; i++) {
-      if(insize > 0) {
-        inputparts++;
-        ibuf[i] = *indata;
-        indata++;
-        insize--;
-      }
-      else
-        ibuf[i] = 0;
+    while(insize > 0) {
+        for(i = inputparts = 0; i < 3; i++) {
+            if(insize > 0) {
+                inputparts++;
+                ibuf[i] = *indata;
+                indata++;
+                insize--;
+            }
+            else
+                ibuf[i] = 0;
+        }
+
+        obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
+        obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
+                                   ((ibuf[1] & 0xF0) >> 4));
+        obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
+                                   ((ibuf[2] & 0xC0) >> 6));
+        obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);
+
+        switch(inputparts) {
+        case 1: /* only one byte read */
+            snprintf(output, 5, "%c%c==",
+                     table64[obuf[0]],
+                     table64[obuf[1]]);
+            break;
+        case 2: /* two bytes read */
+            snprintf(output, 5, "%c%c%c=",
+                     table64[obuf[0]],
+                     table64[obuf[1]],
+                     table64[obuf[2]]);
+            break;
+        default:
+            snprintf(output, 5, "%c%c%c%c",
+                     table64[obuf[0]],
+                     table64[obuf[1]],
+                     table64[obuf[2]],
+                     table64[obuf[3]]);
+            break;
+        }
+        output += 4;
     }
+    *output = 0;
+    *outptr = base64data; /* make it return the actual data memory */
 
-    obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
-    obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
-                               ((ibuf[1] & 0xF0) >> 4));
-    obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
-                               ((ibuf[2] & 0xC0) >> 6));
-    obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);
-
-    switch(inputparts) {
-    case 1: /* only one byte read */
-      snprintf(output, 5, "%c%c==",
-               table64[obuf[0]],
-               table64[obuf[1]]);
-      break;
-    case 2: /* two bytes read */
-      snprintf(output, 5, "%c%c%c=",
-               table64[obuf[0]],
-               table64[obuf[1]],
-               table64[obuf[2]]);
-      break;
-    default:
-      snprintf(output, 5, "%c%c%c%c",
-               table64[obuf[0]],
-               table64[obuf[1]],
-               table64[obuf[2]],
-               table64[obuf[3]] );
-      break;
-    }
-    output += 4;
-  }
-  *output=0;
-  *outptr = base64data; /* make it return the actual data memory */
-
-  return strlen(base64data); /* return the length of the new data */
+    return strlen(base64data); /* return the length of the new data */
 }
 /* ---- End of Base64 Encoding ---- */
 
@@ -404,7 +405,7 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
 }
 
 LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context,
+libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
                          libssh2_trace_handler_func callback)
 {
     session->tracehandler = callback;
@@ -432,18 +433,18 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
         "Publickey",
         "Socket",
     };
-    const char* contexttext = contexts[0];
+    const char *contexttext = contexts[0];
     unsigned int contextindex;
 
-    if (!(session->showmask & context)) {
+    if(!(session->showmask & context)) {
         /* no such output asked for */
         return;
     }
 
     /* Find the first matching context string for this message */
-    for (contextindex = 0; contextindex < ARRAY_SIZE(contexts);
+    for(contextindex = 0; contextindex < ARRAY_SIZE(contexts);
          contextindex++) {
-        if ((context & (1 << contextindex)) != 0) {
+        if((context & (1 << contextindex)) != 0) {
             contexttext = contexts[contextindex];
             break;
         }
@@ -458,7 +459,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
     len = snprintf(buffer, buflen, "[libssh2] %d.%06d %s: ",
                    (int)now.tv_sec, (int)now.tv_usec, contexttext);
 
-    if (len >= buflen)
+    if(len >= buflen)
         msglen = buflen - 1;
     else {
         buflen -= len;
@@ -469,7 +470,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
         msglen += len < buflen ? len : buflen - 1;
     }
 
-    if (session->tracehandler)
+    if(session->tracehandler)
         (session->tracehandler)(session, session->tracehandler_context, buffer,
                                 msglen);
     else
@@ -486,7 +487,7 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
 }
 
 LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context,
+libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
                          libssh2_trace_handler_func callback)
 {
     (void) session;
@@ -616,21 +617,20 @@ void _libssh2_list_insert(struct list_node *after, /* insert before this */
 #define _W32_FT_OFFSET (116444736000000000)
 
 int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp)
- {
-  union {
-    unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */
-    FILETIME ft;
-  }  _now;
-  (void)tzp;
-  if(tp)
-    {
-      GetSystemTimeAsFileTime (&_now.ft);
-      tp->tv_usec=(long)((_now.ns100 / 10) % 1000000 );
-      tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
+{
+    union {
+        unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */
+        FILETIME ft;
+    } _now;
+    (void)tzp;
+    if(tp) {
+        GetSystemTimeAsFileTime(&_now.ft);
+        tp->tv_usec = (long)((_now.ns100 / 10) % 1000000);
+        tp->tv_sec = (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
     }
-  /* Always return 0 as per Open Group Base Specifications Issue 6.
-     Do not set errno on error.  */
-  return 0;
+    /* Always return 0 as per Open Group Base Specifications Issue 6.
+       Do not set errno on error.  */
+    return 0;
 }
 
 
@@ -654,7 +654,7 @@ void _libssh2_xor_data(unsigned char *output,
 {
     size_t i;
 
-    for (i = 0; i < length; i++)
+    for(i = 0; i < length; i++)
         *output++ = *input1++ ^ *input2++;
 }
 
@@ -665,12 +665,11 @@ void _libssh2_aes_ctr_increment(unsigned char *ctr,
 {
     unsigned char *pc;
     unsigned int val, carry;
-  
+
     pc = ctr + length - 1;
     carry = 1;
 
-    while(pc >= ctr)
-    {
+    while(pc >= ctr) {
         val = (unsigned int)*pc + carry;
         *pc-- = val & 0xFF;
         carry = val >> 8;
diff --git a/src/misc.h b/src/misc.h
index 44e2996d..0e63b031 100644
--- a/src/misc.h
+++ b/src/misc.h
@@ -49,8 +49,8 @@ struct list_node {
     struct list_head *head;
 };
 
-int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errmsg, int errflags);
-int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg);
+int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char *errmsg, int errflags);
+int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg);
 
 void _libssh2_list_init(struct list_head *head);
 
diff --git a/src/openssl.c b/src/openssl.c
index c04955f8..41aa2ba0 100644
--- a/src/openssl.c
+++ b/src/openssl.c
@@ -59,7 +59,7 @@ write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
 
     *p = 0;
     BN_bn2bin(bn, p + 1);
-    if (!(*(p + 1) & 0x80)) {
+    if(!(*(p + 1) & 0x80)) {
         memmove(p, p + 1, --bn_bytes);
     }
     _libssh2_htonu32(p - 4, bn_bytes);  /* Post write bn size. */
@@ -100,7 +100,7 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
     n = BN_new();
     BN_bin2bn(ndata, nlen, n);
 
-    if (ddata) {
+    if(ddata) {
         d = BN_new();
         BN_bin2bn(ddata, dlen, d);
 
@@ -154,7 +154,7 @@ _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
     unsigned char hash[SHA_DIGEST_LENGTH];
     int ret;
 
-    if (_libssh2_sha1(m, m_len, hash))
+    if(_libssh2_sha1(m, m_len, hash))
         return -1; /* failure */
     ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,
                      (unsigned char *) sig, sig_len, rsactx);
@@ -192,7 +192,7 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
     pub_key = BN_new();
     BN_bin2bn(y, y_len, pub_key);
 
-    if (x_len) {
+    if(x_len) {
         priv_key = BN_new();
         BN_bin2bn(x, x_len, priv_key);
     }
@@ -239,7 +239,7 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
     dsasig->r = r;
     dsasig->s = s;
 #endif
-    if (!_libssh2_sha1(m, m_len, hash))
+    if(!_libssh2_sha1(m, m_len, hash))
         /* _libssh2_sha1() succeeded */
         ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);
 
@@ -276,20 +276,20 @@ _libssh2_ecdsa_curve_type_from_name(const char *name, libssh2_curve_type *out_ty
     int ret = 0;
     libssh2_curve_type type;
 
-    if ( name == NULL || strlen(name) != 19 )
+    if(name == NULL || strlen(name) != 19)
         return -1;
 
-    if ( strcmp(name, "ecdsa-sha2-nistp256") == 0)
+    if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
         type = LIBSSH2_EC_CURVE_NISTP256;
-    else if ( strcmp(name, "ecdsa-sha2-nistp384") == 0)
+    else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)
         type = LIBSSH2_EC_CURVE_NISTP384;
-    else if ( strcmp(name, "ecdsa-sha2-nistp521") == 0)
+    else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
         type = LIBSSH2_EC_CURVE_NISTP521;
     else {
         ret = -1;
     }
 
-    if (ret == 0 && out_type) {
+    if(ret == 0 && out_type) {
         *out_type = type;
     }
 
@@ -313,16 +313,16 @@ _libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,
     EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
     EC_POINT *point = NULL;
 
-    if ( ec_key ) {
+    if(ec_key) {
         ec_group = EC_KEY_get0_group(ec_key);
         point = EC_POINT_new(ec_group);
         ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
         ret = EC_KEY_set_public_key(ec_key, point);
 
-        if (point != NULL)
+        if(point != NULL)
             EC_POINT_free(point);
 
-        if ( ec_ctx != NULL )
+        if(ec_ctx != NULL)
             *ec_ctx = ec_key;
     }
 
@@ -366,16 +366,18 @@ _libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
     BN_bin2bn(s, s_len, ecdsa_sig_.s);
 #endif
 
-    if ( type == LIBSSH2_EC_CURVE_NISTP256 ) {
+    if(type == LIBSSH2_EC_CURVE_NISTP256) {
         LIBSSH2_ECDSA_VERIFY(256);
-    }else if ( type == LIBSSH2_EC_CURVE_NISTP384 ) {
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
         LIBSSH2_ECDSA_VERIFY(384);
-    }else if ( type == LIBSSH2_EC_CURVE_NISTP521 ) {
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
         LIBSSH2_ECDSA_VERIFY(512);
     }
 
 #if HAVE_OPAQUE_STRUCTS
-    if ( ecdsa_sig )
+    if(ecdsa_sig)
         ECDSA_SIG_free(ecdsa_sig);
 #else
     BN_clear_free(ecdsa_sig_.s);
@@ -416,7 +418,7 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
 #else
     ret = EVP_Cipher(ctx, buf, block, blocksize);
 #endif
-    if (ret == 1) {
+    if(ret == 1) {
         memcpy(block, buf, blocksize);
     }
     return ret == 1 ? 0 : 1;
@@ -446,7 +448,7 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
     const EVP_CIPHER *aes_cipher;
     (void) enc;
 
-    switch (EVP_CIPHER_CTX_key_length(ctx)) {
+    switch(EVP_CIPHER_CTX_key_length(ctx)) {
     case 16:
         aes_cipher = EVP_aes_128_ecb();
         break;
@@ -461,7 +463,7 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
     }
 
     c = malloc(sizeof(*c));
-    if (c == NULL)
+    if(c == NULL)
         return 0;
 
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -469,12 +471,12 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 #else
     c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));
 #endif
-    if (c->aes_ctx == NULL) {
+    if(c->aes_ctx == NULL) {
         free(c);
         return 0;
     }
 
-    if (EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
+    if(EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
 #ifdef HAVE_OPAQUE_STRUCTS
         EVP_CIPHER_CTX_free(c->aes_ctx);
 #else
@@ -502,10 +504,10 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
     unsigned char b1[AES_BLOCK_SIZE];
     int outlen = 0;
 
-    if (inl != 16) /* libssh2 only ever encrypt one block */
+    if(inl != 16) /* libssh2 only ever encrypt one block */
         return 0;
 
-    if (c == NULL) {
+    if(c == NULL) {
         return 0;
     }
 
@@ -516,7 +518,7 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
   the ciphertext block C1.  The counter X is then incremented
 */
 
-    if (EVP_EncryptUpdate(c->aes_ctx, b1, &outlen, c->ctr, AES_BLOCK_SIZE) != 1) {
+    if(EVP_EncryptUpdate(c->aes_ctx, b1, &outlen, c->ctr, AES_BLOCK_SIZE) != 1) {
         return 0;
     }
 
@@ -531,11 +533,11 @@ aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */
 {
     aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
 
-    if (c == NULL) {
+    if(c == NULL) {
         return 1;
     }
 
-    if (c->aes_ctx != NULL) {
+    if(c->aes_ctx != NULL) {
 #ifdef HAVE_OPAQUE_STRUCTS
         EVP_CIPHER_CTX_free(c->aes_ctx);
 #else
@@ -554,7 +556,7 @@ make_ctr_evp (size_t keylen, EVP_CIPHER *aes_ctr_cipher, int type)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen);
-    if (aes_ctr_cipher) {
+    if(aes_ctr_cipher) {
         EVP_CIPHER_meth_set_iv_length(aes_ctr_cipher, 16);
         EVP_CIPHER_meth_set_init(aes_ctr_cipher, aes_ctr_init);
         EVP_CIPHER_meth_set_do_cipher(aes_ctr_cipher, aes_ctr_do_cipher);
@@ -578,12 +580,12 @@ _libssh2_EVP_aes_128_ctr(void)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     static EVP_CIPHER * aes_ctr_cipher;
-    return !aes_ctr_cipher?
-        make_ctr_evp (16, aes_ctr_cipher, NID_aes_128_ctr) : aes_ctr_cipher;
+    return !aes_ctr_cipher ?
+        make_ctr_evp(16, aes_ctr_cipher, NID_aes_128_ctr) : aes_ctr_cipher;
 #else
     static EVP_CIPHER aes_ctr_cipher;
-    return !aes_ctr_cipher.key_len?
-        make_ctr_evp (16, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
+    return !aes_ctr_cipher.key_len ?
+        make_ctr_evp(16, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
 #endif
 }
 
@@ -592,12 +594,12 @@ _libssh2_EVP_aes_192_ctr(void)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     static EVP_CIPHER * aes_ctr_cipher;
-    return !aes_ctr_cipher?
-        make_ctr_evp (24, aes_ctr_cipher, NID_aes_192_ctr) : aes_ctr_cipher;
+    return !aes_ctr_cipher ?
+        make_ctr_evp(24, aes_ctr_cipher, NID_aes_192_ctr) : aes_ctr_cipher;
 #else
     static EVP_CIPHER aes_ctr_cipher;
-    return !aes_ctr_cipher.key_len?
-        make_ctr_evp (24, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
+    return !aes_ctr_cipher.key_len ?
+        make_ctr_evp(24, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
 #endif
 }
 
@@ -606,12 +608,12 @@ _libssh2_EVP_aes_256_ctr(void)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     static EVP_CIPHER * aes_ctr_cipher;
-    return !aes_ctr_cipher?
-        make_ctr_evp (32, aes_ctr_cipher, NID_aes_256_ctr) : aes_ctr_cipher;
+    return !aes_ctr_cipher ?
+        make_ctr_evp(32, aes_ctr_cipher, NID_aes_256_ctr) : aes_ctr_cipher;
 #else
     static EVP_CIPHER aes_ctr_cipher;
-    return !aes_ctr_cipher.key_len?
-        make_ctr_evp (32, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
+    return !aes_ctr_cipher.key_len ?
+        make_ctr_evp(32, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
 #endif
 }
 
@@ -635,7 +637,7 @@ passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
     int passphrase_len = strlen(passphrase);
     (void) rwflag;
 
-    if (passphrase_len > (size - 1)) {
+    if(passphrase_len > (size - 1)) {
         passphrase_len = size - 1;
     }
     memcpy(buf, passphrase, passphrase_len);
@@ -645,12 +647,12 @@ passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
 }
 
 typedef void * (*pem_read_bio_func)(BIO *, void **, pem_password_cb *,
-                                    void * u);
+                                    void *u);
 
 static int
-read_private_key_from_memory(void ** key_ctx,
+read_private_key_from_memory(void **key_ctx,
                              pem_read_bio_func read_private_key,
-                             const char * filedata,
+                             const char *filedata,
                              size_t filedata_len,
                              unsigned const char *passphrase)
 {
@@ -659,7 +661,7 @@ read_private_key_from_memory(void ** key_ctx,
     *key_ctx = NULL;
 
     bp = BIO_new_mem_buf((char *)filedata, filedata_len);
-    if (!bp) {
+    if(!bp) {
         return -1;
     }
     *key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,
@@ -670,9 +672,9 @@ read_private_key_from_memory(void ** key_ctx,
 }
 
 static int
-read_private_key_from_file(void ** key_ctx,
+read_private_key_from_file(void **key_ctx,
                            pem_read_bio_func read_private_key,
-                           const char * filename,
+                           const char *filename,
                            unsigned const char *passphrase)
 {
     BIO * bp;
@@ -680,7 +682,7 @@ read_private_key_from_file(void ** key_ctx,
     *key_ctx = NULL;
 
     bp = BIO_new_file(filename, "r");
-    if (!bp) {
+    if(!bp) {
         return -1;
     }
 
@@ -716,7 +718,7 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
         (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
     (void) session;
 
-    _libssh2_init_if_needed ();
+    _libssh2_init_if_needed();
 
     return read_private_key_from_file((void **) rsa, read_rsa,
                                       filename, passphrase);
@@ -748,7 +750,7 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
         (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
     (void) session;
 
-    _libssh2_init_if_needed ();
+    _libssh2_init_if_needed();
 
     return read_private_key_from_file((void **) dsa, read_dsa,
                                       filename, passphrase);
@@ -781,7 +783,7 @@ _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
     pem_read_bio_func read_ec = (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
     (void) session;
 
-    _libssh2_init_if_needed ();
+    _libssh2_init_if_needed();
 
     return read_private_key_from_file((void **) ec_ctx, read_ec,
       filename, passphrase);
@@ -804,13 +806,13 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
     sig_len = RSA_size(rsactx);
     sig = LIBSSH2_ALLOC(session, sig_len);
 
-    if (!sig) {
+    if(!sig) {
         return -1;
     }
 
     ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
 
-    if (!ret) {
+    if(!ret) {
         LIBSSH2_FREE(session, sig);
         return -1;
     }
@@ -834,7 +836,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     (void) hash_len;
 
     sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx);
-    if (!sig) {
+    if(!sig) {
         return -1;
     }
 
@@ -845,12 +847,12 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     s = sig->s;
 #endif
     r_len = BN_num_bytes(r);
-    if (r_len < 1 || r_len > 20) {
+    if(r_len < 1 || r_len > 20) {
         DSA_SIG_free(sig);
         return -1;
     }
     s_len = BN_num_bytes(s);
-    if (s_len < 1 || s_len > 20) {
+    if(s_len < 1 || s_len > 20) {
         DSA_SIG_free(sig);
         return -1;
     }
@@ -882,7 +884,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     unsigned char *out_buffer = NULL;
 
     ECDSA_SIG *sig = ECDSA_do_sign(hash, hash_len, ec_ctx);
-    if ( sig == NULL )
+    if(sig == NULL)
         return -1;
 #if HAVE_OPAQUE_STRUCTS
     ECDSA_SIG_get0(sig, &pr, &ps);
@@ -895,7 +897,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     s_len = BN_num_bytes(ps) + 1;
 
     temp_buffer = malloc(r_len + s_len + 8);
-    if ( temp_buffer == NULL ) {
+    if(temp_buffer == NULL) {
         rc = -1;
         goto clean_exit;
     }
@@ -907,7 +909,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     out_buffer_len = (size_t)(sp - temp_buffer);
 
     out_buffer = LIBSSH2_CALLOC(session, out_buffer_len);
-    if ( out_buffer == NULL ) {
+    if(out_buffer == NULL) {
         rc = -1;
         goto clean_exit;
     }
@@ -919,10 +921,10 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
 
 clean_exit:
 
-    if ( temp_buffer != NULL )
+    if(temp_buffer != NULL)
         free(temp_buffer);
 
-    if ( sig )
+    if(sig)
         ECDSA_SIG_free(sig);
 
     return rc;
@@ -935,10 +937,10 @@ _libssh2_sha1_init(libssh2_sha1_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if (*ctx == NULL)
+    if(*ctx == NULL)
         return 0;
 
-    if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1")))
+    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1")))
         return 1;
 
     EVP_MD_CTX_free(*ctx);
@@ -958,10 +960,10 @@ _libssh2_sha1(const unsigned char *message, unsigned long len,
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if (ctx == NULL)
+    if(ctx == NULL)
         return 1; /* error */
 
-    if (EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) {
+    if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) {
         EVP_DigestUpdate(ctx, message, len);
         EVP_DigestFinal(ctx, out, NULL);
         EVP_MD_CTX_free(ctx);
@@ -972,7 +974,7 @@ _libssh2_sha1(const unsigned char *message, unsigned long len,
     EVP_MD_CTX ctx;
 
     EVP_MD_CTX_init(&ctx);
-    if (EVP_DigestInit(&ctx, EVP_get_digestbyname("sha1"))) {
+    if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha1"))) {
         EVP_DigestUpdate(&ctx, message, len);
         EVP_DigestFinal(&ctx, out, NULL);
         return 0; /* success */
@@ -987,10 +989,10 @@ _libssh2_sha256_init(libssh2_sha256_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if (*ctx == NULL)
+    if(*ctx == NULL)
         return 0;
 
-    if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256")))
+    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256")))
         return 1;
 
     EVP_MD_CTX_free(*ctx);
@@ -1010,7 +1012,7 @@ _libssh2_sha256(const unsigned char *message, unsigned long len,
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if (ctx == NULL)
+    if(ctx == NULL)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"))) {
@@ -1039,10 +1041,10 @@ _libssh2_sha384_init(libssh2_sha384_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if (*ctx == NULL)
+    if(*ctx == NULL)
         return 0;
 
-    if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384")))
+    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384")))
         return 1;
 
     EVP_MD_CTX_free(*ctx);
@@ -1062,7 +1064,7 @@ _libssh2_sha384(const unsigned char *message, unsigned long len,
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if (ctx == NULL)
+    if(ctx == NULL)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"))) {
@@ -1091,10 +1093,10 @@ _libssh2_sha512_init(libssh2_sha512_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if (*ctx == NULL)
+    if(*ctx == NULL)
         return 0;
 
-    if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512")))
+    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512")))
         return 1;
 
     EVP_MD_CTX_free(*ctx);
@@ -1114,7 +1116,7 @@ _libssh2_sha512(const unsigned char *message, unsigned long len,
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if (ctx == NULL)
+    if(ctx == NULL)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"))) {
@@ -1143,10 +1145,10 @@ _libssh2_md5_init(libssh2_md5_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if (*ctx == NULL)
+    if(*ctx == NULL)
         return 0;
 
-    if (EVP_DigestInit(*ctx, EVP_get_digestbyname("md5")))
+    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("md5")))
         return 1;
 
     EVP_MD_CTX_free(*ctx);
@@ -1165,8 +1167,8 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
 {
     int            e_bytes, n_bytes;
     unsigned long  len;
-    unsigned char* key;
-    unsigned char* p;
+    unsigned char *key;
+    unsigned char *p;
     const BIGNUM * e;
     const BIGNUM * n;
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -1182,7 +1184,7 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
     len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
 
     key = LIBSSH2_ALLOC(session, len);
-    if (key == NULL) {
+    if(key == NULL) {
         return NULL;
     }
 
@@ -1208,8 +1210,8 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
 {
     int            p_bytes, q_bytes, g_bytes, k_bytes;
     unsigned long  len;
-    unsigned char* key;
-    unsigned char* p;
+    unsigned char *key;
+    unsigned char *p;
 
     const BIGNUM * p_bn;
     const BIGNUM * q;
@@ -1237,7 +1239,7 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
     len = 4 + 7 + 4 + p_bytes + 4 + q_bytes + 4 + g_bytes + 4 + k_bytes;
 
     key = LIBSSH2_ALLOC(session, len);
-    if (key == NULL) {
+    if(key == NULL) {
         return NULL;
     }
 
@@ -1268,8 +1270,8 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
                            EVP_PKEY *pk)
 {
     RSA*           rsa = NULL;
-    unsigned char* key;
-    unsigned char* method_buf = NULL;
+    unsigned char *key;
+    unsigned char *method_buf = NULL;
     size_t  key_len;
 
     _libssh2_debug(session,
@@ -1277,18 +1279,18 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
                    "Computing public key from RSA private key envelop");
 
     rsa = EVP_PKEY_get1_RSA(pk);
-    if (rsa == NULL) {
+    if(rsa == NULL) {
         /* Assume memory allocation error... what else could it be ? */
         goto __alloc_error;
     }
 
     method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-rsa. */
-    if (method_buf == NULL) {
+    if(method_buf == NULL) {
         goto __alloc_error;
     }
 
     key = gen_publickey_from_rsa(session, rsa, &key_len);
-    if (key == NULL) {
+    if(key == NULL) {
         goto __alloc_error;
     }
     RSA_free(rsa);
@@ -1301,10 +1303,10 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
     return 0;
 
   __alloc_error:
-    if (rsa != NULL) {
+    if(rsa != NULL) {
         RSA_free(rsa);
     }
-    if (method_buf != NULL) {
+    if(method_buf != NULL) {
         LIBSSH2_FREE(session, method_buf);
     }
 
@@ -1323,8 +1325,8 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
                            EVP_PKEY *pk)
 {
     DSA*           dsa = NULL;
-    unsigned char* key;
-    unsigned char* method_buf = NULL;
+    unsigned char *key;
+    unsigned char *method_buf = NULL;
     size_t  key_len;
 
     _libssh2_debug(session,
@@ -1332,18 +1334,18 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
                    "Computing public key from DSA private key envelop");
 
     dsa = EVP_PKEY_get1_DSA(pk);
-    if (dsa == NULL) {
+    if(dsa == NULL) {
         /* Assume memory allocation error... what else could it be ? */
         goto __alloc_error;
     }
 
     method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-dss. */
-    if (method_buf == NULL) {
+    if(method_buf == NULL) {
         goto __alloc_error;
     }
 
     key = gen_publickey_from_dsa(session, dsa, &key_len);
-    if (key == NULL) {
+    if(key == NULL) {
         goto __alloc_error;
     }
     DSA_free(dsa);
@@ -1356,10 +1358,10 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
     return 0;
 
   __alloc_error:
-    if (dsa != NULL) {
+    if(dsa != NULL) {
         DSA_free(dsa);
     }
-    if (method_buf != NULL) {
+    if(method_buf != NULL) {
         LIBSSH2_FREE(session, method_buf);
     }
 
@@ -1382,7 +1384,7 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     int rc = 0;
     EC_KEY *ec = NULL;
     unsigned char *p;
-    unsigned char* method_buf = NULL;
+    unsigned char *method_buf = NULL;
     unsigned char *key;
     size_t  key_len = 0;
     unsigned char *octal_value = NULL;
@@ -1397,11 +1399,11 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
        "Computing public key from EC private key envelop");
 
     bn_ctx = BN_CTX_new();
-    if ( bn_ctx == NULL )
+    if(bn_ctx == NULL)
         return -1;
 
     ec = EVP_PKEY_get1_EC_KEY(pk);
-    if ( ec == NULL ) {
+    if(ec == NULL) {
         rc = -1;
         goto clean_exit;
     }
@@ -1411,16 +1413,16 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     type = _libssh2_ecdsa_key_get_curve_type(ec);
 
     method_buf = LIBSSH2_ALLOC(session, 19);
-    if (method_buf == NULL) {
+    if(method_buf == NULL) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
             "out of memory");
     }
 
-    if ( type == LIBSSH2_EC_CURVE_NISTP256 )
+    if(type == LIBSSH2_EC_CURVE_NISTP256)
         memcpy(method_buf, "ecdsa-sha2-nistp256", 19);
-    else if ( type == LIBSSH2_EC_CURVE_NISTP384 )
+    else if(type == LIBSSH2_EC_CURVE_NISTP384)
         memcpy(method_buf, "ecdsa-sha2-nistp384", 19);
-    else if ( type == LIBSSH2_EC_CURVE_NISTP521 )
+    else if(type == LIBSSH2_EC_CURVE_NISTP521)
         memcpy(method_buf, "ecdsa-sha2-nistp521", 19);
     else {
         _libssh2_debug(session,
@@ -1432,19 +1434,19 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
 
     /* get length */
     octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx);
-    if (octal_len > EC_MAX_POINT_LEN) {
+    if(octal_len > EC_MAX_POINT_LEN) {
         rc = -1;
         goto clean_exit;
     }
 
     octal_value = malloc(octal_len);
-    if ( octal_value == NULL ) {
+    if(octal_value == NULL) {
         rc = -1;
         goto clean_exit;
     }
 
     /* convert to octal */
-    if (EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
+    if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
        octal_value, octal_len, bn_ctx) != octal_len) {
            rc = -1;
            goto clean_exit;
@@ -1453,7 +1455,7 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     /* Key form is: type_len(4) + type(19) + domain_len(4) + domain(8) + pub_key_len(4) + pub_key(~65). */
     key_len = 4 + 19 + 4 + 8 + 4 + octal_len;
     key = LIBSSH2_ALLOC(session, key_len);
-    if (key == NULL) {
+    if(key == NULL) {
         rc = -1;
         goto  clean_exit;
     }
@@ -1462,13 +1464,13 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     p = key;
 
     /* Key type */
-    _libssh2_store_str(&p, (const char*)method_buf, 19);
+    _libssh2_store_str(&p, (const char *)method_buf, 19);
 
     /* Name domain */
-    _libssh2_store_str(&p, (const char*)method_buf + 11, 8);
+    _libssh2_store_str(&p, (const char *)method_buf + 11, 8);
 
     /* Public key */
-    _libssh2_store_str(&p, (const char*)octal_value, octal_len);
+    _libssh2_store_str(&p, (const char *)octal_value, octal_len);
 
     *method         = method_buf;
     *method_len     = 19;
@@ -1477,20 +1479,20 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
 
 clean_exit:
 
-    if ( ec != NULL)
+    if(ec != NULL)
         EC_KEY_free(ec);
 
-    if (bn_ctx != NULL) {
+    if(bn_ctx != NULL) {
         BN_CTX_free(bn_ctx);
     }
 
-    if ( octal_value != NULL )
+    if(octal_value != NULL)
         free(octal_value);
 
-    if ( rc == 0 )
+    if(rc == 0)
         return 0;
 
-    if (method_buf != NULL )
+    if(method_buf != NULL)
         LIBSSH2_FREE(session, method_buf);
 
     return -1;
@@ -1518,7 +1520,7 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
 
     /* create key */
     BN_CTX *bn_ctx = BN_CTX_new();
-    if (!bn_ctx)
+    if(!bn_ctx)
         return -1;
 
     private_key = EC_KEY_new_by_curve_name(curve_type);
@@ -1529,24 +1531,24 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
 
     /* get length */
     octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx);
-    if (octal_len > EC_MAX_POINT_LEN) {
+    if(octal_len > EC_MAX_POINT_LEN) {
         ret = -1;
         goto clean_exit;
     }
 
     /* convert to octal */
-    if (EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
-       octal_value, octal_len, bn_ctx) != octal_len){
+    if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
+       octal_value, octal_len, bn_ctx) != octal_len) {
            ret = -1;
            goto clean_exit;
     }
 
-    if (out_private_key != NULL)
+    if(out_private_key != NULL)
         *out_private_key = private_key;
 
-    if (out_public_key_octal) {
+    if(out_public_key_octal) {
         *out_public_key_octal = malloc(octal_len);
-        if (out_public_key_octal == NULL) {
+        if(out_public_key_octal == NULL) {
             ret = -1;
             goto clean_exit;
         }
@@ -1554,12 +1556,12 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
         memcpy(*out_public_key_octal, octal_value, octal_len);
     }
 
-    if (out_public_key_octal_len != NULL)
+    if(out_public_key_octal_len != NULL)
         *out_public_key_octal_len = octal_len;
 
 clean_exit:
 
-    if (bn_ctx)
+    if(bn_ctx)
         BN_CTX_free(bn_ctx);
 
     return (ret == 1) ? 0 : -1;
@@ -1584,34 +1586,34 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
 
     BN_CTX *bn_ctx = BN_CTX_new();
 
-    if ( !bn_ctx )
+    if(!bn_ctx)
         return -1;
 
-    if ( k == NULL )
+    if(k == NULL)
         return -1;
 
     private_key_group = EC_KEY_get0_group(private_key);
 
     server_public_key_point = EC_POINT_new(private_key_group);
-    if ( server_public_key_point == NULL )
+    if(server_public_key_point == NULL)
         return -1;
 
     rc = EC_POINT_oct2point(private_key_group, server_public_key_point, server_public_key, server_public_key_len, bn_ctx);
-    if ( rc != 1 ) {
+    if(rc != 1) {
         ret = -1;
         goto clean_exit;
     }
 
     secret_len = (EC_GROUP_get_degree(private_key_group) + 7) / 8;
     secret = malloc(secret_len);
-    if (!secret) {
+    if(!secret) {
         ret = -1;
         goto clean_exit;
     }
 
     secret_len = ECDH_compute_key(secret, secret_len, server_public_key_point, private_key, NULL);
 
-    if( secret_len <= 0 || secret_len > EC_MAX_POINT_LEN ) {
+    if(secret_len <= 0 || secret_len > EC_MAX_POINT_LEN) {
         ret = -1;
         goto clean_exit;
     }
@@ -1620,13 +1622,13 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
 
 clean_exit:
 
-    if ( server_public_key_point != NULL )
+    if(server_public_key_point != NULL)
         EC_POINT_free(server_public_key_point);
 
-    if ( bn_ctx != NULL )
+    if(bn_ctx != NULL)
         BN_CTX_free(bn_ctx);
 
-    if ( secret != NULL )
+    if(secret != NULL)
         free(secret);
 
     return ret;
@@ -1655,7 +1657,7 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
                    privatekey);
 
     bp = BIO_new_file(privatekey, "r");
-    if (bp == NULL) {
+    if(bp == NULL) {
         return _libssh2_error(session,
                               LIBSSH2_ERROR_FILE,
                               "Unable to extract public key from private key "
@@ -1663,10 +1665,10 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
     }
 
     BIO_reset(bp);
-    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void*)passphrase);
+    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
     BIO_free(bp);
 
-    if (pk == NULL) {
+    if(pk == NULL) {
         return _libssh2_error(session,
                               LIBSSH2_ERROR_FILE,
                               "Unable to extract public key "
@@ -1681,7 +1683,7 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
     pktype = pk->type;
 #endif
 
-    switch (pktype) {
+    switch(pktype) {
     case EVP_PKEY_RSA :
         st = gen_publickey_from_rsa_evp(
             session, method, method_len, pubkeydata, pubkeydata_len, pk);
@@ -1734,15 +1736,15 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
                    "Computing public key from private key.");
 
     bp = BIO_new_mem_buf((char *)privatekeydata, privatekeydata_len);
-    if (!bp) {
+    if(!bp) {
         return -1;
     }
 
     BIO_reset(bp);
-    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void*)passphrase);
+    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
     BIO_free(bp);
 
-    if (pk == NULL) {
+    if(pk == NULL) {
         return _libssh2_error(session,
                               LIBSSH2_ERROR_FILE,
                               "Unable to extract public key "
@@ -1757,7 +1759,7 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     pktype = pk->type;
 #endif
 
-    switch (pktype) {
+    switch(pktype) {
     case EVP_PKEY_RSA :
         st = gen_publickey_from_rsa_evp(session, method, method_len,
                                         pubkeydata, pubkeydata_len, pk);
diff --git a/src/os400qc3.c b/src/os400qc3.c
index aacac4a2..955ed3b1 100644
--- a/src/os400qc3.c
+++ b/src/os400qc3.c
@@ -129,7 +129,7 @@ struct pkcs5params {
     char        padopt;         /* Pad option. */
     char        padchar;        /* Pad character. */
     int         (*kdf)(LIBSSH2_SESSION *session, char **dk,
-                       const unsigned char * passphrase, pkcs5params *pkcs5);
+                       const unsigned char *passphrase, pkcs5params *pkcs5);
     int         hash;           /* KDF hash algorithm. */
     size_t      hashlen;        /* KDF hash digest length. */
     char *      salt;           /* Salt. */
@@ -292,7 +292,7 @@ static const pkcs5algo *    kdf2prftable[] = {
 
 /* Public key extraction support. */
 static struct {
-    unsigned char * oid;
+    unsigned char *oid;
     int             (*sshpubkey)(LIBSSH2_SESSION *session, char **pubkey,
                                  asn1Element *params, asn1Element *key,
                                  const char *method);
@@ -370,7 +370,7 @@ getASN1Element(asn1Element *elem, char *beg, char *end)
      * if an error occurs.
      */
 
-    if (beg >= end || !*beg)
+    if(beg >= end || !*beg)
         return NULL;
 
     /* Process header byte. */
@@ -379,45 +379,46 @@ getASN1Element(asn1Element *elem, char *beg, char *end)
     elem->constructed = (b & 0x20) != 0;
     elem->class = (b >> 6) & 3;
     b &= 0x1F;
-    if (b == 0x1F)
+    if(b == 0x1F)
         return NULL;            /* Long tag values not supported here. */
     elem->tag = b;
 
     /* Process length. */
-    if (beg >= end)
+    if(beg >= end)
         return NULL;
     b = (unsigned char) *beg++;
-    if (!(b & 0x80))
+    if(!(b & 0x80))
         len = b;
-    else if (!(b &= 0x7F)) {
+    else if(!(b &= 0x7F)) {
         /* Unspecified length. Since we have all the data, we can determine the
          * effective length by skipping element until an end element is
          * found.
          */
-        if (!elem->constructed)
+        if(!elem->constructed)
             return NULL;
         elem->beg = beg;
-        while (beg < end && *beg) {
+        while(beg < end && *beg) {
             beg = getASN1Element(&lelem, beg, end);
-        if (!beg)
+        if(!beg)
             return NULL;
         }
-        if (beg >= end)
+        if(beg >= end)
             return NULL;
         elem->end = beg;
         return beg + 1;
-    } else if (beg + b > end)
+    }
+    else if(beg + b > end)
         return NULL;                        /* Does not fit in source. */
     else {
         /* Get long length. */
         len = 0;
         do {
-            if (len & 0xFF000000L)
+            if(len & 0xFF000000L)
                 return NULL;    /* Lengths > 32 bits are not supported. */
             len = (len << 8) | (unsigned char) *beg++;
-        } while (--b);
+        } while(--b);
     }
-    if ((unsigned long) (end - beg) < len)
+    if((unsigned long) (end - beg) < len)
         return NULL;            /* Element data does not fit in source. */
     elem->beg = beg;
     elem->end = beg + len;
@@ -434,14 +435,14 @@ asn1_new(unsigned int type, unsigned int length)
 
     e = (asn1Element *) malloc(sizeof *e);
 
-    if (e) {
-        if (length >= 0x80)
-            for (i = length; i; i >>= 8)
+    if(e) {
+        if(length >= 0x80)
+            for(i = length; i; i >>= 8)
                 hdrl++;
 
         buf = (unsigned char *) malloc(hdrl + length);
 
-        if (buf) {
+        if(buf) {
             e->header = buf;
             e->beg = buf + hdrl;
             e->end = e->beg + length;
@@ -450,16 +451,17 @@ asn1_new(unsigned int type, unsigned int length)
             e->constructed = (type >> 5) & 0x01;
             e->header[0] = type;
 
-            if (length < 0x80)
+            if(length < 0x80)
                 e->header[1] = length;
             else {
                 e->header[1] = (hdrl - 2) | 0x80;
                 do {
                     e->header[--hdrl] = length;
                     length >>= 8;
-                } while (length);
+                } while(length);
             }
-        } else {
+        }
+        else {
             free((char *) e);
             e = NULL;
         }
@@ -478,7 +480,7 @@ asn1_new_from_bytes(const unsigned char *data, unsigned int length)
                    (unsigned char *) data, (unsigned char *) data + length);
     e = asn1_new(te.tag, te.end - te.beg);
 
-    if (e)
+    if(e)
         memcpy(e->header, data, e->end - e->header);
 
     return e;
@@ -487,8 +489,8 @@ asn1_new_from_bytes(const unsigned char *data, unsigned int length)
 static void
 asn1delete(asn1Element *e)
 {
-    if (e) {
-        if (e->header)
+    if(e) {
+        if(e->header)
             free((char *) e->header);
         free((char *) e);
     }
@@ -500,18 +502,18 @@ asn1uint(_libssh2_bn *bn)
     asn1Element *e;
     int bits;
     int length;
-    unsigned char * p;
+    unsigned char *p;
 
-    if (!bn)
+    if(!bn)
         return NULL;
 
     bits = _libssh2_bn_bits(bn);
     length = (bits + 8) >> 3;
     e = asn1_new(ASN1_INTEGER, length);
 
-    if (e) {
+    if(e) {
         p = e->beg;
-        if (!(bits & 0x07))
+        if(!(bits & 0x07))
             *p++ = 0;
         _libssh2_bn_to_bin(bn, p);
     }
@@ -529,13 +531,13 @@ asn1containerv(unsigned int type, valiststr args)
     unsigned int length = 0;
 
     memcpy((char *) &va, (char *) &args, sizeof args);
-    while ((p = va_arg(va.list, asn1Element *)))
+    while((p = va_arg(va.list, asn1Element *)))
         length += p->end - p->header;
     va_end(va.list);
     e = asn1_new(type, length);
-    if (e) {
+    if(e) {
         bp = e->beg;
-        while ((p = va_arg(args.list, asn1Element *))) {
+        while((p = va_arg(args.list, asn1Element *))) {
             memcpy(bp, p->header, p->end - p->header);
             bp += p->end - p->header;
         }
@@ -562,7 +564,7 @@ asn1bytes(unsigned int type, const unsigned char *bytes, unsigned int length)
     asn1Element *e;
 
     e = asn1_new(type, length);
-    if (e && length)
+    if(e && length)
         memcpy(e->beg, bytes, length);
     return e;
 }
@@ -583,7 +585,7 @@ rsapublickey(_libssh2_bn *e, _libssh2_bn *m)
     asn1delete(modulus);
     asn1delete(publicexponent);
 
-    if (!modulus || !publicexponent) {
+    if(!modulus || !publicexponent) {
         asn1delete(rsapubkey);
         rsapubkey = NULL;
     }
@@ -630,7 +632,7 @@ rsaprivatekey(_libssh2_bn *e, _libssh2_bn *m, _libssh2_bn *d,
     asn1delete(exponent2);
     asn1delete(coefficient);
 
-    if (!version || !modulus || !publicexponent || !privateexponent ||
+    if(!version || !modulus || !publicexponent || !privateexponent ||
         !prime1 || !prime2 || !exponent1 || !exponent2 || !coefficient) {
         asn1delete(rsaprivkey);
         rsaprivkey = NULL;
@@ -659,7 +661,7 @@ subjectpublickeyinfo(asn1Element *pubkey, const unsigned char *algo,
     asn1delete(algorithm);
     asn1delete(algorithmid);
     asn1delete(subjpubkey);
-    if (!algorithm || !algorithmid || !subjpubkey) {
+    if(!algorithm || !algorithmid || !subjpubkey) {
         asn1delete(subjpubkeyinfo);
         subjpubkeyinfo = NULL;
     }
@@ -676,7 +678,7 @@ rsasubjectpublickeyinfo(asn1Element *pubkey)
     subjpubkeyinfo = subjectpublickeyinfo(pubkey,
                                           OID_rsaEncryption, parameters);
     asn1delete(parameters);
-    if (!parameters) {
+    if(!parameters) {
         asn1delete(subjpubkeyinfo);
         subjpubkeyinfo = NULL;
     }
@@ -705,7 +707,7 @@ privatekeyinfo(asn1Element *privkey, const unsigned char *algo,
     asn1delete(version);
     asn1delete(algorithm);
     asn1delete(privatekeyalgorithm);
-    if (!version || !algorithm || !privatekeyalgorithm) {
+    if(!version || !algorithm || !privatekeyalgorithm) {
         asn1delete(privkeyinfo);
         privkeyinfo = NULL;
     }
@@ -721,7 +723,7 @@ rsaprivatekeyinfo(asn1Element *privkey)
     parameters = asn1bytes(ASN1_NULL, NULL, 0);
     privkeyinfo = privatekeyinfo(privkey, OID_rsaEncryption, parameters);
     asn1delete(parameters);
-    if (!parameters) {
+    if(!parameters) {
         asn1delete(privkeyinfo);
         privkeyinfo = NULL;
     }
@@ -741,7 +743,7 @@ _libssh2_bn_init(void)
     _libssh2_bn *bignum;
 
     bignum = (_libssh2_bn *) malloc(sizeof *bignum);
-    if (bignum) {
+    if(bignum) {
         bignum->bignum = NULL;
         bignum->length = 0;
     }
@@ -752,10 +754,10 @@ _libssh2_bn_init(void)
 void
 _libssh2_bn_free(_libssh2_bn *bn)
 {
-    if (bn) {
-        if (bn->bignum) {
+    if(bn) {
+        if(bn->bignum) {
 #ifdef LIBSSH2_CLEAR_MEMORY
-            if (bn->length)
+            if(bn->length)
                 memset((char *) bn->bignum, 0, bn->length);
 #endif
             free(bn->bignum);
@@ -770,19 +772,19 @@ _libssh2_bn_resize(_libssh2_bn *bn, size_t newlen)
 {
     unsigned char *bignum;
 
-    if (!bn)
+    if(!bn)
         return -1;
-    if (newlen == bn->length)
+    if(newlen == bn->length)
         return 0;
 
-    if (!bn->bignum)
+    if(!bn->bignum)
         bignum = (unsigned char *) malloc(newlen);
     else {
 #ifdef LIBSSH2_CLEAR_MEMORY
-        if (newlen < bn->length)
+        if(newlen < bn->length)
             memset((char *) bn->bignum + newlen, 0, bn->length - newlen);
 #endif
-        if (!newlen) {
+        if(!newlen) {
             free((char *) bn->bignum);
             bn->bignum = NULL;
             bn->length = 0;
@@ -791,10 +793,10 @@ _libssh2_bn_resize(_libssh2_bn *bn, size_t newlen)
         bignum = (unsigned char *) realloc((char *) bn->bignum, newlen);
     }
 
-    if (!bignum)
+    if(!bignum)
         return -1;
 
-    if (newlen > bn->length)
+    if(newlen > bn->length)
         memset((char *) bignum + bn->length, 0, newlen - bn->length);
 
     bn->bignum = bignum;
@@ -808,13 +810,14 @@ _libssh2_bn_bits(_libssh2_bn *bn)
     unsigned int i;
     unsigned char b;
 
-    if (bn && bn->bignum) {
-        for (i = bn->length; i--;)
-            if ((b = bn->bignum[i])) {
+    if(bn && bn->bignum) {
+        for(i = bn->length; i--;)
+            b = bn->bignum[i];
+            if(b) {
                 i *= 8;
                 do {
                     i++;
-                } while (b >>= 1);
+                } while(b >>= 1);
                 return i;
             }
     }
@@ -827,16 +830,16 @@ _libssh2_bn_from_bin(_libssh2_bn *bn, int len, const unsigned char *val)
 {
     int i;
 
-    if (!bn || (len && !val))
+    if(!bn || (len && !val))
         return -1;
 
-    for (; len && !*val; len--)
+    for(; len && !*val; len--)
         val++;
 
-    if (_libssh2_bn_resize(bn, len))
+    if(_libssh2_bn_resize(bn, len))
         return -1;
 
-    for (i = len; i--;)
+    for(i = len; i--;)
         bn->bignum[i] = *val++;
 
     return 0;
@@ -854,10 +857,10 @@ _libssh2_bn_to_bin(_libssh2_bn *bn, unsigned char *val)
 {
     int i;
 
-    if (!bn || !val)
+    if(!bn || !val)
         return -1;
 
-    for (i = bn->length; i--;)
+    for(i = bn->length; i--;)
         *val++ = bn->bignum[i];
 
     return 0;
@@ -868,13 +871,13 @@ _libssh2_bn_from_bn(_libssh2_bn *to, _libssh2_bn *from)
 {
     int i;
 
-    if (!to || !from)
+    if(!to || !from)
         return -1;
 
-    if (_libssh2_bn_resize(to, from->length))
+    if(_libssh2_bn_resize(to, from->length))
         return -1;
 
-    for (i = to->length; i--;)
+    for(i = to->length; i--;)
         to->bignum[i] = from->bignum[i];
 
     return 0;
@@ -897,10 +900,10 @@ _libssh2_random(unsigned char *buf, int len)
 static _libssh2_os400qc3_crypto_ctx *
 libssh2_init_crypto_ctx(_libssh2_os400qc3_crypto_ctx *ctx)
 {
-    if (!ctx)
+    if(!ctx)
         ctx = (_libssh2_os400qc3_crypto_ctx *) malloc(sizeof *ctx);
 
-    if (ctx) {
+    if(ctx) {
         memset((char *) ctx, 0, sizeof *ctx);
         ctx->hash.Final_Op_Flag = Qc3_Continue;
     }
@@ -918,17 +921,17 @@ null_token(const char *token)
 void
 _libssh2_os400qc3_crypto_dtor(_libssh2_os400qc3_crypto_ctx *x)
 {
-    if (!x)
+    if(!x)
         return;
-    if (!null_token(x->hash.Alg_Context_Token)) {
+    if(!null_token(x->hash.Alg_Context_Token)) {
         Qc3DestroyAlgorithmContext(x->hash.Alg_Context_Token, (char *) &ecnull);
         memset(x->hash.Alg_Context_Token, 0, sizeof x->hash.Alg_Context_Token);
     }
-    if (!null_token(x->key.Key_Context_Token)) {
+    if(!null_token(x->key.Key_Context_Token)) {
         Qc3DestroyKeyContext(x->key.Key_Context_Token, (char *) &ecnull);
         memset(x->key.Key_Context_Token, 0, sizeof x->key.Key_Context_Token);
     }
-    if (x->kek) {
+    if(x->kek) {
         _libssh2_os400qc3_crypto_dtor(x->kek);
         free((char *) x->kek);
         x->kek = NULL;
@@ -947,7 +950,7 @@ libssh2_os400qc3_hash_init(Qc3_Format_ALGD0100_T *x, unsigned int algorithm)
     Qc3_Format_ALGD0500_T algd;
     Qus_EC_t errcode;
 
-    if (!x)
+    if(!x)
         return 0;
 
     memset((char *) x, 0, sizeof *x);
@@ -988,7 +991,7 @@ libssh2_os400qc3_hash(const unsigned char *message, unsigned long len,
 {
     Qc3_Format_ALGD0100_T ctx;
 
-    if (!libssh2_os400qc3_hash_init(&ctx, algo))
+    if(!libssh2_os400qc3_hash_init(&ctx, algo))
         return 1;
 
     libssh2_os400qc3_hash_update(&ctx, (unsigned char *) message, len);
@@ -1000,11 +1003,11 @@ void
 libssh2_os400qc3_hmac_init(_libssh2_os400qc3_crypto_ctx *ctx,
                            int algo, size_t minkeylen, void *key, int keylen)
 {
-    if (keylen < minkeylen) {
+    if(keylen < minkeylen) {
         char *lkey = alloca(minkeylen);
 
         /* Pad key with zeroes if too short. */
-        if (!lkey)
+        if(!lkey)
             return;
         memcpy(lkey, (char *) key, keylen);
         memset(lkey + keylen, 0, minkeylen - keylen);
@@ -1057,7 +1060,7 @@ _libssh2_cipher_init(_libssh2_cipher_ctx *h, _libssh2_cipher_type(algo),
 
     (void) encrypt;
 
-    if (!h)
+    if(!h)
         return -1;
 
     libssh2_init_crypto_ctx(h);
@@ -1069,18 +1072,18 @@ _libssh2_cipher_init(_libssh2_cipher_ctx *h, _libssh2_cipher_type(algo),
     algd.Reserved = 0;
     algd.MAC_Length = 0;
     algd.Effective_Key_Size = 0;
-    memset(algd.Init_Vector, 0 , sizeof algd.Init_Vector);
-    if (algo.mode != Qc3_ECB && algo.size)
+    memset(algd.Init_Vector, 0, sizeof algd.Init_Vector);
+    if(algo.mode != Qc3_ECB && algo.size)
         memcpy(algd.Init_Vector, iv, algo.size);
     set_EC_length(errcode, sizeof errcode);
     Qc3CreateAlgorithmContext((char *) &algd, algo.fmt,
                               h->hash.Alg_Context_Token, &errcode);
-    if (errcode.Bytes_Available)
+    if(errcode.Bytes_Available)
         return -1;
     Qc3CreateKeyContext((char *) secret, &algo.keylen, binstring,
                         &algo.algo, qc3clear, NULL, NULL,
                         h->key.Key_Context_Token, (char *) &errcode);
-    if (errcode.Bytes_Available) {
+    if(errcode.Bytes_Available) {
         _libssh2_os400qc3_crypto_dtor(h);
         return -1;
     }
@@ -1100,7 +1103,7 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx *ctx,
     (void) algo;
 
     set_EC_length(errcode, sizeof errcode);
-    if (encrypt)
+    if(encrypt)
         Qc3EncryptData((char *) block, &blksize, Qc3_Data,
                        ctx->hash.Alg_Context_Token, Qc3_Alg_Token,
                        ctx->key.Key_Context_Token, Qc3_Key_Token, anycsp, NULL,
@@ -1150,15 +1153,15 @@ _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
     int i;
 
     ctx = libssh2_init_crypto_ctx(NULL);
-    if (!ctx)
+    if(!ctx)
         ret = -1;
-    if (!ret) {
+    if(!ret) {
         _libssh2_bn_from_bin(e, elen, edata);
         _libssh2_bn_from_bin(n, nlen, ndata);
-        if (!e || !n)
+        if(!e || !n)
             ret = -1;
     }
-    if (!ret && ddata) {
+    if(!ret && ddata) {
         /* Private key. */
         d = _libssh2_bn_init_from_bin();
         _libssh2_bn_from_bin(d, dlen, ddata);
@@ -1172,26 +1175,27 @@ _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
         _libssh2_bn_from_bin(e2, e2len, e2data);
         coeff = _libssh2_bn_init_from_bin();
         _libssh2_bn_from_bin(coeff, coefflen, coeffdata);
-        if (!d || !p || !q ||!e1 || !e2 || !coeff)
+        if(!d || !p || !q ||!e1 || !e2 || !coeff)
             ret = -1;
 
-        if (!ret) {
+        if(!ret) {
             /* Build a PKCS#8 private key. */
             key = rsaprivatekey(e, n, d, p, q, e1, e2, coeff);
             structkey = rsaprivatekeyinfo(key);
         }
         keytype = Qc3_RSA_Private;
-    } else if (!ret) {
+    }
+    else if(!ret) {
         key = rsapublickey(e, n);
         structkey = rsasubjectpublickeyinfo(key);
         keytype = Qc3_RSA_Public;
     }
-    if (!key || !structkey)
+    if(!key || !structkey)
         ret = -1;
 
     set_EC_length(errcode, sizeof errcode);
 
-    if (!ret) {
+    if(!ret) {
         /* Create the algorithm context. */
         algd.Public_Key_Alg = Qc3_RSA;
         algd.PKA_Block_Format = Qc3_PKCS1_01;
@@ -1199,18 +1203,18 @@ _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
         algd.Signing_Hash_Alg = Qc3_SHA1;
         Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Public_Key,
                                   ctx->hash.Alg_Context_Token, &errcode);
-        if (errcode.Bytes_Available)
+        if(errcode.Bytes_Available)
             ret = -1;
         ctx->hash.Final_Op_Flag = Qc3_Continue;
     }
 
     /* Create the key context. */
-    if (!ret) {
+    if(!ret) {
         i = structkey->end - structkey->header;
         Qc3CreateKeyContext(structkey->header, &i, berstring, &keytype,
                             qc3clear, NULL, NULL, ctx->key.Key_Context_Token,
                             (char *) &errcode);
-        if (errcode.Bytes_Available)
+        if(errcode.Bytes_Available)
             ret = -1;
     }
 
@@ -1224,7 +1228,7 @@ _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
     _libssh2_bn_free(coeff);
     asn1delete(key);
     asn1delete(structkey);
-    if (ret && ctx) {
+    if(ret && ctx) {
         _libssh2_rsa_free(ctx);
         ctx = NULL;
     }
@@ -1276,7 +1280,7 @@ _libssh2_os400qc3_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
                           dhkeyagreement, dhparameter, NULL);
     asn1delete(dhkeyagreement);
     asn1delete(dhparameter);
-    if (!base || !prime || !dhparameter ||
+    if(!base || !prime || !dhparameter ||
         !dhkeyagreement || !dhparameter || !pkcs3) {
         asn1delete(pkcs3);
         return -1;
@@ -1288,7 +1292,7 @@ _libssh2_os400qc3_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
     Qc3GenDHKeyPair((char *) pkcs3->header, &pkcs3len, anycsp, NULL,
                     dhctx->token, pubkey, &pubkeysize, &pubkeylen, &errcode);
     asn1delete(pkcs3);
-    if (errcode.Bytes_Available)
+    if(errcode.Bytes_Available)
         return -1;
     return _libssh2_bn_from_bin(public, pubkeylen, (unsigned char *) pubkey);
 }
@@ -1312,7 +1316,7 @@ _libssh2_os400qc3_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
     set_EC_length(errcode, sizeof errcode);
     Qc3CalculateDHSecretKey(dhctx->token, pubkey, &pubkeysize,
                             secretbuf, &secretbufsize, &secretbuflen, &errcode);
-    if (errcode.Bytes_Available)
+    if(errcode.Bytes_Available)
         return -1;
     return _libssh2_bn_from_bin(secret,
                                 secretbuflen, (unsigned char *) secretbuf);
@@ -1321,7 +1325,7 @@ _libssh2_os400qc3_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
 void
 _libssh2_os400qc3_dh_dtor(_libssh2_dh_ctx *dhctx)
 {
-    if (!null_token(dhctx->token)) {
+    if(!null_token(dhctx->token)) {
         Qc3DestroyAlgorithmContext(dhctx->token, (char *) &ecnull);
         memset((char *) dhctx, 0, sizeof *dhctx);
     }
@@ -1339,9 +1343,9 @@ oidcmp(const asn1Element *e, const unsigned char *oid)
 {
     int i = e->end - e->beg - *oid++;
 
-    if (*e->header != ASN1_OBJ_ID)
+    if(*e->header != ASN1_OBJ_ID)
         return -2;
-    if (!i)
+    if(!i)
         i = memcmp(e->beg, oid, oid[-1]);
     return i;
 }
@@ -1352,20 +1356,20 @@ asn1getword(asn1Element *e, unsigned long *v)
     unsigned long a;
     const unsigned char *cp;
 
-    if (*e->header != ASN1_INTEGER)
+    if(*e->header != ASN1_INTEGER)
         return -1;
-    for (cp = e->beg; cp < e->end && !*cp; cp++)
+    for(cp = e->beg; cp < e->end && !*cp; cp++)
         ;
-    if (e->end - cp > sizeof a)
+    if(e->end - cp > sizeof a)
         return -1;
-    for (a = 0; cp < e->end; cp++)
+    for(a = 0; cp < e->end; cp++)
         a = (a << 8) | *cp;
     *v = a;
     return 0;
 }
 
 static int
-pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
+pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char *passphrase,
        pkcs5params *pkcs5)
 {
     int i;
@@ -1374,11 +1378,12 @@ pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
     char *data = (char *) pkcs5->salt;
 
     *dk = NULL;
-    if (pkcs5->dklen > pkcs5->hashlen)
+    if(pkcs5->dklen > pkcs5->hashlen)
         return -1;
 
     /* Allocate the derived key buffer. */
-    if (!(*dk = LIBSSH2_ALLOC(session, pkcs5->hashlen)))
+    *dk = LIBSSH2_ALLOC(session, pkcs5->hashlen);
+    if(!*dk)
         return -1;
 
     /* Initial hash. */
@@ -1391,7 +1396,7 @@ pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
 
     /* Iterate. */
     len = pkcs5->hashlen;
-    for (i = 1; i < pkcs5->itercount; i++)
+    for(i = 1; i < pkcs5->itercount; i++)
         Qc3CalculateHash((char *) *dk, &len, Qc3_Data, (char *) &hctx,
                          Qc3_Alg_Token, anycsp, NULL, *dk, (char *) &ecnull);
 
@@ -1407,7 +1412,7 @@ pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
 }
 
 static int
-pbkdf2(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
+pbkdf2(LIBSSH2_SESSION *session, char **dk, const unsigned char *passphrase,
        pkcs5params *pkcs5)
 {
     size_t i;
@@ -1423,15 +1428,16 @@ pbkdf2(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
     *dk = NULL;
     t = ((unsigned long long) pkcs5->dklen + pkcs5->hashlen - 1) /
         pkcs5->hashlen;
-    if (t > 0xFFFFFFFF)
+    if(t > 0xFFFFFFFF)
         return -1;
     mac = alloca(pkcs5->hashlen);
-    if (!mac)
+    if(!mac)
         return -1;
 
     /* Allocate the derived key buffer. */
     l = t;
-    if (!(buf = LIBSSH2_ALLOC(session, l * pkcs5->hashlen)))
+    buf = LIBSSH2_ALLOC(session, l * pkcs5->hashlen);
+    if(!buf)
         return -1;
     *dk = buf;
 
@@ -1440,16 +1446,16 @@ pbkdf2(LIBSSH2_SESSION *session, char **dk, const unsigned char * passphrase,
                                (void *) passphrase, strlen(passphrase));
 
     /* Process each hLen-size blocks. */
-    for (i = 1; i <= l; i++) {
+    for(i = 1; i <= l; i++) {
         ni = htonl(i);
         libssh2_os400qc3_hmac_update(&hctx, pkcs5->salt, pkcs5->saltlen);
         libssh2_os400qc3_hmac_update(&hctx, (char *) &ni, sizeof ni);
         libssh2_os400qc3_hmac_final(&hctx, mac);
         memcpy(buf, mac, pkcs5->hashlen);
-        for (j = 1; j < pkcs5->itercount; j++) {
+        for(j = 1; j < pkcs5->itercount; j++) {
             libssh2_os400qc3_hmac_update(&hctx, mac, pkcs5->hashlen);
             libssh2_os400qc3_hmac_final(&hctx, mac);
-            for (k = 0; k < pkcs5->hashlen; k++)
+            for(k = 0; k < pkcs5->hashlen; k++)
                 buf[k] ^= mac[k];
         }
         buf += pkcs5->hashlen;
@@ -1469,15 +1475,15 @@ parse_pkcs5_algorithm(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
     char *cp;
 
     cp = getASN1Element(&oid, algid->beg, algid->end);
-    if (!cp || *oid.header != ASN1_OBJ_ID)
+    if(!cp || *oid.header != ASN1_OBJ_ID)
         return -1;
     param.header = NULL;
-    if (cp < algid->end)
+    if(cp < algid->end)
         cp = getASN1Element(&param, cp, algid->end);
-    if (cp != algid->end)
+    if(cp != algid->end)
         return -1;
-    for (; *algotable; algotable++)
-        if (!oidcmp(&oid, (*algotable)->oid))
+    for(; *algotable; algotable++)
+        if(!oidcmp(&oid, (*algotable)->oid))
             return (*(*algotable)->parse)(session, pkcs5, *algotable,
                                           param.header? &param: NULL);
     return -1;
@@ -1491,17 +1497,17 @@ parse_pbes2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
     asn1Element encryptionScheme;
     char *cp;
 
-    if (!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
     cp = getASN1Element(&keyDerivationFunc, param->beg, param->end);
-    if (!cp || *keyDerivationFunc.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!cp || *keyDerivationFunc.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
-    if (getASN1Element(&encryptionScheme, cp, param->end) != param->end ||
+    if(getASN1Element(&encryptionScheme, cp, param->end) != param->end ||
         *encryptionScheme.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
-    if (parse_pkcs5_algorithm(session, pkcs5, &encryptionScheme, pbes2enctable))
+    if(parse_pkcs5_algorithm(session, pkcs5, &encryptionScheme, pbes2enctable))
         return -1;
-    if (parse_pkcs5_algorithm(session, pkcs5, &keyDerivationFunc, pbkdf2table))
+    if(parse_pkcs5_algorithm(session, pkcs5, &keyDerivationFunc, pbkdf2table))
         return -1;
     return 0;
 }
@@ -1517,40 +1523,40 @@ parse_pbkdf2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
     unsigned long itercount;
     char *cp;
 
-    if (!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
     cp = getASN1Element(&salt, param->beg, param->end);
     /* otherSource not supported. */
-    if (!cp || *salt.header != ASN1_OCTET_STRING)
+    if(!cp || *salt.header != ASN1_OCTET_STRING)
         return -1;
     cp = getASN1Element(&iterationCount, cp, param->end);
-    if (!cp || *iterationCount.header != ASN1_INTEGER)
+    if(!cp || *iterationCount.header != ASN1_INTEGER)
         return -1;
     keyLength.header = prf.header = NULL;
-    if (cp < param->end) {
+    if(cp < param->end) {
         cp = getASN1Element(&prf, cp, param->end);
-        if (!cp)
+        if(!cp)
             return -1;
-        if (*prf.header == ASN1_INTEGER) {
+        if(*prf.header == ASN1_INTEGER) {
             keyLength = prf;
             prf.header = NULL;
-            if (cp < param->end)
+            if(cp < param->end)
                 cp = getASN1Element(&prf, cp, param->end);
         }
-        if (cp != param->end)
+        if(cp != param->end)
             return -1;
     }
     pkcs5->hash = algo->hash;
     pkcs5->hashlen = algo->hashlen;
-    if (prf.header) {
-        if (*prf.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(prf.header) {
+        if(*prf.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
             return -1;
-        if (parse_pkcs5_algorithm(session, pkcs5, &prf, kdf2prftable))
+        if(parse_pkcs5_algorithm(session, pkcs5, &prf, kdf2prftable))
             return -1;
     }
     pkcs5->saltlen = salt.end - salt.beg;
     pkcs5->salt = salt.beg;
-    if (asn1getword(&iterationCount, &itercount) ||
+    if(asn1getword(&iterationCount, &itercount) ||
         !itercount || itercount > 100000)
         return -1;
     pkcs5->itercount = itercount;
@@ -1562,7 +1568,7 @@ static int
 parse_hmacWithSHA1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
                    pkcs5algo *algo, asn1Element *param)
 {
-    if (!param || *param->header != ASN1_NULL)
+    if(!param || *param->header != ASN1_NULL)
         return -1;
     pkcs5->hash = algo->hash;
     pkcs5->hashlen = algo->hashlen;
@@ -1573,7 +1579,7 @@ static int
 parse_iv(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
          pkcs5algo *algo, asn1Element *param)
 {
-    if (!param || *param->header != ASN1_OCTET_STRING ||
+    if(!param || *param->header != ASN1_OCTET_STRING ||
         param->end - param->beg != algo->ivlen)
         return -1;
     pkcs5->cipher = algo->cipher;
@@ -1595,19 +1601,19 @@ parse_rc2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
     unsigned long effkeysize;
     char *cp;
 
-    if (!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
     cp = getASN1Element(&iv, param->beg, param->end);
-    if (!cp)
+    if(!cp)
         return -1;
     effkeysize = algo->effkeysize;
-    if (*iv.header == ASN1_INTEGER) {
-        if (asn1getword(&iv, &effkeysize) || effkeysize > 1024)
+    if(*iv.header == ASN1_INTEGER) {
+        if(asn1getword(&iv, &effkeysize) || effkeysize > 1024)
             return -1;
 
         cp = getASN1Element(&iv, cp, param->end);
-        if (effkeysize < 256)
-            switch (effkeysize) {
+        if(effkeysize < 256)
+            switch(effkeysize) {
             case 160:
                 effkeysize = 40;
             case 120:
@@ -1619,7 +1625,7 @@ parse_rc2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
                 return -1;
             }
     }
-    if (effkeysize > 1024 || cp != param->end ||
+    if(effkeysize > 1024 || cp != param->end ||
         *iv.header != ASN1_OCTET_STRING || iv.end - iv.beg != algo->ivlen)
         return -1;
     pkcs5->cipher = algo->cipher;
@@ -1643,17 +1649,17 @@ parse_pbes1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
     unsigned long itercount;
     char *cp;
 
-    if (!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
 
     cp = getASN1Element(&salt, param->beg, param->end);
-    if (!cp || *salt.header != ASN1_OCTET_STRING ||
+    if(!cp || *salt.header != ASN1_OCTET_STRING ||
         salt.end - salt.beg != algo->saltlen)
         return -1;
-    if (getASN1Element(&iterationCount, cp, param->end) != param->end ||
+    if(getASN1Element(&iterationCount, cp, param->end) != param->end ||
         *iterationCount.header != ASN1_INTEGER)
         return -1;
-    if (asn1getword(&iterationCount, &itercount) ||
+    if(asn1getword(&iterationCount, &itercount) ||
         !itercount || itercount > 100000)
         return -1;
     pkcs5->cipher = algo->cipher;
@@ -1697,20 +1703,20 @@ pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
     privkeyinfo->end = privkeyinfo->beg + datalen;
 
     /* If no passphrase is given, it cannot be an encrypted key. */
-    if (!passphrase || !*passphrase)
+    if(!passphrase || !*passphrase)
         return 0;
 
     /* Parse PKCS#8 data, checking if ASN.1 format is PrivateKeyInfo or
        EncryptedPrivateKeyInfo. */
-    if (getASN1Element(&encprivkeyinfo, privkeyinfo->beg, privkeyinfo->end) !=
+    if(getASN1Element(&encprivkeyinfo, privkeyinfo->beg, privkeyinfo->end) !=
         (char *) data + datalen ||
         *encprivkeyinfo.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
     cp = getASN1Element(&pkcs5alg, encprivkeyinfo.beg, encprivkeyinfo.end);
-    if (!cp)
+    if(!cp)
         return -1;
 
-    switch (*pkcs5alg.header) {
+    switch(*pkcs5alg.header) {
     case ASN1_INTEGER:                          /* Version. */
         return 0;       /* This is a PrivateKeyInfo --> not encrypted. */
     case ASN1_SEQ | ASN1_CONSTRUCTED:           /* AlgorithIdentifier. */
@@ -1720,18 +1726,18 @@ pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
     }
 
     /* Get the encrypted key data. */
-    if (getASN1Element(privkeyinfo, cp, encprivkeyinfo.end) !=
+    if(getASN1Element(privkeyinfo, cp, encprivkeyinfo.end) !=
         encprivkeyinfo.end || *privkeyinfo->header != ASN1_OCTET_STRING)
         return -1;
 
     /* PKCS#5: parse the PBES AlgorithmIdentifier and recursively get all
        encryption parameters. */
     memset((char *) &pkcs5, 0, sizeof pkcs5);
-    if (parse_pkcs5_algorithm(session, &pkcs5, &pkcs5alg, pbestable))
+    if(parse_pkcs5_algorithm(session, &pkcs5, &pkcs5alg, pbestable))
         return -1;
 
     /* Compute the derived key. */
-    if ((*pkcs5.kdf)(session, &dk, passphrase, &pkcs5))
+    if((*pkcs5.kdf)(session, &dk, passphrase, &pkcs5))
         return -1;
 
     /* Prepare the algorithm descriptor. */
@@ -1746,7 +1752,7 @@ pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
 
     /* Create the key and algorithm context tokens. */
     *ctx = libssh2_init_crypto_ctx(NULL);
-    if (!*ctx) {
+    if(!*ctx) {
         LIBSSH2_FREE(session, dk);
         return -1;
     }
@@ -1756,7 +1762,7 @@ pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
                         qc3clear, NULL, NULL, (*ctx)->key.Key_Context_Token,
                         (char *) &errcode);
     LIBSSH2_FREE(session, dk);
-    if (errcode.Bytes_Available) {
+    if(errcode.Bytes_Available) {
         free((char *) *ctx);
         *ctx = NULL;
         return -1;
@@ -1764,7 +1770,7 @@ pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
 
     Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Block_Cipher,
                               (*ctx)->hash.Alg_Context_Token, &errcode);
-    if (errcode.Bytes_Available) {
+    if(errcode.Bytes_Available) {
         Qc3DestroyKeyContext((*ctx)->key.Key_Context_Token, (char *) &ecnull);
         free((char *) *ctx);
         *ctx = NULL;
@@ -1787,7 +1793,7 @@ rsapkcs8privkey(LIBSSH2_SESSION *session,
     int pkilen;
     Qus_EC_t errcode;
 
-    switch (pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
+    switch(pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
     case 1:
         keyform = Qc3_Encrypted;
         kek = kekctx->key.Key_Context_Token;
@@ -1803,8 +1809,8 @@ rsapkcs8privkey(LIBSSH2_SESSION *session,
     Qc3CreateKeyContext((unsigned char *) pki.beg, &pkilen, berstring,
                         rsaprivate, &keyform, kek, kea,
                         ctx->key.Key_Context_Token, (char *) &errcode);
-    if (errcode.Bytes_Available) {
-        if (kekctx)
+    if(errcode.Bytes_Available) {
+        if(kekctx)
             _libssh2_os400qc3_crypto_dtor(kekctx);
         return -1;
     }
@@ -1816,7 +1822,7 @@ static char *
 storewithlength(char *p, const char *data, int length)
 {
     _libssh2_htonu32(p, length);
-    if (length)
+    if(length)
         memcpy(p + 4, data, length);
     return p + 4 + length;
 }
@@ -1832,18 +1838,18 @@ sshrsapubkey(LIBSSH2_SESSION *session, char **sshpubkey,
     int len;
     char *cp;
 
-    if (getASN1Element(&keyseq, key->beg + 1, key->end) != key->end ||
+    if(getASN1Element(&keyseq, key->beg + 1, key->end) != key->end ||
         *keyseq.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
-    if (!getASN1Element(&m, keyseq.beg, keyseq.end) ||
+    if(!getASN1Element(&m, keyseq.beg, keyseq.end) ||
         *m.header != ASN1_INTEGER)
         return -1;
-    if (getASN1Element(&e, m.end, keyseq.end) != keyseq.end ||
+    if(getASN1Element(&e, m.end, keyseq.end) != keyseq.end ||
         *e.header != ASN1_INTEGER)
         return -1;
     len = 4 + methlen + 4 + (e.end - e.beg) + 4 + (m.end - m.beg);
     cp = LIBSSH2_ALLOC(session, len);
-    if (!cp)
+    if(!cp)
         return -1;
     *sshpubkey = cp;
     cp = storewithlength(cp, method, methlen);
@@ -1875,10 +1881,11 @@ rsapkcs8pubkey(LIBSSH2_SESSION *session,
     int pkilen;
     Qus_EC_t errcode;
 
-    if (!(buf = alloca(datalen)))
+    buf = alloca(datalen);
+    if(!buf)
         return -1;
 
-    switch (pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
+    switch(pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
     case 1:
         keyform = Qc3_Encrypted;
         kek = kekctx->key.Key_Context_Token;
@@ -1894,27 +1901,27 @@ rsapkcs8pubkey(LIBSSH2_SESSION *session,
     Qc3ExtractPublicKey(pki.beg, &pkilen, berstring, &keyform,
                         kek, kea, buf, (int *) &datalen, &len, &errcode);
     _libssh2_os400qc3_crypto_dtor(kekctx);
-    if (errcode.Bytes_Available)
+    if(errcode.Bytes_Available)
         return -1;
     /* Get the algorithm OID and key data from SubjectPublicKeyInfo. */
-    if (getASN1Element(&subjpubkeyinfo, buf, buf + len) != buf + len ||
+    if(getASN1Element(&subjpubkeyinfo, buf, buf + len) != buf + len ||
         *subjpubkeyinfo.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
     cp = getASN1Element(&algorithmid, subjpubkeyinfo.beg, subjpubkeyinfo.end);
-    if (!cp || *algorithmid.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+    if(!cp || *algorithmid.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
         return -1;
-    if (!getASN1Element(&algorithm, algorithmid.beg, algorithmid.end) ||
+    if(!getASN1Element(&algorithm, algorithmid.beg, algorithmid.end) ||
         *algorithm.header != ASN1_OBJ_ID)
         return -1;
-    if (getASN1Element(&subjpubkey, cp, subjpubkeyinfo.end) !=
+    if(getASN1Element(&subjpubkey, cp, subjpubkeyinfo.end) !=
         subjpubkeyinfo.end || *subjpubkey.header != ASN1_BIT_STRING)
         return -1;
     /* Check for supported algorithm. */
-    for (i = 0; pka[i].oid; i++)
-        if (!oidcmp(&algorithm, pka[i].oid)) {
+    for(i = 0; pka[i].oid; i++)
+        if(!oidcmp(&algorithm, pka[i].oid)) {
             len = (*pka[i].sshpubkey)(session, &p->data, &algorithmid,
                                       &subjpubkey, pka[i].method);
-            if (len < 0)
+            if(len < 0)
                 return -1;
             p->length = len;
             p->method = pka[i].method;
@@ -1934,21 +1941,21 @@ pkcs1topkcs8(LIBSSH2_SESSION *session,
 
     *data8 = NULL;
     *datalen8 = 0;
-    if (datalen1 < 2)
+    if(datalen1 < 2)
         return -1;
     prvk = asn1_new_from_bytes(data1, datalen1);
-    if (!prvk)
+    if(!prvk)
         return -1;
     pkcs8 = rsaprivatekeyinfo(prvk);
     asn1delete(prvk);
-    if (!prvk) {
+    if(!prvk) {
         asn1delete(pkcs8);
         pkcs8 = NULL;
     }
-    if (!pkcs8)
+    if(!pkcs8)
         return -1;
     data = (unsigned char *) LIBSSH2_ALLOC(session, pkcs8->end - pkcs8->header);
-    if (!data) {
+    if(!data) {
         asn1delete(pkcs8);
         return -1;
     }
@@ -1968,7 +1975,7 @@ rsapkcs1privkey(LIBSSH2_SESSION *session,
     unsigned int datalen8;
     int ret;
 
-    if (pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
+    if(pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
         return -1;
     ret = rsapkcs8privkey(session, data8, datalen8, passphrase, loadkeydata);
     LIBSSH2_FREE(session, (char *) data8);
@@ -1984,7 +1991,7 @@ rsapkcs1pubkey(LIBSSH2_SESSION *session,
     unsigned int datalen8;
     int ret;
 
-    if (pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
+    if(pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
         return -1;
     ret = rsapkcs8pubkey(session, data8, datalen8, passphrase, loadkeydata);
     LIBSSH2_FREE(session, (char *) data8);
@@ -2003,24 +2010,24 @@ try_pem_load(LIBSSH2_SESSION *session, FILE *fp,
     int ret;
 
     fseek(fp, 0L, SEEK_SET);
-    for (;;) {
+    for(;;) {
         ret = _libssh2_pem_parse(session, header, trailer,
                                  passphrase,
                                  fp, &data, &datalen);
 
-        if (!ret) {
+        if(!ret) {
             ret = (*proc)(session, data, datalen, passphrase, loadkeydata);
-            if (!ret)
+            if(!ret)
                 return 0;
         }
 
-        if (data) {
+        if(data) {
             LIBSSH2_FREE(session, data);
             data = NULL;
         }
         c = getc(fp);
 
-        if (c == EOF)
+        if(c == EOF)
             break;
 
         ungetc(c, fp);
@@ -2040,7 +2047,7 @@ load_rsa_private_file(LIBSSH2_SESSION *session, const char *filename,
     int ret;
     long filesize;
 
-    if (!fp)
+    if(!fp)
         return -1;
 
     /* Try with "ENCRYPTED PRIVATE KEY" PEM armor.
@@ -2050,27 +2057,27 @@ load_rsa_private_file(LIBSSH2_SESSION *session, const char *filename,
 
     /* Try with "PRIVATE KEY" PEM armor.
        --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
-    if (ret)
+    if(ret)
         ret = try_pem_load(session, fp, passphrase, beginprivkeyhdr,
                            endprivkeyhdr, proc8, loadkeydata);
 
     /* Try with "RSA PRIVATE KEY" PEM armor.
        --> PKCS#1 RSAPrivateKey */
-    if (ret)
+    if(ret)
         ret = try_pem_load(session, fp, passphrase, beginrsaprivkeyhdr,
                            endrsaprivkeyhdr, proc1, loadkeydata);
     fclose(fp);
 
-    if (ret) {
+    if(ret) {
         /* Try DER encoding. */
         fp = fopen(filename, fopenrbmode);
         fseek(fp, 0L, SEEK_END);
         filesize = ftell(fp);
 
-        if (filesize <= 32768) {        /* Limit to a reasonable size. */
+        if(filesize <= 32768) {        /* Limit to a reasonable size. */
             datalen = filesize;
             data = (unsigned char *) alloca(datalen);
-            if (data) {
+            if(data) {
                 fseek(fp, 0L, SEEK_SET);
                 fread(data, datalen, 1, fp);
 
@@ -2081,7 +2088,7 @@ load_rsa_private_file(LIBSSH2_SESSION *session, const char *filename,
 
                 /* Try as PKCS#1 DER data.
                    --> PKCS#1 RSAPrivateKey */
-                if (ret)
+                if(ret)
                     ret = (*proc1)(session, data, datalen, passphrase,
                                    loadkeydata);
             }
@@ -2101,11 +2108,11 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx **rsa, LIBSSH2_SESSION *session,
     Qc3_Format_ALGD0400_T algd;
     Qus_EC_t errcode;
 
-    if (!ctx)
+    if(!ctx)
         return -1;
     ret = load_rsa_private_file(session, filename, passphrase,
                                 rsapkcs1privkey, rsapkcs8privkey, (void *) ctx);
-    if (!ret) {
+    if(!ret) {
         /* Create the algorithm context. */
         algd.Public_Key_Alg = Qc3_RSA;
         algd.PKA_Block_Format = Qc3_PKCS1_01;
@@ -2114,10 +2121,10 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx **rsa, LIBSSH2_SESSION *session,
         set_EC_length(errcode, sizeof errcode);
         Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Public_Key,
                                   ctx->hash.Alg_Context_Token, &errcode);
-        if (errcode.Bytes_Available)
+        if(errcode.Bytes_Available)
             ret = -1;
     }
-    if (ret) {
+    if(ret) {
         _libssh2_os400qc3_crypto_dtor(ctx);
         ctx = NULL;
     }
@@ -2142,22 +2149,24 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
 
     ret = load_rsa_private_file(session, privatekey, passphrase,
                                 rsapkcs1pubkey, rsapkcs8pubkey, (void *) &p);
-    if (!ret) {
+    if(!ret) {
         *method_len = strlen(p.method);
-        if ((*method = LIBSSH2_ALLOC(session, *method_len)))
+        *method = LIBSSH2_ALLOC(session, *method_len);
+        if(*method)
             memcpy((char *) *method, p.method, *method_len);
         else
             ret = -1;
     }
 
-    if (ret) {
-        if (*method)
+    if(ret) {
+        if(*method)
             LIBSSH2_FREE(session, *method);
-        if (p.data)
+        if(p.data)
             LIBSSH2_FREE(session, (void *) p.data);
         *method = NULL;
         *method_len = 0;
-    } else {
+    }
+    else {
         *pubkeydata = (unsigned char *) p.data;
         *pubkeydata_len = p.length;
     }
@@ -2179,7 +2188,7 @@ _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
     Qc3_Format_ALGD0400_T algd;
     Qus_EC_t errcode;
 
-    if (!ctx)
+    if(!ctx)
         return -1;
 
     /* Try with "ENCRYPTED PRIVATE KEY" PEM armor.
@@ -2190,29 +2199,30 @@ _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
 
     /* Try with "PRIVATE KEY" PEM armor.
        --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
-    if (ret)
+    if(ret)
         ret = _libssh2_pem_parse_memory(session,
                                         beginprivkeyhdr, endprivkeyhdr,
                                         filedata, filedata_len,
                                         &data, &datalen);
 
-    if (!ret) {
+    if(!ret) {
         /* Process PKCS#8. */
         ret = rsapkcs8privkey(session,
                               data, datalen, passphrase, (void *) &ctx);
-    } else {
+    }
+    else {
         /* Try with "RSA PRIVATE KEY" PEM armor.
            --> PKCS#1 RSAPrivateKey */
         ret = _libssh2_pem_parse_memory(session,
                                         beginrsaprivkeyhdr, endrsaprivkeyhdr,
                                         filedata, filedata_len,
                                         &data, &datalen);
-        if (!ret)
+        if(!ret)
             ret = rsapkcs1privkey(session,
                                   data, datalen, passphrase, (void *) &ctx);
     }
 
-    if (ret) {
+    if(ret) {
         /* Try as PKCS#8 DER data.
            --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
         ret = rsapkcs8privkey(session, filedata, filedata_len,
@@ -2220,15 +2230,15 @@ _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
 
         /* Try as PKCS#1 DER data.
            --> PKCS#1 RSAPrivateKey */
-        if (ret)
+        if(ret)
             ret = rsapkcs1privkey(session, filedata, filedata_len,
                                   passphrase, (void *) &ctx);
     }
 
-    if (data)
+    if(data)
         LIBSSH2_FREE(session, data);
 
-    if (!ret) {
+    if(!ret) {
         /* Create the algorithm context. */
         algd.Public_Key_Alg = Qc3_RSA;
         algd.PKA_Block_Format = Qc3_PKCS1_01;
@@ -2237,11 +2247,11 @@ _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
         set_EC_length(errcode, sizeof errcode);
         Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Public_Key,
                                   ctx->hash.Alg_Context_Token, &errcode);
-        if (errcode.Bytes_Available)
+        if(errcode.Bytes_Available)
             ret = -1;
     }
 
-    if (ret) {
+    if(ret) {
         _libssh2_os400qc3_crypto_dtor(ctx);
         ctx = NULL;
     }
@@ -2279,29 +2289,30 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
 
     /* Try with "PRIVATE KEY" PEM armor.
        --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
-    if (ret)
+    if(ret)
         ret = _libssh2_pem_parse_memory(session,
                                         beginprivkeyhdr, endprivkeyhdr,
                                         privatekeydata, privatekeydata_len,
                                         &data, &datalen);
 
-    if (!ret) {
+    if(!ret) {
         /* Process PKCS#8. */
         ret = rsapkcs8pubkey(session,
                              data, datalen, passphrase, (void *) &p);
-    } else {
+    }
+    else {
         /* Try with "RSA PRIVATE KEY" PEM armor.
            --> PKCS#1 RSAPrivateKey */
         ret = _libssh2_pem_parse_memory(session,
                                         beginrsaprivkeyhdr, endrsaprivkeyhdr,
                                         privatekeydata, privatekeydata_len,
                                         &data, &datalen);
-        if (!ret)
+        if(!ret)
             ret = rsapkcs1pubkey(session,
                                  data, datalen, passphrase, (void *) &p);
     }
 
-    if (ret) {
+    if(ret) {
         /* Try as PKCS#8 DER data.
            --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
         ret = rsapkcs8pubkey(session, privatekeydata, privatekeydata_len,
@@ -2309,29 +2320,31 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
 
         /* Try as PKCS#1 DER data.
            --> PKCS#1 RSAPrivateKey */
-        if (ret)
+        if(ret)
             ret = rsapkcs1pubkey(session, privatekeydata, privatekeydata_len,
                                  passphrase, (void *) &p);
     }
 
-    if (data)
+    if(data)
         LIBSSH2_FREE(session, data);
 
-    if (!ret) {
+    if(!ret) {
         *method_len = strlen(p.method);
-        if ((*method = LIBSSH2_ALLOC(session, *method_len)))
+        *method = LIBSSH2_ALLOC(session, *method_len);
+        if(*method)
             memcpy((char *) *method, p.method, *method_len);
         else
             ret = -1;
     }
-    if (ret) {
-        if (*method)
+    if(ret) {
+        if(*method)
             LIBSSH2_FREE(session, *method);
-        if (p.data)
+        if(p.data)
             LIBSSH2_FREE(session, (void *) p.data);
         *method = NULL;
         *method_len = 0;
-    } else {
+    }
+    else {
         *pubkeydata = (unsigned char *) p.data;
         *pubkeydata_len = p.length;
     }
@@ -2378,10 +2391,10 @@ _libssh2_os400qc3_rsa_sha1_signv(LIBSSH2_SESSION *session,
                           anycsp, NULL, sigbuf, &sigbufsize, &siglen,
                           (char *) &errcode);
     ctx->hash.Final_Op_Flag = Qc3_Continue;
-    if (errcode.Bytes_Available)
+    if(errcode.Bytes_Available)
         return -1;
     sig = LIBSSH2_ALLOC(session, siglen);
-    if (!sig)
+    if(!sig)
         return -1;
     memcpy((char *) sig, sigbuf, siglen);
     *signature = sig;
diff --git a/src/os400qc3.h b/src/os400qc3.h
index 2e2f56a9..7af24168 100644
--- a/src/os400qc3.h
+++ b/src/os400qc3.h
@@ -296,8 +296,8 @@ typedef struct {        /* Diffie-Hellman context. */
                                    Qc3_CTR, 24}
 #define _libssh2_cipher_aes256ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 32,       \
                                    Qc3_CTR, 32}
-#define _libssh2_cipher_3des   {Qc3_Alg_Block_Cipher, Qc3_TDES, 0,          \
-                                Qc3_CBC, 24}
+#define _libssh2_cipher_3des {Qc3_Alg_Block_Cipher, Qc3_TDES, 0,            \
+                              Qc3_CBC, 24}
 #define _libssh2_cipher_arcfour {Qc3_Alg_Stream_Cipher, Qc3_RC4, 0, 0, 16}
 
 #define _libssh2_cipher_dtor(ctx) _libssh2_os400qc3_crypto_dtor(ctx)
diff --git a/src/packet.c b/src/packet.c
index 5f1feb8c..39390bcd 100644
--- a/src/packet.c
+++ b/src/packet.c
@@ -87,7 +87,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
 
     (void) datalen;
 
-    if (listen_state->state == libssh2_NB_state_idle) {
+    if(listen_state->state == libssh2_NB_state_idle) {
         unsigned char *s = data + (sizeof("forwarded-tcpip") - 1) + 5;
         listen_state->sender_channel = _libssh2_ntohu32(s);
         s += 4;
@@ -118,9 +118,9 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
         listen_state->state = libssh2_NB_state_allocated;
     }
 
-    if (listen_state->state != libssh2_NB_state_sent) {
-        while (listn) {
-            if ((listn->port == (int) listen_state->port) &&
+    if(listen_state->state != libssh2_NB_state_sent) {
+        while(listn) {
+            if((listn->port == (int) listen_state->port) &&
                 (strlen(listn->host) == listen_state->host_len) &&
                 (memcmp (listn->host, listen_state->host,
                          listen_state->host_len) == 0)) {
@@ -128,8 +128,8 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                 LIBSSH2_CHANNEL *channel = NULL;
                 listen_state->channel = NULL;
 
-                if (listen_state->state == libssh2_NB_state_allocated) {
-                    if (listn->queue_maxsize &&
+                if(listen_state->state == libssh2_NB_state_allocated) {
+                    if(listn->queue_maxsize &&
                         (listn->queue_maxsize <= listn->queue_size)) {
                         /* Queue is full */
                         failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
@@ -140,7 +140,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                     }
 
                     channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-                    if (!channel) {
+                    if(!channel) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Unable to allocate a channel for "
                                        "new connection");
@@ -156,7 +156,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                                                           channel->
                                                           channel_type_len +
                                                           1);
-                    if (!channel->channel_type) {
+                    if(!channel->channel_type) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Unable to allocate a channel for new"
                                        " connection");
@@ -203,12 +203,12 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                     listen_state->state = libssh2_NB_state_created;
                 }
 
-                if (listen_state->state == libssh2_NB_state_created) {
+                if(listen_state->state == libssh2_NB_state_created) {
                     rc = _libssh2_transport_send(session, listen_state->packet,
                                                  17, NULL, 0);
-                    if (rc == LIBSSH2_ERROR_EAGAIN)
+                    if(rc == LIBSSH2_ERROR_EAGAIN)
                         return rc;
-                    else if (rc) {
+                    else if(rc) {
                         listen_state->state = libssh2_NB_state_idle;
                         return _libssh2_error(session, rc,
                                               "Unable to send channel "
@@ -216,7 +216,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                     }
 
                     /* Link the channel into the end of the queue list */
-                    if (listen_state->channel) {
+                    if(listen_state->channel) {
                         _libssh2_list_add(&listn->queue,
                                           &listen_state->channel->node);
                         listn->queue_size++;
@@ -243,9 +243,10 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
 
     rc = _libssh2_transport_send(session, listen_state->packet,
                                  packet_len, NULL, 0);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         listen_state->state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc, "Unable to send open failure");
 
@@ -273,7 +274,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
 
     (void) datalen;
 
-    if (x11open_state->state == libssh2_NB_state_idle) {
+    if(x11open_state->state == libssh2_NB_state_idle) {
         unsigned char *s = data + (sizeof("x11") - 1) + 5;
         x11open_state->sender_channel = _libssh2_ntohu32(s);
         s += 4;
@@ -295,10 +296,10 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
         x11open_state->state = libssh2_NB_state_allocated;
     }
 
-    if (session->x11) {
-        if (x11open_state->state == libssh2_NB_state_allocated) {
+    if(session->x11) {
+        if(x11open_state->state == libssh2_NB_state_allocated) {
             channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-            if (!channel) {
+            if(!channel) {
                 _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                "allocate a channel for new connection");
                 failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
@@ -310,7 +311,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
             channel->channel_type = LIBSSH2_ALLOC(session,
                                                   channel->channel_type_len +
                                                   1);
-            if (!channel->channel_type) {
+            if(!channel->channel_type) {
                 _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                "allocate a channel for new connection");
                 LIBSSH2_FREE(session, channel);
@@ -350,12 +351,13 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
             x11open_state->state = libssh2_NB_state_created;
         }
 
-        if (x11open_state->state == libssh2_NB_state_created) {
+        if(x11open_state->state == libssh2_NB_state_created) {
             rc = _libssh2_transport_send(session, x11open_state->packet, 17,
                                          NULL, 0);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 return rc;
-            } else if (rc) {
+            }
+            else if(rc) {
                 x11open_state->state = libssh2_NB_state_idle;
                 return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                       "Unable to send channel open "
@@ -389,9 +391,10 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
 
     rc = _libssh2_transport_send(session, x11open_state->packet, packet_len,
                                  NULL, 0);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         x11open_state->state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc, "Unable to send open failure");
     }
@@ -416,10 +419,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                     size_t datalen, int macstate)
 {
     int rc = 0;
-    char *message=NULL;
-    char *language=NULL;
-    size_t message_len=0;
-    size_t language_len=0;
+    char *message = NULL;
+    char *language = NULL;
+    size_t message_len = 0;
+    size_t language_len = 0;
     LIBSSH2_CHANNEL *channelp = NULL;
     size_t data_head = 0;
     unsigned char msg = data[0];
@@ -430,7 +433,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                        "Packet type %d received, length=%d",
                        (int) msg, (int) datalen);
 
-        if ((macstate == LIBSSH2_MAC_INVALID) &&
+        if((macstate == LIBSSH2_MAC_INVALID) &&
             (!session->macerror ||
              LIBSSH2_MACERROR(session, (char *) data, datalen))) {
             /* Bad MAC input, but no callback set or non-zero return from the
@@ -456,9 +459,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         break;
     }
 
-    if (session->packAdd_state == libssh2_NB_state_allocated) {
+    if(session->packAdd_state == libssh2_NB_state_allocated) {
         /* A couple exceptions to the packet adding rule: */
-        switch (msg) {
+        switch(msg) {
 
             /*
               byte      SSH_MSG_DISCONNECT
@@ -489,9 +492,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                     }
                     else
                         /* bad size, clear it */
-                        message_len=0;
+                        message_len = 0;
                 }
-                if (session->ssh_msg_disconnect) {
+                if(session->ssh_msg_disconnect) {
                     LIBSSH2_DISCONNECT(session, reason, message,
                                        message_len, language, language_len);
                 }
@@ -511,11 +514,12 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
             */
 
         case SSH_MSG_IGNORE:
-            if (datalen >= 2) {
-                if (session->ssh_msg_ignore) {
+            if(datalen >= 2) {
+                if(session->ssh_msg_ignore) {
                     LIBSSH2_IGNORE(session, (char *) data + 1, datalen - 1);
                 }
-            } else if (session->ssh_msg_ignore) {
+            }
+            else if(session->ssh_msg_ignore) {
                 LIBSSH2_IGNORE(session, "", 0);
             }
             LIBSSH2_FREE(session, data);
@@ -531,7 +535,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 
         case SSH_MSG_DEBUG:
             if(datalen >= 2) {
-                int always_display= data[1];
+                int always_display = data[1];
 
                 if(datalen >= 6) {
                     message_len = _libssh2_ntohu32(data + 2);
@@ -546,7 +550,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                     }
                 }
 
-                if (session->ssh_msg_debug) {
+                if(session->ssh_msg_debug) {
                     LIBSSH2_DEBUG(session, always_display, message,
                                   message_len, language, language_len);
                 }
@@ -570,8 +574,8 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 
         case SSH_MSG_GLOBAL_REQUEST:
             if(datalen >= 5) {
-                uint32_t len =0;
-                unsigned char want_reply=0;
+                uint32_t len = 0;
+                unsigned char want_reply = 0;
                 len = _libssh2_ntohu32(data + 1);
                 if(datalen >= (6 + len)) {
                     want_reply = data[5 + len];
@@ -582,13 +586,13 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 }
 
 
-                if (want_reply) {
+                if(want_reply) {
                     static const unsigned char packet =
                         SSH_MSG_REQUEST_FAILURE;
                   libssh2_packet_add_jump_point5:
                     session->packAdd_state = libssh2_NB_state_jump5;
                     rc = _libssh2_transport_send(session, &packet, 1, NULL, 0);
-                    if (rc == LIBSSH2_ERROR_EAGAIN)
+                    if(rc == LIBSSH2_ERROR_EAGAIN)
                         return rc;
                 }
             }
@@ -624,7 +628,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                     _libssh2_channel_locate(session,
                                             _libssh2_ntohu32(data + 1));
 
-            if (!channelp) {
+            if(!channelp) {
                 _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN,
                                "Packet received for unknown channel");
                 LIBSSH2_FREE(session, data);
@@ -634,7 +638,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 #ifdef LIBSSH2DEBUG
             {
                 uint32_t stream_id = 0;
-                if (msg == SSH_MSG_CHANNEL_EXTENDED_DATA)
+                if(msg == SSH_MSG_CHANNEL_EXTENDED_DATA)
                     stream_id = _libssh2_ntohu32(data + 5);
 
                 _libssh2_debug(session, LIBSSH2_TRACE_CONN,
@@ -645,7 +649,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                                stream_id);
             }
 #endif
-            if ((channelp->remote.extended_data_ignore_mode ==
+            if((channelp->remote.extended_data_ignore_mode ==
                  LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) &&
                 (msg == SSH_MSG_CHANNEL_EXTENDED_DATA)) {
                 /* Pretend we didn't receive this */
@@ -654,7 +658,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                                "Ignoring extended data and refunding %d bytes",
                                (int) (datalen - 13));
-                if (channelp->read_avail + datalen - data_head >=
+                if(channelp->read_avail + datalen - data_head >=
                     channelp->remote.window_size)
                     datalen = channelp->remote.window_size -
                         channelp->read_avail + data_head;
@@ -675,7 +679,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                                                             packAdd_channelp,
                                                             datalen - 13,
                                                             1, NULL);
-                if (rc == LIBSSH2_ERROR_EAGAIN)
+                if(rc == LIBSSH2_ERROR_EAGAIN)
                     return rc;
 
                 session->packAdd_state = libssh2_NB_state_idle;
@@ -686,7 +690,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
              * REMEMBER! remote means remote as source of data,
              * NOT remote window!
              */
-            if (channelp->remote.packet_size < (datalen - data_head)) {
+            if(channelp->remote.packet_size < (datalen - data_head)) {
                 /*
                  * Spec says we MAY ignore bytes sent beyond
                  * packet_size
@@ -697,7 +701,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                                " to receive, truncating");
                 datalen = channelp->remote.packet_size + data_head;
             }
-            if (channelp->remote.window_size <= channelp->read_avail) {
+            if(channelp->remote.window_size <= channelp->read_avail) {
                 /*
                  * Spec says we MAY ignore bytes sent beyond
                  * window_size
@@ -713,7 +717,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
             /* Reset EOF status */
             channelp->remote.eof = 0;
 
-            if (channelp->read_avail + datalen - data_head >
+            if(channelp->read_avail + datalen - data_head >
                 channelp->remote.window_size) {
                 _libssh2_error(session,
                                LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
@@ -746,7 +750,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 channelp =
                     _libssh2_channel_locate(session,
                                             _libssh2_ntohu32(data + 1));
-            if (!channelp)
+            if(!channelp)
                 /* We may have freed already, just quietly ignore this... */
                 ;
             else {
@@ -783,7 +787,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                                "Channel %d received request type %.*s (wr %X)",
                                channel, len, data + 9, want_reply);
 
-                if (len == sizeof("exit-status") - 1
+                if(len == sizeof("exit-status") - 1
                     && !memcmp("exit-status", data + 9,
                                sizeof("exit-status") - 1)) {
 
@@ -792,7 +796,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                         channelp =
                             _libssh2_channel_locate(session, channel);
 
-                    if (channelp) {
+                    if(channelp) {
                         channelp->exit_status =
                             _libssh2_ntohu32(data + 9 + sizeof("exit-status"));
                         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
@@ -804,20 +808,20 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                     }
 
                 }
-                else if (len == sizeof("exit-signal") - 1
+                else if(len == sizeof("exit-signal") - 1
                          && !memcmp("exit-signal", data + 9,
                                     sizeof("exit-signal") - 1)) {
                     /* command terminated due to signal */
                     if(datalen >= 20)
                         channelp = _libssh2_channel_locate(session, channel);
 
-                    if (channelp) {
+                    if(channelp) {
                         /* set signal name (without SIG prefix) */
                         uint32_t namelen =
                             _libssh2_ntohu32(data + 9 + sizeof("exit-signal"));
                         channelp->exit_signal =
                             LIBSSH2_ALLOC(session, namelen + 1);
-                        if (!channelp->exit_signal)
+                        if(!channelp->exit_signal)
                             rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                                 "memory for signal name");
                         else {
@@ -836,14 +840,14 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 }
 
 
-                if (want_reply) {
+                if(want_reply) {
                     unsigned char packet[5];
                   libssh2_packet_add_jump_point4:
                     session->packAdd_state = libssh2_NB_state_jump4;
                     packet[0] = SSH_MSG_CHANNEL_FAILURE;
-                    memcpy(&packet[1], data+1, 4);
+                    memcpy(&packet[1], data + 1, 4);
                     rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
-                    if (rc == LIBSSH2_ERROR_EAGAIN)
+                    if(rc == LIBSSH2_ERROR_EAGAIN)
                         return rc;
                 }
             }
@@ -861,7 +865,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 channelp =
                     _libssh2_channel_locate(session,
                                             _libssh2_ntohu32(data + 1));
-            if (!channelp) {
+            if(!channelp) {
                 /* We may have freed already, just quietly ignore this... */
                 LIBSSH2_FREE(session, data);
                 session->packAdd_state = libssh2_NB_state_idle;
@@ -890,7 +894,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         case SSH_MSG_CHANNEL_OPEN:
             if(datalen < 17)
                 ;
-            else if ((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
+            else if((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
                      ((sizeof("forwarded-tcpip") - 1) ==
                       _libssh2_ntohu32(data + 1))
                      &&
@@ -906,7 +910,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 rc = packet_queue_listener(session, data, datalen,
                                            &session->packAdd_Qlstn_state);
             }
-            else if ((datalen >= (sizeof("x11") + 4)) &&
+            else if((datalen >= (sizeof("x11") + 4)) &&
                      ((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) &&
                      (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) {
 
@@ -919,7 +923,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 rc = packet_x11_open(session, data, datalen,
                                      &session->packAdd_x11open_state);
             }
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
 
             LIBSSH2_FREE(session, data);
@@ -961,10 +965,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         session->packAdd_state = libssh2_NB_state_sent;
     }
 
-    if (session->packAdd_state == libssh2_NB_state_sent) {
+    if(session->packAdd_state == libssh2_NB_state_sent) {
         LIBSSH2_PACKET *packetp =
             LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
-        if (!packetp) {
+        if(!packetp) {
             _libssh2_debug(session, LIBSSH2_ERROR_ALLOC,
                            "memory for packet");
             LIBSSH2_FREE(session, data);
@@ -980,10 +984,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         session->packAdd_state = libssh2_NB_state_sent1;
     }
 
-    if ((msg == SSH_MSG_KEXINIT &&
+    if((msg == SSH_MSG_KEXINIT &&
          !(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) ||
         (session->packAdd_state == libssh2_NB_state_sent2)) {
-        if (session->packAdd_state == libssh2_NB_state_sent1) {
+        if(session->packAdd_state == libssh2_NB_state_sent1) {
             /*
              * Remote wants new keys
              * Well, it's already in the brigade,
@@ -1012,7 +1016,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
          * send NEWKEYS yet, otherwise remote will drop us like a rock
          */
         rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
     }
 
@@ -1037,8 +1041,8 @@ _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
     _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                    "Looking for packet of type: %d", (int) packet_type);
 
-    while (packet) {
-        if (packet->data[0] == packet_type
+    while(packet) {
+        if(packet->data[0] == packet_type
             && (packet->data_len >= (match_ofs + match_len))
             && (!match_buf ||
                 (memcmp(packet->data + match_ofs, match_buf,
@@ -1075,7 +1079,7 @@ _libssh2_packet_askv(LIBSSH2_SESSION * session,
     int i, packet_types_len = strlen((char *) packet_types);
 
     for(i = 0; i < packet_types_len; i++) {
-        if (0 == _libssh2_packet_ask(session, packet_types[i], data,
+        if(0 == _libssh2_packet_ask(session, packet_types[i], data,
                                      data_len, match_ofs,
                                      match_buf, match_len)) {
             return 0;
@@ -1102,8 +1106,8 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
                         size_t match_len,
                         packet_require_state_t *state)
 {
-    if (state->start == 0) {
-        if (_libssh2_packet_ask(session, packet_type, data, data_len,
+    if(state->start == 0) {
+        if(_libssh2_packet_ask(session, packet_type, data, data_len,
                                 match_ofs, match_buf,
                                 match_len) == 0) {
             /* A packet was available in the packet brigade */
@@ -1113,26 +1117,28 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
         state->start = time(NULL);
     }
 
-    while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
+    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
         int ret = _libssh2_transport_read(session);
-        if (ret == LIBSSH2_ERROR_EAGAIN)
+        if(ret == LIBSSH2_ERROR_EAGAIN)
             return ret;
-        else if (ret < 0) {
+        else if(ret < 0) {
             state->start = 0;
             /* an error which is not just because of blocking */
             return ret;
-        } else if (ret == packet_type) {
+        }
+        else if(ret == packet_type) {
             /* Be lazy, let packet_ask pull it out of the brigade */
             ret = _libssh2_packet_ask(session, packet_type, data, data_len,
                                       match_ofs, match_buf, match_len);
             state->start = 0;
             return ret;
-        } else if (ret == 0) {
+        }
+        else if(ret == 0) {
             /* nothing available, wait until data arrives or we time out */
             long left = LIBSSH2_READ_TIMEOUT - (long)(time(NULL) -
                                                       state->start);
 
-            if (left <= 0) {
+            if(left <= 0) {
                 state->start = 0;
                 return LIBSSH2_ERROR_TIMEOUT;
             }
@@ -1160,13 +1166,13 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
     unsigned char i, all_packets[255];
     int ret;
 
-    if (*state == libssh2_NB_state_idle) {
+    if(*state == libssh2_NB_state_idle) {
         for(i = 1; i < 255; i++) {
             all_packets[i - 1] = i;
         }
         all_packets[254] = 0;
 
-        if (_libssh2_packet_askv(session, all_packets, &data, &data_len, 0,
+        if(_libssh2_packet_askv(session, all_packets, &data, &data_len, 0,
                                  NULL, 0) == 0) {
             i = data[0];
             /* A packet was available in the packet brigade, burn it */
@@ -1179,20 +1185,22 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
         *state = libssh2_NB_state_created;
     }
 
-    while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
+    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
         ret = _libssh2_transport_read(session);
-        if (ret == LIBSSH2_ERROR_EAGAIN) {
+        if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
-        } else if (ret < 0) {
+        }
+        else if(ret < 0) {
             *state = libssh2_NB_state_idle;
             return ret;
-        } else if (ret == 0) {
+        }
+        else if(ret == 0) {
             /* FIXME: this might busyloop */
             continue;
         }
 
         /* Be lazy, let packet_ask pull it out of the brigade */
-        if (0 ==
+        if(0 ==
             _libssh2_packet_ask(session, (unsigned char)ret,
                                          &data, &data_len, 0, NULL, 0)) {
             /* Smoke 'em if you got 'em */
@@ -1222,37 +1230,37 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
                          const unsigned char *match_buf, size_t match_len,
                          packet_requirev_state_t * state)
 {
-    if (_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs,
+    if(_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs,
                              match_buf, match_len) == 0) {
         /* One of the packets listed was available in the packet brigade */
         state->start = 0;
         return 0;
     }
 
-    if (state->start == 0) {
+    if(state->start == 0) {
         state->start = time(NULL);
     }
 
-    while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
+    while(session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
         int ret = _libssh2_transport_read(session);
-        if ((ret < 0) && (ret != LIBSSH2_ERROR_EAGAIN)) {
+        if((ret < 0) && (ret != LIBSSH2_ERROR_EAGAIN)) {
             state->start = 0;
             return ret;
         }
-        if (ret <= 0) {
+        if(ret <= 0) {
             long left = LIBSSH2_READ_TIMEOUT -
                 (long)(time(NULL) - state->start);
 
-            if (left <= 0) {
+            if(left <= 0) {
                 state->start = 0;
                 return LIBSSH2_ERROR_TIMEOUT;
             }
-            else if (ret == LIBSSH2_ERROR_EAGAIN) {
+            else if(ret == LIBSSH2_ERROR_EAGAIN) {
                 return ret;
             }
         }
 
-        if (strchr((char *) packet_types, ret)) {
+        if(strchr((char *) packet_types, ret)) {
             /* Be lazy, let packet_ask pull it out of the brigade */
             return _libssh2_packet_askv(session, packet_types, data,
                                         data_len, match_ofs, match_buf,
diff --git a/src/pem.c b/src/pem.c
index 044fd455..4fa02bb5 100644
--- a/src/pem.c
+++ b/src/pem.c
@@ -43,23 +43,23 @@ readline(char *line, int line_size, FILE * fp)
 {
     size_t len;
 
-    if (!line) {
+    if(!line) {
         return -1;
     }
-    if (!fgets(line, line_size, fp)) {
+    if(!fgets(line, line_size, fp)) {
         return -1;
     }
 
-    if (*line) {
+    if(*line) {
         len = strlen(line);
-        if (len > 0 && line[len - 1] == '\n') {
+        if(len > 0 && line[len - 1] == '\n') {
             line[len - 1] = '\0';
         }
     }
 
-    if (*line) {
+    if(*line) {
         len = strlen(line);
-        if (len > 0 && line[len - 1] == '\r') {
+        if(len > 0 && line[len - 1] == '\r') {
             line[len - 1] = '\0';
         }
     }
@@ -76,14 +76,14 @@ readline_memory(char *line, size_t line_size,
 
     off = *filedata_offset;
 
-    for (len = 0; off + len < filedata_len && len < line_size - 1; len++) {
-        if (filedata[off + len] == '\n' ||
+    for(len = 0; off + len < filedata_len && len < line_size - 1; len++) {
+        if(filedata[off + len] == '\n' ||
             filedata[off + len] == '\r') {
                 break;
         }
     }
 
-    if (len) {
+    if(len) {
         memcpy(line, filedata + off, len);
         *filedata_offset += len;
     }
@@ -120,62 +120,62 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
     do {
         *line = '\0';
 
-        if (readline(line, LINE_SIZE, fp)) {
+        if(readline(line, LINE_SIZE, fp)) {
             return -1;
         }
     }
-    while (strcmp(line, headerbegin) != 0);
+    while(strcmp(line, headerbegin) != 0);
 
-    if (readline(line, LINE_SIZE, fp)) {
+    if(readline(line, LINE_SIZE, fp)) {
         return -1;
     }
 
-    if (passphrase &&
+    if(passphrase &&
             memcmp(line, crypt_annotation, strlen(crypt_annotation)) == 0) {
         const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method;
         int i;
 
-        if (readline(line, LINE_SIZE, fp)) {
+        if(readline(line, LINE_SIZE, fp)) {
             ret = -1;
             goto out;
         }
 
         all_methods = libssh2_crypt_methods();
-        while ((cur_method = *all_methods++)) {
-            if (*cur_method->pem_annotation &&
+        while((cur_method = *all_methods++)) {
+            if(*cur_method->pem_annotation &&
                     memcmp(line, cur_method->pem_annotation,
                            strlen(cur_method->pem_annotation)) == 0) {
                 method = cur_method;
-                memcpy(iv, line+strlen(method->pem_annotation)+1,
+                memcpy(iv, line + strlen(method->pem_annotation) + 1,
                        2*method->iv_len);
             }
         }
 
         /* None of the available crypt methods were able to decrypt the key */
-        if (method == NULL)
+        if(method == NULL)
             return -1;
 
         /* Decode IV from hex */
-        for (i = 0; i < method->iv_len; ++i) {
+        for(i = 0; i < method->iv_len; ++i) {
             iv[i]  = hex_decode(iv[2*i]) << 4;
-            iv[i] |= hex_decode(iv[2*i+1]);
+            iv[i] |= hex_decode(iv[2*i + 1]);
         }
 
         /* skip to the next line */
-        if (readline(line, LINE_SIZE, fp)) {
+        if(readline(line, LINE_SIZE, fp)) {
             ret = -1;
             goto out;
         }
     }
 
     do {
-        if (*line) {
+        if(*line) {
             char *tmp;
             size_t linelen;
 
             linelen = strlen(line);
             tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if (!tmp) {
+            if(!tmp) {
                 ret = -1;
                 goto out;
             }
@@ -186,23 +186,23 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
 
         *line = '\0';
 
-        if (readline(line, LINE_SIZE, fp)) {
+        if(readline(line, LINE_SIZE, fp)) {
             ret = -1;
             goto out;
         }
-    } while (strcmp(line, headerend) != 0);
+    } while(strcmp(line, headerend) != 0);
 
-    if (!b64data) {
+    if(!b64data) {
         return -1;
     }
 
-    if (libssh2_base64_decode(session, (char**) data, datalen,
+    if(libssh2_base64_decode(session, (char **) data, datalen,
                               b64data, b64datalen)) {
         ret = -1;
         goto out;
     }
 
-    if (method) {
+    if(method) {
         /* Set up decryption */
         int free_iv = 0, free_secret = 0, len_decrypted = 0, padding = 0;
         int blocksize = method->blocksize;
@@ -211,42 +211,42 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         libssh2_md5_ctx fingerprint_ctx;
 
         /* Perform key derivation (PBKDF1/MD5) */
-        if (!libssh2_md5_init(&fingerprint_ctx)) {
+        if(!libssh2_md5_init(&fingerprint_ctx)) {
             ret = -1;
             goto out;
         }
         libssh2_md5_update(fingerprint_ctx, passphrase,
-                           strlen((char*)passphrase));
+                           strlen((char *)passphrase));
         libssh2_md5_update(fingerprint_ctx, iv, 8);
         libssh2_md5_final(fingerprint_ctx, secret);
-        if (method->secret_len > MD5_DIGEST_LENGTH) {
-            if (!libssh2_md5_init(&fingerprint_ctx)) {
+        if(method->secret_len > MD5_DIGEST_LENGTH) {
+            if(!libssh2_md5_init(&fingerprint_ctx)) {
                 ret = -1;
                 goto out;
             }
             libssh2_md5_update(fingerprint_ctx, secret, MD5_DIGEST_LENGTH);
             libssh2_md5_update(fingerprint_ctx, passphrase,
-                               strlen((char*)passphrase));
+                               strlen((char *)passphrase));
             libssh2_md5_update(fingerprint_ctx, iv, 8);
             libssh2_md5_final(fingerprint_ctx, secret + MD5_DIGEST_LENGTH);
         }
 
         /* Initialize the decryption */
-        if (method->init(session, method, iv, &free_iv, secret,
+        if(method->init(session, method, iv, &free_iv, secret,
                          &free_secret, 0, &abstract)) {
-            memset((char*)secret, 0, sizeof(secret));
+            memset((char *)secret, 0, sizeof(secret));
             LIBSSH2_FREE(session, data);
             ret = -1;
             goto out;
         }
 
-        if (free_secret) {
-            memset((char*)secret, 0, sizeof(secret));
+        if(free_secret) {
+            memset((char *)secret, 0, sizeof(secret));
         }
 
         /* Do the actual decryption */
-        if ((*datalen % blocksize) != 0) {
-            memset((char*)secret, 0, sizeof(secret));
+        if((*datalen % blocksize) != 0) {
+            memset((char *)secret, 0, sizeof(secret));
             method->dtor(session, &abstract);
             memset(*data, 0, *datalen);
             LIBSSH2_FREE(session, *data);
@@ -254,11 +254,11 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
             goto out;
         }
 
-        while (len_decrypted <= *datalen - blocksize) {
-            if (method->crypt(session, *data + len_decrypted, blocksize,
+        while(len_decrypted <= *datalen - blocksize) {
+            if(method->crypt(session, *data + len_decrypted, blocksize,
                               &abstract)) {
                 ret = LIBSSH2_ERROR_DECRYPT;
-                memset((char*)secret, 0, sizeof(secret));
+                memset((char *)secret, 0, sizeof(secret));
                 method->dtor(session, &abstract);
                 memset(*data, 0, *datalen);
                 LIBSSH2_FREE(session, *data);
@@ -270,17 +270,17 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
 
         /* Account for padding */
         padding = (*data)[*datalen - 1];
-        memset(&(*data)[*datalen-padding],0,padding);
+        memset(&(*data)[*datalen-padding], 0, padding);
         *datalen -= padding;
 
         /* Clean up */
-        memset((char*)secret, 0, sizeof(secret));
+        memset((char *)secret, 0, sizeof(secret));
         method->dtor(session, &abstract);
     }
 
     ret = 0;
   out:
-    if (b64data) {
+    if(b64data) {
         LIBSSH2_FREE(session, b64data);
     }
     return ret;
@@ -302,22 +302,22 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
     do {
         *line = '\0';
 
-        if (readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
+        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
             return -1;
         }
     }
-    while (strcmp(line, headerbegin) != 0);
+    while(strcmp(line, headerbegin) != 0);
 
     *line = '\0';
 
     do {
-        if (*line) {
+        if(*line) {
             char *tmp;
             size_t linelen;
 
             linelen = strlen(line);
             tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if (!tmp) {
+            if(!tmp) {
                 ret = -1;
                 goto out;
             }
@@ -328,17 +328,17 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
 
         *line = '\0';
 
-        if (readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
+        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
             ret = -1;
             goto out;
         }
-    } while (strcmp(line, headerend) != 0);
+    } while(strcmp(line, headerend) != 0);
 
-    if (!b64data) {
+    if(!b64data) {
         return -1;
     }
 
-    if (libssh2_base64_decode(session, (char**) data, datalen,
+    if(libssh2_base64_decode(session, (char **) data, datalen,
                               b64data, b64datalen)) {
         ret = -1;
         goto out;
@@ -346,7 +346,7 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
 
     ret = 0;
   out:
-    if (b64data) {
+    if(b64data) {
         LIBSSH2_FREE(session, b64data);
     }
     return ret;
@@ -359,27 +359,28 @@ read_asn1_length(const unsigned char *data,
     unsigned int lenlen;
     int nextpos;
 
-    if (datalen < 1) {
+    if(datalen < 1) {
         return -1;
     }
     *len = data[0];
 
-    if (*len >= 0x80) {
+    if(*len >= 0x80) {
         lenlen = *len & 0x7F;
         *len = data[1];
-        if (1 + lenlen > datalen) {
+        if(1 + lenlen > datalen) {
             return -1;
         }
-        if (lenlen > 1) {
+        if(lenlen > 1) {
             *len <<= 8;
             *len |= data[2];
         }
-    } else {
+    }
+    else {
         lenlen = 0;
     }
 
     nextpos = 1 + lenlen;
-    if (lenlen > 2 || 1 + lenlen + *len > datalen) {
+    if(lenlen > 2 || 1 + lenlen + *len > datalen) {
         return -1;
     }
 
@@ -392,11 +393,11 @@ _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
     unsigned int len;
     int lenlen;
 
-    if (*datalen < 1) {
+    if(*datalen < 1) {
         return -1;
     }
 
-    if ((*data)[0] != '\x30') {
+    if((*data)[0] != '\x30') {
         return -1;
     }
 
@@ -404,7 +405,7 @@ _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
     (*datalen)--;
 
     lenlen = read_asn1_length(*data, *datalen, &len);
-    if (lenlen < 0 || lenlen + len != *datalen) {
+    if(lenlen < 0 || lenlen + len != *datalen) {
         return -1;
     }
 
@@ -421,11 +422,11 @@ _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
     unsigned int len;
     int lenlen;
 
-    if (*datalen < 1) {
+    if(*datalen < 1) {
         return -1;
     }
 
-    if ((*data)[0] != '\x02') {
+    if((*data)[0] != '\x02') {
         return -1;
     }
 
@@ -433,7 +434,7 @@ _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
     (*datalen)--;
 
     lenlen = read_asn1_length(*data, *datalen, &len);
-    if (lenlen < 0 || lenlen + len > *datalen) {
+    if(lenlen < 0 || lenlen + len > *datalen) {
         return -1;
     }
 
diff --git a/src/publickey.c b/src/publickey.c
index bfee0a84..5aba47fc 100644
--- a/src/publickey.c
+++ b/src/publickey.c
@@ -60,7 +60,7 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] =
     {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1},
     {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1},
     {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey",
-     sizeof("publickey") - 1} ,
+     sizeof("publickey") - 1},
     {0, NULL, 0}
 };
 
@@ -78,13 +78,13 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] =
 #define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX       8
 
 static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = {
-    {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1} ,
+    {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1},
     {LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied",
      sizeof("access denied") - 1},
     {LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded",
-     sizeof("storage exceeded") - 1} ,
+     sizeof("storage exceeded") - 1},
     {LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported",
-     sizeof("version not supported") - 1} ,
+     sizeof("version not supported") - 1},
     {LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found",
      sizeof("key not found") - 1},
     {LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported",
@@ -110,13 +110,14 @@ publickey_status_error(const LIBSSH2_PUBLICKEY *pkey,
     const char *msg;
 
     /* GENERAL_FAILURE got remapped between version 1 and 2 */
-    if (status == 6 && pkey && pkey->version == 1) {
+    if(status == 6 && pkey && pkey->version == 1) {
         status = 7;
     }
 
-    if (status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
+    if(status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
         msg = "unknown";
-    } else {
+    }
+    else {
         msg = publickey_status_codes[status].name;
     }
 
@@ -139,11 +140,12 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
     *data = NULL; /* default to nothing returned */
     *data_len = 0;
 
-    if (pkey->receive_state == libssh2_NB_state_idle) {
+    if(pkey->receive_state == libssh2_NB_state_idle) {
         rc = _libssh2_channel_read(channel, 0, (char *) buffer, 4);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc != 4) {
+        }
+        else if(rc != 4) {
             return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
                                   "Invalid response from publickey subsystem");
         }
@@ -151,7 +153,7 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
         pkey->receive_packet_len = _libssh2_ntohu32(buffer);
         pkey->receive_packet =
             LIBSSH2_ALLOC(session, pkey->receive_packet_len);
-        if (!pkey->receive_packet) {
+        if(!pkey->receive_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate publickey response "
                                   "buffer");
@@ -160,12 +162,13 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
         pkey->receive_state = libssh2_NB_state_sent;
     }
 
-    if (pkey->receive_state == libssh2_NB_state_sent) {
+    if(pkey->receive_state == libssh2_NB_state_sent) {
         rc = _libssh2_channel_read(channel, 0, (char *) pkey->receive_packet,
                                    pkey->receive_packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc != (int)pkey->receive_packet_len) {
+        }
+        else if(rc != (int)pkey->receive_packet_len) {
             LIBSSH2_FREE(session, pkey->receive_packet);
             pkey->receive_packet = NULL;
             pkey->receive_state = libssh2_NB_state_idle;
@@ -195,20 +198,20 @@ publickey_response_id(unsigned char **pdata, size_t data_len)
     unsigned char *data = *pdata;
     const LIBSSH2_PUBLICKEY_CODE_LIST *codes = publickey_response_codes;
 
-    if (data_len < 4) {
+    if(data_len < 4) {
         /* Malformed response */
         return -1;
     }
     response_len = _libssh2_ntohu32(data);
     data += 4;
     data_len -= 4;
-    if (data_len < response_len) {
+    if(data_len < response_len) {
         /* Malformed response */
         return -1;
     }
 
-    while (codes->name) {
-        if ((unsigned long)codes->name_len == response_len &&
+    while(codes->name) {
+        if((unsigned long)codes->name_len == response_len &&
             strncmp(codes->name, (char *) data, response_len) == 0) {
             *pdata = data + response_len;
             return codes->code;
@@ -231,11 +234,12 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
     size_t data_len;
     int response;
 
-    while (1) {
+    while(1) {
         int rc = publickey_packet_receive(pkey, &data, &data_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
                                   "Timeout waiting for response from "
                                   "publickey subsystem");
@@ -244,7 +248,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
         s = data;
         response = publickey_response_id(&s, data_len);
 
-        switch (response) {
+        switch(response) {
         case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
             /* Error, or processing complete */
         {
@@ -252,7 +256,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
 
             LIBSSH2_FREE(session, data);
 
-            if (status == LIBSSH2_PUBLICKEY_SUCCESS)
+            if(status == LIBSSH2_PUBLICKEY_SUCCESS)
                 return 0;
 
             publickey_status_error(pkey, session, status);
@@ -260,7 +264,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
         }
         default:
             LIBSSH2_FREE(session, data);
-            if (response < 0) {
+            if(response < 0) {
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
                                       "Invalid publickey subsystem response");
@@ -289,7 +293,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
     int response;
     int rc;
 
-    if (session->pkeyInit_state == libssh2_NB_state_idle) {
+    if(session->pkeyInit_state == libssh2_NB_state_idle) {
         session->pkeyInit_data = NULL;
         session->pkeyInit_pkey = NULL;
         session->pkeyInit_channel = NULL;
@@ -300,7 +304,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_state = libssh2_NB_state_allocated;
     }
 
-    if (session->pkeyInit_state == libssh2_NB_state_allocated) {
+    if(session->pkeyInit_state == libssh2_NB_state_allocated) {
 
         session->pkeyInit_channel =
             _libssh2_channel_open(session, "session",
@@ -308,8 +312,8 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
                                   LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                   LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
                                   0);
-        if (!session->pkeyInit_channel) {
-            if (libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN)
+        if(!session->pkeyInit_channel) {
+            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN)
                 /* The error state is already set, so leave it */
                 return NULL;
             _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
@@ -320,17 +324,18 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_state = libssh2_NB_state_sent;
     }
 
-    if (session->pkeyInit_state == libssh2_NB_state_sent) {
+    if(session->pkeyInit_state == libssh2_NB_state_sent) {
         rc = _libssh2_channel_process_startup(session->pkeyInit_channel,
                                               "subsystem",
                                               sizeof("subsystem") - 1,
                                               "publickey",
                                               sizeof("publickey") - 1);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block starting publickey subsystem");
             return NULL;
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
                            "Unable to request publickey subsystem");
             goto err_exit;
@@ -339,11 +344,11 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_state = libssh2_NB_state_sent1;
     }
 
-    if (session->pkeyInit_state == libssh2_NB_state_sent1) {
+    if(session->pkeyInit_state == libssh2_NB_state_sent1) {
         unsigned char *s;
         rc = _libssh2_channel_extended_data(session->pkeyInit_channel,
                                             LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block starting publickey subsystem");
             return NULL;
@@ -351,7 +356,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
 
         session->pkeyInit_pkey =
             LIBSSH2_CALLOC(session, sizeof(LIBSSH2_PUBLICKEY));
-        if (!session->pkeyInit_pkey) {
+        if(!session->pkeyInit_pkey) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate a new publickey structure");
             goto err_exit;
@@ -377,15 +382,16 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_state = libssh2_NB_state_sent2;
     }
 
-    if (session->pkeyInit_state == libssh2_NB_state_sent2) {
+    if(session->pkeyInit_state == libssh2_NB_state_sent2) {
         rc = _libssh2_channel_write(session->pkeyInit_channel, 0,
                                     session->pkeyInit_buffer,
                                     19 - session->pkeyInit_buffer_sent);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending publickey version packet");
             return NULL;
-        } else if (rc < 0) {
+        }
+        else if(rc < 0) {
             _libssh2_error(session, rc,
                            "Unable to send publickey version packet");
             goto err_exit;
@@ -400,18 +406,19 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_state = libssh2_NB_state_sent3;
     }
 
-    if (session->pkeyInit_state == libssh2_NB_state_sent3) {
-        while (1) {
+    if(session->pkeyInit_state == libssh2_NB_state_sent3) {
+        while(1) {
             unsigned char *s;
             rc = publickey_packet_receive(session->pkeyInit_pkey,
                                           &session->pkeyInit_data,
                                           &session->pkeyInit_data_len);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block waiting for response from "
                                "publickey subsystem");
                 return NULL;
-            } else if (rc) {
+            }
+            else if(rc) {
                 _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
                                "Timeout waiting for response from "
                                "publickey subsystem");
@@ -419,14 +426,14 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
             }
 
             s = session->pkeyInit_data;
-            if ((response =
+            if((response =
                  publickey_response_id(&s, session->pkeyInit_data_len)) < 0) {
                 _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
                                "Invalid publickey subsystem response code");
                 goto err_exit;
             }
 
-            switch (response) {
+            switch(response) {
             case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
                 /* Error */
             {
@@ -443,7 +450,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
                 /* lang starts here */
                 s += lang_len;
 
-                if (s >
+                if(s >
                     session->pkeyInit_data + session->pkeyInit_data_len) {
                     _libssh2_error(session,
                                    LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
@@ -459,7 +466,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
             case LIBSSH2_PUBLICKEY_RESPONSE_VERSION:
                 /* What we want */
                 session->pkeyInit_pkey->version = _libssh2_ntohu32(s);
-                if (session->pkeyInit_pkey->version >
+                if(session->pkeyInit_pkey->version >
                     LIBSSH2_PUBLICKEY_VERSION) {
                     _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
                                    "Truncate remote publickey version from %lu",
@@ -489,19 +496,19 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
     /* Never reached except by direct goto */
   err_exit:
     session->pkeyInit_state = libssh2_NB_state_sent4;
-    if (session->pkeyInit_channel) {
+    if(session->pkeyInit_channel) {
         rc = _libssh2_channel_close(session->pkeyInit_channel);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block closing channel");
             return NULL;
         }
     }
-    if (session->pkeyInit_pkey) {
+    if(session->pkeyInit_pkey) {
         LIBSSH2_FREE(session, session->pkeyInit_pkey);
         session->pkeyInit_pkey = NULL;
     }
-    if (session->pkeyInit_data) {
+    if(session->pkeyInit_data) {
         LIBSSH2_FREE(session, session->pkeyInit_data);
         session->pkeyInit_data = NULL;
     }
@@ -553,16 +560,16 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
     channel = pkey->channel;
     session = channel->session;
 
-    if (pkey->add_state == libssh2_NB_state_idle) {
+    if(pkey->add_state == libssh2_NB_state_idle) {
         pkey->add_packet = NULL;
 
         _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey",
                        name);
 
-        if (pkey->version == 1) {
+        if(pkey->version == 1) {
             for(i = 0; i < num_attrs; i++) {
                 /* Search for a comment attribute */
-                if (attrs[i].name_len == (sizeof("comment") - 1) &&
+                if(attrs[i].name_len == (sizeof("comment") - 1) &&
                     strncmp(attrs[i].name, "comment",
                             sizeof("comment") - 1) == 0) {
                     comment = (unsigned char *) attrs[i].value;
@@ -571,7 +578,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
                 }
             }
             packet_len += 4 + comment_len;
-        } else {
+        }
+        else {
             packet_len += 5;    /* overwrite(1) + attribute_count(4) */
             for(i = 0; i < num_attrs; i++) {
                 packet_len += 9 + attrs[i].name_len + attrs[i].value_len;
@@ -580,7 +588,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
         }
 
         pkey->add_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!pkey->add_packet) {
+        if(!pkey->add_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "publickey \"add\" packet");
@@ -593,10 +601,10 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
         pkey->add_s += 4;
         memcpy(pkey->add_s, "add", sizeof("add") - 1);
         pkey->add_s += sizeof("add") - 1;
-        if (pkey->version == 1) {
+        if(pkey->version == 1) {
             _libssh2_htonu32(pkey->add_s, comment_len);
             pkey->add_s += 4;
-            if (comment) {
+            if(comment) {
                 memcpy(pkey->add_s, comment, comment_len);
                 pkey->add_s += comment_len;
             }
@@ -609,7 +617,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
             pkey->add_s += 4;
             memcpy(pkey->add_s, blob, blob_len);
             pkey->add_s += blob_len;
-        } else {
+        }
+        else {
             /* Version == 2 */
 
             _libssh2_htonu32(pkey->add_s, name_len);
@@ -644,12 +653,13 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
         pkey->add_state = libssh2_NB_state_created;
     }
 
-    if (pkey->add_state == libssh2_NB_state_created) {
+    if(pkey->add_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, pkey->add_packet,
                                     (pkey->add_s - pkey->add_packet));
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((pkey->add_s - pkey->add_packet) != rc) {
+        }
+        else if((pkey->add_s - pkey->add_packet) != rc) {
             LIBSSH2_FREE(session, pkey->add_packet);
             pkey->add_packet = NULL;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
@@ -662,7 +672,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
     }
 
     rc = publickey_response_success(pkey);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
     }
 
@@ -693,11 +703,11 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
     channel = pkey->channel;
     session = channel->session;
 
-    if (pkey->remove_state == libssh2_NB_state_idle) {
+    if(pkey->remove_state == libssh2_NB_state_idle) {
         pkey->remove_packet = NULL;
 
         pkey->remove_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!pkey->remove_packet) {
+        if(!pkey->remove_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "publickey \"remove\" packet");
@@ -727,12 +737,13 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
         pkey->remove_state = libssh2_NB_state_created;
     }
 
-    if (pkey->remove_state == libssh2_NB_state_created) {
+    if(pkey->remove_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, pkey->remove_packet,
                                     (pkey->remove_s - pkey->remove_packet));
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((pkey->remove_s - pkey->remove_packet) != rc) {
+        }
+        else if((pkey->remove_s - pkey->remove_packet) != rc) {
             LIBSSH2_FREE(session, pkey->remove_packet);
             pkey->remove_packet = NULL;
             pkey->remove_state = libssh2_NB_state_idle;
@@ -746,7 +757,7 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
     }
 
     rc = publickey_response_success(pkey);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
     }
 
@@ -776,7 +787,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
     channel = pkey->channel;
     session = channel->session;
 
-    if (pkey->listFetch_state == libssh2_NB_state_idle) {
+    if(pkey->listFetch_state == libssh2_NB_state_idle) {
         pkey->listFetch_data = NULL;
 
         pkey->listFetch_s = pkey->listFetch_buffer;
@@ -793,14 +804,15 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         pkey->listFetch_state = libssh2_NB_state_created;
     }
 
-    if (pkey->listFetch_state == libssh2_NB_state_created) {
+    if(pkey->listFetch_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0,
                                     pkey->listFetch_buffer,
                                     (pkey->listFetch_s -
                                      pkey->listFetch_buffer));
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
+        }
+        else if((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
             pkey->listFetch_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "Unable to send publickey list packet");
@@ -809,12 +821,13 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         pkey->listFetch_state = libssh2_NB_state_sent;
     }
 
-    while (1) {
+    while(1) {
         rc = publickey_packet_receive(pkey, &pkey->listFetch_data,
                                       &pkey->listFetch_data_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
                            "Timeout waiting for response from "
                            "publickey subsystem");
@@ -822,7 +835,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         }
 
         pkey->listFetch_s = pkey->listFetch_data;
-        if ((response =
+        if((response =
              publickey_response_id(&pkey->listFetch_s,
                                    pkey->listFetch_data_len)) < 0) {
             _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
@@ -830,7 +843,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
             goto err_exit;
         }
 
-        switch (response) {
+        switch(response) {
         case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
             /* Error, or processing complete */
         {
@@ -847,14 +860,14 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
             /* lang starts at pkey->listFetch_s */
             pkey->listFetch_s += lang_len;
 
-            if (pkey->listFetch_s >
+            if(pkey->listFetch_s >
                 pkey->listFetch_data + pkey->listFetch_data_len) {
                 _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
                                "Malformed publickey subsystem packet");
                 goto err_exit;
             }
 
-            if (status == LIBSSH2_PUBLICKEY_SUCCESS) {
+            if(status == LIBSSH2_PUBLICKEY_SUCCESS) {
                 LIBSSH2_FREE(session, pkey->listFetch_data);
                 pkey->listFetch_data = NULL;
                 *pkey_list = list;
@@ -868,7 +881,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         }
         case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY:
             /* What we want */
-            if (keys >= max_keys) {
+            if(keys >= max_keys) {
                 libssh2_publickey_list *newlist;
                 /* Grow the key list if necessary */
                 max_keys += 8;
@@ -876,7 +889,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                     LIBSSH2_REALLOC(session, list,
                                     (max_keys +
                                      1) * sizeof(libssh2_publickey_list));
-                if (!newlist) {
+                if(!newlist) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for "
                                    "publickey list");
@@ -884,17 +897,17 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                 }
                 list = newlist;
             }
-            if (pkey->version == 1) {
+            if(pkey->version == 1) {
                 unsigned long comment_len;
 
                 comment_len = _libssh2_ntohu32(pkey->listFetch_s);
                 pkey->listFetch_s += 4;
-                if (comment_len) {
+                if(comment_len) {
                     list[keys].num_attrs = 1;
                     list[keys].attrs =
                         LIBSSH2_ALLOC(session,
                                       sizeof(libssh2_publickey_attribute));
-                    if (!list[keys].attrs) {
+                    if(!list[keys].attrs) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Unable to allocate memory for "
                                        "publickey attributes");
@@ -907,7 +920,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                     list[keys].attrs[0].mandatory = 0;
 
                     pkey->listFetch_s += comment_len;
-                } else {
+                }
+                else {
                     list[keys].num_attrs = 0;
                     list[keys].attrs = NULL;
                 }
@@ -919,7 +933,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                 pkey->listFetch_s += 4;
                 list[keys].blob = pkey->listFetch_s;
                 pkey->listFetch_s += list[keys].blob_len;
-            } else {
+            }
+            else {
                 /* Version == 2 */
                 list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s);
                 pkey->listFetch_s += 4;
@@ -931,12 +946,12 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                 pkey->listFetch_s += list[keys].blob_len;
                 list[keys].num_attrs = _libssh2_ntohu32(pkey->listFetch_s);
                 pkey->listFetch_s += 4;
-                if (list[keys].num_attrs) {
+                if(list[keys].num_attrs) {
                     list[keys].attrs =
                         LIBSSH2_ALLOC(session,
                                       list[keys].num_attrs *
                                       sizeof(libssh2_publickey_attribute));
-                    if (!list[keys].attrs) {
+                    if(!list[keys].attrs) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Unable to allocate memory for "
                                        "publickey attributes");
@@ -957,7 +972,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                         /* actually an ignored value */
                         list[keys].attrs[i].mandatory = 0;
                     }
-                } else {
+                }
+                else {
                     list[keys].attrs = NULL;
                 }
             }
@@ -979,11 +995,11 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
 
     /* Only reached via explicit goto */
   err_exit:
-    if (pkey->listFetch_data) {
+    if(pkey->listFetch_data) {
         LIBSSH2_FREE(session, pkey->listFetch_data);
         pkey->listFetch_data = NULL;
     }
-    if (list) {
+    if(list) {
         libssh2_publickey_list_free(pkey, list);
     }
     pkey->listFetch_state = libssh2_NB_state_idle;
@@ -1005,8 +1021,8 @@ libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
 
     session = pkey->channel->session;
 
-    while (p->packet) {
-        if (p->attrs) {
+    while(p->packet) {
+        if(p->attrs) {
             LIBSSH2_FREE(session, p->attrs);
         }
         LIBSSH2_FREE(session, p->packet);
@@ -1033,25 +1049,25 @@ libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey)
     /*
      * Make sure all memory used in the state variables are free
      */
-    if (pkey->receive_packet) {
+    if(pkey->receive_packet) {
         LIBSSH2_FREE(session, pkey->receive_packet);
         pkey->receive_packet = NULL;
     }
-    if (pkey->add_packet) {
+    if(pkey->add_packet) {
         LIBSSH2_FREE(session, pkey->add_packet);
         pkey->add_packet = NULL;
     }
-    if (pkey->remove_packet) {
+    if(pkey->remove_packet) {
         LIBSSH2_FREE(session, pkey->remove_packet);
         pkey->remove_packet = NULL;
     }
-    if (pkey->listFetch_data) {
+    if(pkey->listFetch_data) {
         LIBSSH2_FREE(session, pkey->listFetch_data);
         pkey->listFetch_data = NULL;
     }
 
     rc = _libssh2_channel_free(pkey->channel);
-    if (rc == LIBSSH2_ERROR_EAGAIN)
+    if(rc == LIBSSH2_ERROR_EAGAIN)
         return rc;
 
     LIBSSH2_FREE(session, pkey);
diff --git a/src/scp.c b/src/scp.c
index d1665a6f..1438d4e8 100644
--- a/src/scp.c
+++ b/src/scp.c
@@ -141,9 +141,9 @@ shell_quotearg(const char *path, unsigned char *buf,
     endp = &buf[bufsize];
     src = path;
     dst = buf;
-    while (*src && dst < endp - 1) {
+    while(*src && dst < endp - 1) {
 
-        switch (*src) {
+        switch(*src) {
             /*
              * Special handling for apostrophe.
              * An apostrophe is always written in quotation marks, e.g.
@@ -151,16 +151,16 @@ shell_quotearg(const char *path, unsigned char *buf,
              */
 
         case '\'':
-            switch (state) {
+            switch(state) {
             case UQSTRING:      /* Unquoted string */
-                if (dst+1 >= endp)
+                if(dst + 1 >= endp)
                     return 0;
                 *dst++ = '"';
                 break;
             case QSTRING:       /* Continue quoted string */
                 break;
             case SQSTRING:      /* Close single quoted string */
-                if (dst+2 >= endp)
+                if(dst + 2 >= endp)
                     return 0;
                 *dst++ = '\'';
                 *dst++ = '"';
@@ -179,20 +179,20 @@ shell_quotearg(const char *path, unsigned char *buf,
              */
 
         case '!':
-            switch (state) {
+            switch(state) {
             case UQSTRING:
-                if (dst+1 >= endp)
+                if(dst + 1 >= endp)
                     return 0;
                 *dst++ = '\\';
                 break;
             case QSTRING:
-                if (dst+2 >= endp)
+                if(dst + 2 >= endp)
                     return 0;
                 *dst++ = '"';           /* Closing quotation mark */
                 *dst++ = '\\';
                 break;
             case SQSTRING:              /* Close single quoted string */
-                if (dst+2 >= endp)
+                if(dst + 2 >= endp)
                     return 0;
                 *dst++ = '\'';
                 *dst++ = '\\';
@@ -208,14 +208,14 @@ shell_quotearg(const char *path, unsigned char *buf,
              */
 
         default:
-            switch (state) {
+            switch(state) {
             case UQSTRING:
-                if (dst+1 >= endp)
+                if(dst + 1 >= endp)
                     return 0;
                 *dst++ = '\'';
                 break;
             case QSTRING:
-                if (dst+2 >= endp)
+                if(dst + 2 >= endp)
                     return 0;
                 *dst++ = '"';           /* Closing quotation mark */
                 *dst++ = '\'';
@@ -229,21 +229,21 @@ shell_quotearg(const char *path, unsigned char *buf,
             break;
         }
 
-        if (dst+1 >= endp)
+        if(dst + 1 >= endp)
             return 0;
         *dst++ = *src++;
     }
 
-    switch (state) {
+    switch(state) {
     case UQSTRING:
         break;
     case QSTRING:           /* Close quoted string */
-        if (dst+1 >= endp)
+        if(dst + 1 >= endp)
             return 0;
         *dst++ = '"';
         break;
     case SQSTRING:          /* Close single quoted string */
-        if (dst+1 >= endp)
+        if(dst + 1 >= endp)
             return 0;
         *dst++ = '\'';
         break;
@@ -251,7 +251,7 @@ shell_quotearg(const char *path, unsigned char *buf,
         break;
     }
 
-    if (dst+1 >= endp)
+    if(dst + 1 >= endp)
         return 0;
     *dst = '\0';
 
@@ -275,7 +275,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
     int tmp_err_code;
     const char *tmp_err_msg;
 
-    if (session->scpRecv_state == libssh2_NB_state_idle) {
+    if(session->scpRecv_state == libssh2_NB_state_idle) {
         session->scpRecv_mode = 0;
         session->scpRecv_size = 0;
         session->scpRecv_mtime = 0;
@@ -287,7 +287,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_command =
             LIBSSH2_ALLOC(session, session->scpRecv_command_len);
 
-        if (!session->scpRecv_command) {
+        if(!session->scpRecv_command) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate a command buffer for "
                            "SCP session");
@@ -312,7 +312,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_created;
     }
 
-    if (session->scpRecv_state == libssh2_NB_state_created) {
+    if(session->scpRecv_state == libssh2_NB_state_created) {
         /* Allocate a channel */
         session->scpRecv_channel =
             _libssh2_channel_open(session, "session",
@@ -320,8 +320,8 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                                   LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                   LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
                                   0);
-        if (!session->scpRecv_channel) {
-            if (libssh2_session_last_errno(session) !=
+        if(!session->scpRecv_channel) {
+            if(libssh2_session_last_errno(session) !=
                 LIBSSH2_ERROR_EAGAIN) {
                 LIBSSH2_FREE(session, session->scpRecv_command);
                 session->scpRecv_command = NULL;
@@ -337,17 +337,18 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_sent;
     }
 
-    if (session->scpRecv_state == libssh2_NB_state_sent) {
+    if(session->scpRecv_state == libssh2_NB_state_sent) {
         /* Request SCP for the desired file */
         rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec",
                                               sizeof("exec") - 1,
                                               (char *) session->scpRecv_command,
                                               session->scpRecv_command_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block requesting SCP startup");
             return NULL;
-        } else if (rc) {
+        }
+        else if(rc) {
             LIBSSH2_FREE(session, session->scpRecv_command);
             session->scpRecv_command = NULL;
             goto scp_recv_error;
@@ -362,14 +363,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_sent1;
     }
 
-    if (session->scpRecv_state == libssh2_NB_state_sent1) {
+    if(session->scpRecv_state == libssh2_NB_state_sent1) {
         rc = _libssh2_channel_write(session->scpRecv_channel, 0,
                                     session->scpRecv_response, 1);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending initial wakeup");
             return NULL;
-        } else if (rc != 1) {
+        }
+        else if(rc != 1) {
             goto scp_recv_error;
         }
 
@@ -379,23 +381,23 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_sent2;
     }
 
-    if ((session->scpRecv_state == libssh2_NB_state_sent2)
+    if((session->scpRecv_state == libssh2_NB_state_sent2)
         || (session->scpRecv_state == libssh2_NB_state_sent3)) {
-        while (sb && (session->scpRecv_response_len <
+        while(sb && (session->scpRecv_response_len <
                       LIBSSH2_SCP_RESPONSE_BUFLEN)) {
             unsigned char *s, *p;
 
-            if (session->scpRecv_state == libssh2_NB_state_sent2) {
+            if(session->scpRecv_state == libssh2_NB_state_sent2) {
                 rc = _libssh2_channel_read(session->scpRecv_channel, 0,
                                            (char *) session->
                                            scpRecv_response +
                                            session->scpRecv_response_len, 1);
-                if (rc == LIBSSH2_ERROR_EAGAIN) {
+                if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting for SCP response");
                     return NULL;
                 }
-                else if (rc < 0) {
+                else if(rc < 0) {
                     /* error, give up */
                     _libssh2_error(session, rc, "Failed reading SCP response");
                     goto scp_recv_error;
@@ -405,7 +407,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
                 session->scpRecv_response_len++;
 
-                if (session->scpRecv_response[0] != 'T') {
+                if(session->scpRecv_response[0] != 'T') {
                     size_t err_len;
                     char *err_msg;
 
@@ -419,7 +421,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                         _libssh2_channel_packet_data_len(session->
                                                          scpRecv_channel, 0);
                     err_msg = LIBSSH2_ALLOC(session, err_len + 1);
-                    if (!err_msg) {
+                    if(!err_msg) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Failed to get memory ");
                         goto scp_recv_error;
@@ -431,7 +433,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     /* If it failed for any reason, we ignore it anyway. */
 
                     /* zero terminate the error */
-                    err_msg[err_len]=0;
+                    err_msg[err_len] = 0;
 
                     _libssh2_debug(session, LIBSSH2_TRACE_SCP,
                                    "got %02x %s", session->scpRecv_response[0],
@@ -444,7 +446,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     goto scp_recv_error;
                 }
 
-                if ((session->scpRecv_response_len > 1) &&
+                if((session->scpRecv_response_len > 1) &&
                     ((session->
                       scpRecv_response[session->scpRecv_response_len - 1] <
                       '0')
@@ -465,11 +467,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     goto scp_recv_error;
                 }
 
-                if ((session->scpRecv_response_len < 9)
+                if((session->scpRecv_response_len < 9)
                     || (session->
                         scpRecv_response[session->scpRecv_response_len - 1] !=
                         '\n')) {
-                    if (session->scpRecv_response_len ==
+                    if(session->scpRecv_response_len ==
                         LIBSSH2_SCP_RESPONSE_BUFLEN) {
                         /* You had your chance */
                         _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -483,7 +485,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
                 /* We're guaranteed not to go under response_len == 0 by the
                    logic above */
-                while ((session->
+                while((session->
                         scpRecv_response[session->scpRecv_response_len - 1] ==
                         '\r')
                        || (session->
@@ -493,18 +495,18 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 session->scpRecv_response[session->scpRecv_response_len] =
                     '\0';
 
-                if (session->scpRecv_response_len < 8) {
+                if(session->scpRecv_response_len < 8) {
                     /* EOL came too soon */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, "
-                                   "too short" );
+                                   "too short");
                     goto scp_recv_error;
                 }
 
                 s = session->scpRecv_response + 1;
 
                 p = (unsigned char *) strchr((char *) s, ' ');
-                if (!p || ((p - s) <= 0)) {
+                if(!p || ((p - s) <= 0)) {
                     /* No spaces or space in the wrong spot */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, "
@@ -517,7 +519,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 session->scpRecv_mtime = strtol((char *) s, NULL, 10);
 
                 s = (unsigned char *) strchr((char *) p, ' ');
-                if (!s || ((s - p) <= 0)) {
+                if(!s || ((s - p) <= 0)) {
                     /* No spaces or space in the wrong spot */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, malformed mtime.usec");
@@ -527,7 +529,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 /* Ignore mtime.usec */
                 s++;
                 p = (unsigned char *) strchr((char *) s, ' ');
-                if (!p || ((p - s) <= 0)) {
+                if(!p || ((p - s) <= 0)) {
                     /* No spaces or space in the wrong spot */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, too short or malformed");
@@ -544,14 +546,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 session->scpRecv_state = libssh2_NB_state_sent3;
             }
 
-            if (session->scpRecv_state == libssh2_NB_state_sent3) {
+            if(session->scpRecv_state == libssh2_NB_state_sent3) {
                 rc = _libssh2_channel_write(session->scpRecv_channel, 0,
                                             session->scpRecv_response, 1);
-                if (rc == LIBSSH2_ERROR_EAGAIN) {
+                if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting to send SCP ACK");
                     return NULL;
-                } else if (rc != 1) {
+                }
+                else if(rc != 1) {
                     goto scp_recv_error;
                 }
 
@@ -568,28 +571,28 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_sent4;
     }
 
-    if (session->scpRecv_state == libssh2_NB_state_sent4) {
+    if(session->scpRecv_state == libssh2_NB_state_sent4) {
         session->scpRecv_response_len = 0;
 
         session->scpRecv_state = libssh2_NB_state_sent5;
     }
 
-    if ((session->scpRecv_state == libssh2_NB_state_sent5)
+    if((session->scpRecv_state == libssh2_NB_state_sent5)
         || (session->scpRecv_state == libssh2_NB_state_sent6)) {
-        while (session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) {
+        while(session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) {
             char *s, *p, *e = NULL;
 
-            if (session->scpRecv_state == libssh2_NB_state_sent5) {
+            if(session->scpRecv_state == libssh2_NB_state_sent5) {
                 rc = _libssh2_channel_read(session->scpRecv_channel, 0,
                                            (char *) session->
                                            scpRecv_response +
                                            session->scpRecv_response_len, 1);
-                if (rc == LIBSSH2_ERROR_EAGAIN) {
+                if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting for SCP response");
                     return NULL;
                 }
-                else if (rc < 0) {
+                else if(rc < 0) {
                     /* error, bail out*/
                     _libssh2_error(session, rc, "Failed reading SCP response");
                     goto scp_recv_error;
@@ -599,13 +602,13 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
                 session->scpRecv_response_len++;
 
-                if (session->scpRecv_response[0] != 'C') {
+                if(session->scpRecv_response[0] != 'C') {
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server");
                     goto scp_recv_error;
                 }
 
-                if ((session->scpRecv_response_len > 1) &&
+                if((session->scpRecv_response_len > 1) &&
                     (session->
                      scpRecv_response[session->scpRecv_response_len - 1] !=
                      '\r')
@@ -621,11 +624,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     goto scp_recv_error;
                 }
 
-                if ((session->scpRecv_response_len < 7)
+                if((session->scpRecv_response_len < 7)
                     || (session->
                         scpRecv_response[session->scpRecv_response_len - 1] !=
                         '\n')) {
-                    if (session->scpRecv_response_len ==
+                    if(session->scpRecv_response_len ==
                         LIBSSH2_SCP_RESPONSE_BUFLEN) {
                         /* You had your chance */
                         _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -639,7 +642,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
                 /* We're guaranteed not to go under response_len == 0 by the
                    logic above */
-                while ((session->
+                while((session->
                         scpRecv_response[session->scpRecv_response_len - 1] ==
                         '\r')
                        || (session->
@@ -650,7 +653,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 session->scpRecv_response[session->scpRecv_response_len] =
                     '\0';
 
-                if (session->scpRecv_response_len < 6) {
+                if(session->scpRecv_response_len < 6) {
                     /* EOL came too soon */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, too short");
@@ -660,7 +663,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 s = (char *) session->scpRecv_response + 1;
 
                 p = strchr(s, ' ');
-                if (!p || ((p - s) <= 0)) {
+                if(!p || ((p - s) <= 0)) {
                     /* No spaces or space in the wrong spot */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, malformed mode");
@@ -671,14 +674,14 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 /* Make sure we don't get fooled by leftover values */
 
                 session->scpRecv_mode = strtol(s, &e, 8);
-                if (e && *e) {
+                if(e && *e) {
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, invalid mode");
                     goto scp_recv_error;
                 }
 
                 s = strchr(p, ' ');
-                if (!s || ((s - p) <= 0)) {
+                if(!s || ((s - p) <= 0)) {
                     /* No spaces or space in the wrong spot */
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, too short or malformed");
@@ -688,7 +691,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 *s = '\0';
                 /* Make sure we don't get fooled by leftover values */
                 session->scpRecv_size = scpsize_strtol(p, &e, 10);
-                if (e && *e) {
+                if(e && *e) {
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Invalid response from SCP server, invalid size");
                     goto scp_recv_error;
@@ -700,14 +703,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 session->scpRecv_state = libssh2_NB_state_sent6;
             }
 
-            if (session->scpRecv_state == libssh2_NB_state_sent6) {
+            if(session->scpRecv_state == libssh2_NB_state_sent6) {
                 rc = _libssh2_channel_write(session->scpRecv_channel, 0,
                                             session->scpRecv_response, 1);
-                if (rc == LIBSSH2_ERROR_EAGAIN) {
+                if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block sending SCP ACK");
                     return NULL;
-                } else if (rc != 1) {
+                }
+                else if(rc != 1) {
                     goto scp_recv_error;
                 }
                 _libssh2_debug(session, LIBSSH2_TRACE_SCP,
@@ -723,7 +727,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_state = libssh2_NB_state_sent7;
     }
 
-    if (sb) {
+    if(sb) {
         memset(sb, 0, sizeof(libssh2_struct_stat));
 
         sb->st_mtime = session->scpRecv_mtime;
@@ -747,7 +751,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
   scp_recv_error:
     tmp_err_code = session->err_code;
     tmp_err_msg = session->err_msg;
-    while (libssh2_channel_free(session->scpRecv_channel) ==
+    while(libssh2_channel_free(session->scpRecv_channel) ==
            LIBSSH2_ERROR_EAGAIN);
     session->err_code = tmp_err_code;
     session->err_msg = tmp_err_msg;
@@ -779,7 +783,7 @@ libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat * sb)
     BLOCK_ADJUST_ERRNO(ptr, session, scp_recv(session, path, sb_ptr));
 
     /* ...and populate the caller's with as much info as fits. */
-    if (sb) {
+    if(sb) {
         memset(sb, 0, sizeof(struct stat));
 
         sb->st_mtime = sb_intl.st_mtime;
@@ -821,7 +825,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     int tmp_err_code;
     const char *tmp_err_msg;
 
-    if (session->scpSend_state == libssh2_NB_state_idle) {
+    if(session->scpSend_state == libssh2_NB_state_idle) {
         session->scpSend_command_len =
             _libssh2_shell_quotedsize(path) + sizeof("scp -t ") +
             ((mtime || atime)?1:0);
@@ -829,7 +833,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_command =
             LIBSSH2_ALLOC(session, session->scpSend_command_len);
 
-        if (!session->scpSend_command) {
+        if(!session->scpSend_command) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate a command buffer for "
                            "SCP session");
@@ -855,13 +859,13 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_state = libssh2_NB_state_created;
     }
 
-    if (session->scpSend_state == libssh2_NB_state_created) {
+    if(session->scpSend_state == libssh2_NB_state_created) {
         session->scpSend_channel =
             _libssh2_channel_open(session, "session", sizeof("session") - 1,
                                   LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                   LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
-        if (!session->scpSend_channel) {
-            if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
+        if(!session->scpSend_channel) {
+            if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
                 /* previous call set libssh2_session_last_error(), pass it
                    through */
                 LIBSSH2_FREE(session, session->scpSend_command);
@@ -878,18 +882,18 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_state = libssh2_NB_state_sent;
     }
 
-    if (session->scpSend_state == libssh2_NB_state_sent) {
+    if(session->scpSend_state == libssh2_NB_state_sent) {
         /* Request SCP for the desired file */
         rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec",
                                               sizeof("exec") - 1,
                                               (char *) session->scpSend_command,
                                               session->scpSend_command_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block requesting SCP startup");
             return NULL;
         }
-        else if (rc) {
+        else if(rc) {
             /* previous call set libssh2_session_last_error(), pass it
                through */
             LIBSSH2_FREE(session, session->scpSend_command);
@@ -904,28 +908,28 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_state = libssh2_NB_state_sent1;
     }
 
-    if (session->scpSend_state == libssh2_NB_state_sent1) {
+    if(session->scpSend_state == libssh2_NB_state_sent1) {
         /* Wait for ACK */
         rc = _libssh2_channel_read(session->scpSend_channel, 0,
                                    (char *) session->scpSend_response, 1);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block waiting for response from remote");
             return NULL;
         }
-        else if (rc < 0) {
+        else if(rc < 0) {
             _libssh2_error(session, rc, "SCP failure");
             goto scp_send_error;
         }
         else if(!rc)
             /* remain in the same state */
             goto scp_send_empty_channel;
-        else if (session->scpSend_response[0] != 0) {
+        else if(session->scpSend_response[0] != 0) {
             _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                            "Invalid ACK response from remote");
             goto scp_send_error;
         }
-        if (mtime || atime) {
+        if(mtime || atime) {
             /* Send mtime and atime to be used for file */
             session->scpSend_response_len =
                 snprintf((char *) session->scpSend_response,
@@ -939,16 +943,17 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     }
 
     /* Send mtime and atime to be used for file */
-    if (mtime || atime) {
-        if (session->scpSend_state == libssh2_NB_state_sent2) {
+    if(mtime || atime) {
+        if(session->scpSend_state == libssh2_NB_state_sent2) {
             rc = _libssh2_channel_write(session->scpSend_channel, 0,
                                         session->scpSend_response,
                                         session->scpSend_response_len);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block sending time data for SCP file");
                 return NULL;
-            } else if (rc != (int)session->scpSend_response_len) {
+            }
+            else if(rc != (int)session->scpSend_response_len) {
                 _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                "Unable to send time data for SCP file");
                 goto scp_send_error;
@@ -957,23 +962,23 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
             session->scpSend_state = libssh2_NB_state_sent3;
         }
 
-        if (session->scpSend_state == libssh2_NB_state_sent3) {
+        if(session->scpSend_state == libssh2_NB_state_sent3) {
             /* Wait for ACK */
             rc = _libssh2_channel_read(session->scpSend_channel, 0,
                                        (char *) session->scpSend_response, 1);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block waiting for response");
                 return NULL;
             }
-            else if (rc < 0) {
+            else if(rc < 0) {
                 _libssh2_error(session, rc, "SCP failure");
                 goto scp_send_error;
             }
             else if(!rc)
                 /* remain in the same state */
                 goto scp_send_empty_channel;
-            else if (session->scpSend_response[0] != 0) {
+            else if(session->scpSend_response[0] != 0) {
                 _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                "Invalid SCP ACK response");
                 goto scp_send_error;
@@ -981,16 +986,17 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
             session->scpSend_state = libssh2_NB_state_sent4;
         }
-    } else {
-        if (session->scpSend_state == libssh2_NB_state_sent2) {
+    }
+    else {
+        if(session->scpSend_state == libssh2_NB_state_sent2) {
             session->scpSend_state = libssh2_NB_state_sent4;
         }
     }
 
-    if (session->scpSend_state == libssh2_NB_state_sent4) {
+    if(session->scpSend_state == libssh2_NB_state_sent4) {
         /* Send mode, size, and basename */
         const char *base = strrchr(path, '/');
-        if (base)
+        if(base)
             base++;
         else
             base = path;
@@ -1006,15 +1012,16 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_state = libssh2_NB_state_sent5;
     }
 
-    if (session->scpSend_state == libssh2_NB_state_sent5) {
+    if(session->scpSend_state == libssh2_NB_state_sent5) {
         rc = _libssh2_channel_write(session->scpSend_channel, 0,
                                     session->scpSend_response,
                                     session->scpSend_response_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block send core file data for SCP file");
             return NULL;
-        } else if (rc != (int)session->scpSend_response_len) {
+        }
+        else if(rc != (int)session->scpSend_response_len) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                            "Unable to send core file data for SCP file");
             goto scp_send_error;
@@ -1023,31 +1030,31 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         session->scpSend_state = libssh2_NB_state_sent6;
     }
 
-    if (session->scpSend_state == libssh2_NB_state_sent6) {
+    if(session->scpSend_state == libssh2_NB_state_sent6) {
         /* Wait for ACK */
         rc = _libssh2_channel_read(session->scpSend_channel, 0,
                                    (char *) session->scpSend_response, 1);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block waiting for response");
             return NULL;
         }
-        else if (rc < 0) {
+        else if(rc < 0) {
             _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                            "Invalid ACK response from remote");
             goto scp_send_error;
         }
-        else if (rc == 0)
+        else if(rc == 0)
             goto scp_send_empty_channel;
 
-        else if (session->scpSend_response[0] != 0) {
+        else if(session->scpSend_response[0] != 0) {
             size_t err_len;
             char *err_msg;
 
             err_len =
                 _libssh2_channel_packet_data_len(session->scpSend_channel, 0);
             err_msg = LIBSSH2_ALLOC(session, err_len + 1);
-            if (!err_msg) {
+            if(!err_msg) {
                 _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                "failed to get memory");
                 goto scp_send_error;
@@ -1056,8 +1063,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
             /* Read the remote error message */
             rc = _libssh2_channel_read(session->scpSend_channel, 0,
                                        err_msg, err_len);
-            if (rc > 0) {
-                err_msg[err_len]=0;
+            if(rc > 0) {
+                err_msg[err_len] = 0;
                 _libssh2_debug(session, LIBSSH2_TRACE_SCP,
                                "got %02x %s", session->scpSend_response[0],
                                err_msg);
@@ -1085,8 +1092,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
   scp_send_error:
     tmp_err_code = session->err_code;
     tmp_err_msg = session->err_msg;
-    while (libssh2_channel_free(session->scpSend_channel) ==
-           LIBSSH2_ERROR_EAGAIN);
+    while(libssh2_channel_free(session->scpSend_channel) ==
+          LIBSSH2_ERROR_EAGAIN);
     session->err_code = tmp_err_code;
     session->err_msg = tmp_err_msg;
     session->scpSend_channel = NULL;
diff --git a/src/session.c b/src/session.c
index 381efb2d..1aee4293 100644
--- a/src/session.c
+++ b/src/session.c
@@ -99,15 +99,16 @@ banner_receive(LIBSSH2_SESSION * session)
     int ret;
     int banner_len;
 
-    if (session->banner_TxRx_state == libssh2_NB_state_idle) {
+    if(session->banner_TxRx_state == libssh2_NB_state_idle) {
         banner_len = 0;
 
         session->banner_TxRx_state = libssh2_NB_state_created;
-    } else {
+    }
+    else {
         banner_len = session->banner_TxRx_total_send;
     }
 
-    while ((banner_len < (int) sizeof(session->banner_TxRx_banner)) &&
+    while((banner_len < (int) sizeof(session->banner_TxRx_banner)) &&
            ((banner_len == 0)
             || (session->banner_TxRx_banner[banner_len - 1] != '\n'))) {
         char c = '\0';
@@ -117,7 +118,7 @@ banner_receive(LIBSSH2_SESSION * session)
 
         ret = LIBSSH2_RECV(session, &c, 1,
                             LIBSSH2_SOCKET_RECV_FLAGS(session));
-        if (ret < 0) {
+        if(ret < 0) {
             if(session->api_block_mode || (ret != -EAGAIN))
                 /* ignore EAGAIN when non-blocking */
                 _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
@@ -127,8 +128,8 @@ banner_receive(LIBSSH2_SESSION * session)
             _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
                            "Recved %d bytes banner", ret);
 
-        if (ret < 0) {
-            if (ret == -EAGAIN) {
+        if(ret < 0) {
+            if(ret == -EAGAIN) {
                 session->socket_block_directions =
                     LIBSSH2_SESSION_BLOCK_INBOUND;
                 session->banner_TxRx_total_send = banner_len;
@@ -141,12 +142,12 @@ banner_receive(LIBSSH2_SESSION * session)
             return LIBSSH2_ERROR_SOCKET_RECV;
         }
 
-        if (ret == 0) {
+        if(ret == 0) {
             session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
             return LIBSSH2_ERROR_SOCKET_DISCONNECT;
         }
 
-        if (c == '\0') {
+        if(c == '\0') {
             /* NULLs are not allowed in SSH banners */
             session->banner_TxRx_state = libssh2_NB_state_idle;
             session->banner_TxRx_total_send = 0;
@@ -156,7 +157,7 @@ banner_receive(LIBSSH2_SESSION * session)
         session->banner_TxRx_banner[banner_len++] = c;
     }
 
-    while (banner_len &&
+    while(banner_len &&
            ((session->banner_TxRx_banner[banner_len - 1] == '\n') ||
             (session->banner_TxRx_banner[banner_len - 1] == '\r'))) {
         banner_len--;
@@ -166,11 +167,11 @@ banner_receive(LIBSSH2_SESSION * session)
     session->banner_TxRx_state = libssh2_NB_state_idle;
     session->banner_TxRx_total_send = 0;
 
-    if (!banner_len)
+    if(!banner_len)
         return LIBSSH2_ERROR_BANNER_RECV;
 
     session->remote.banner = LIBSSH2_ALLOC(session, banner_len + 1);
-    if (!session->remote.banner) {
+    if(!session->remote.banner) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Error allocating space for remote banner");
     }
@@ -201,18 +202,19 @@ banner_send(LIBSSH2_SESSION * session)
     char banner_dup[256];
 #endif
 
-    if (session->banner_TxRx_state == libssh2_NB_state_idle) {
-        if (session->local.banner) {
+    if(session->banner_TxRx_state == libssh2_NB_state_idle) {
+        if(session->local.banner) {
             /* setopt_string will have given us our \r\n characters */
             banner_len = strlen((char *) session->local.banner);
             banner = (char *) session->local.banner;
         }
 #ifdef LIBSSH2DEBUG
         /* Hack and slash to avoid sending CRLF in debug output */
-        if (banner_len < 256) {
+        if(banner_len < 256) {
             memcpy(banner_dup, banner, banner_len - 2);
             banner_dup[banner_len - 2] = '\0';
-        } else {
+        }
+        else {
             memcpy(banner_dup, banner, 255);
             banner[255] = '\0';
         }
@@ -231,7 +233,7 @@ banner_send(LIBSSH2_SESSION * session)
                         banner + session->banner_TxRx_total_send,
                         banner_len - session->banner_TxRx_total_send,
                         LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if (ret < 0)
+    if(ret < 0)
         _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
                        "Error sending %d bytes: %d",
                        banner_len - session->banner_TxRx_total_send, -ret);
@@ -241,12 +243,12 @@ banner_send(LIBSSH2_SESSION * session)
                        banner_len - session->banner_TxRx_total_send,
                        banner, session->banner_TxRx_total_send);
 
-    if (ret != (banner_len - session->banner_TxRx_total_send)) {
-        if (ret >= 0 || ret == -EAGAIN) {
+    if(ret != (banner_len - session->banner_TxRx_total_send)) {
+        if(ret >= 0 || ret == -EAGAIN) {
             /* the whole packet could not be sent, save the what was */
             session->socket_block_directions =
                 LIBSSH2_SESSION_BLOCK_OUTBOUND;
-            if (ret > 0)
+            if(ret > 0)
                 session->banner_TxRx_total_send += ret;
             return LIBSSH2_ERROR_EAGAIN;
         }
@@ -278,7 +280,7 @@ session_nonblock(libssh2_socket_t sockfd,   /* operate on this */
     int flags;
 
     flags = fcntl(sockfd, F_GETFL, 0);
-    if (nonblock)
+    if(nonblock)
         return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
     else
         return fcntl(sockfd, F_SETFL, flags & (~O_NONBLOCK));
@@ -327,7 +329,7 @@ session_nonblock(libssh2_socket_t sockfd,   /* operate on this */
 #define SETBLOCK 6
 #endif
 
-#if (SETBLOCK == 0)
+#if(SETBLOCK == 0)
 #error "no non-blocking method was found/used/set"
 #endif
 }
@@ -344,9 +346,9 @@ get_socket_nonblocking(int sockfd)
 #define GETBLOCK 0
 #ifdef HAVE_O_NONBLOCK
     /* most recent unix versions */
-    int flags;
+    int flags = fcntl(sockfd, F_GETFL, 0);
 
-    if ((flags = fcntl(sockfd, F_GETFL, 0)) == -1) {
+    if(flags == -1) {
         /* Assume blocking on error */
         return 1;
     }
@@ -360,7 +362,7 @@ get_socket_nonblocking(int sockfd)
     unsigned int option_value;
     socklen_t option_len = sizeof(option_value);
 
-    if (getsockopt
+    if(getsockopt
         (sockfd, SOL_SOCKET, SO_ERROR, (void *) &option_value, &option_len)) {
         /* Assume blocking on error */
         return 1;
@@ -373,7 +375,7 @@ get_socket_nonblocking(int sockfd)
 #if defined(HAVE_SO_NONBLOCK) && (GETBLOCK == 0)
     /* BeOS */
     long b;
-    if (getsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b))) {
+    if(getsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b))) {
         /* Assume blocking on error */
         return 1;
     }
@@ -382,19 +384,19 @@ get_socket_nonblocking(int sockfd)
 #define GETBLOCK 5
 #endif
 
-#if defined(SO_STATE) && defined( __VMS ) && (GETBLOCK == 0)
+#if defined(SO_STATE) && defined(__VMS) && (GETBLOCK == 0)
 
     /* VMS TCP/IP Services */
 
     size_t sockstat = 0;
     int    callstat = 0;
-    size_t size = sizeof( int );
+    size_t size = sizeof(int);
 
     callstat = getsockopt(sockfd, SOL_SOCKET, SO_STATE,
                                   (char *)&sockstat, &size);
-    if ( callstat == -1 ) return(0);
-    if ( (sockstat&SS_NBIO) )return(1);
-    return(0);
+    if(callstat == -1) return 0;
+    if((sockstat&SS_NBIO) != 0) return 1;
+    return 0;
 
 #undef GETBLOCK
 #define GETBLOCK 6
@@ -406,7 +408,7 @@ get_socket_nonblocking(int sockfd)
 #define GETBLOCK 7
 #endif
 
-#if (GETBLOCK == 0)
+#if(GETBLOCK == 0)
 #error "no non-blocking method was found/used/get"
 #endif
 }
@@ -419,16 +421,16 @@ libssh2_session_banner_set(LIBSSH2_SESSION * session, const char *banner)
 {
     size_t banner_len = banner ? strlen(banner) : 0;
 
-    if (session->local.banner) {
+    if(session->local.banner) {
         LIBSSH2_FREE(session, session->local.banner);
         session->local.banner = NULL;
     }
 
-    if (!banner_len)
+    if(!banner_len)
         return 0;
 
     session->local.banner = LIBSSH2_ALLOC(session, banner_len + 3);
-    if (!session->local.banner) {
+    if(!session->local.banner) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for local banner");
     }
@@ -474,18 +476,18 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
     LIBSSH2_REALLOC_FUNC((*local_realloc)) = libssh2_default_realloc;
     LIBSSH2_SESSION *session;
 
-    if (my_alloc) {
+    if(my_alloc) {
         local_alloc = my_alloc;
     }
-    if (my_free) {
+    if(my_free) {
         local_free = my_free;
     }
-    if (my_realloc) {
+    if(my_realloc) {
         local_realloc = my_realloc;
     }
 
     session = local_alloc(sizeof(LIBSSH2_SESSION), &abstract);
-    if (session) {
+    if(session) {
         memset(session, 0, sizeof(LIBSSH2_SESSION));
         session->alloc = local_alloc;
         session->free = local_free;
@@ -497,7 +499,7 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
         session->api_block_mode = 1; /* blocking API by default */
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                        "New session resource allocated");
-        _libssh2_init_if_needed ();
+        _libssh2_init_if_needed();
     }
     return session;
 }
@@ -517,7 +519,7 @@ libssh2_session_callback_set(LIBSSH2_SESSION * session,
 {
     void *oldcb;
 
-    switch (cbtype) {
+    switch(cbtype) {
     case LIBSSH2_CALLBACK_IGNORE:
         oldcb = session->ssh_msg_ignore;
         session->ssh_msg_ignore = callback;
@@ -579,8 +581,8 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
        being stored as error when a blocking function has returned */
     session->err_code = LIBSSH2_ERROR_NONE;
 
-    rc = libssh2_keepalive_send (session, &seconds_to_next);
-    if (rc < 0)
+    rc = libssh2_keepalive_send(session, &seconds_to_next);
+    if(rc < 0)
         return rc;
 
     ms_to_next = seconds_to_next * 1000;
@@ -597,19 +599,19 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
         ms_to_next = 1000;
     }
 
-    if (session->api_timeout > 0 &&
+    if(session->api_timeout > 0 &&
         (seconds_to_next == 0 ||
          ms_to_next > session->api_timeout)) {
-        time_t now = time (NULL);
+        time_t now = time(NULL);
         elapsed_ms = (long)(1000*difftime(now, start_time));
-        if (elapsed_ms > session->api_timeout) {
+        if(elapsed_ms > session->api_timeout) {
             return _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
                                   "API timeout expired");
         }
         ms_to_next = (session->api_timeout - elapsed_ms);
         has_timeout = 1;
     }
-    else if (ms_to_next > 0) {
+    else if(ms_to_next > 0) {
         has_timeout = 1;
     }
     else
@@ -675,10 +677,10 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
 {
     int rc;
 
-    if (session->startup_state == libssh2_NB_state_idle) {
+    if(session->startup_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                        "session_startup for socket %d", sock);
-        if (LIBSSH2_INVALID_SOCKET == sock) {
+        if(LIBSSH2_INVALID_SOCKET == sock) {
             /* Did we forget something? */
             return _libssh2_error(session, LIBSSH2_ERROR_BAD_SOCKET,
                                   "Bad socket provided");
@@ -688,10 +690,10 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->socket_prev_blockstate =
             !get_socket_nonblocking(session->socket_fd);
 
-        if (session->socket_prev_blockstate) {
+        if(session->socket_prev_blockstate) {
             /* If in blocking state change to non-blocking */
             rc = session_nonblock(session->socket_fd, 1);
-            if (rc) {
+            if(rc) {
                 return _libssh2_error(session, rc,
                                       "Failed changing socket's "
                                       "blocking state to non-blocking");
@@ -701,11 +703,11 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->startup_state = libssh2_NB_state_created;
     }
 
-    if (session->startup_state == libssh2_NB_state_created) {
+    if(session->startup_state == libssh2_NB_state_created) {
         rc = banner_send(session);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        else if (rc) {
+        else if(rc) {
             return _libssh2_error(session, rc,
                                   "Failed sending banner");
         }
@@ -713,12 +715,12 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->banner_TxRx_state = libssh2_NB_state_idle;
     }
 
-    if (session->startup_state == libssh2_NB_state_sent) {
+    if(session->startup_state == libssh2_NB_state_sent) {
         do {
             rc = banner_receive(session);
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
-            else if (rc)
+            else if(rc)
                 return _libssh2_error(session, rc,
                                       "Failed getting banner");
         } while(strncmp("SSH-", (char *)session->remote.banner, 4));
@@ -726,18 +728,18 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->startup_state = libssh2_NB_state_sent1;
     }
 
-    if (session->startup_state == libssh2_NB_state_sent1) {
+    if(session->startup_state == libssh2_NB_state_sent1) {
         rc = _libssh2_kex_exchange(session, 0, &session->startup_key_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        else if (rc)
+        else if(rc)
             return _libssh2_error(session, rc,
                                   "Unable to exchange encryption keys");
 
         session->startup_state = libssh2_NB_state_sent2;
     }
 
-    if (session->startup_state == libssh2_NB_state_sent2) {
+    if(session->startup_state == libssh2_NB_state_sent2) {
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                        "Requesting userauth service");
 
@@ -751,13 +753,13 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->startup_state = libssh2_NB_state_sent3;
     }
 
-    if (session->startup_state == libssh2_NB_state_sent3) {
+    if(session->startup_state == libssh2_NB_state_sent3) {
         rc = _libssh2_transport_send(session, session->startup_service,
                                      sizeof("ssh-userauth") + 5 - 1,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        else if (rc) {
+        else if(rc) {
             return _libssh2_error(session, rc,
                                   "Unable to ask for ssh-userauth service");
         }
@@ -765,18 +767,18 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
         session->startup_state = libssh2_NB_state_sent4;
     }
 
-    if (session->startup_state == libssh2_NB_state_sent4) {
+    if(session->startup_state == libssh2_NB_state_sent4) {
         rc = _libssh2_packet_require(session, SSH_MSG_SERVICE_ACCEPT,
                                      &session->startup_data,
                                      &session->startup_data_len, 0, NULL, 0,
                                      &session->startup_req_state);
-        if (rc)
+        if(rc)
             return rc;
 
         session->startup_service_length =
             _libssh2_ntohu32(session->startup_data + 1);
 
-        if ((session->startup_service_length != (sizeof("ssh-userauth") - 1))
+        if((session->startup_service_length != (sizeof("ssh-userauth") - 1))
             || strncmp("ssh-userauth", (char *) session->startup_data + 5,
                        session->startup_service_length)) {
             LIBSSH2_FREE(session, session->startup_data);
@@ -846,203 +848,203 @@ session_free(LIBSSH2_SESSION *session)
     LIBSSH2_LISTENER *l;
     int packets_left = 0;
 
-    if (session->free_state == libssh2_NB_state_idle) {
+    if(session->free_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Freeing session resource",
                        session->remote.banner);
 
         session->free_state = libssh2_NB_state_created;
     }
 
-    if (session->free_state == libssh2_NB_state_created) {
-        while ((ch = _libssh2_list_first(&session->channels))) {
+    if(session->free_state == libssh2_NB_state_created) {
+        while((ch = _libssh2_list_first(&session->channels))) {
 
             rc = _libssh2_channel_free(ch);
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
         }
 
         session->free_state = libssh2_NB_state_sent;
     }
 
-    if (session->free_state == libssh2_NB_state_sent) {
-        while ((l = _libssh2_list_first(&session->listeners))) {
+    if(session->free_state == libssh2_NB_state_sent) {
+        while((l = _libssh2_list_first(&session->listeners))) {
             rc = _libssh2_channel_forward_cancel(l);
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
         }
 
         session->free_state = libssh2_NB_state_sent1;
     }
 
-    if (session->state & LIBSSH2_STATE_NEWKEYS) {
+    if(session->state & LIBSSH2_STATE_NEWKEYS) {
         /* hostkey */
-        if (session->hostkey && session->hostkey->dtor) {
+        if(session->hostkey && session->hostkey->dtor) {
             session->hostkey->dtor(session, &session->server_hostkey_abstract);
         }
 
         /* Client to Server */
         /* crypt */
-        if (session->local.crypt && session->local.crypt->dtor) {
+        if(session->local.crypt && session->local.crypt->dtor) {
             session->local.crypt->dtor(session,
                                        &session->local.crypt_abstract);
         }
         /* comp */
-        if (session->local.comp && session->local.comp->dtor) {
+        if(session->local.comp && session->local.comp->dtor) {
             session->local.comp->dtor(session, 1,
                                       &session->local.comp_abstract);
         }
         /* mac */
-        if (session->local.mac && session->local.mac->dtor) {
+        if(session->local.mac && session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
         }
 
         /* Server to Client */
         /* crypt */
-        if (session->remote.crypt && session->remote.crypt->dtor) {
+        if(session->remote.crypt && session->remote.crypt->dtor) {
             session->remote.crypt->dtor(session,
                                         &session->remote.crypt_abstract);
         }
         /* comp */
-        if (session->remote.comp && session->remote.comp->dtor) {
+        if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
                                        &session->remote.comp_abstract);
         }
         /* mac */
-        if (session->remote.mac && session->remote.mac->dtor) {
+        if(session->remote.mac && session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
         }
 
         /* session_id */
-        if (session->session_id) {
+        if(session->session_id) {
             LIBSSH2_FREE(session, session->session_id);
         }
     }
 
     /* Free banner(s) */
-    if (session->remote.banner) {
+    if(session->remote.banner) {
         LIBSSH2_FREE(session, session->remote.banner);
     }
-    if (session->local.banner) {
+    if(session->local.banner) {
         LIBSSH2_FREE(session, session->local.banner);
     }
 
     /* Free preference(s) */
-    if (session->kex_prefs) {
+    if(session->kex_prefs) {
         LIBSSH2_FREE(session, session->kex_prefs);
     }
-    if (session->hostkey_prefs) {
+    if(session->hostkey_prefs) {
         LIBSSH2_FREE(session, session->hostkey_prefs);
     }
 
-    if (session->local.kexinit) {
+    if(session->local.kexinit) {
         LIBSSH2_FREE(session, session->local.kexinit);
     }
-    if (session->local.crypt_prefs) {
+    if(session->local.crypt_prefs) {
         LIBSSH2_FREE(session, session->local.crypt_prefs);
     }
-    if (session->local.mac_prefs) {
+    if(session->local.mac_prefs) {
         LIBSSH2_FREE(session, session->local.mac_prefs);
     }
-    if (session->local.comp_prefs) {
+    if(session->local.comp_prefs) {
         LIBSSH2_FREE(session, session->local.comp_prefs);
     }
-    if (session->local.lang_prefs) {
+    if(session->local.lang_prefs) {
         LIBSSH2_FREE(session, session->local.lang_prefs);
     }
 
-    if (session->remote.kexinit) {
+    if(session->remote.kexinit) {
         LIBSSH2_FREE(session, session->remote.kexinit);
     }
-    if (session->remote.crypt_prefs) {
+    if(session->remote.crypt_prefs) {
         LIBSSH2_FREE(session, session->remote.crypt_prefs);
     }
-    if (session->remote.mac_prefs) {
+    if(session->remote.mac_prefs) {
         LIBSSH2_FREE(session, session->remote.mac_prefs);
     }
-    if (session->remote.comp_prefs) {
+    if(session->remote.comp_prefs) {
         LIBSSH2_FREE(session, session->remote.comp_prefs);
     }
-    if (session->remote.lang_prefs) {
+    if(session->remote.lang_prefs) {
         LIBSSH2_FREE(session, session->remote.lang_prefs);
     }
 
     /*
      * Make sure all memory used in the state variables are free
      */
-    if (session->kexinit_data) {
+    if(session->kexinit_data) {
         LIBSSH2_FREE(session, session->kexinit_data);
     }
-    if (session->startup_data) {
+    if(session->startup_data) {
         LIBSSH2_FREE(session, session->startup_data);
     }
-    if (session->userauth_list_data) {
+    if(session->userauth_list_data) {
         LIBSSH2_FREE(session, session->userauth_list_data);
     }
-    if (session->userauth_pswd_data) {
+    if(session->userauth_pswd_data) {
         LIBSSH2_FREE(session, session->userauth_pswd_data);
     }
-    if (session->userauth_pswd_newpw) {
+    if(session->userauth_pswd_newpw) {
         LIBSSH2_FREE(session, session->userauth_pswd_newpw);
     }
-    if (session->userauth_host_packet) {
+    if(session->userauth_host_packet) {
         LIBSSH2_FREE(session, session->userauth_host_packet);
     }
-    if (session->userauth_host_method) {
+    if(session->userauth_host_method) {
         LIBSSH2_FREE(session, session->userauth_host_method);
     }
-    if (session->userauth_host_data) {
+    if(session->userauth_host_data) {
         LIBSSH2_FREE(session, session->userauth_host_data);
     }
-    if (session->userauth_pblc_data) {
+    if(session->userauth_pblc_data) {
         LIBSSH2_FREE(session, session->userauth_pblc_data);
     }
-    if (session->userauth_pblc_packet) {
+    if(session->userauth_pblc_packet) {
         LIBSSH2_FREE(session, session->userauth_pblc_packet);
     }
-    if (session->userauth_pblc_method) {
+    if(session->userauth_pblc_method) {
         LIBSSH2_FREE(session, session->userauth_pblc_method);
     }
-    if (session->userauth_kybd_data) {
+    if(session->userauth_kybd_data) {
         LIBSSH2_FREE(session, session->userauth_kybd_data);
     }
-    if (session->userauth_kybd_packet) {
+    if(session->userauth_kybd_packet) {
         LIBSSH2_FREE(session, session->userauth_kybd_packet);
     }
-    if (session->userauth_kybd_auth_instruction) {
+    if(session->userauth_kybd_auth_instruction) {
         LIBSSH2_FREE(session, session->userauth_kybd_auth_instruction);
     }
-    if (session->open_packet) {
+    if(session->open_packet) {
         LIBSSH2_FREE(session, session->open_packet);
     }
-    if (session->open_data) {
+    if(session->open_data) {
         LIBSSH2_FREE(session, session->open_data);
     }
-    if (session->direct_message) {
+    if(session->direct_message) {
         LIBSSH2_FREE(session, session->direct_message);
     }
-    if (session->fwdLstn_packet) {
+    if(session->fwdLstn_packet) {
         LIBSSH2_FREE(session, session->fwdLstn_packet);
     }
-    if (session->pkeyInit_data) {
+    if(session->pkeyInit_data) {
         LIBSSH2_FREE(session, session->pkeyInit_data);
     }
-    if (session->scpRecv_command) {
+    if(session->scpRecv_command) {
         LIBSSH2_FREE(session, session->scpRecv_command);
     }
-    if (session->scpSend_command) {
+    if(session->scpSend_command) {
         LIBSSH2_FREE(session, session->scpSend_command);
     }
-    if (session->sftpInit_sftp) {
+    if(session->sftpInit_sftp) {
         LIBSSH2_FREE(session, session->sftpInit_sftp);
     }
 
     /* Free payload buffer */
-    if (session->packet.total_num) {
+    if(session->packet.total_num) {
         LIBSSH2_FREE(session, session->packet.payload);
     }
 
     /* Cleanup all remaining packets */
-    while ((pkg = _libssh2_list_first(&session->packets))) {
+    while((pkg = _libssh2_list_first(&session->packets))) {
         packets_left++;
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
             "packet left with id %d", pkg->data[0]);
@@ -1059,18 +1061,18 @@ session_free(LIBSSH2_SESSION *session)
     if(session->socket_prev_blockstate) {
         /* if the socket was previously blocking, put it back so */
         rc = session_nonblock(session->socket_fd, 0);
-        if (rc) {
+        if(rc) {
             _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
              "unable to reset socket's blocking state");
         }
     }
 
-    if (session->server_hostkey) {
+    if(session->server_hostkey) {
         LIBSSH2_FREE(session, session->server_hostkey);
     }
 
     /* error string */
-    if (session->err_msg && ((session->err_flags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
+    if(session->err_msg && ((session->err_flags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
         LIBSSH2_FREE(session, (char *)session->err_msg);
     }
 
@@ -1107,14 +1109,14 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
     unsigned long descr_len = 0, lang_len = 0;
     int rc;
 
-    if (session->disconnect_state == libssh2_NB_state_idle) {
+    if(session->disconnect_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
                        "Disconnecting: reason=%d, desc=%s, lang=%s", reason,
                        description, lang);
-        if (description)
+        if(description)
             descr_len = strlen(description);
 
-        if (lang)
+        if(lang)
             lang_len = strlen(lang);
 
         if(descr_len > 256)
@@ -1138,7 +1140,7 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
     rc = _libssh2_transport_send(session, session->disconnect_data,
                                  session->disconnect_data_len,
                                  (unsigned char *)lang, lang_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN)
+    if(rc == LIBSSH2_ERROR_EAGAIN)
         return rc;
 
     session->disconnect_state = libssh2_NB_state_idle;
@@ -1174,7 +1176,7 @@ libssh2_session_methods(LIBSSH2_SESSION * session, int method_type)
     /* All methods have char *name as their first element */
     const LIBSSH2_KEX_METHOD *method = NULL;
 
-    switch (method_type) {
+    switch(method_type) {
     case LIBSSH2_METHOD_KEX:
         method = session->kex;
         break;
@@ -1219,7 +1221,7 @@ libssh2_session_methods(LIBSSH2_SESSION * session, int method_type)
         return NULL;
     }
 
-    if (!method) {
+    if(!method) {
         _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
                        "No method negotiated");
         return NULL;
@@ -1250,32 +1252,33 @@ libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg,
     size_t msglen = 0;
 
     /* No error to report */
-    if (!session->err_code) {
-        if (errmsg) {
-            if (want_buf) {
+    if(!session->err_code) {
+        if(errmsg) {
+            if(want_buf) {
                 *errmsg = LIBSSH2_ALLOC(session, 1);
-                if (*errmsg) {
+                if(*errmsg) {
                     **errmsg = 0;
                 }
-            } else {
+            }
+            else {
                 *errmsg = (char *) "";
             }
         }
-        if (errmsg_len) {
+        if(errmsg_len) {
             *errmsg_len = 0;
         }
         return 0;
     }
 
-    if (errmsg) {
+    if(errmsg) {
         const char *error = session->err_msg ? session->err_msg : "";
 
         msglen = strlen(error);
 
-        if (want_buf) {
+        if(want_buf) {
             /* Make a copy so the calling program can own it */
             *errmsg = LIBSSH2_ALLOC(session, msglen + 1);
-            if (*errmsg) {
+            if(*errmsg) {
                 memcpy(*errmsg, error, msglen);
                 (*errmsg)[msglen] = 0;
             }
@@ -1284,7 +1287,7 @@ libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg,
             *errmsg = (char *)error;
     }
 
-    if (errmsg_len) {
+    if(errmsg_len) {
         *errmsg_len = msglen;
     }
 
@@ -1312,7 +1315,7 @@ libssh2_session_last_errno(LIBSSH2_SESSION * session)
 LIBSSH2_API int
 libssh2_session_set_last_error(LIBSSH2_SESSION* session,
                                int errcode,
-                               const char* errmsg)
+                               const char *errmsg)
 {
     return _libssh2_error_flags(session, errcode, errmsg,
                                 LIBSSH2_ERR_FLAG_DUP);
@@ -1420,14 +1423,15 @@ libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended)
     session = channel->session;
     packet = _libssh2_list_first(&session->packets);
 
-    while (packet) {
-        if ( channel->local.id == _libssh2_ntohu32(packet->data + 1)) {
-            if ( extended == 1 &&
-                 (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA
-                  || packet->data[0] == SSH_MSG_CHANNEL_DATA )) {
+    while(packet) {
+        if(channel->local.id == _libssh2_ntohu32(packet->data + 1)) {
+            if(extended == 1 &&
+                (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA
+                 || packet->data[0] == SSH_MSG_CHANNEL_DATA)) {
                 return 1;
-            } else if ( extended == 0 &&
-                        packet->data[0] == SSH_MSG_CHANNEL_DATA) {
+            }
+            else if(extended == 0 &&
+                    packet->data[0] == SSH_MSG_CHANNEL_DATA) {
                 return 1;
             }
             /* else - no data of any type is ready to be read */
@@ -1478,7 +1482,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
 #else
     struct pollfd sockets[256];
 
-    if (nfds > 256)
+    if(nfds > 256)
         /* systems without alloca use a fixed-size array, this can be fixed if
            we really want to, at least if the compiler is a C99 capable one */
         return -1;
@@ -1486,7 +1490,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
     /* Setup sockets for polling */
     for(i = 0; i < nfds; i++) {
         fds[i].revents = 0;
-        switch (fds[i].type) {
+        switch(fds[i].type) {
         case LIBSSH2_POLLFD_SOCKET:
             sockets[i].fd = fds[i].fd.socket;
             sockets[i].events = fds[i].events;
@@ -1497,7 +1501,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
             sockets[i].fd = fds[i].fd.channel->session->socket_fd;
             sockets[i].events = POLLIN;
             sockets[i].revents = 0;
-            if (!session)
+            if(!session)
                 session = fds[i].fd.channel->session;
             break;
 
@@ -1505,12 +1509,12 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
             sockets[i].fd = fds[i].fd.listener->session->socket_fd;
             sockets[i].events = POLLIN;
             sockets[i].revents = 0;
-            if (!session)
+            if(!session)
                 session = fds[i].fd.listener->session;
             break;
 
         default:
-            if (session)
+            if(session)
                 _libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
                                "Invalid descriptor passed to libssh2_poll()");
             return -1;
@@ -1526,38 +1530,38 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
     FD_ZERO(&wfds);
     for(i = 0; i < nfds; i++) {
         fds[i].revents = 0;
-        switch (fds[i].type) {
+        switch(fds[i].type) {
         case LIBSSH2_POLLFD_SOCKET:
-            if (fds[i].events & LIBSSH2_POLLFD_POLLIN) {
+            if(fds[i].events & LIBSSH2_POLLFD_POLLIN) {
                 FD_SET(fds[i].fd.socket, &rfds);
-                if (fds[i].fd.socket > maxfd)
+                if(fds[i].fd.socket > maxfd)
                     maxfd = fds[i].fd.socket;
             }
-            if (fds[i].events & LIBSSH2_POLLFD_POLLOUT) {
+            if(fds[i].events & LIBSSH2_POLLFD_POLLOUT) {
                 FD_SET(fds[i].fd.socket, &wfds);
-                if (fds[i].fd.socket > maxfd)
+                if(fds[i].fd.socket > maxfd)
                     maxfd = fds[i].fd.socket;
             }
             break;
 
         case LIBSSH2_POLLFD_CHANNEL:
             FD_SET(fds[i].fd.channel->session->socket_fd, &rfds);
-            if (fds[i].fd.channel->session->socket_fd > maxfd)
+            if(fds[i].fd.channel->session->socket_fd > maxfd)
                 maxfd = fds[i].fd.channel->session->socket_fd;
-            if (!session)
+            if(!session)
                 session = fds[i].fd.channel->session;
             break;
 
         case LIBSSH2_POLLFD_LISTENER:
             FD_SET(fds[i].fd.listener->session->socket_fd, &rfds);
-            if (fds[i].fd.listener->session->socket_fd > maxfd)
+            if(fds[i].fd.listener->session->socket_fd > maxfd)
                 maxfd = fds[i].fd.listener->session->socket_fd;
-            if (!session)
+            if(!session)
                 session = fds[i].fd.listener->session;
             break;
 
         default:
-            if (session)
+            if(session)
                 _libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
                                "Invalid descriptor passed to libssh2_poll()");
             return -1;
@@ -1580,10 +1584,10 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         active_fds = 0;
 
         for(i = 0; i < nfds; i++) {
-            if (fds[i].events != fds[i].revents) {
-                switch (fds[i].type) {
+            if(fds[i].events != fds[i].revents) {
+                switch(fds[i].type) {
                 case LIBSSH2_POLLFD_CHANNEL:
-                    if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
+                    if((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
                         /* Want to be ready for read */
                         ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) {
                         /* Not yet known to be ready for read */
@@ -1592,7 +1596,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                                                       0) ?
                             LIBSSH2_POLLFD_POLLIN : 0;
                     }
-                    if ((fds[i].events & LIBSSH2_POLLFD_POLLEXT) &&
+                    if((fds[i].events & LIBSSH2_POLLFD_POLLEXT) &&
                         /* Want to be ready for extended read */
                         ((fds[i].revents & LIBSSH2_POLLFD_POLLEXT) == 0)) {
                         /* Not yet known to be ready for extended read */
@@ -1601,7 +1605,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                                                       1) ?
                             LIBSSH2_POLLFD_POLLEXT : 0;
                     }
-                    if ((fds[i].events & LIBSSH2_POLLFD_POLLOUT) &&
+                    if((fds[i].events & LIBSSH2_POLLFD_POLLOUT) &&
                         /* Want to be ready for write */
                         ((fds[i].revents & LIBSSH2_POLLFD_POLLOUT) == 0)) {
                         /* Not yet known to be ready for write */
@@ -1609,11 +1613,11 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                             poll_channel_write(fds[i].fd. channel) ?
                             LIBSSH2_POLLFD_POLLOUT : 0;
                     }
-                    if (fds[i].fd.channel->remote.close
+                    if(fds[i].fd.channel->remote.close
                         || fds[i].fd.channel->local.close) {
                         fds[i].revents |= LIBSSH2_POLLFD_CHANNEL_CLOSED;
                     }
-                    if (fds[i].fd.channel->session->socket_state ==
+                    if(fds[i].fd.channel->session->socket_state ==
                         LIBSSH2_SOCKET_DISCONNECTED) {
                         fds[i].revents |=
                             LIBSSH2_POLLFD_CHANNEL_CLOSED |
@@ -1622,7 +1626,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                     break;
 
                 case LIBSSH2_POLLFD_LISTENER:
-                    if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
+                    if((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
                         /* Want a connection */
                         ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) {
                         /* No connections known of yet */
@@ -1630,7 +1634,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                             poll_listener_queued(fds[i].fd. listener) ?
                             LIBSSH2_POLLFD_POLLIN : 0;
                     }
-                    if (fds[i].fd.listener->session->socket_state ==
+                    if(fds[i].fd.listener->session->socket_state ==
                         LIBSSH2_SOCKET_DISCONNECTED) {
                         fds[i].revents |=
                             LIBSSH2_POLLFD_LISTENER_CLOSED |
@@ -1639,12 +1643,12 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                     break;
                 }
             }
-            if (fds[i].revents) {
+            if(fds[i].revents) {
                 active_fds++;
             }
         }
 
-        if (active_fds) {
+        if(active_fds) {
             /* Don't block on the sockets if we have channels/listeners which
                are ready */
             timeout_remaining = 0;
@@ -1669,23 +1673,23 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         timeout_remaining = 0;
 #endif /* HAVE_GETTIMEOFDAY */
 
-        if (sysret > 0) {
+        if(sysret > 0) {
             for(i = 0; i < nfds; i++) {
-                switch (fds[i].type) {
+                switch(fds[i].type) {
                 case LIBSSH2_POLLFD_SOCKET:
                     fds[i].revents = sockets[i].revents;
                     sockets[i].revents = 0; /* In case we loop again, be nice */
-                    if (fds[i].revents) {
+                    if(fds[i].revents) {
                         active_fds++;
                     }
                     break;
                 case LIBSSH2_POLLFD_CHANNEL:
-                    if (sockets[i].events & POLLIN) {
+                    if(sockets[i].events & POLLIN) {
                         /* Spin session until no data available */
-                        while (_libssh2_transport_read(fds[i].fd.channel->session)
+                        while(_libssh2_transport_read(fds[i].fd.channel->session)
                                > 0);
                     }
-                    if (sockets[i].revents & POLLHUP) {
+                    if(sockets[i].revents & POLLHUP) {
                         fds[i].revents |=
                             LIBSSH2_POLLFD_CHANNEL_CLOSED |
                             LIBSSH2_POLLFD_SESSION_CLOSED;
@@ -1693,12 +1697,12 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                     sockets[i].revents = 0;
                     break;
                 case LIBSSH2_POLLFD_LISTENER:
-                    if (sockets[i].events & POLLIN) {
+                    if(sockets[i].events & POLLIN) {
                         /* Spin session until no data available */
-                        while (_libssh2_transport_read(fds[i].fd.listener->session)
+                        while(_libssh2_transport_read(fds[i].fd.listener->session)
                                > 0);
                     }
-                    if (sockets[i].revents & POLLHUP) {
+                    if(sockets[i].revents & POLLHUP) {
                         fds[i].revents |=
                             LIBSSH2_POLLFD_LISTENER_CLOSED |
                             LIBSSH2_POLLFD_SESSION_CLOSED;
@@ -1716,7 +1720,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
             struct timeval tv_begin, tv_end;
 
             _libssh2_gettimeofday((struct timeval *) &tv_begin, NULL);
-            sysret = select(maxfd+1, &rfds, &wfds, NULL, &tv);
+            sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
             _libssh2_gettimeofday((struct timeval *) &tv_end, NULL);
 
             timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
@@ -1726,38 +1730,38 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         /* If the platform doesn't support gettimeofday,
          * then just make the call non-blocking and walk away
          */
-        sysret = select(maxfd+1, &rfds, &wfds, NULL, &tv);
+        sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
         timeout_remaining = 0;
 #endif
 
-        if (sysret > 0) {
+        if(sysret > 0) {
             for(i = 0; i < nfds; i++) {
-                switch (fds[i].type) {
+                switch(fds[i].type) {
                 case LIBSSH2_POLLFD_SOCKET:
-                    if (FD_ISSET(fds[i].fd.socket, &rfds)) {
+                    if(FD_ISSET(fds[i].fd.socket, &rfds)) {
                         fds[i].revents |= LIBSSH2_POLLFD_POLLIN;
                     }
-                    if (FD_ISSET(fds[i].fd.socket, &wfds)) {
+                    if(FD_ISSET(fds[i].fd.socket, &wfds)) {
                         fds[i].revents |= LIBSSH2_POLLFD_POLLOUT;
                     }
-                    if (fds[i].revents) {
+                    if(fds[i].revents) {
                         active_fds++;
                     }
                     break;
 
                 case LIBSSH2_POLLFD_CHANNEL:
-                    if (FD_ISSET(fds[i].fd.channel->session->socket_fd, &rfds)) {
+                    if(FD_ISSET(fds[i].fd.channel->session->socket_fd, &rfds)) {
                         /* Spin session until no data available */
-                        while (_libssh2_transport_read(fds[i].fd.channel->session)
+                        while(_libssh2_transport_read(fds[i].fd.channel->session)
                                > 0);
                     }
                     break;
 
                 case LIBSSH2_POLLFD_LISTENER:
-                    if (FD_ISSET
+                    if(FD_ISSET
                         (fds[i].fd.listener->session->socket_fd, &rfds)) {
                         /* Spin session until no data available */
-                        while (_libssh2_transport_read(fds[i].fd.listener->session)
+                        while(_libssh2_transport_read(fds[i].fd.listener->session)
                                > 0);
                     }
                     break;
@@ -1766,7 +1770,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         }
 #endif /* else no select() or poll() -- timeout (and by extension
         * timeout_remaining) will be equal to 0 */
-    } while ((timeout_remaining > 0) && !active_fds);
+    } while((timeout_remaining > 0) && !active_fds);
 
     return active_fds;
 }
@@ -1792,10 +1796,10 @@ LIBSSH2_API const char *
 libssh2_session_banner_get(LIBSSH2_SESSION *session)
 {
     /* to avoid a coredump when session is NULL */
-    if (NULL == session)
+    if(NULL == session)
         return NULL;
 
-    if (NULL==session->remote.banner)
+    if(NULL == session->remote.banner)
         return NULL;
 
     return (const char *) session->remote.banner;
diff --git a/src/session.h b/src/session.h
index aff4f2c5..7b6c291e 100644
--- a/src/session.h
+++ b/src/session.h
@@ -51,9 +51,9 @@
    function.
 
 */
-#define BLOCK_ADJUST(rc,sess,x) \
+#define BLOCK_ADJUST(rc, sess, x) \
     do { \
-       time_t entry_time = time (NULL); \
+       time_t entry_time = time(NULL); \
        do { \
           rc = x; \
           /* the order of the check below is important to properly deal with \
@@ -70,9 +70,9 @@
  * immediately. If the API is blocking and we get a NULL we check the errno
  * and *only* if that is EAGAIN we loop and wait for socket action.
  */
-#define BLOCK_ADJUST_ERRNO(ptr,sess,x) \
+#define BLOCK_ADJUST_ERRNO(ptr, sess, x) \
     do { \
-       time_t entry_time = time (NULL); \
+       time_t entry_time = time(NULL); \
        int rc; \
        do { \
            ptr = x; \
diff --git a/src/sftp.c b/src/sftp.c
index d46e569e..707a2ede 100644
--- a/src/sftp.c
+++ b/src/sftp.c
@@ -181,7 +181,7 @@ add_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
 
     zombie = LIBSSH2_ALLOC(sftp->channel->session,
                            sizeof(struct sftp_zombie_requests));
-    if (!zombie)
+    if(!zombie)
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "malloc fail for zombie request  ID");
     else {
@@ -268,7 +268,7 @@ sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
     }
 
     packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP_PACKET));
-    if (!packet) {
+    if(!packet) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate datablock for SFTP packet");
     }
@@ -327,9 +327,9 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
                                        (char *)&sftp->partial_size[
                                            sftp->partial_size_len],
                                        4 - sftp->partial_size_len);
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
-            else if (rc < 0)
+            else if(rc < 0)
                 return _libssh2_error(session, rc, "channel read");
 
             sftp->partial_size_len += rc;
@@ -341,7 +341,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
             sftp->partial_len = _libssh2_ntohu32(sftp->partial_size);
             /* make sure we don't proceed if the packet size is unreasonably
                large */
-            if (sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN)
+            if(sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN)
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
                                       "SFTP packet too large");
@@ -350,7 +350,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
                            "Data begin - Packet Length: %lu",
                            sftp->partial_len);
             packet = LIBSSH2_ALLOC(session, sftp->partial_len);
-            if (!packet)
+            if(!packet)
                 return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                       "Unable to allocate SFTP packet");
             sftp->partial_size_len = 0;
@@ -378,13 +378,13 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
         }
 
         /* Read as much of the packet as we can */
-        while (sftp->partial_len > sftp->partial_received) {
+        while(sftp->partial_len > sftp->partial_received) {
             rc = _libssh2_channel_read(channel, 0,
                                        (char *)&packet[sftp->partial_received],
                                        sftp->partial_len -
                                        sftp->partial_received);
 
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 /*
                  * We received EAGAIN, save what we have and return EAGAIN to
                  * the caller. Set 'partial_packet' so that this function
@@ -393,7 +393,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
                 sftp->packet_state = libssh2_NB_state_sent1;
                 return rc;
             }
-            else if (rc < 0) {
+            else if(rc < 0) {
                 LIBSSH2_FREE(session, packet);
                 sftp->partial_packet = NULL;
                 return _libssh2_error(session, rc,
@@ -408,7 +408,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
            so we take a copy of the packet type before we call it. */
         packet_type = packet[0];
         rc = sftp_packet_add(sftp, packet, sftp->partial_len);
-        if (rc) {
+        if(rc) {
             LIBSSH2_FREE(session, packet);
             return rc;
         }
@@ -477,7 +477,7 @@ sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,
 
     /* Special consideration when getting VERSION packet */
 
-    while (packet) {
+    while(packet) {
         if((packet->data[0] == packet_type) &&
            ((packet_type == SSH_FXP_VERSION) ||
             (packet->request_id == request_id))) {
@@ -512,20 +512,20 @@ sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
     _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Requiring packet %d id %ld",
                    (int) packet_type, request_id);
 
-    if (sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {
+    if(sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {
         /* The right packet was available in the packet brigade */
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
                        (int) packet_type);
         return LIBSSH2_ERROR_NONE;
     }
 
-    while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
+    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
         rc = sftp_packet_read(sftp);
-        if (rc < 0)
+        if(rc < 0)
             return rc;
 
         /* data was read, check the queue again */
-        if (!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {
+        if(!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {
             /* The right packet was available in the packet brigade */
             _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
                            (int) packet_type);
@@ -550,12 +550,12 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
     int rc;
 
     /* If no timeout is active, start a new one */
-    if (sftp->requirev_start == 0)
+    if(sftp->requirev_start == 0)
         sftp->requirev_start = time(NULL);
 
-    while (sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
+    while(sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
         for(i = 0; i < num_valid_responses; i++) {
-            if (sftp_packet_ask(sftp, valid_responses[i], request_id,
+            if(sftp_packet_ask(sftp, valid_responses[i], request_id,
                                 data, data_len) == 0) {
                 /*
                  * Set to zero before all returns to say
@@ -567,19 +567,20 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
         }
 
         rc = sftp_packet_read(sftp);
-        if ((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {
+        if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {
             sftp->requirev_start = 0;
             return rc;
-        } else if (rc <= 0) {
+        }
+        else if(rc <= 0) {
             /* prevent busy-looping */
             long left =
                 LIBSSH2_READ_TIMEOUT - (long)(time(NULL) - sftp->requirev_start);
 
-            if (left <= 0) {
+            if(left <= 0) {
                 sftp->requirev_start = 0;
                 return LIBSSH2_ERROR_TIMEOUT;
             }
-            else if (rc == LIBSSH2_ERROR_EAGAIN) {
+            else if(rc == LIBSSH2_ERROR_EAGAIN) {
                 return rc;
             }
         }
@@ -605,27 +606,27 @@ sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs)
     /* TODO: When we add SFTP4+ functionality flag_mask can get additional
        bits */
 
-    if (!attrs) {
+    if(!attrs) {
         _libssh2_htonu32(s, 0);
         return 4;
     }
 
     _libssh2_store_u32(&s, attrs->flags & flag_mask);
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
         _libssh2_store_u64(&s, attrs->filesize);
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
         _libssh2_store_u32(&s, attrs->uid);
         _libssh2_store_u32(&s, attrs->gid);
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
         _libssh2_store_u32(&s, attrs->permissions);
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
         _libssh2_store_u32(&s, attrs->atime);
         _libssh2_store_u32(&s, attrs->mtime);
     }
@@ -644,24 +645,24 @@ sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES * attrs, const unsigned char *p)
     attrs->flags = _libssh2_ntohu32(s);
     s += 4;
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
         attrs->filesize = _libssh2_ntohu64(s);
         s += 8;
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
         attrs->uid = _libssh2_ntohu32(s);
         s += 4;
         attrs->gid = _libssh2_ntohu32(s);
         s += 4;
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
         attrs->permissions = _libssh2_ntohu32(s);
         s += 4;
     }
 
-    if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
         attrs->atime = _libssh2_ntohu32(s);
         s += 4;
         attrs->mtime = _libssh2_ntohu32(s);
@@ -688,12 +689,12 @@ LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor)
     (void) channel;
 
     /* Free the partial packet storage for sftp_packet_read */
-    if (sftp->partial_packet) {
+    if(sftp->partial_packet) {
         LIBSSH2_FREE(session, sftp->partial_packet);
     }
 
     /* Free the packet storage for _libssh2_sftp_packet_readdir */
-    if (sftp->readdir_packet) {
+    if(sftp->readdir_packet) {
         LIBSSH2_FREE(session, sftp->readdir_packet);
     }
 
@@ -712,7 +713,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     ssize_t rc;
     LIBSSH2_SFTP *sftp_handle;
 
-    if (session->sftpInit_state == libssh2_NB_state_idle) {
+    if(session->sftpInit_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Initializing SFTP subsystem");
 
@@ -735,13 +736,13 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
 
     sftp_handle = session->sftpInit_sftp;
 
-    if (session->sftpInit_state == libssh2_NB_state_created) {
+    if(session->sftpInit_state == libssh2_NB_state_created) {
         session->sftpInit_channel =
             _libssh2_channel_open(session, "session", sizeof("session") - 1,
                                   LIBSSH2_CHANNEL_WINDOW_DEFAULT,
                                   LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
-        if (!session->sftpInit_channel) {
-            if (libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
+        if(!session->sftpInit_channel) {
+            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block starting up channel");
             }
@@ -756,16 +757,17 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         session->sftpInit_state = libssh2_NB_state_sent;
     }
 
-    if (session->sftpInit_state == libssh2_NB_state_sent) {
+    if(session->sftpInit_state == libssh2_NB_state_sent) {
         int ret = _libssh2_channel_process_startup(session->sftpInit_channel,
                                                    "subsystem",
                                                    sizeof("subsystem") - 1, "sftp",
                                                    strlen("sftp"));
-        if (ret == LIBSSH2_ERROR_EAGAIN) {
+        if(ret == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block to request SFTP subsystem");
             return NULL;
-        } else if (ret) {
+        }
+        else if(ret) {
             _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
                            "Unable to request SFTP subsystem");
             goto sftp_init_error;
@@ -774,10 +776,10 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         session->sftpInit_state = libssh2_NB_state_sent1;
     }
 
-    if (session->sftpInit_state == libssh2_NB_state_sent1) {
+    if(session->sftpInit_state == libssh2_NB_state_sent1) {
         rc = _libssh2_channel_extended_data(session->sftpInit_channel,
                                             LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block requesting handle extended data");
             return NULL;
@@ -786,7 +788,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         sftp_handle =
             session->sftpInit_sftp =
             LIBSSH2_CALLOC(session, sizeof(LIBSSH2_SFTP));
-        if (!sftp_handle) {
+        if(!sftp_handle) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate a new SFTP structure");
             goto sftp_init_error;
@@ -806,13 +808,13 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         session->sftpInit_state = libssh2_NB_state_sent2;
     }
 
-    if (session->sftpInit_state == libssh2_NB_state_sent2) {
+    if(session->sftpInit_state == libssh2_NB_state_sent2) {
         /* sent off what's left of the init buffer to send */
         rc = _libssh2_channel_write(session->sftpInit_channel, 0,
                                     session->sftpInit_buffer +
                                     session->sftpInit_sent,
                                     9 - session->sftpInit_sent);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending SSH_FXP_INIT");
             return NULL;
@@ -836,17 +838,17 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
 
     rc = sftp_packet_require(sftp_handle, SSH_FXP_VERSION,
                              0, &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
-         _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                        "Would block receiving SSH_FXP_VERSION");
-         return NULL;
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
+        _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
+                       "Would block receiving SSH_FXP_VERSION");
+        return NULL;
     }
-    else if (rc) {
+    else if(rc) {
         _libssh2_error(session, rc,
                        "Timeout waiting for response from SFTP subsystem");
         goto sftp_init_error;
     }
-    if (data_len < 5) {
+    if(data_len < 5) {
         _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                        "Invalid SSH_FXP_VERSION response");
         LIBSSH2_FREE(session, data);
@@ -856,7 +858,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     s = data + 1;
     sftp_handle->version = _libssh2_ntohu32(s);
     s += 4;
-    if (sftp_handle->version > LIBSSH2_SFTP_VERSION) {
+    if(sftp_handle->version > LIBSSH2_SFTP_VERSION) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Truncating remote SFTP version from %lu",
                        sftp_handle->version);
@@ -865,7 +867,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                    "Enabling SFTP version %lu compatibility",
                    sftp_handle->version);
-    while (s < (data + data_len)) {
+    while(s < (data + data_len)) {
         size_t extname_len, extdata_len;
 
         extname_len = _libssh2_ntohu32(s);
@@ -898,10 +900,10 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     return sftp_handle;
 
   sftp_init_error:
-    while (_libssh2_channel_free(session->sftpInit_channel) ==
+    while(_libssh2_channel_free(session->sftpInit_channel) ==
            LIBSSH2_ERROR_EAGAIN);
     session->sftpInit_channel = NULL;
-    if (session->sftpInit_sftp) {
+    if(session->sftpInit_sftp) {
         LIBSSH2_FREE(session, session->sftpInit_sftp);
         session->sftpInit_sftp = NULL;
     }
@@ -944,55 +946,55 @@ sftp_shutdown(LIBSSH2_SFTP *sftp)
     /*
      * Make sure all memory used in the state variables are free
      */
-    if (sftp->partial_packet) {
+    if(sftp->partial_packet) {
         LIBSSH2_FREE(session, sftp->partial_packet);
         sftp->partial_packet = NULL;
     }
-    if (sftp->open_packet) {
+    if(sftp->open_packet) {
         LIBSSH2_FREE(session, sftp->open_packet);
         sftp->open_packet = NULL;
     }
-    if (sftp->readdir_packet) {
+    if(sftp->readdir_packet) {
         LIBSSH2_FREE(session, sftp->readdir_packet);
         sftp->readdir_packet = NULL;
     }
-    if (sftp->fstat_packet) {
+    if(sftp->fstat_packet) {
         LIBSSH2_FREE(session, sftp->fstat_packet);
         sftp->fstat_packet = NULL;
     }
-    if (sftp->unlink_packet) {
+    if(sftp->unlink_packet) {
         LIBSSH2_FREE(session, sftp->unlink_packet);
         sftp->unlink_packet = NULL;
     }
-    if (sftp->rename_packet) {
+    if(sftp->rename_packet) {
         LIBSSH2_FREE(session, sftp->rename_packet);
         sftp->rename_packet = NULL;
     }
-    if (sftp->fstatvfs_packet) {
+    if(sftp->fstatvfs_packet) {
         LIBSSH2_FREE(session, sftp->fstatvfs_packet);
         sftp->fstatvfs_packet = NULL;
     }
-    if (sftp->statvfs_packet) {
+    if(sftp->statvfs_packet) {
         LIBSSH2_FREE(session, sftp->statvfs_packet);
         sftp->statvfs_packet = NULL;
     }
-    if (sftp->mkdir_packet) {
+    if(sftp->mkdir_packet) {
         LIBSSH2_FREE(session, sftp->mkdir_packet);
         sftp->mkdir_packet = NULL;
     }
-    if (sftp->rmdir_packet) {
+    if(sftp->rmdir_packet) {
         LIBSSH2_FREE(session, sftp->rmdir_packet);
         sftp->rmdir_packet = NULL;
     }
-    if (sftp->stat_packet) {
+    if(sftp->stat_packet) {
         LIBSSH2_FREE(session, sftp->stat_packet);
         sftp->stat_packet = NULL;
     }
-    if (sftp->symlink_packet) {
+    if(sftp->symlink_packet) {
         LIBSSH2_FREE(session, sftp->symlink_packet);
         sftp->symlink_packet = NULL;
     }
-    if (sftp->fsync_packet) {
+    if(sftp->fsync_packet) {
         LIBSSH2_FREE(session, sftp->fsync_packet);
         sftp->fsync_packet = NULL;
     }
@@ -1041,7 +1043,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
     ssize_t rc;
     int open_file = (open_type == LIBSSH2_SFTP_OPENFILE)?1:0;
 
-    if (sftp->open_state == libssh2_NB_state_idle) {
+    if(sftp->open_state == libssh2_NB_state_idle) {
         /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) +
            flags(4) */
         sftp->open_packet_len = filename_len + 13 +
@@ -1050,7 +1052,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         /* surprise! this starts out with nothing sent */
         sftp->open_packet_sent = 0;
         s = sftp->open_packet = LIBSSH2_ALLOC(session, sftp->open_packet_len);
-        if (!sftp->open_packet) {
+        if(!sftp->open_packet) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for FXP_OPEN or "
                            "FXP_OPENDIR packet");
@@ -1067,7 +1069,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         _libssh2_store_u32(&s, sftp->open_request_id);
         _libssh2_store_str(&s, filename, filename_len);
 
-        if (open_file) {
+        if(open_file) {
             _libssh2_store_u32(&s, flags);
             s += sftp_attr2bin(s, &attrs);
         }
@@ -1078,12 +1080,12 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         sftp->open_state = libssh2_NB_state_created;
     }
 
-    if (sftp->open_state == libssh2_NB_state_created) {
+    if(sftp->open_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->open_packet+
                                     sftp->open_packet_sent,
                                     sftp->open_packet_len -
                                     sftp->open_packet_sent);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending FXP_OPEN or FXP_OPENDIR command");
             return NULL;
@@ -1108,7 +1110,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         }
     }
 
-    if (sftp->open_state == libssh2_NB_state_sent) {
+    if(sftp->open_state == libssh2_NB_state_sent) {
         size_t data_len;
         unsigned char *data;
         static const unsigned char fopen_responses[2] =
@@ -1116,13 +1118,13 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         rc = sftp_packet_requirev(sftp, 2, fopen_responses,
                                   sftp->open_request_id, &data,
                                   &data_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block waiting for status message");
             return NULL;
         }
         sftp->open_state = libssh2_NB_state_idle;
-        if (rc) {
+        if(rc) {
             _libssh2_error(session, rc, "Timeout waiting for status message");
             return NULL;
         }
@@ -1131,7 +1133,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
            a fine response while STATUS means error. It seems though that at
            times we get an SSH_FX_OK back in a STATUS, followed the "real"
            HANDLE so we need to properly deal with that. */
-        if (data[0] == SSH_FXP_STATUS) {
+        if(data[0] == SSH_FXP_STATUS) {
             int badness = 1;
 
             if(data_len < 9) {
@@ -1180,7 +1182,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         }
 
         fp = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_SFTP_HANDLE));
-        if (!fp) {
+        if(!fp) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate new SFTP handle structure");
             LIBSSH2_FREE(session, data);
@@ -1190,7 +1192,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
             LIBSSH2_SFTP_HANDLE_DIR;
 
         fp->handle_len = _libssh2_ntohu32(data + 5);
-        if (fp->handle_len > SFTP_HANDLE_MAXLEN)
+        if(fp->handle_len > SFTP_HANDLE_MAXLEN)
             /* SFTP doesn't allow handles longer than 256 characters */
             fp->handle_len = SFTP_HANDLE_MAXLEN;
 
@@ -1286,7 +1288,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
        and second phases on the next call and resume sending.
     */
 
-    switch (sftp->read_state) {
+    switch(sftp->read_state) {
     case libssh2_NB_state_idle:
 
         /* Some data may already have been read from the server in the
@@ -1310,9 +1312,10 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             return copy;
         }
 
-        if (filep->eof) {
+        if(filep->eof) {
             return 0;
-        } else {
+        }
+        else {
             /* We allow a number of bytes being requested at any given time
                without having been acked - until we reach EOF. */
 
@@ -1363,7 +1366,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                    at next call */
                 assert(rc != LIBSSH2_ERROR_EAGAIN || !filep->data_left);
                 assert(rc != LIBSSH2_ERROR_EAGAIN || !filep->eof);
-                if (rc)
+                if(rc)
                     return rc;
             }
         }
@@ -1377,14 +1380,14 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             uint32_t request_id;
 
             uint32_t size = count;
-            if (size < buffer_size)
+            if(size < buffer_size)
                 size = buffer_size;
-            if (size > MAX_SFTP_READ_SIZE)
+            if(size > MAX_SFTP_READ_SIZE)
                 size = MAX_SFTP_READ_SIZE;
 
             chunk = LIBSSH2_ALLOC(session, packet_len +
                                   sizeof(struct sftp_pipeline_chunk));
-            if (!chunk)
+            if(!chunk)
                 return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                       "malloc fail for FXP_WRITE");
 
@@ -1407,8 +1410,8 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
             /* add this new entry LAST in the list */
             _libssh2_list_add(&handle->packet_list, &chunk->node);
-            count -= MIN(size,count); /* deduct the size we used, as we might
-                                       * have to create more packets */
+            count -= MIN(size, count); /* deduct the size we used, as we might
+                                        * have to create more packets */
             _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                            "read request id %d sent (offset: %d, size: %d)",
                            request_id, (int)chunk->offset, (int)chunk->len);
@@ -1441,9 +1444,10 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                     /* We still have data left to send for this chunk.
                      * If there is at least one completely sent chunk,
                      * we can get out of this loop and start reading.  */
-                    if (chunk != _libssh2_list_first(&handle->packet_list)) {
+                    if(chunk != _libssh2_list_first(&handle->packet_list)) {
                         break;
-                    } else {
+                    }
+                    else {
                         continue;
                     }
                 }
@@ -1473,9 +1477,10 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             if(chunk->lefttosend) {
                 /* if the chunk still has data left to send, we shouldn't wait
                    for an ACK for it just yet */
-                if (bytes_in_buffer > 0) {
+                if(bytes_in_buffer > 0) {
                     return bytes_in_buffer;
-                } else {
+                }
+                else {
                     /* we should never reach this point */
                     return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                           "sftp_read() internal error");
@@ -1485,13 +1490,13 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             rc = sftp_packet_requirev(sftp, 2, read_responses,
                                       chunk->request_id, &data, &data_len);
 
-            if (rc==LIBSSH2_ERROR_EAGAIN && bytes_in_buffer != 0) {
+            if(rc == LIBSSH2_ERROR_EAGAIN && bytes_in_buffer != 0) {
                 /* do not return EAGAIN if we have already
                  * written data into the buffer */
                 return bytes_in_buffer;
             }
 
-            if (rc < 0) {
+            if(rc < 0) {
                 sftp->read_state = libssh2_NB_state_sent2;
                 return rc;
             }
@@ -1501,7 +1506,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
              * FX_EOF when we reach the end of the file.
              */
 
-            switch (data[0]) {
+            switch(data[0]) {
             case SSH_FXP_STATUS:
                 /* remove the chunk we just processed */
 
@@ -1515,7 +1520,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                 rc32 = _libssh2_ntohu32(data + 5);
                 LIBSSH2_FREE(session, data);
 
-                if (rc32 == LIBSSH2_FX_EOF) {
+                if(rc32 == LIBSSH2_FX_EOF) {
                     filep->eof = TRUE;
                     return bytes_in_buffer;
                 }
@@ -1527,7 +1532,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                 break;
 
             case SSH_FXP_DATA:
-                if (chunk->offset != filep->offset) {
+                if(chunk->offset != filep->offset) {
                     /* This could happen if the server returns less bytes than
                        requested, which shouldn't happen for normal files. See:
                        https://tools.ietf.org/html/draft-ietf-secsh-filexfer-02
@@ -1538,7 +1543,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                 }
 
                 rc32 = _libssh2_ntohu32(data + 5);
-                if (rc32 > (data_len - 9))
+                if(rc32 > (data_len - 9))
                     return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                           "SFTP Protocol badness");
 
@@ -1592,9 +1597,10 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                 /* check if we have space left in the buffer
                  * and either continue to the next chunk or stop
                  */
-                if (bytes_in_buffer < buffer_size) {
+                if(bytes_in_buffer < buffer_size) {
                     chunk = next;
-                } else {
+                }
+                else {
                     chunk = NULL;
                 }
 
@@ -1606,7 +1612,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             }
         }
 
-        if (bytes_in_buffer > 0)
+        if(bytes_in_buffer > 0)
             return bytes_in_buffer;
 
         break;
@@ -1655,8 +1661,8 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
         SSH_FXP_NAME, SSH_FXP_STATUS };
     ssize_t retcode;
 
-    if (sftp->readdir_state == libssh2_NB_state_idle) {
-        if (handle->u.dir.names_left) {
+    if(sftp->readdir_state == libssh2_NB_state_idle) {
+        if(handle->u.dir.names_left) {
             /*
              * A prior request returned more than one directory entry,
              * feed it back from the buffer
@@ -1673,7 +1679,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
             s += 4;
 
             filename_len = real_filename_len;
-            if (filename_len >= buffer_maxlen) {
+            if(filename_len >= buffer_maxlen) {
                 filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
                 goto end;
             }
@@ -1685,10 +1691,10 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
             real_longentry_len = _libssh2_ntohu32(s);
             s += 4;
 
-            if (longentry && (longentry_maxlen>1)) {
+            if(longentry && (longentry_maxlen>1)) {
                 longentry_len = real_longentry_len;
 
-                if (longentry_len >= longentry_maxlen) {
+                if(longentry_len >= longentry_maxlen) {
                     filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
                     goto end;
                 }
@@ -1698,7 +1704,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
             }
             s += real_longentry_len;
 
-            if (attrs)
+            if(attrs)
                 memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
 
             s += sftp_bin2attr(attrs ? attrs : &attrs_dummy, s);
@@ -1706,7 +1712,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
             handle->u.dir.next_name = (char *) s;
           end:
 
-            if ((--handle->u.dir.names_left) == 0)
+            if((--handle->u.dir.names_left) == 0)
                 LIBSSH2_FREE(session, handle->u.dir.names_packet);
 
             _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
@@ -1718,7 +1724,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
         /* Request another entry(entries?) */
 
         s = sftp->readdir_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->readdir_packet)
+        if(!sftp->readdir_packet)
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "FXP_READDIR packet");
@@ -1732,15 +1738,15 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
         sftp->readdir_state = libssh2_NB_state_created;
     }
 
-    if (sftp->readdir_state == libssh2_NB_state_created) {
+    if(sftp->readdir_state == libssh2_NB_state_created) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Reading entries from directory handle");
         retcode = _libssh2_channel_write(channel, 0, sftp->readdir_packet,
                                          packet_len);
-        if (retcode == LIBSSH2_ERROR_EAGAIN) {
+        if(retcode == LIBSSH2_ERROR_EAGAIN) {
             return retcode;
         }
-        else if ((ssize_t)packet_len != retcode) {
+        else if((ssize_t)packet_len != retcode) {
             LIBSSH2_FREE(session, sftp->readdir_packet);
             sftp->readdir_packet = NULL;
             sftp->readdir_state = libssh2_NB_state_idle;
@@ -1757,18 +1763,18 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     retcode = sftp_packet_requirev(sftp, 2, read_responses,
                                    sftp->readdir_request_id, &data,
                                    &data_len);
-    if (retcode == LIBSSH2_ERROR_EAGAIN)
+    if(retcode == LIBSSH2_ERROR_EAGAIN)
         return retcode;
-    else if (retcode) {
+    else if(retcode) {
         sftp->readdir_state = libssh2_NB_state_idle;
         return _libssh2_error(session, retcode,
                               "Timeout waiting for status message");
     }
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
-        if (retcode == LIBSSH2_FX_EOF) {
+        if(retcode == LIBSSH2_FX_EOF) {
             sftp->readdir_state = libssh2_NB_state_idle;
             return 0;
         }
@@ -1785,7 +1791,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     num_names = _libssh2_ntohu32(data + 5);
     _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%lu entries returned",
                    num_names);
-    if (!num_names) {
+    if(!num_names) {
         LIBSSH2_FREE(session, data);
         return 0;
     }
@@ -1876,7 +1882,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
     default:
     case libssh2_NB_state_idle:
 
-        /* Number of bytes sent off that haven't been acked and therefor we
+        /* Number of bytes sent off that haven't been acked and therefore we
            will get passed in here again.
 
            Also, add up the number of bytes that actually already have been
@@ -1908,7 +1914,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
 
             chunk = LIBSSH2_ALLOC(session, packet_len +
                                   sizeof(struct sftp_pipeline_chunk));
-            if (!chunk)
+            if(!chunk)
                 return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                       "malloc fail for FXP_WRITE");
 
@@ -1985,8 +1991,8 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
             /* we check the packets in order */
             rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                                      chunk->request_id, &data, &data_len);
-            if (rc < 0) {
-                if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc < 0) {
+                if(rc == LIBSSH2_ERROR_EAGAIN)
                     sftp->write_state = libssh2_NB_state_sent;
                 return rc;
             }
@@ -1995,7 +2001,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
             LIBSSH2_FREE(session, data);
 
             sftp->last_errno = retcode;
-            if (retcode == LIBSSH2_FX_OK) {
+            if(retcode == LIBSSH2_FX_OK) {
                 acked += chunk->len; /* number of payload data that was acked
                                         here */
 
@@ -2085,11 +2091,11 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
     ssize_t rc;
     uint32_t retcode;
 
-    if (sftp->fsync_state == libssh2_NB_state_idle) {
+    if(sftp->fsync_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Issuing fsync command");
         s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!packet) {
+        if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_EXTENDED "
                                   "packet");
@@ -2103,13 +2109,14 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
         _libssh2_store_str(&s, handle->handle, handle->handle_len);
 
         sftp->fsync_state = libssh2_NB_state_created;
-    } else {
+    }
+    else {
         packet = sftp->fsync_packet;
     }
 
-    if (sftp->fsync_state == libssh2_NB_state_created) {
+    if(sftp->fsync_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN ||
+        if(rc == LIBSSH2_ERROR_EAGAIN ||
             (0 <= rc && rc < (ssize_t)packet_len)) {
             sftp->fsync_packet = packet;
             return LIBSSH2_ERROR_EAGAIN;
@@ -2118,7 +2125,7 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
         LIBSSH2_FREE(session, packet);
         sftp->fsync_packet = NULL;
 
-        if (rc < 0) {
+        if(rc < 0) {
             sftp->fsync_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "_libssh2_channel_write() failed");
@@ -2128,9 +2135,10 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
 
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                              sftp->fsync_request_id, &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->fsync_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP EXTENDED REPLY");
@@ -2141,7 +2149,7 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
     retcode = _libssh2_ntohu32(data + 5);
     LIBSSH2_FREE(session, data);
 
-    if (retcode != LIBSSH2_FX_OK) {
+    if(retcode != LIBSSH2_FX_OK) {
         sftp->last_errno = retcode;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "fsync failed");
@@ -2185,11 +2193,11 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
         { SSH_FXP_ATTRS, SSH_FXP_STATUS };
     ssize_t rc;
 
-    if (sftp->fstat_state == libssh2_NB_state_idle) {
+    if(sftp->fstat_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Issuing %s command",
                        setstat ? "set-stat" : "stat");
         s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->fstat_packet) {
+        if(!sftp->fstat_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "FSTAT/FSETSTAT packet");
@@ -2201,20 +2209,20 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
         _libssh2_store_u32(&s, sftp->fstat_request_id);
         _libssh2_store_str(&s, handle->handle, handle->handle_len);
 
-        if (setstat) {
+        if(setstat) {
             s += sftp_attr2bin(s, attrs);
         }
 
         sftp->fstat_state = libssh2_NB_state_created;
     }
 
-    if (sftp->fstat_state == libssh2_NB_state_created) {
+    if(sftp->fstat_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->fstat_packet,
                                     packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
-        else if ((ssize_t)packet_len != rc) {
+        else if((ssize_t)packet_len != rc) {
             LIBSSH2_FREE(session, sftp->fstat_packet);
             sftp->fstat_packet = NULL;
             sftp->fstat_state = libssh2_NB_state_idle;
@@ -2231,9 +2239,9 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
     rc = sftp_packet_requirev(sftp, 2, fstat_responses,
                               sftp->fstat_request_id, &data,
                               &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN)
+    if(rc == LIBSSH2_ERROR_EAGAIN)
         return rc;
-    else if (rc) {
+    else if(rc) {
         sftp->fstat_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Timeout waiting for status message");
@@ -2241,14 +2249,15 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
 
     sftp->fstat_state = libssh2_NB_state_idle;
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         uint32_t retcode;
 
         retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
-        if (retcode == LIBSSH2_FX_OK) {
+        if(retcode == LIBSSH2_FX_OK) {
             return 0;
-        } else {
+        }
+        else {
             sftp->last_errno = retcode;
             return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                   "SFTP Protocol Error");
@@ -2293,7 +2302,7 @@ libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle, libssh2_uint64_t offset)
     sftp_packetlist_flush(handle);
 
     /* free the left received buffered data */
-    if (handle->u.file.data_left) {
+    if(handle->u.file.data_left) {
         LIBSSH2_FREE(handle->sftp->channel->session, handle->u.file.data);
         handle->u.file.data_left = handle->u.file.data_len = 0;
         handle->u.file.data = NULL;
@@ -2394,15 +2403,16 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
     unsigned char *s, *data = NULL;
     int rc = 0;
 
-    if (handle->close_state == libssh2_NB_state_idle) {
+    if(handle->close_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Closing handle");
         s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!handle->close_packet) {
+        if(!handle->close_packet) {
             handle->close_state = libssh2_NB_state_idle;
             rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                 "Unable to allocate memory for FXP_CLOSE "
                                 "packet");
-        } else {
+        }
+        else {
 
             _libssh2_store_u32(&s, packet_len - 4);
             *(s++) = SSH_FXP_CLOSE;
@@ -2413,30 +2423,33 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
         }
     }
 
-    if (handle->close_state == libssh2_NB_state_created) {
+    if(handle->close_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, handle->close_packet,
                                     packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((ssize_t)packet_len != rc) {
+        }
+        else if((ssize_t)packet_len != rc) {
             handle->close_state = libssh2_NB_state_idle;
             rc = _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                 "Unable to send FXP_CLOSE command");
-        } else
+        }
+        else
             handle->close_state = libssh2_NB_state_sent;
 
         LIBSSH2_FREE(session, handle->close_packet);
         handle->close_packet = NULL;
     }
 
-    if (handle->close_state == libssh2_NB_state_sent) {
+    if(handle->close_state == libssh2_NB_state_sent) {
         rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                                  handle->close_request_id, &data,
                                  &data_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
 
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, rc,
                            "Error waiting for status message");
         }
@@ -2449,11 +2462,12 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
            happened for which we should have set an error code */
         assert(rc);
 
-    } else {
+    }
+    else {
         int retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
 
-        if (retcode != LIBSSH2_FX_OK) {
+        if(retcode != LIBSSH2_FX_OK) {
             sftp->last_errno = retcode;
             handle->close_state = libssh2_NB_state_idle;
             rc = _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
@@ -2464,7 +2478,7 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
     /* remove this handle from the parent's list */
     _libssh2_list_remove(&handle->node);
 
-    if ((handle->handle_type == LIBSSH2_SFTP_HANDLE_DIR)
+    if((handle->handle_type == LIBSSH2_SFTP_HANDLE_DIR)
         && handle->u.dir.names_left) {
         LIBSSH2_FREE(session, handle->u.dir.names_packet);
     }
@@ -2513,10 +2527,10 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
     unsigned char *s, *data;
     int rc;
 
-    if (sftp->unlink_state == libssh2_NB_state_idle) {
+    if(sftp->unlink_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Unlinking %s", filename);
         s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->unlink_packet) {
+        if(!sftp->unlink_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_REMOVE "
                                   "packet");
@@ -2530,12 +2544,13 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
         sftp->unlink_state = libssh2_NB_state_created;
     }
 
-    if (sftp->unlink_state == libssh2_NB_state_created) {
+    if(sftp->unlink_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->unlink_packet,
                                     packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((ssize_t)packet_len != rc) {
+        }
+        else if((ssize_t)packet_len != rc) {
             LIBSSH2_FREE(session, sftp->unlink_packet);
             sftp->unlink_packet = NULL;
             sftp->unlink_state = libssh2_NB_state_idle;
@@ -2551,10 +2566,10 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                              sftp->unlink_request_id, &data,
                              &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
     }
-    else if (rc) {
+    else if(rc) {
         sftp->unlink_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP STATUS");
@@ -2565,9 +2580,10 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
     retcode = _libssh2_ntohu32(data + 5);
     LIBSSH2_FREE(session, data);
 
-    if (retcode == LIBSSH2_FX_OK) {
+    if(retcode == LIBSSH2_FX_OK) {
         return 0;
-    } else {
+    }
+    else {
         sftp->last_errno = retcode;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "SFTP Protocol Error");
@@ -2611,17 +2627,17 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
     unsigned char *data;
     ssize_t rc;
 
-    if (sftp->version < 2) {
+    if(sftp->version < 2) {
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "Server does not support RENAME");
     }
 
-    if (sftp->rename_state == libssh2_NB_state_idle) {
+    if(sftp->rename_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Renaming %s to %s",
                        source_filename, dest_filename);
         sftp->rename_s = sftp->rename_packet =
             LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->rename_packet) {
+        if(!sftp->rename_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_RENAME "
                                   "packet");
@@ -2635,18 +2651,19 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
                            source_filename_len);
         _libssh2_store_str(&sftp->rename_s, dest_filename, dest_filename_len);
 
-        if (sftp->version >= 5)
+        if(sftp->version >= 5)
             _libssh2_store_u32(&sftp->rename_s, flags);
 
         sftp->rename_state = libssh2_NB_state_created;
     }
 
-    if (sftp->rename_state == libssh2_NB_state_created) {
+    if(sftp->rename_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->rename_packet,
                                     sftp->rename_s - sftp->rename_packet);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if ((ssize_t)packet_len != rc) {
+        }
+        else if((ssize_t)packet_len != rc) {
             LIBSSH2_FREE(session, sftp->rename_packet);
             sftp->rename_packet = NULL;
             sftp->rename_state = libssh2_NB_state_idle;
@@ -2662,9 +2679,10 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                              sftp->rename_request_id, &data,
                              &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->rename_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP STATUS");
@@ -2679,7 +2697,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
 
     /* now convert the SFTP error code to libssh2 return code or error
        message */
-    switch (retcode) {
+    switch(retcode) {
     case LIBSSH2_FX_OK:
         retcode = LIBSSH2_ERROR_NONE;
         break;
@@ -2743,11 +2761,11 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
     static const unsigned char responses[2] =
         { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
 
-    if (sftp->fstatvfs_state == libssh2_NB_state_idle) {
+    if(sftp->fstatvfs_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Getting file system statistics");
         s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!packet) {
+        if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_EXTENDED "
                                   "packet");
@@ -2766,9 +2784,9 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
         packet = sftp->fstatvfs_packet;
     }
 
-    if (sftp->fstatvfs_state == libssh2_NB_state_created) {
+    if(sftp->fstatvfs_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN ||
+        if(rc == LIBSSH2_ERROR_EAGAIN ||
             (0 <= rc && rc < (ssize_t)packet_len)) {
             sftp->fstatvfs_packet = packet;
             return LIBSSH2_ERROR_EAGAIN;
@@ -2777,7 +2795,7 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
         LIBSSH2_FREE(session, packet);
         sftp->fstatvfs_packet = NULL;
 
-        if (rc < 0) {
+        if(rc < 0) {
             sftp->fstatvfs_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "_libssh2_channel_write() failed");
@@ -2788,15 +2806,16 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
     rc = sftp_packet_requirev(sftp, 2, responses, sftp->fstatvfs_request_id,
                               &data, &data_len);
 
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->fstatvfs_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP EXTENDED REPLY");
     }
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         int retcode = _libssh2_ntohu32(data + 5);
         sftp->fstatvfs_state = libssh2_NB_state_idle;
         LIBSSH2_FREE(session, data);
@@ -2805,7 +2824,7 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
                               "SFTP Protocol Error");
     }
 
-    if (data_len < 93) {
+    if(data_len < 93) {
         LIBSSH2_FREE(session, data);
         sftp->fstatvfs_state = libssh2_NB_state_idle;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
@@ -2870,11 +2889,11 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
     static const unsigned char responses[2] =
         { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
 
-    if (sftp->statvfs_state == libssh2_NB_state_idle) {
+    if(sftp->statvfs_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Getting file system statistics of %s", path);
         s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!packet) {
+        if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_EXTENDED "
                                   "packet");
@@ -2893,9 +2912,9 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
         packet = sftp->statvfs_packet;
     }
 
-    if (sftp->statvfs_state == libssh2_NB_state_created) {
+    if(sftp->statvfs_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN ||
+        if(rc == LIBSSH2_ERROR_EAGAIN ||
             (0 <= rc && rc < (ssize_t)packet_len)) {
             sftp->statvfs_packet = packet;
             return LIBSSH2_ERROR_EAGAIN;
@@ -2904,7 +2923,7 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
         LIBSSH2_FREE(session, packet);
         sftp->statvfs_packet = NULL;
 
-        if (rc < 0) {
+        if(rc < 0) {
             sftp->statvfs_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "_libssh2_channel_write() failed");
@@ -2914,15 +2933,16 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
 
     rc = sftp_packet_requirev(sftp, 2, responses, sftp->statvfs_request_id,
                               &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->statvfs_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP EXTENDED REPLY");
     }
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         int retcode = _libssh2_ntohu32(data + 5);
         sftp->statvfs_state = libssh2_NB_state_idle;
         LIBSSH2_FREE(session, data);
@@ -2931,7 +2951,7 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
                               "SFTP Protocol Error");
     }
 
-    if (data_len < 93) {
+    if(data_len < 93) {
         LIBSSH2_FREE(session, data);
         sftp->statvfs_state = libssh2_NB_state_idle;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
@@ -2999,11 +3019,11 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     unsigned char *packet, *s, *data;
     int rc;
 
-    if (sftp->mkdir_state == libssh2_NB_state_idle) {
+    if(sftp->mkdir_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
                        "Creating directory %s with mode 0%lo", path, mode);
         s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!packet) {
+        if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_MKDIR "
                                   "packet");
@@ -3025,13 +3045,13 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
         packet = sftp->mkdir_packet;
     }
 
-    if (sftp->mkdir_state == libssh2_NB_state_created) {
+    if(sftp->mkdir_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             sftp->mkdir_packet = packet;
             return rc;
         }
-        if (packet_len != rc) {
+        if(packet_len != rc) {
             LIBSSH2_FREE(session, packet);
             sftp->mkdir_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
@@ -3044,9 +3064,10 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
 
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->mkdir_request_id,
                              &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->mkdir_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP STATUS");
@@ -3057,10 +3078,11 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     retcode = _libssh2_ntohu32(data + 5);
     LIBSSH2_FREE(session, data);
 
-    if (retcode == LIBSSH2_FX_OK) {
+    if(retcode == LIBSSH2_FX_OK) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "OK!");
         return 0;
-    } else {
+    }
+    else {
         sftp->last_errno = retcode;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "SFTP Protocol Error");
@@ -3099,11 +3121,11 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
     unsigned char *s, *data;
     int rc;
 
-    if (sftp->rmdir_state == libssh2_NB_state_idle) {
+    if(sftp->rmdir_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Removing directory: %s",
                        path);
         s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->rmdir_packet) {
+        if(!sftp->rmdir_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_RMDIR "
                                   "packet");
@@ -3118,12 +3140,13 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
         sftp->rmdir_state = libssh2_NB_state_created;
     }
 
-    if (sftp->rmdir_state == libssh2_NB_state_created) {
+    if(sftp->rmdir_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->rmdir_packet,
                                     packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (packet_len != rc) {
+        }
+        else if(packet_len != rc) {
             LIBSSH2_FREE(session, sftp->rmdir_packet);
             sftp->rmdir_packet = NULL;
             sftp->rmdir_state = libssh2_NB_state_idle;
@@ -3138,9 +3161,10 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
 
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                              sftp->rmdir_request_id, &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return rc;
-    } else if (rc) {
+    }
+    else if(rc) {
         sftp->rmdir_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Error waiting for FXP STATUS");
@@ -3151,9 +3175,10 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
     retcode = _libssh2_ntohu32(data + 5);
     LIBSSH2_FREE(session, data);
 
-    if (retcode == LIBSSH2_FX_OK) {
+    if(retcode == LIBSSH2_FX_OK) {
         return 0;
-    } else {
+    }
+    else {
         sftp->last_errno = retcode;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "SFTP Protocol Error");
@@ -3195,13 +3220,13 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
         { SSH_FXP_ATTRS, SSH_FXP_STATUS };
     int rc;
 
-    if (sftp->stat_state == libssh2_NB_state_idle) {
+    if(sftp->stat_state == libssh2_NB_state_idle) {
         _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s",
                        (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" :
                        (stat_type ==
                         LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
         s = sftp->stat_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->stat_packet) {
+        if(!sftp->stat_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for FXP_*STAT "
                                   "packet");
@@ -3209,7 +3234,7 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
 
         _libssh2_store_u32(&s, packet_len - 4);
 
-        switch (stat_type) {
+        switch(stat_type) {
         case LIBSSH2_SFTP_SETSTAT:
             *(s++) = SSH_FXP_SETSTAT;
             break;
@@ -3226,17 +3251,18 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
         _libssh2_store_u32(&s, sftp->stat_request_id);
         _libssh2_store_str(&s, path, path_len);
 
-        if (stat_type == LIBSSH2_SFTP_SETSTAT)
+        if(stat_type == LIBSSH2_SFTP_SETSTAT)
             s += sftp_attr2bin(s, attrs);
 
         sftp->stat_state = libssh2_NB_state_created;
     }
 
-    if (sftp->stat_state == libssh2_NB_state_created) {
+    if(sftp->stat_state == libssh2_NB_state_created) {
         rc = _libssh2_channel_write(channel, 0, sftp->stat_packet, packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
-        } else if (packet_len != rc) {
+        }
+        else if(packet_len != rc) {
             LIBSSH2_FREE(session, sftp->stat_packet);
             sftp->stat_packet = NULL;
             sftp->stat_state = libssh2_NB_state_idle;
@@ -3251,9 +3277,9 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
 
     rc = sftp_packet_requirev(sftp, 2, stat_responses,
                               sftp->stat_request_id, &data, &data_len);
-    if (rc == LIBSSH2_ERROR_EAGAIN)
+    if(rc == LIBSSH2_ERROR_EAGAIN)
         return rc;
-    else if (rc) {
+    else if(rc) {
         sftp->stat_state = libssh2_NB_state_idle;
         return _libssh2_error(session, rc,
                               "Timeout waiting for status message");
@@ -3261,14 +3287,15 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
 
     sftp->stat_state = libssh2_NB_state_idle;
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         int retcode;
 
         retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
-        if (retcode == LIBSSH2_FX_OK) {
+        if(retcode == LIBSSH2_FX_OK) {
             return 0;
-        } else {
+        }
+        else {
             sftp->last_errno = retcode;
             return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                   "SFTP Protocol Error");
@@ -3317,14 +3344,14 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
         { SSH_FXP_NAME, SSH_FXP_STATUS };
     int retcode;
 
-    if ((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) {
+    if((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) {
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "Server does not support SYMLINK or READLINK");
     }
 
-    if (sftp->symlink_state == libssh2_NB_state_idle) {
+    if(sftp->symlink_state == libssh2_NB_state_idle) {
         s = sftp->symlink_packet = LIBSSH2_ALLOC(session, packet_len);
-        if (!sftp->symlink_packet) {
+        if(!sftp->symlink_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "SYMLINK/READLINK/REALPATH packet");
@@ -3338,7 +3365,7 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
 
         _libssh2_store_u32(&s, packet_len - 4);
 
-        switch (link_type) {
+        switch(link_type) {
         case LIBSSH2_SFTP_REALPATH:
             *(s++) = SSH_FXP_REALPATH;
             break;
@@ -3355,18 +3382,18 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
         _libssh2_store_u32(&s, sftp->symlink_request_id);
         _libssh2_store_str(&s, path, path_len);
 
-        if (link_type == LIBSSH2_SFTP_SYMLINK)
+        if(link_type == LIBSSH2_SFTP_SYMLINK)
             _libssh2_store_str(&s, target, target_len);
 
         sftp->symlink_state = libssh2_NB_state_created;
     }
 
-    if (sftp->symlink_state == libssh2_NB_state_created) {
+    if(sftp->symlink_state == libssh2_NB_state_created) {
         ssize_t rc = _libssh2_channel_write(channel, 0, sftp->symlink_packet,
                                             packet_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        else if (packet_len != rc) {
+        else if(packet_len != rc) {
             LIBSSH2_FREE(session, sftp->symlink_packet);
             sftp->symlink_packet = NULL;
             sftp->symlink_state = libssh2_NB_state_idle;
@@ -3382,9 +3409,9 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
     retcode = sftp_packet_requirev(sftp, 2, link_responses,
                                    sftp->symlink_request_id, &data,
                                    &data_len);
-    if (retcode == LIBSSH2_ERROR_EAGAIN)
+    if(retcode == LIBSSH2_ERROR_EAGAIN)
         return retcode;
-    else if (retcode) {
+    else if(retcode) {
         sftp->symlink_state = libssh2_NB_state_idle;
         return _libssh2_error(session, retcode,
                               "Error waiting for status message");
@@ -3392,10 +3419,10 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
 
     sftp->symlink_state = libssh2_NB_state_idle;
 
-    if (data[0] == SSH_FXP_STATUS) {
+    if(data[0] == SSH_FXP_STATUS) {
         retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
-        if (retcode == LIBSSH2_FX_OK)
+        if(retcode == LIBSSH2_FX_OK)
             return LIBSSH2_ERROR_NONE;
         else {
             sftp->last_errno = retcode;
@@ -3404,7 +3431,7 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
         }
     }
 
-    if (_libssh2_ntohu32(data + 5) < 1) {
+    if(_libssh2_ntohu32(data + 5) < 1) {
         LIBSSH2_FREE(session, data);
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "Invalid READLINK/REALPATH response, "
@@ -3413,7 +3440,7 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
 
     /* this reads a u32 and stores it into a signed 32bit value */
     link_len = _libssh2_ntohu32(data + 9);
-    if (link_len < target_len) {
+    if(link_len < target_len) {
         memcpy(target, data + 13, link_len);
         target[link_len] = 0;
         retcode = (int)link_len;
@@ -3460,7 +3487,7 @@ libssh2_sftp_last_error(LIBSSH2_SFTP *sftp)
 LIBSSH2_API LIBSSH2_CHANNEL *
 libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp)
 {
-    if (!sftp)
+    if(!sftp)
         return NULL;
 
     return sftp->channel;
diff --git a/src/transport.c b/src/transport.c
index 20aac453..804c9eac 100644
--- a/src/transport.c
+++ b/src/transport.c
@@ -65,16 +65,16 @@ debugdump(LIBSSH2_SESSION * session,
     unsigned int width = 0x10;
     char buffer[256];  /* Must be enough for width*4 + about 30 or so */
     size_t used;
-    static const char* hex_chars = "0123456789ABCDEF";
+    static const char *hex_chars = "0123456789ABCDEF";
 
-    if (!(session->showmask & LIBSSH2_TRACE_TRANS)) {
+    if(!(session->showmask & LIBSSH2_TRACE_TRANS)) {
         /* not asked for, bail out */
         return;
     }
 
     used = snprintf(buffer, sizeof(buffer), "=> %s (%d bytes)\n",
                     desc, (int) size);
-    if (session->tracehandler)
+    if(session->tracehandler)
         (session->tracehandler)(session, session->tracehandler_context,
                                 buffer, used);
     else
@@ -86,9 +86,9 @@ debugdump(LIBSSH2_SESSION * session,
 
         /* hex not disabled, show it */
         for(c = 0; c < width; c++) {
-            if (i + c < size) {
-                buffer[used++] = hex_chars[(ptr[i+c] >> 4) & 0xF];
-                buffer[used++] = hex_chars[ptr[i+c] & 0xF];
+            if(i + c < size) {
+                buffer[used++] = hex_chars[(ptr[i + c] >> 4) & 0xF];
+                buffer[used++] = hex_chars[ptr[i + c] & 0xF];
             }
             else {
                 buffer[used++] = ' ';
@@ -96,7 +96,7 @@ debugdump(LIBSSH2_SESSION * session,
             }
 
             buffer[used++] = ' ';
-            if ((width/2) - 1 == c)
+            if((width/2) - 1 == c)
                 buffer[used++] = ' ';
         }
 
@@ -110,7 +110,7 @@ debugdump(LIBSSH2_SESSION * session,
         buffer[used++] = '\n';
         buffer[used] = 0;
 
-        if (session->tracehandler)
+        if(session->tracehandler)
             (session->tracehandler)(session, session->tracehandler_context,
                                     buffer, used);
         else
@@ -138,8 +138,8 @@ decrypt(LIBSSH2_SESSION * session, unsigned char *source,
        we risk losing those extra bytes */
     assert((len % blocksize) == 0);
 
-    while (len >= blocksize) {
-        if (session->remote.crypt->crypt(session, source, blocksize,
+    while(len >= blocksize) {
+        if(session->remote.crypt->crypt(session, source, blocksize,
                                          &session->remote.crypt_abstract)) {
             LIBSSH2_FREE(session, p->payload);
             return LIBSSH2_ERROR_DECRYPT;
@@ -169,11 +169,11 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
     int rc;
     int compressed;
 
-    if (session->fullpacket_state == libssh2_NB_state_idle) {
+    if(session->fullpacket_state == libssh2_NB_state_idle) {
         session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED;
         session->fullpacket_payload_len = p->packet_length - 1;
 
-        if (encrypted) {
+        if(encrypted) {
 
             /* Calculate MAC hash */
             session->remote.mac->hash(session, macbuf,  /* store hash here */
@@ -188,7 +188,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
              * buffer. Note that 'payload_len' here is the packet_length
              * field which includes the padding but not the MAC.
              */
-            if (memcmp(macbuf, p->payload + session->fullpacket_payload_len,
+            if(memcmp(macbuf, p->payload + session->fullpacket_payload_len,
                        session->remote.mac->mac_len)) {
                 session->fullpacket_macstate = LIBSSH2_MAC_INVALID;
             }
@@ -206,7 +206,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
             ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
              session->local.comp->use_in_auth);
 
-        if (compressed && session->remote.comp_abstract) {
+        if(compressed && session->remote.comp_abstract) {
             /*
              * The buffer for the decompression (remote.comp_abstract) is
              * initialised in time when it is needed so as long it is NULL we
@@ -237,13 +237,13 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
         session->fullpacket_state = libssh2_NB_state_created;
     }
 
-    if (session->fullpacket_state == libssh2_NB_state_created) {
+    if(session->fullpacket_state == libssh2_NB_state_created) {
         rc = _libssh2_packet_add(session, p->payload,
                                  session->fullpacket_payload_len,
                                  session->fullpacket_macstate);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        if (rc) {
+        if(rc) {
             session->fullpacket_state = libssh2_NB_state_idle;
             return rc;
         }
@@ -298,7 +298,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
      * of packet_read, then don't redirect, as that would be an infinite loop!
      */
 
-    if (session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
+    if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
         !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
 
         /* Whoever wants a packet won't get anything until the key re-exchange
@@ -307,7 +307,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
                        " key re-exchange from _libssh2_transport_read");
         rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if (rc)
+        if(rc)
             return rc;
     }
 
@@ -316,20 +316,21 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
      * I know this is very ugly and not a really good use of "goto", but
      * this case statement would be even uglier to do it any other way
      */
-    if (session->readPack_state == libssh2_NB_state_jump1) {
+    if(session->readPack_state == libssh2_NB_state_jump1) {
         session->readPack_state = libssh2_NB_state_idle;
         encrypted = session->readPack_encrypted;
         goto libssh2_transport_read_point1;
     }
 
     do {
-        if (session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
+        if(session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
             return LIBSSH2_ERROR_NONE;
         }
 
-        if (session->state & LIBSSH2_STATE_NEWKEYS) {
+        if(session->state & LIBSSH2_STATE_NEWKEYS) {
             blocksize = session->remote.crypt->blocksize;
-        } else {
+        }
+        else {
             encrypted = 0;      /* not encrypted */
             blocksize = 5;      /* not strictly true, but we can use 5 here to
                                    make the checks below work fine still */
@@ -348,18 +349,19 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         /* if remainbuf turns negative we have a bad internal error */
         assert(remainbuf >= 0);
 
-        if (remainbuf < blocksize) {
+        if(remainbuf < blocksize) {
             /* If we have less than a blocksize left, it is too
                little data to deal with, read more */
             ssize_t nread;
 
             /* move any remainder to the start of the buffer so
                that we can do a full refill */
-            if (remainbuf) {
+            if(remainbuf) {
                 memmove(p->buf, &p->buf[p->readidx], remainbuf);
                 p->readidx = 0;
                 p->writeidx = remainbuf;
-            } else {
+            }
+            else {
                 /* nothing to move, just zero the indexes */
                 p->readidx = p->writeidx = 0;
             }
@@ -369,10 +371,10 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                 LIBSSH2_RECV(session, &p->buf[remainbuf],
                               PACKETBUFSIZE - remainbuf,
                               LIBSSH2_SOCKET_RECV_FLAGS(session));
-            if (nread <= 0) {
+            if(nread <= 0) {
                 /* check if this is due to EAGAIN and return the special
                    return code if so, error out normally otherwise */
-                if ((nread < 0) && (nread == -EAGAIN)) {
+                if((nread < 0) && (nread == -EAGAIN)) {
                     session->socket_block_directions |=
                         LIBSSH2_SESSION_BLOCK_INBOUND;
                     return LIBSSH2_ERROR_EAGAIN;
@@ -398,12 +400,12 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         /* how much data to deal with from the buffer */
         numbytes = remainbuf;
 
-        if (!p->total_num) {
+        if(!p->total_num) {
             /* No payload package area allocated yet. To know the
                size of this payload, we need to decrypt the first
                blocksize data. */
 
-            if (numbytes < blocksize) {
+            if(numbytes < blocksize) {
                 /* we can't act on anything less than blocksize, but this
                    check is only done for the initial block since once we have
                    got the start of a block we can in fact deal with fractions
@@ -413,15 +415,16 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                 return LIBSSH2_ERROR_EAGAIN;
             }
 
-            if (encrypted) {
+            if(encrypted) {
                 rc = decrypt(session, &p->buf[p->readidx], block, blocksize);
-                if (rc != LIBSSH2_ERROR_NONE) {
+                if(rc != LIBSSH2_ERROR_NONE) {
                     return rc;
                 }
                 /* save the first 5 bytes of the decrypted package, to be
                    used in the hash calculation later down. */
                 memcpy(p->init, block, 5);
-            } else {
+            }
+            else {
                 /* the data is plain, just copy it verbatim to
                    the working block buffer */
                 memcpy(block, &p->buf[p->readidx], blocksize);
@@ -434,7 +437,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
              * and we can extract packet and padding length from it
              */
             p->packet_length = _libssh2_ntohu32(block);
-            if (p->packet_length < 1)
+            if(p->packet_length < 1)
                 return LIBSSH2_ERROR_DECRYPT;
 
             p->padding_length = block[4];
@@ -453,21 +456,21 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
              * or less (including length, padding length, payload,
              * padding, and MAC.)."
              */
-            if (total_num > LIBSSH2_PACKET_MAXPAYLOAD) {
+            if(total_num > LIBSSH2_PACKET_MAXPAYLOAD) {
                 return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
             }
 
             /* Get a packet handle put data into. We get one to
                hold all data, including padding and MAC. */
             p->payload = LIBSSH2_ALLOC(session, total_num);
-            if (!p->payload) {
+            if(!p->payload) {
                 return LIBSSH2_ERROR_ALLOC;
             }
             p->total_num = total_num;
             /* init write pointer to start of payload buffer */
             p->wptr = p->payload;
 
-            if (blocksize > 5) {
+            if(blocksize > 5) {
                 /* copy the data from index 5 to the end of
                    the blocksize from the temporary buffer to
                    the start of the decrypted buffer */
@@ -487,13 +490,13 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
            package */
         remainpack = p->total_num - p->data_num;
 
-        if (numbytes > remainpack) {
+        if(numbytes > remainpack) {
             /* if we have more data in the buffer than what is going into this
                particular packet, we limit this round to this packet only */
             numbytes = remainpack;
         }
 
-        if (encrypted) {
+        if(encrypted) {
             /* At the end of the incoming stream, there is a MAC,
                and we don't want to decrypt that since we need it
                "raw". We MUST however decrypt the padding data
@@ -503,13 +506,14 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
             /* if what we have plus numbytes is bigger than the
                total minus the skip margin, we should lower the
                amount to decrypt even more */
-            if ((p->data_num + numbytes) > (p->total_num - skip)) {
+            if((p->data_num + numbytes) > (p->total_num - skip)) {
                 numdecrypt = (p->total_num - skip) - p->data_num;
-            } else {
+            }
+            else {
                 int frac;
                 numdecrypt = numbytes;
                 frac = numdecrypt % blocksize;
-                if (frac) {
+                if(frac) {
                     /* not an aligned amount of blocks,
                        align it */
                     numdecrypt -= frac;
@@ -518,16 +522,17 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                     numbytes = 0;
                 }
             }
-        } else {
+        }
+        else {
             /* unencrypted data should not be decrypted at all */
             numdecrypt = 0;
         }
 
         /* if there are bytes to decrypt, do that */
-        if (numdecrypt > 0) {
+        if(numdecrypt > 0) {
             /* now decrypt the lot */
             rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt);
-            if (rc != LIBSSH2_ERROR_NONE) {
+            if(rc != LIBSSH2_ERROR_NONE) {
                 p->total_num = 0;   /* no packet buffer available */
                 return rc;
             }
@@ -545,7 +550,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
 
         /* if there are bytes to copy that aren't decrypted, simply
            copy them as-is to the target buffer */
-        if (numbytes > 0) {
+        if(numbytes > 0) {
             memcpy(p->wptr, &p->buf[p->readidx], numbytes);
 
             /* advance the read pointer */
@@ -560,14 +565,13 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
            current packet */
         remainpack = p->total_num - p->data_num;
 
-        if (!remainpack) {
+        if(!remainpack) {
             /* we have a full packet */
           libssh2_transport_read_point1:
             rc = fullpacket(session, encrypted);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
 
-                if (session->packAdd_state != libssh2_NB_state_idle)
-                {
+                if(session->packAdd_state != libssh2_NB_state_idle) {
                     /* fullpacket only returns LIBSSH2_ERROR_EAGAIN if
                      * libssh2_packet_add returns LIBSSH2_ERROR_EAGAIN. If that
                      * returns LIBSSH2_ERROR_EAGAIN but the packAdd_state is idle,
@@ -587,7 +591,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
 
             return rc;
         }
-    } while (1);                /* loop */
+    } while(1);                /* loop */
 
     return LIBSSH2_ERROR_SOCKET_RECV; /* we never reach this point */
 }
@@ -600,13 +604,13 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
     ssize_t length;
     struct transportpacket *p = &session->packet;
 
-    if (!p->olen) {
+    if(!p->olen) {
         *ret = 0;
         return LIBSSH2_ERROR_NONE;
     }
 
     /* send as much as possible of the existing packet */
-    if ((data != p->odata) || (data_len != p->olen)) {
+    if((data != p->odata) || (data_len != p->olen)) {
         /* When we are about to complete the sending of a packet, it is vital
            that the caller doesn't try to send a new/different packet since
            we don't add this one up until the previous one has been sent. To
@@ -622,7 +626,7 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
 
     rc = LIBSSH2_SEND(session, &p->outbuf[p->osent], length,
                        LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if (rc < 0)
+    if(rc < 0)
         _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
                        "Error sending %d bytes: %d", length, -rc);
     else {
@@ -633,7 +637,7 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
                   &p->outbuf[p->osent], rc);
     }
 
-    if (rc == length) {
+    if(rc == length) {
         /* the remainder of the package was sent */
         p->ototal_num = 0;
         p->olen = 0;
@@ -643,9 +647,9 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
         return LIBSSH2_ERROR_NONE;
 
     }
-    else if (rc < 0) {
+    else if(rc < 0) {
         /* nothing was sent */
-        if (rc != -EAGAIN)
+        if(rc != -EAGAIN)
             /* send failure! */
             return LIBSSH2_ERROR_SOCKET_SEND;
 
@@ -705,14 +709,14 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
      *
      * See the similar block in _libssh2_transport_read for more details.
      */
-    if (session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
+    if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
         !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
         /* Don't write any new packets if we're still in the middle of a key
          * exchange. */
         _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
                        " key re-exchange from _libssh2_transport_send");
         rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if (rc)
+        if(rc)
             return rc;
     }
 
@@ -723,12 +727,12 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
     /* FIRST, check if we have a pending write to complete. send_existing
        only sanity-check data and data_len and not data2 and data2_len!! */
     rc = send_existing(session, data, data_len, &ret);
-    if (rc)
+    if(rc)
         return rc;
 
     session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND;
 
-    if (ret)
+    if(ret)
         /* set by send_existing if data was sent */
         return rc;
 
@@ -740,7 +744,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
          session->local.comp->use_in_auth);
 
-    if (encrypted && compressed) {
+    if(encrypted && compressed) {
         /* the idea here is that these function must fail if the output gets
            larger than what fits in the assigned buffer so thus they don't
            check the input size as we don't know how much it compresses */
@@ -761,7 +765,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
             dest2_len -= dest_len;
 
             rc = session->local.comp->comp(session,
-                                           &p->outbuf[5+dest_len], &dest2_len,
+                                           &p->outbuf[5 + dest_len], &dest2_len,
                                            data2, data2_len,
                                            &session->local.comp_abstract);
         }
@@ -781,7 +785,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         /* copy the payload data */
         memcpy(&p->outbuf[5], data, data_len);
         if(data2 && data2_len)
-            memcpy(&p->outbuf[5+data_len], data2, data2_len);
+            memcpy(&p->outbuf[5 + data_len], data2, data2_len);
         data_len += data2_len; /* use the combined length */
     }
 
@@ -805,7 +809,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
     /* if the padding becomes too small we add another blocksize worth
        of it (taken from the original libssh2 where it didn't have any
        real explanation) */
-    if (padding_length < 4) {
+    if(padding_length < 4) {
         padding_length += blocksize;
     }
 #ifdef RANDOM_PADDING
@@ -834,7 +838,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
     /* fill the padding area with random junk */
     _libssh2_random(p->outbuf + 5 + data_len, padding_length);
 
-    if (encrypted) {
+    if(encrypted) {
         size_t i;
 
         /* Calculate MAC hash. Put the output at index packet_length,
@@ -850,7 +854,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
            The MAC field is not encrypted. */
         for(i = 0; i < packet_length; i += session->local.crypt->blocksize) {
             unsigned char *ptr = &p->outbuf[i];
-            if (session->local.crypt->crypt(session, ptr,
+            if(session->local.crypt->crypt(session, ptr,
                                             session->local.crypt->blocksize,
                                             &session->local.crypt_abstract))
                 return LIBSSH2_ERROR_ENCRYPT;     /* encryption failure */
@@ -861,7 +865,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
 
     ret = LIBSSH2_SEND(session, p->outbuf, total_length,
                         LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if (ret < 0)
+    if(ret < 0)
         _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
                        "Error sending %d bytes: %d", total_length, -ret);
     else {
@@ -870,8 +874,8 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         debugdump(session, "libssh2_transport_write send()", p->outbuf, ret);
     }
 
-    if (ret != total_length) {
-        if (ret >= 0 || ret == -EAGAIN) {
+    if(ret != total_length) {
+        if(ret >= 0 || ret == -EAGAIN) {
             /* the whole packet could not be sent, save the rest */
             session->socket_block_directions |= LIBSSH2_SESSION_BLOCK_OUTBOUND;
             p->odata = orgdata;
diff --git a/src/userauth.c b/src/userauth.c
index 226eb8bc..46d17667 100644
--- a/src/userauth.c
+++ b/src/userauth.c
@@ -71,7 +71,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
     unsigned char *s;
     int rc;
 
-    if (session->userauth_list_state == libssh2_NB_state_idle) {
+    if(session->userauth_list_state == libssh2_NB_state_idle) {
         /* Zero the whole thing out */
         memset(&session->userauth_list_packet_requirev_state, 0,
                sizeof(session->userauth_list_packet_requirev_state));
@@ -80,7 +80,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
 
         s = session->userauth_list_data =
             LIBSSH2_ALLOC(session, session->userauth_list_data_len);
-        if (!session->userauth_list_data) {
+        if(!session->userauth_list_data) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for userauth_list");
             return NULL;
@@ -94,11 +94,11 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
         session->userauth_list_state = libssh2_NB_state_created;
     }
 
-    if (session->userauth_list_state == libssh2_NB_state_created) {
+    if(session->userauth_list_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, session->userauth_list_data,
                                      session->userauth_list_data_len,
                                      (unsigned char *)"none", 4);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block requesting userauth list");
             return NULL;
@@ -107,7 +107,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
         LIBSSH2_FREE(session, session->userauth_list_data);
         session->userauth_list_data = NULL;
 
-        if (rc) {
+        if(rc) {
             _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                            "Unable to send userauth-none request");
             session->userauth_list_state = libssh2_NB_state_idle;
@@ -117,23 +117,24 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
         session->userauth_list_state = libssh2_NB_state_sent;
     }
 
-    if (session->userauth_list_state == libssh2_NB_state_sent) {
+    if(session->userauth_list_state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_requirev(session, reply_codes,
                                       &session->userauth_list_data,
                                       &session->userauth_list_data_len, 0,
                                       NULL, 0,
                                       &session->userauth_list_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block requesting userauth list");
             return NULL;
-        } else if (rc) {
+        }
+        else if(rc) {
             _libssh2_error(session, rc, "Failed getting response");
             session->userauth_list_state = libssh2_NB_state_idle;
             return NULL;
         }
 
-        if (session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+        if(session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
             /* Wow, who'dve thought... */
             _libssh2_error(session, LIBSSH2_ERROR_NONE, "No error");
             LIBSSH2_FREE(session, session->userauth_list_data);
@@ -205,7 +206,7 @@ userauth_password(LIBSSH2_SESSION *session,
         };
     int rc;
 
-    if (session->userauth_pswd_state == libssh2_NB_state_idle) {
+    if(session->userauth_pswd_state == libssh2_NB_state_idle) {
         /* Zero the whole thing out */
         memset(&session->userauth_pswd_packet_requirev_state, 0,
                sizeof(session->userauth_pswd_packet_requirev_state));
@@ -223,7 +224,7 @@ userauth_password(LIBSSH2_SESSION *session,
            struct */
         s = session->userauth_pswd_data =
             LIBSSH2_ALLOC(session, session->userauth_pswd_data_len);
-        if (!session->userauth_pswd_data) {
+        if(!session->userauth_pswd_data) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "userauth-password request");
@@ -243,11 +244,11 @@ userauth_password(LIBSSH2_SESSION *session,
         session->userauth_pswd_state = libssh2_NB_state_created;
     }
 
-    if (session->userauth_pswd_state == libssh2_NB_state_created) {
+    if(session->userauth_pswd_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, session->userauth_pswd_data,
                                      session->userauth_pswd_data_len,
                                      password, password_len);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                   "Would block writing password request");
         }
@@ -256,7 +257,7 @@ userauth_password(LIBSSH2_SESSION *session,
         LIBSSH2_FREE(session, session->userauth_pswd_data);
         session->userauth_pswd_data = NULL;
 
-        if (rc) {
+        if(rc) {
             session->userauth_pswd_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "Unable to send userauth-password request");
@@ -267,10 +268,10 @@ userauth_password(LIBSSH2_SESSION *session,
 
   password_response:
 
-    if ((session->userauth_pswd_state == libssh2_NB_state_sent)
+    if((session->userauth_pswd_state == libssh2_NB_state_sent)
         || (session->userauth_pswd_state == libssh2_NB_state_sent1)
         || (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
-        if (session->userauth_pswd_state == libssh2_NB_state_sent) {
+        if(session->userauth_pswd_state == libssh2_NB_state_sent) {
             rc = _libssh2_packet_requirev(session, reply_codes,
                                           &session->userauth_pswd_data,
                                           &session->userauth_pswd_data_len,
@@ -278,15 +279,15 @@ userauth_password(LIBSSH2_SESSION *session,
                                           &session->
                                           userauth_pswd_packet_requirev_state);
 
-            if (rc) {
-                if (rc != LIBSSH2_ERROR_EAGAIN)
+            if(rc) {
+                if(rc != LIBSSH2_ERROR_EAGAIN)
                     session->userauth_pswd_state = libssh2_NB_state_idle;
 
                 return _libssh2_error(session, rc,
                                       "Waiting for password response");
             }
 
-            if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+            if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
                 _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                                "Password authentication successful");
                 LIBSSH2_FREE(session, session->userauth_pswd_data);
@@ -294,7 +295,8 @@ userauth_password(LIBSSH2_SESSION *session,
                 session->state |= LIBSSH2_STATE_AUTHENTICATED;
                 session->userauth_pswd_state = libssh2_NB_state_idle;
                 return 0;
-            } else if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
+            }
+            else if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
                 _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                                "Password authentication failed");
                 LIBSSH2_FREE(session, session->userauth_pswd_data);
@@ -312,27 +314,27 @@ userauth_password(LIBSSH2_SESSION *session,
             session->userauth_pswd_state = libssh2_NB_state_sent1;
         }
 
-        if ((session->userauth_pswd_data[0] ==
+        if((session->userauth_pswd_data[0] ==
              SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)
             || (session->userauth_pswd_data0 ==
                 SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)) {
             session->userauth_pswd_data0 = SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
 
-            if ((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
+            if((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
                 (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
-                if (session->userauth_pswd_state == libssh2_NB_state_sent1) {
+                if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
                     _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                                    "Password change required");
                     LIBSSH2_FREE(session, session->userauth_pswd_data);
                     session->userauth_pswd_data = NULL;
                 }
-                if (passwd_change_cb) {
-                    if (session->userauth_pswd_state == libssh2_NB_state_sent1) {
+                if(passwd_change_cb) {
+                    if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
                         passwd_change_cb(session,
                                          &session->userauth_pswd_newpw,
                                          &session->userauth_pswd_newpw_len,
                                          &session->abstract);
-                        if (!session->userauth_pswd_newpw) {
+                        if(!session->userauth_pswd_newpw) {
                             return _libssh2_error(session,
                                                   LIBSSH2_ERROR_PASSWORD_EXPIRED,
                                                   "Password expired, and "
@@ -346,7 +348,7 @@ userauth_password(LIBSSH2_SESSION *session,
                         s = session->userauth_pswd_data =
                             LIBSSH2_ALLOC(session,
                                           session->userauth_pswd_data_len);
-                        if (!session->userauth_pswd_data) {
+                        if(!session->userauth_pswd_data) {
                             LIBSSH2_FREE(session,
                                          session->userauth_pswd_newpw);
                             session->userauth_pswd_newpw = NULL;
@@ -371,14 +373,14 @@ userauth_password(LIBSSH2_SESSION *session,
                         session->userauth_pswd_state = libssh2_NB_state_sent2;
                     }
 
-                    if (session->userauth_pswd_state == libssh2_NB_state_sent2) {
+                    if(session->userauth_pswd_state == libssh2_NB_state_sent2) {
                         rc = _libssh2_transport_send(session,
                                                      session->userauth_pswd_data,
                                                      session->userauth_pswd_data_len,
                                                      (unsigned char *)
                                                      session->userauth_pswd_newpw,
                                                      session->userauth_pswd_newpw_len);
-                        if (rc == LIBSSH2_ERROR_EAGAIN) {
+                        if(rc == LIBSSH2_ERROR_EAGAIN) {
                             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                                   "Would block waiting");
                         }
@@ -389,7 +391,7 @@ userauth_password(LIBSSH2_SESSION *session,
                         LIBSSH2_FREE(session, session->userauth_pswd_newpw);
                         session->userauth_pswd_newpw = NULL;
 
-                        if (rc) {
+                        if(rc) {
                             return _libssh2_error(session,
                                                   LIBSSH2_ERROR_SOCKET_SEND,
                                                   "Unable to send userauth "
@@ -404,7 +406,8 @@ userauth_password(LIBSSH2_SESSION *session,
                         goto password_response;
                     }
                 }
-            } else {
+            }
+            else {
                 session->userauth_pswd_state = libssh2_NB_state_idle;
                 return _libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED,
                                       "Password Expired, and no callback "
@@ -454,13 +457,13 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     size_t pubkey_len = pubkeyfiledata_len;
     unsigned int tmp_len;
 
-    if (pubkeyfiledata_len <= 1) {
+    if(pubkeyfiledata_len <= 1) {
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid data in public key file");
     }
 
     pubkey = LIBSSH2_ALLOC(session, pubkeyfiledata_len);
-    if (!pubkey) {
+    if(!pubkey) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for public key data");
     }
@@ -470,16 +473,17 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     /*
      *   Remove trailing whitespace
      */
-    while (pubkey_len && isspace(pubkey[pubkey_len - 1]))
+    while(pubkey_len && isspace(pubkey[pubkey_len - 1]))
         pubkey_len--;
 
-    if (!pubkey_len) {
+    if(!pubkey_len) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Missing public key data");
     }
 
-    if ((sp1 = memchr(pubkey, ' ', pubkey_len)) == NULL) {
+    sp1 = memchr(pubkey, ' ', pubkey_len);
+    if(sp1 == NULL) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid public key data");
@@ -487,12 +491,13 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
 
     sp1++;
 
-    if ((sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey - 1))) == NULL) {
+    sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey - 1));
+    if(sp2 == NULL) {
         /* Assume that the id string is missing, but that it's okay */
         sp2 = pubkey + pubkey_len;
     }
 
-    if (libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
+    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
                               (char *) sp1, sp2 - sp1)) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -539,28 +544,28 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
                    pubkeyfile);
     /* Read Public Key */
     fd = fopen(pubkeyfile, "r");
-    if (!fd) {
+    if(!fd) {
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Unable to open public key file");
     }
-    while (!feof(fd) && 1 == fread(&c, 1, 1, fd) && c != '\r' && c != '\n') {
+    while(!feof(fd) && 1 == fread(&c, 1, 1, fd) && c != '\r' && c != '\n') {
         pubkey_len++;
     }
     rewind(fd);
 
-    if (pubkey_len <= 1) {
+    if(pubkey_len <= 1) {
         fclose(fd);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid data in public key file");
     }
 
     pubkey = LIBSSH2_ALLOC(session, pubkey_len);
-    if (!pubkey) {
+    if(!pubkey) {
         fclose(fd);
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for public key data");
     }
-    if (fread(pubkey, 1, pubkey_len, fd) != pubkey_len) {
+    if(fread(pubkey, 1, pubkey_len, fd) != pubkey_len) {
         LIBSSH2_FREE(session, pubkey);
         fclose(fd);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -570,17 +575,18 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     /*
      * Remove trailing whitespace
      */
-    while (pubkey_len && isspace(pubkey[pubkey_len - 1])) {
+    while(pubkey_len && isspace(pubkey[pubkey_len - 1])) {
         pubkey_len--;
     }
 
-    if (!pubkey_len) {
+    if(!pubkey_len) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Missing public key data");
     }
 
-    if ((sp1 = memchr(pubkey, ' ', pubkey_len)) == NULL) {
+    sp1 = memchr(pubkey, ' ', pubkey_len);
+    if(sp1 == NULL) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid public key data");
@@ -589,12 +595,13 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     sp1++;
 
     sp_len = sp1 > pubkey ? (sp1 - pubkey) - 1 : 0;
-    if ((sp2 = memchr(sp1, ' ', pubkey_len - sp_len)) == NULL) {
+    sp2 = memchr(sp1, ' ', pubkey_len - sp_len);
+    if(sp2 == NULL) {
         /* Assume that the id string is missing, but that it's okay */
         sp2 = pubkey + pubkey_len;
     }
 
-    if (libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
+    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
                               (char *) sp1, sp2 - sp1)) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -626,8 +633,8 @@ memory_read_privatekey(LIBSSH2_SESSION * session,
 
     *hostkey_method = NULL;
     *hostkey_abstract = NULL;
-    while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
-        if ((*hostkey_methods_avail)->initPEMFromMemory
+    while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
+        if((*hostkey_methods_avail)->initPEMFromMemory
              && strncmp((*hostkey_methods_avail)->name, (const char *) method,
                         method_len) == 0) {
             *hostkey_method = *hostkey_methods_avail;
@@ -635,12 +642,12 @@ memory_read_privatekey(LIBSSH2_SESSION * session,
         }
         hostkey_methods_avail++;
     }
-    if (!*hostkey_method) {
+    if(!*hostkey_method) {
         return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
                               "No handler for specified private key");
     }
 
-    if ((*hostkey_method)->
+    if((*hostkey_method)->
         initPEMFromMemory(session, privkeyfiledata, privkeyfiledata_len,
                           (unsigned char *) passphrase,
                           hostkey_abstract)) {
@@ -668,8 +675,8 @@ file_read_privatekey(LIBSSH2_SESSION * session,
                    privkeyfile);
     *hostkey_method = NULL;
     *hostkey_abstract = NULL;
-    while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
-        if ((*hostkey_methods_avail)->initPEM
+    while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
+        if((*hostkey_methods_avail)->initPEM
             && strncmp((*hostkey_methods_avail)->name, (const char *) method,
                        method_len) == 0) {
             *hostkey_method = *hostkey_methods_avail;
@@ -677,12 +684,12 @@ file_read_privatekey(LIBSSH2_SESSION * session,
         }
         hostkey_methods_avail++;
     }
-    if (!*hostkey_method) {
+    if(!*hostkey_method) {
         return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
                               "No handler for specified private key");
     }
 
-    if ((*hostkey_method)->
+    if((*hostkey_method)->
         initPEM(session, privkeyfile, (unsigned char *) passphrase,
                 hostkey_abstract)) {
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -720,15 +727,15 @@ sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     datavec.iov_base = (void *)data;
     datavec.iov_len  = data_len;
 
-    if (privkeyobj->signv(session, sig, sig_len, 1, &datavec,
+    if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
                           &hostkey_abstract)) {
-        if (privkeyobj->dtor) {
+        if(privkeyobj->dtor) {
             privkeyobj->dtor(session, abstract);
         }
         return -1;
     }
 
-    if (privkeyobj->dtor) {
+    if(privkeyobj->dtor) {
         privkeyobj->dtor(session, &hostkey_abstract);
     }
     return 0;
@@ -756,15 +763,15 @@ sign_fromfile(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     datavec.iov_base = (void *)data;
     datavec.iov_len  = data_len;
 
-    if (privkeyobj->signv(session, sig, sig_len, 1, &datavec,
+    if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
                           &hostkey_abstract)) {
-        if (privkeyobj->dtor) {
+        if(privkeyobj->dtor) {
             privkeyobj->dtor(session, &hostkey_abstract);
         }
         return -1;
     }
 
-    if (privkeyobj->dtor) {
+    if(privkeyobj->dtor) {
         privkeyobj->dtor(session, &hostkey_abstract);
     }
     return 0;
@@ -791,7 +798,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                           "RSA is not supported by crypto backend");
 #endif
 
-    if (session->userauth_host_state == libssh2_NB_state_idle) {
+    if(session->userauth_host_state == libssh2_NB_state_idle) {
         const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
         unsigned char *pubkeydata, *sig = NULL;
         size_t pubkeydata_len = 0;
@@ -804,7 +811,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         memset(&session->userauth_host_packet_requirev_state, 0,
                sizeof(session->userauth_host_packet_requirev_state));
 
-        if (publickey) {
+        if(publickey) {
             rc = file_read_publickey(session, &session->userauth_host_method,
                                      &session->userauth_host_method_len,
                                      &pubkeydata, &pubkeydata_len, publickey);
@@ -819,7 +826,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                                            &session->userauth_host_method_len,
                                            &pubkeydata, &pubkeydata_len,
                                            privatekey, passphrase);
-            if (rc)
+            if(rc)
                 /* libssh2_pub_priv_keyfile calls _libssh2_error() */
                 return rc;
         }
@@ -844,7 +851,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                           session->userauth_host_packet_len + 4 +
                           (4 + session->userauth_host_method_len) +
                           (4 + pubkeydata_len));
-        if (!session->userauth_host_packet) {
+        if(!session->userauth_host_packet) {
             LIBSSH2_FREE(session, session->userauth_host_method);
             session->userauth_host_method = NULL;
             LIBSSH2_FREE(session, pubkeydata);
@@ -888,31 +895,31 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         datavec[2].iov_base = (void *)session->userauth_host_packet;
         datavec[2].iov_len = session->userauth_host_packet_len;
 
-        if (privkeyobj && privkeyobj->signv &&
+        if(privkeyobj && privkeyobj->signv &&
                           privkeyobj->signv(session, &sig, &sig_len, 3,
                                             datavec, &abstract)) {
             LIBSSH2_FREE(session, session->userauth_host_method);
             session->userauth_host_method = NULL;
             LIBSSH2_FREE(session, session->userauth_host_packet);
             session->userauth_host_packet = NULL;
-            if (privkeyobj->dtor) {
+            if(privkeyobj->dtor) {
                 privkeyobj->dtor(session, &abstract);
             }
             return -1;
         }
 
-        if (privkeyobj && privkeyobj->dtor) {
+        if(privkeyobj && privkeyobj->dtor) {
             privkeyobj->dtor(session, &abstract);
         }
 
-        if (sig_len > pubkeydata_len) {
+        if(sig_len > pubkeydata_len) {
             unsigned char *newpacket;
             /* Should *NEVER* happen, but...well.. better safe than sorry */
             newpacket = LIBSSH2_REALLOC(session, session->userauth_host_packet,
                                         session->userauth_host_packet_len + 4 +
                                         (4 + session->userauth_host_method_len)
                                         + (4 + sig_len)); /* PK sigblob */
-            if (!newpacket) {
+            if(!newpacket) {
                 LIBSSH2_FREE(session, sig);
                 LIBSSH2_FREE(session, session->userauth_host_packet);
                 session->userauth_host_packet = NULL;
@@ -946,15 +953,15 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         session->userauth_host_state = libssh2_NB_state_created;
     }
 
-    if (session->userauth_host_state == libssh2_NB_state_created) {
+    if(session->userauth_host_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, session->userauth_host_packet,
                                      session->userauth_host_s -
                                      session->userauth_host_packet,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
         }
-        else if (rc) {
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_host_packet);
             session->userauth_host_packet = NULL;
             session->userauth_host_state = libssh2_NB_state_idle;
@@ -967,7 +974,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         session->userauth_host_state = libssh2_NB_state_sent;
     }
 
-    if (session->userauth_host_state == libssh2_NB_state_sent) {
+    if(session->userauth_host_state == libssh2_NB_state_sent) {
         static const unsigned char reply_codes[3] =
             { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
         size_t data_len;
@@ -976,17 +983,17 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                                       &data_len, 0, NULL, 0,
                                       &session->
                                       userauth_host_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
         }
 
         session->userauth_host_state = libssh2_NB_state_idle;
-        if (rc) {
+        if(rc) {
             return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
                                   "Auth failed");
         }
 
-        if (session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+        if(session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
             _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                            "Hostbased authentication successful");
             /* We are us and we've proved it. */
@@ -1047,13 +1054,13 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
     int rc;
     unsigned char *s;
 
-    if (session->userauth_pblc_state == libssh2_NB_state_idle) {
+    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
 
         /*
          * The call to _libssh2_ntohu32 later relies on pubkeydata having at
          * least 4 valid bytes containing the length of the method name.
          */
-        if (pubkeydata_len < 4)
+        if(pubkeydata_len < 4)
             return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
                                   "Invalid public key, too short");
 
@@ -1067,7 +1074,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
          * allocation/free.
          * For other uses, we allocate and populate it here.
          */
-        if (!session->userauth_pblc_method) {
+        if(!session->userauth_pblc_method) {
             session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata);
 
             if(session->userauth_pblc_method_len > pubkeydata_len)
@@ -1080,7 +1087,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
 
             session->userauth_pblc_method =
                 LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
-            if (!session->userauth_pblc_method) {
+            if(!session->userauth_pblc_method) {
                 return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                       "Unable to allocate memory for public key "
                                       "data");
@@ -1093,7 +1100,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
          * file must match length embedded in the key.
          * TODO: The data should match too but we don't check that. Should we?
          */
-        else if (session->userauth_pblc_method_len !=
+        else if(session->userauth_pblc_method_len !=
                  _libssh2_ntohu32(pubkeydata))
             return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
                                   "Invalid public key");
@@ -1122,7 +1129,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                           session->userauth_pblc_packet_len + 4 +
                           (4 + session->userauth_pblc_method_len)
                           + (4 + pubkeydata_len));
-        if (!session->userauth_pblc_packet) {
+        if(!session->userauth_pblc_packet) {
             LIBSSH2_FREE(session, session->userauth_pblc_method);
             session->userauth_pblc_method = NULL;
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -1148,13 +1155,13 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         session->userauth_pblc_state = libssh2_NB_state_created;
     }
 
-    if (session->userauth_pblc_state == libssh2_NB_state_created) {
+    if(session->userauth_pblc_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
                                      session->userauth_pblc_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN)
+        if(rc == LIBSSH2_ERROR_EAGAIN)
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-        else if (rc) {
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_pblc_packet);
             session->userauth_pblc_packet = NULL;
             LIBSSH2_FREE(session, session->userauth_pblc_method);
@@ -1167,17 +1174,17 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         session->userauth_pblc_state = libssh2_NB_state_sent;
     }
 
-    if (session->userauth_pblc_state == libssh2_NB_state_sent) {
+    if(session->userauth_pblc_state == libssh2_NB_state_sent) {
         rc = _libssh2_packet_requirev(session, reply_codes,
                                       &session->userauth_pblc_data,
                                       &session->userauth_pblc_data_len, 0,
                                       NULL, 0,
                                       &session->
                                       userauth_pblc_packet_requirev_state);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
         }
-        else if (rc) {
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_pblc_packet);
             session->userauth_pblc_packet = NULL;
             LIBSSH2_FREE(session, session->userauth_pblc_method);
@@ -1187,7 +1194,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                                   "Waiting for USERAUTH response");
         }
 
-        if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+        if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
             _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                            "Pubkey authentication prematurely successful");
             /*
@@ -1205,7 +1212,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
             return 0;
         }
 
-        if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) {
+        if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) {
             /* This public key is not allowed for this user on this server */
             LIBSSH2_FREE(session, session->userauth_pblc_data);
             session->userauth_pblc_data = NULL;
@@ -1226,14 +1233,14 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         session->userauth_pblc_state = libssh2_NB_state_sent1;
     }
 
-    if (session->userauth_pblc_state == libssh2_NB_state_sent1) {
+    if(session->userauth_pblc_state == libssh2_NB_state_sent1) {
         unsigned char *buf;
         unsigned char *sig;
         size_t sig_len;
 
         s = buf = LIBSSH2_ALLOC(session, 4 + session->session_id_len
                                 + session->userauth_pblc_packet_len);
-        if (!buf) {
+        if(!buf) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "userauth-publickey signed data");
@@ -1242,15 +1249,16 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         _libssh2_store_str(&s, (const char *)session->session_id,
                            session->session_id_len);
 
-        memcpy (s, session->userauth_pblc_packet,
-                session->userauth_pblc_packet_len);
+        memcpy(s, session->userauth_pblc_packet,
+               session->userauth_pblc_packet_len);
         s += session->userauth_pblc_packet_len;
 
         rc = sign_callback(session, &sig, &sig_len, buf, s - buf, abstract);
         LIBSSH2_FREE(session, buf);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-        } else if (rc) {
+        }
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_pblc_method);
             session->userauth_pblc_method = NULL;
             LIBSSH2_FREE(session, session->userauth_pblc_packet);
@@ -1264,7 +1272,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
          * If this function was restarted, pubkeydata_len might still be 0
          * which will cause an unnecessary but harmless realloc here.
          */
-        if (sig_len > pubkeydata_len) {
+        if(sig_len > pubkeydata_len) {
             unsigned char *newpacket;
             /* Should *NEVER* happen, but...well.. better safe than sorry */
             newpacket = LIBSSH2_REALLOC(session,
@@ -1272,7 +1280,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                                         session->userauth_pblc_packet_len + 4 +
                                         (4 + session->userauth_pblc_method_len)
                                         + (4 + sig_len)); /* PK sigblob */
-            if (!newpacket) {
+            if(!newpacket) {
                 LIBSSH2_FREE(session, sig);
                 LIBSSH2_FREE(session, session->userauth_pblc_packet);
                 session->userauth_pblc_packet = NULL;
@@ -1307,14 +1315,15 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         session->userauth_pblc_state = libssh2_NB_state_sent2;
     }
 
-    if (session->userauth_pblc_state == libssh2_NB_state_sent2) {
+    if(session->userauth_pblc_state == libssh2_NB_state_sent2) {
         rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
                                      session->userauth_pblc_s -
                                      session->userauth_pblc_packet,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-        } else if (rc) {
+        }
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_pblc_packet);
             session->userauth_pblc_packet = NULL;
             session->userauth_pblc_state = libssh2_NB_state_idle;
@@ -1334,16 +1343,17 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                                   &session->userauth_pblc_data,
                                   &session->userauth_pblc_data_len, 0, NULL, 0,
                                   &session->userauth_pblc_packet_requirev_state);
-    if (rc == LIBSSH2_ERROR_EAGAIN) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
         return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                               "Would block requesting userauth list");
-    } else if (rc) {
+    }
+    else if(rc) {
         session->userauth_pblc_state = libssh2_NB_state_idle;
         return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
                               "Waiting for publickey USERAUTH response");
     }
 
-    if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+    if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
         _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                        "Publickey authentication successful");
         /* We are us and we've proved it. */
@@ -1391,8 +1401,8 @@ userauth_publickey_frommemory(LIBSSH2_SESSION *session,
     privkey_file.filename = privatekeydata;
     privkey_file.passphrase = passphrase;
 
-    if (session->userauth_pblc_state == libssh2_NB_state_idle) {
-        if (publickeydata_len && publickeydata) {
+    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
+        if(publickeydata_len && publickeydata) {
             rc = memory_read_publickey(session, &session->userauth_pblc_method,
                                        &session->userauth_pblc_method_len,
                                        &pubkeydata, &pubkeydata_len,
@@ -1400,9 +1410,9 @@ userauth_publickey_frommemory(LIBSSH2_SESSION *session,
             if(rc)
                 return rc;
         }
-        else if (privatekeydata_len && privatekeydata) {
+        else if(privatekeydata_len && privatekeydata) {
             /* Compute public key from private key. */
-            if (_libssh2_pub_priv_keyfilememory(session,
+            if(_libssh2_pub_priv_keyfilememory(session,
                                                 &session->userauth_pblc_method,
                                                 &session->userauth_pblc_method_len,
                                                 &pubkeydata, &pubkeydata_len,
@@ -1453,12 +1463,12 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
     privkey_file.filename = privatekey;
     privkey_file.passphrase = passphrase;
 
-    if (session->userauth_pblc_state == libssh2_NB_state_idle) {
-        if (publickey) {
+    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
+        if(publickey) {
             rc = file_read_publickey(session, &session->userauth_pblc_method,
                                      &session->userauth_pblc_method_len,
-                                     &pubkeydata, &pubkeydata_len,publickey);
-            if (rc)
+                                     &pubkeydata, &pubkeydata_len, publickey);
+            if(rc)
                 return rc;
         }
         else {
@@ -1470,7 +1480,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
                                            privatekey, passphrase);
 
             /* _libssh2_pub_priv_keyfile calls _libssh2_error() */
-            if (rc)
+            if(rc)
                 return rc;
         }
     }
@@ -1502,7 +1512,7 @@ libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
     if(NULL == passphrase)
         /* if given a NULL pointer, make it point to a zero-length
            string to save us from having to check this all over */
-        passphrase="";
+        passphrase = "";
 
     BLOCK_ADJUST(rc, session,
                  userauth_publickey_frommemory(session, user, user_len,
@@ -1530,7 +1540,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
     if(NULL == passphrase)
         /* if given a NULL pointer, make it point to a zero-length
            string to save us from having to check this all over */
-        passphrase="";
+        passphrase = "";
 
     BLOCK_ADJUST(rc, session,
                  userauth_publickey_fromfile(session, user, user_len,
@@ -1585,7 +1595,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
     unsigned int language_tag_len;
     unsigned int i;
 
-    if (session->userauth_kybd_state == libssh2_NB_state_idle) {
+    if(session->userauth_kybd_state == libssh2_NB_state_idle) {
         session->userauth_kybd_auth_name = NULL;
         session->userauth_kybd_auth_instruction = NULL;
         session->userauth_kybd_num_prompts = 0;
@@ -1610,7 +1620,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
 
         session->userauth_kybd_data = s =
             LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
-        if (!s) {
+        if(!s) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory for "
                                   "keyboard-interactive authentication");
@@ -1639,13 +1649,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
         session->userauth_kybd_state = libssh2_NB_state_created;
     }
 
-    if (session->userauth_kybd_state == libssh2_NB_state_created) {
+    if(session->userauth_kybd_state == libssh2_NB_state_created) {
         rc = _libssh2_transport_send(session, session->userauth_kybd_data,
                                      session->userauth_kybd_packet_len,
                                      NULL, 0);
-        if (rc == LIBSSH2_ERROR_EAGAIN) {
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-        } else if (rc) {
+        }
+        else if(rc) {
             LIBSSH2_FREE(session, session->userauth_kybd_data);
             session->userauth_kybd_data = NULL;
             session->userauth_kybd_state = libssh2_NB_state_idle;
@@ -1659,24 +1670,25 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
     }
 
     for(;;) {
-        if (session->userauth_kybd_state == libssh2_NB_state_sent) {
+        if(session->userauth_kybd_state == libssh2_NB_state_sent) {
             rc = _libssh2_packet_requirev(session, reply_codes,
                                           &session->userauth_kybd_data,
                                           &session->userauth_kybd_data_len,
                                           0, NULL, 0,
                                           &session->
                                           userauth_kybd_packet_requirev_state);
-            if (rc == LIBSSH2_ERROR_EAGAIN) {
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
                 return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                       "Would block");
-            } else if (rc) {
+            }
+            else if(rc) {
                 session->userauth_kybd_state = libssh2_NB_state_idle;
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_AUTHENTICATION_FAILED,
                                       "Waiting for keyboard USERAUTH response");
             }
 
-            if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+            if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
                 _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                                "Keyboard-interactive authentication successful");
                 LIBSSH2_FREE(session, session->userauth_kybd_data);
@@ -1686,7 +1698,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                 return 0;
             }
 
-            if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
+            if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
                 _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
                                "Keyboard-interactive authentication failed");
                 LIBSSH2_FREE(session, session->userauth_kybd_data);
@@ -1708,7 +1720,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                 session->userauth_kybd_auth_name =
                     LIBSSH2_ALLOC(session,
                                   session->userauth_kybd_auth_name_len);
-                if (!session->userauth_kybd_auth_name) {
+                if(!session->userauth_kybd_auth_name) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for "
                                    "keyboard-interactive 'name' "
@@ -1727,7 +1739,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                 session->userauth_kybd_auth_instruction =
                     LIBSSH2_ALLOC(session,
                                   session->userauth_kybd_auth_instruction_len);
-                if (!session->userauth_kybd_auth_instruction) {
+                if(!session->userauth_kybd_auth_instruction) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for "
                                    "keyboard-interactive 'instruction' "
@@ -1755,7 +1767,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                     LIBSSH2_CALLOC(session,
                                    sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
                                    session->userauth_kybd_num_prompts);
-                if (!session->userauth_kybd_prompts) {
+                if(!session->userauth_kybd_prompts) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for "
                                    "keyboard-interactive prompts array");
@@ -1766,7 +1778,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                     LIBSSH2_CALLOC(session,
                                    sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
                                    session->userauth_kybd_num_prompts);
-                if (!session->userauth_kybd_responses) {
+                if(!session->userauth_kybd_responses) {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                    "Unable to allocate memory for "
                                    "keyboard-interactive responses array");
@@ -1781,7 +1793,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                     session->userauth_kybd_prompts[i].text =
                         LIBSSH2_CALLOC(session,
                                        session->userauth_kybd_prompts[i].length);
-                    if (!session->userauth_kybd_prompts[i].text) {
+                    if(!session->userauth_kybd_prompts[i].text) {
                         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                        "Unable to allocate memory for "
                                        "keyboard-interactive prompt message");
@@ -1826,7 +1838,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
 
             session->userauth_kybd_data = s =
                 LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
-            if (!s) {
+            if(!s) {
                 _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                "Unable to allocate memory for keyboard-"
                                "interactive response packet");
@@ -1846,14 +1858,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             session->userauth_kybd_state = libssh2_NB_state_sent1;
         }
 
-        if (session->userauth_kybd_state == libssh2_NB_state_sent1) {
+        if(session->userauth_kybd_state == libssh2_NB_state_sent1) {
             rc = _libssh2_transport_send(session, session->userauth_kybd_data,
                                          session->userauth_kybd_packet_len,
                                          NULL, 0);
-            if (rc == LIBSSH2_ERROR_EAGAIN)
+            if(rc == LIBSSH2_ERROR_EAGAIN)
                 return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                       "Would block");
-            if (rc) {
+            if(rc) {
                 _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                "Unable to send userauth-keyboard-interactive"
                                " request");
@@ -1872,14 +1884,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
         LIBSSH2_FREE(session, session->userauth_kybd_data);
         session->userauth_kybd_data = NULL;
 
-        if (session->userauth_kybd_prompts) {
+        if(session->userauth_kybd_prompts) {
             for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
                 LIBSSH2_FREE(session, session->userauth_kybd_prompts[i].text);
                 session->userauth_kybd_prompts[i].text = NULL;
             }
         }
 
-        if (session->userauth_kybd_responses) {
+        if(session->userauth_kybd_responses) {
             for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
                 LIBSSH2_FREE(session,
                              session->userauth_kybd_responses[i].text);
@@ -1904,7 +1916,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             session->userauth_kybd_auth_instruction = NULL;
         }
 
-        if (session->userauth_kybd_auth_failure) {
+        if(session->userauth_kybd_auth_failure) {
             session->userauth_kybd_state = libssh2_NB_state_idle;
             return -1;
         }
diff --git a/src/wincng.c b/src/wincng.c
index e58e6ec9..bca2363d 100755
--- a/src/wincng.c
+++ b/src/wincng.c
@@ -245,44 +245,48 @@ _libssh2_wincng_init(void)
 
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgAES_CBC,
                                       BCRYPT_AES_ALGORITHM, NULL, 0);
-    if (BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_CBC, BCRYPT_CHAINING_MODE,
+    if(BCRYPT_SUCCESS(ret)) {
+        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_CBC,
+                                BCRYPT_CHAINING_MODE,
                                 (PBYTE)BCRYPT_CHAIN_MODE_CBC,
                                 sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
-        if (!BCRYPT_SUCCESS(ret)) {
+        if(!BCRYPT_SUCCESS(ret)) {
             (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgAES_CBC, 0);
         }
     }
 
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgAES_ECB,
                                       BCRYPT_AES_ALGORITHM, NULL, 0);
-    if (BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_ECB, BCRYPT_CHAINING_MODE,
+    if(BCRYPT_SUCCESS(ret)) {
+        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_ECB,
+                                BCRYPT_CHAINING_MODE,
                                 (PBYTE)BCRYPT_CHAIN_MODE_ECB,
                                 sizeof(BCRYPT_CHAIN_MODE_ECB), 0);
-        if (!BCRYPT_SUCCESS(ret)) {
+        if(!BCRYPT_SUCCESS(ret)) {
             (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgAES_ECB, 0);
         }
     }
 
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgRC4_NA,
                                       BCRYPT_RC4_ALGORITHM, NULL, 0);
-    if (BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgRC4_NA, BCRYPT_CHAINING_MODE,
+    if(BCRYPT_SUCCESS(ret)) {
+        ret = BCryptSetProperty(_libssh2_wincng.hAlgRC4_NA,
+                                BCRYPT_CHAINING_MODE,
                                 (PBYTE)BCRYPT_CHAIN_MODE_NA,
                                 sizeof(BCRYPT_CHAIN_MODE_NA), 0);
-        if (!BCRYPT_SUCCESS(ret)) {
+        if(!BCRYPT_SUCCESS(ret)) {
             (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRC4_NA, 0);
         }
     }
 
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlg3DES_CBC,
                                       BCRYPT_3DES_ALGORITHM, NULL, 0);
-    if (BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlg3DES_CBC, BCRYPT_CHAINING_MODE,
+    if(BCRYPT_SUCCESS(ret)) {
+        ret = BCryptSetProperty(_libssh2_wincng.hAlg3DES_CBC,
+                                BCRYPT_CHAINING_MODE,
                                 (PBYTE)BCRYPT_CHAIN_MODE_CBC,
                                 sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
-        if (!BCRYPT_SUCCESS(ret)) {
+        if(!BCRYPT_SUCCESS(ret)) {
             (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlg3DES_CBC, 0);
         }
     }
@@ -326,11 +330,11 @@ _libssh2_wincng_safe_free(void *buf, int len)
     (void)len;
 #endif
 
-    if (!buf)
+    if(!buf)
         return;
 
 #ifdef LIBSSH2_CLEAR_MEMORY
-    if (len > 0)
+    if(len > 0)
         SecureZeroMemory(buf, len);
 #endif
 
@@ -357,7 +361,7 @@ _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
                             (unsigned char *)&dwHash,
                             sizeof(dwHash),
                             &cbData, 0);
-    if ((!BCRYPT_SUCCESS(ret)) || dwHash != hashlen) {
+    if((!BCRYPT_SUCCESS(ret)) || dwHash != hashlen) {
         return -1;
     }
 
@@ -365,12 +369,12 @@ _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
                             (unsigned char *)&dwHashObject,
                             sizeof(dwHashObject),
                             &cbData, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         return -1;
     }
 
     pbHashObject = malloc(dwHashObject);
-    if (!pbHashObject) {
+    if(!pbHashObject) {
         return -1;
     }
 
@@ -378,7 +382,7 @@ _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
     ret = BCryptCreateHash(hAlg, &hHash,
                            pbHashObject, dwHashObject,
                            key, keylen, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(pbHashObject, dwHashObject);
         return -1;
     }
@@ -430,7 +434,7 @@ _libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
     int ret;
 
     ret = _libssh2_wincng_hash_init(&ctx, hAlg, hashlen, NULL, 0);
-    if (!ret) {
+    if(!ret) {
         ret = _libssh2_wincng_hash_update(&ctx, data, datalen);
         ret |= _libssh2_wincng_hash_final(&ctx, hash);
     }
@@ -488,13 +492,13 @@ _libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
 
     datalen = m_len;
     data = malloc(datalen);
-    if (!data) {
+    if(!data) {
         return -1;
     }
 
     hashlen = SHA_DIGEST_LENGTH;
     hash = malloc(hashlen);
-    if (!hash) {
+    if(!hash) {
         free(data);
         return -1;
     }
@@ -507,22 +511,23 @@ _libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
 
     _libssh2_wincng_safe_free(data, datalen);
 
-    if (ret) {
+    if(ret) {
         _libssh2_wincng_safe_free(hash, hashlen);
         return -1;
     }
 
     datalen = sig_len;
     data = malloc(datalen);
-    if (!data) {
+    if(!data) {
         _libssh2_wincng_safe_free(hash, hashlen);
         return -1;
     }
 
-    if (flags & BCRYPT_PAD_PKCS1) {
+    if(flags & BCRYPT_PAD_PKCS1) {
         paddingInfoPKCS1.pszAlgId = BCRYPT_SHA1_ALGORITHM;
         pPaddingInfo = &paddingInfoPKCS1;
-    } else
+    }
+    else
         pPaddingInfo = NULL;
 
     memcpy(data, sig, datalen);
@@ -550,7 +555,7 @@ _libssh2_wincng_load_pem(LIBSSH2_SESSION *session,
     int ret;
 
     fp = fopen(filename, "r");
-    if (!fp) {
+    if(!fp) {
         return -1;
     }
 
@@ -575,19 +580,19 @@ _libssh2_wincng_load_private(LIBSSH2_SESSION *session,
     unsigned int datalen = 0;
     int ret = -1;
 
-    if (ret && tryLoadRSA) {
+    if(ret && tryLoadRSA) {
         ret = _libssh2_wincng_load_pem(session, filename, passphrase,
                                        PEM_RSA_HEADER, PEM_RSA_FOOTER,
                                        &data, &datalen);
     }
 
-    if (ret && tryLoadDSA) {
+    if(ret && tryLoadDSA) {
         ret = _libssh2_wincng_load_pem(session, filename, passphrase,
                                        PEM_DSA_HEADER, PEM_DSA_FOOTER,
                                        &data, &datalen);
     }
 
-    if (!ret) {
+    if(!ret) {
         *ppbEncoded = data;
         *pcbEncoded = datalen;
     }
@@ -610,21 +615,21 @@ _libssh2_wincng_load_private_memory(LIBSSH2_SESSION *session,
 
     (void)passphrase;
 
-    if (ret && tryLoadRSA) {
+    if(ret && tryLoadRSA) {
         ret = _libssh2_pem_parse_memory(session,
                                         PEM_RSA_HEADER, PEM_RSA_FOOTER,
                                         privatekeydata, privatekeydata_len,
                                         &data, &datalen);
     }
 
-    if (ret && tryLoadDSA) {
+    if(ret && tryLoadDSA) {
         ret = _libssh2_pem_parse_memory(session,
                                         PEM_DSA_HEADER, PEM_DSA_FOOTER,
                                         privatekeydata, privatekeydata_len,
                                         &data, &datalen);
     }
 
-    if (!ret) {
+    if(!ret) {
         *ppbEncoded = data;
         *pcbEncoded = datalen;
     }
@@ -647,12 +652,12 @@ _libssh2_wincng_asn_decode(unsigned char *pbEncoded,
                               lpszStructType,
                               pbEncoded, cbEncoded, 0, NULL,
                               NULL, &cbDecoded);
-    if (!ret) {
+    if(!ret) {
         return -1;
     }
 
     pbDecoded = malloc(cbDecoded);
-    if (!pbDecoded) {
+    if(!pbDecoded) {
         return -1;
     }
 
@@ -660,7 +665,7 @@ _libssh2_wincng_asn_decode(unsigned char *pbEncoded,
                               lpszStructType,
                               pbEncoded, cbEncoded, 0, NULL,
                               pbDecoded, &cbDecoded);
-    if (!ret) {
+    if(!ret) {
         _libssh2_wincng_safe_free(pbDecoded, cbDecoded);
         return -1;
     }
@@ -681,25 +686,25 @@ _libssh2_wincng_bn_ltob(unsigned char *pbInput,
     unsigned char *pbOutput;
     unsigned long cbOutput, index, offset, length;
 
-    if (cbInput < 1) {
+    if(cbInput < 1) {
         return 0;
     }
 
     offset = 0;
     length = cbInput - 1;
     cbOutput = cbInput;
-    if (pbInput[length] & (1 << 7)) {
+    if(pbInput[length] & (1 << 7)) {
         offset++;
         cbOutput += offset;
     }
 
     pbOutput = (unsigned char *)malloc(cbOutput);
-    if (!pbOutput) {
+    if(!pbOutput) {
         return -1;
     }
 
     pbOutput[0] = 0;
-    for (index = 0; ((index + offset) < cbOutput)
+    for(index = 0; ((index + offset) < cbOutput)
                     && (index < cbInput); index++) {
         pbOutput[index + offset] = pbInput[length - index];
     }
@@ -724,11 +729,11 @@ _libssh2_wincng_asn_decode_bn(unsigned char *pbEncoded,
     ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
                                      X509_MULTI_BYTE_UINT,
                                      &pbInteger, &cbInteger);
-    if (!ret) {
+    if(!ret) {
         ret = _libssh2_wincng_bn_ltob(((PCRYPT_DATA_BLOB)pbInteger)->pbData,
                                       ((PCRYPT_DATA_BLOB)pbInteger)->cbData,
                                       &pbDecoded, &cbDecoded);
-        if (!ret) {
+        if(!ret) {
             *ppbDecoded = pbDecoded;
             *pcbDecoded = cbDecoded;
         }
@@ -753,30 +758,31 @@ _libssh2_wincng_asn_decode_bns(unsigned char *pbEncoded,
     ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
                                      X509_SEQUENCE_OF_ANY,
                                      &pbDecoded, &cbDecoded);
-    if (!ret) {
+    if(!ret) {
         length = ((PCRYPT_DATA_BLOB)pbDecoded)->cbData;
 
         rpbDecoded = malloc(sizeof(PBYTE) * length);
-        if (rpbDecoded) {
+        if(rpbDecoded) {
             rcbDecoded = malloc(sizeof(DWORD) * length);
-            if (rcbDecoded) {
-                for (index = 0; index < length; index++) {
+            if(rcbDecoded) {
+                for(index = 0; index < length; index++) {
                     pBlob = &((PCRYPT_DER_BLOB)
                               ((PCRYPT_DATA_BLOB)pbDecoded)->pbData)[index];
                     ret = _libssh2_wincng_asn_decode_bn(pBlob->pbData,
                                                         pBlob->cbData,
                                                         &rpbDecoded[index],
                                                         &rcbDecoded[index]);
-                    if (ret)
+                    if(ret)
                         break;
                 }
 
-                if (!ret) {
+                if(!ret) {
                     *prpbDecoded = rpbDecoded;
                     *prcbDecoded = rcbDecoded;
                     *pcbCount = length;
-                } else {
-                    for (length = 0; length < index; length++) {
+                }
+                else {
+                    for(length = 0; length < index; length++) {
                         _libssh2_wincng_safe_free(rpbDecoded[length],
                                                   rcbDecoded[length]);
                         rpbDecoded[length] = NULL;
@@ -785,11 +791,13 @@ _libssh2_wincng_asn_decode_bns(unsigned char *pbEncoded,
                     free(rpbDecoded);
                     free(rcbDecoded);
                 }
-            } else {
+            }
+            else {
                 free(rpbDecoded);
                 ret = -1;
             }
-        } else {
+        }
+        else {
             ret = -1;
         }
 
@@ -806,13 +814,13 @@ _libssh2_wincng_bn_size(const unsigned char *bignum,
 {
     unsigned long offset;
 
-    if (!bignum)
+    if(!bignum)
         return 0;
 
     length--;
 
     offset = 0;
-    while (!(*(bignum + offset)) && (offset < length))
+    while(!(*(bignum + offset)) && (offset < length))
         offset++;
 
     length++;
@@ -856,7 +864,7 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
                _libssh2_wincng_bn_size(ddata, dlen));
     offset = sizeof(BCRYPT_RSAKEY_BLOB);
     keylen = offset + elen + mlen;
-    if (ddata && dlen > 0) {
+    if(ddata && dlen > 0) {
         p1len = max(_libssh2_wincng_bn_size(pdata, plen),
                     _libssh2_wincng_bn_size(e1data, e1len));
         p2len = max(_libssh2_wincng_bn_size(qdata, qlen),
@@ -865,7 +873,7 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
     }
 
     key = malloc(keylen);
-    if (!key) {
+    if(!key) {
         return -1;
     }
 
@@ -881,45 +889,45 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
     memcpy(key + offset, edata, elen);
     offset += elen;
 
-    if (nlen < mlen)
+    if(nlen < mlen)
         memcpy(key + offset + mlen - nlen, ndata, nlen);
     else
         memcpy(key + offset, ndata + nlen - mlen, mlen);
 
-    if (ddata && dlen > 0) {
+    if(ddata && dlen > 0) {
         offset += mlen;
 
-        if (plen < p1len)
+        if(plen < p1len)
             memcpy(key + offset + p1len - plen, pdata, plen);
         else
             memcpy(key + offset, pdata + plen - p1len, p1len);
         offset += p1len;
 
-        if (qlen < p2len)
+        if(qlen < p2len)
             memcpy(key + offset + p2len - qlen, qdata, qlen);
         else
             memcpy(key + offset, qdata + qlen - p2len, p2len);
         offset += p2len;
 
-        if (e1len < p1len)
+        if(e1len < p1len)
             memcpy(key + offset + p1len - e1len, e1data, e1len);
         else
             memcpy(key + offset, e1data + e1len - p1len, p1len);
         offset += p1len;
 
-        if (e2len < p2len)
+        if(e2len < p2len)
             memcpy(key + offset + p2len - e2len, e2data, e2len);
         else
             memcpy(key + offset, e2data + e2len - p2len, p2len);
         offset += p2len;
 
-        if (coefflen < p1len)
+        if(coefflen < p1len)
             memcpy(key + offset + p1len - coefflen, coeffdata, coefflen);
         else
             memcpy(key + offset, coeffdata + coefflen - p1len, p1len);
         offset += p1len;
 
-        if (dlen < mlen)
+        if(dlen < mlen)
             memcpy(key + offset + mlen - dlen, ddata, dlen);
         else
             memcpy(key + offset, ddata + dlen - mlen, mlen);
@@ -928,7 +936,8 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
         rsakey->Magic = BCRYPT_RSAFULLPRIVATE_MAGIC;
         rsakey->cbPrime1 = p1len;
         rsakey->cbPrime2 = p2len;
-    } else {
+    }
+    else {
         lpszBlobType = BCRYPT_RSAPUBLIC_BLOB;
         rsakey->Magic = BCRYPT_RSAPUBLIC_MAGIC;
         rsakey->cbPrime1 = 0;
@@ -938,14 +947,14 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
 
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL, lpszBlobType,
                               &hKey, key, keylen, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(key, keylen);
         return -1;
     }
 
 
     *rsa = malloc(sizeof(libssh2_rsa_ctx));
-    if (!(*rsa)) {
+    if(!(*rsa)) {
         BCryptDestroyKey(hKey);
         _libssh2_wincng_safe_free(key, keylen);
         return -1;
@@ -978,7 +987,7 @@ _libssh2_wincng_rsa_new_private_parse(libssh2_rsa_ctx **rsa,
 
     _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
 
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -986,14 +995,14 @@ _libssh2_wincng_rsa_new_private_parse(libssh2_rsa_ctx **rsa,
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL,
                               LEGACY_RSAPRIVATE_BLOB, &hKey,
                               pbStructInfo, cbStructInfo, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(pbStructInfo, cbStructInfo);
         return -1;
     }
 
 
     *rsa = malloc(sizeof(libssh2_rsa_ctx));
-    if (!(*rsa)) {
+    if(!(*rsa)) {
         BCryptDestroyKey(hKey);
         _libssh2_wincng_safe_free(pbStructInfo, cbStructInfo);
         return -1;
@@ -1023,7 +1032,7 @@ _libssh2_wincng_rsa_new_private(libssh2_rsa_ctx **rsa,
     ret = _libssh2_wincng_load_private(session, filename,
                                        (const char *)passphrase,
                                        &pbEncoded, &cbEncoded, 1, 0);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1057,7 +1066,7 @@ _libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
     ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
                                               (const char *)passphrase,
                                               &pbEncoded, &cbEncoded, 1, 0);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1101,7 +1110,7 @@ _libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
 
     datalen = (unsigned long)hash_len;
     data = malloc(datalen);
-    if (!data) {
+    if(!data) {
         return -1;
     }
 
@@ -1112,20 +1121,22 @@ _libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
     ret = BCryptSignHash(rsa->hKey, &paddingInfo,
                          data, datalen, NULL, 0,
                          &cbData, BCRYPT_PAD_PKCS1);
-    if (BCRYPT_SUCCESS(ret)) {
+    if(BCRYPT_SUCCESS(ret)) {
         siglen = cbData;
         sig = LIBSSH2_ALLOC(session, siglen);
-        if (sig) {
+        if(sig) {
             ret = BCryptSignHash(rsa->hKey, &paddingInfo,
                                  data, datalen, sig, siglen,
                                  &cbData, BCRYPT_PAD_PKCS1);
-            if (BCRYPT_SUCCESS(ret)) {
+            if(BCRYPT_SUCCESS(ret)) {
                 *signature_len = siglen;
                 *signature = sig;
-            } else {
+            }
+            else {
                 LIBSSH2_FREE(session, sig);
             }
-        } else
+        }
+        else
             ret = STATUS_NO_MEMORY;
     }
 
@@ -1137,7 +1148,7 @@ _libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
 void
 _libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa)
 {
-    if (!rsa)
+    if(!rsa)
         return;
 
     BCryptDestroyKey(rsa->hKey);
@@ -1179,11 +1190,11 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
                  _libssh2_wincng_bn_size(ydata, ylen));
     offset = sizeof(BCRYPT_DSA_KEY_BLOB);
     keylen = offset + length * 3;
-    if (xdata && xlen > 0)
+    if(xdata && xlen > 0)
         keylen += 20;
 
     key = malloc(keylen);
-    if (!key) {
+    if(!key) {
         return -1;
     }
 
@@ -1197,39 +1208,40 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
     memset(dsakey->Count, -1, sizeof(dsakey->Count));
     memset(dsakey->Seed, -1, sizeof(dsakey->Seed));
 
-    if (qlen < 20)
+    if(qlen < 20)
         memcpy(dsakey->q + 20 - qlen, qdata, qlen);
     else
         memcpy(dsakey->q, qdata + qlen - 20, 20);
 
-    if (plen < length)
+    if(plen < length)
         memcpy(key + offset + length - plen, pdata, plen);
     else
         memcpy(key + offset, pdata + plen - length, length);
     offset += length;
 
-    if (glen < length)
+    if(glen < length)
         memcpy(key + offset + length - glen, gdata, glen);
     else
         memcpy(key + offset, gdata + glen - length, length);
     offset += length;
 
-    if (ylen < length)
+    if(ylen < length)
         memcpy(key + offset + length - ylen, ydata, ylen);
     else
         memcpy(key + offset, ydata + ylen - length, length);
 
-    if (xdata && xlen > 0) {
+    if(xdata && xlen > 0) {
         offset += length;
 
-        if (xlen < 20)
+        if(xlen < 20)
             memcpy(key + offset + 20 - xlen, xdata, xlen);
         else
             memcpy(key + offset, xdata + xlen - 20, 20);
 
         lpszBlobType = BCRYPT_DSA_PRIVATE_BLOB;
         dsakey->dwMagic = BCRYPT_DSA_PRIVATE_MAGIC;
-    } else {
+    }
+    else {
         lpszBlobType = BCRYPT_DSA_PUBLIC_BLOB;
         dsakey->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
     }
@@ -1237,14 +1249,14 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
 
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgDSA, NULL, lpszBlobType,
                               &hKey, key, keylen, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(key, keylen);
         return -1;
     }
 
 
     *dsa = malloc(sizeof(libssh2_dsa_ctx));
-    if (!(*dsa)) {
+    if(!(*dsa)) {
         BCryptDestroyKey(hKey);
         _libssh2_wincng_safe_free(key, keylen);
         return -1;
@@ -1275,23 +1287,24 @@ _libssh2_wincng_dsa_new_private_parse(libssh2_dsa_ctx **dsa,
 
     _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
 
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
 
-    if (length == 6) {
+    if(length == 6) {
         ret = _libssh2_wincng_dsa_new(dsa,
                                       rpbDecoded[1], rcbDecoded[1],
                                       rpbDecoded[2], rcbDecoded[2],
                                       rpbDecoded[3], rcbDecoded[3],
                                       rpbDecoded[4], rcbDecoded[4],
                                       rpbDecoded[5], rcbDecoded[5]);
-    } else {
+    }
+    else {
         ret = -1;
     }
 
-    for (index = 0; index < length; index++) {
+    for(index = 0; index < length; index++) {
         _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
         rpbDecoded[index] = NULL;
         rcbDecoded[index] = 0;
@@ -1318,7 +1331,7 @@ _libssh2_wincng_dsa_new_private(libssh2_dsa_ctx **dsa,
     ret = _libssh2_wincng_load_private(session, filename,
                                        (const char *)passphrase,
                                        &pbEncoded, &cbEncoded, 0, 1);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1350,7 +1363,7 @@ _libssh2_wincng_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
     ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
                                               (const char *)passphrase,
                                               &pbEncoded, &cbEncoded, 0, 1);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1389,7 +1402,7 @@ _libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
 
     datalen = hash_len;
     data = malloc(datalen);
-    if (!data) {
+    if(!data) {
         return -1;
     }
 
@@ -1397,21 +1410,23 @@ _libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
 
     ret = BCryptSignHash(dsa->hKey, NULL, data, datalen,
                          NULL, 0, &cbData, 0);
-    if (BCRYPT_SUCCESS(ret)) {
+    if(BCRYPT_SUCCESS(ret)) {
         siglen = cbData;
-        if (siglen == 40) {
+        if(siglen == 40) {
             sig = malloc(siglen);
-            if (sig) {
+            if(sig) {
                 ret = BCryptSignHash(dsa->hKey, NULL, data, datalen,
                                      sig, siglen, &cbData, 0);
-                if (BCRYPT_SUCCESS(ret)) {
+                if(BCRYPT_SUCCESS(ret)) {
                     memcpy(sig_fixed, sig, siglen);
                 }
 
                 _libssh2_wincng_safe_free(sig, siglen);
-            } else
+            }
+            else
                 ret = STATUS_NO_MEMORY;
-        } else
+        }
+        else
             ret = STATUS_NO_MEMORY;
     }
 
@@ -1423,7 +1438,7 @@ _libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
 void
 _libssh2_wincng_dsa_free(libssh2_dsa_ctx *dsa)
 {
-    if (!dsa)
+    if(!dsa)
         return;
 
     BCryptDestroyKey(dsa->hKey);
@@ -1477,24 +1492,25 @@ _libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
 
     _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
 
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
 
-    if (length == 9) { /* private RSA key */
+    if(length == 9) { /* private RSA key */
         mthlen = 7;
         mth = LIBSSH2_ALLOC(session, mthlen);
-        if (mth) {
+        if(mth) {
             memcpy(mth, "ssh-rsa", mthlen);
-        } else {
+        }
+        else {
             ret = -1;
         }
 
 
         keylen = 4 + mthlen + 4 + rcbDecoded[2] + 4 + rcbDecoded[1];
         key = LIBSSH2_ALLOC(session, keylen);
-        if (key) {
+        if(key) {
             offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
 
             offset = _libssh2_wincng_pub_priv_write(key, offset,
@@ -1504,23 +1520,26 @@ _libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
             _libssh2_wincng_pub_priv_write(key, offset,
                                            rpbDecoded[1],
                                            rcbDecoded[1]);
-        } else {
+        }
+        else {
             ret = -1;
         }
 
-    } else if (length == 6) { /* private DSA key */
+    }
+    else if(length == 6) { /* private DSA key */
         mthlen = 7;
         mth = LIBSSH2_ALLOC(session, mthlen);
-        if (mth) {
+        if(mth) {
             memcpy(mth, "ssh-dss", mthlen);
-        } else {
+        }
+        else {
             ret = -1;
         }
 
         keylen = 4 + mthlen + 4 + rcbDecoded[1] + 4 + rcbDecoded[2]
                             + 4 + rcbDecoded[3] + 4 + rcbDecoded[4];
         key = LIBSSH2_ALLOC(session, keylen);
-        if (key) {
+        if(key) {
             offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
 
             offset = _libssh2_wincng_pub_priv_write(key, offset,
@@ -1538,16 +1557,18 @@ _libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
             _libssh2_wincng_pub_priv_write(key, offset,
                                            rpbDecoded[4],
                                            rcbDecoded[4]);
-        } else {
+        }
+        else {
             ret = -1;
         }
 
-    } else {
+    }
+    else {
         ret = -1;
     }
 
 
-    for (index = 0; index < length; index++) {
+    for(index = 0; index < length; index++) {
         _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
         rpbDecoded[index] = NULL;
         rcbDecoded[index] = 0;
@@ -1557,12 +1578,13 @@ _libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
     free(rcbDecoded);
 
 
-    if (ret) {
-        if (mth)
+    if(ret) {
+        if(mth)
             LIBSSH2_FREE(session, mth);
-        if (key)
+        if(key)
             LIBSSH2_FREE(session, key);
-    } else {
+    }
+    else {
         *method = mth;
         *method_len = mthlen;
         *pubkeydata = key;
@@ -1589,7 +1611,7 @@ _libssh2_wincng_pub_priv_keyfile(LIBSSH2_SESSION *session,
 
     ret = _libssh2_wincng_load_private(session, privatekey, passphrase,
                                        &pbEncoded, &cbEncoded, 1, 1);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1628,7 +1650,7 @@ _libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     ret = _libssh2_wincng_load_private_memory(session, privatekeydata,
                                               privatekeydata_len, passphrase,
                                               &pbEncoded, &cbEncoded, 1, 1);
-    if (ret) {
+    if(ret) {
         return -1;
     }
 
@@ -1645,8 +1667,8 @@ _libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     (void)passphrase;
 
     return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                          "Unable to extract public key from private key in memory: "
-                          "Method unsupported in Windows CNG backend");
+               "Unable to extract public key from private key in memory: "
+               "Method unsupported in Windows CNG backend");
 #endif /* HAVE_LIBCRYPT32 */
 }
 
@@ -1665,7 +1687,8 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
     BCRYPT_KEY_HANDLE hKey;
     BCRYPT_KEY_DATA_BLOB_HEADER *header;
     unsigned char *pbKeyObject, *pbIV, *key, *pbCtr, *pbIVCopy;
-    unsigned long dwKeyObject, dwIV, dwCtrLength, dwBlockLength, cbData, keylen;
+    unsigned long dwKeyObject, dwIV, dwCtrLength, dwBlockLength,
+                  cbData, keylen;
     int ret;
 
     (void)encrypt;
@@ -1674,7 +1697,7 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
                             (unsigned char *)&dwKeyObject,
                             sizeof(dwKeyObject),
                             &cbData, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         return -1;
     }
 
@@ -1682,19 +1705,19 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
                             (unsigned char *)&dwBlockLength,
                             sizeof(dwBlockLength),
                             &cbData, 0);
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         return -1;
     }
 
     pbKeyObject = malloc(dwKeyObject);
-    if (!pbKeyObject) {
+    if(!pbKeyObject) {
         return -1;
     }
 
 
     keylen = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + type.dwKeyLength;
     key = malloc(keylen);
-    if (!key) {
+    if(!key) {
         free(pbKeyObject);
         return -1;
     }
@@ -1713,7 +1736,7 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
 
     _libssh2_wincng_safe_free(key, keylen);
 
-    if (!BCRYPT_SUCCESS(ret)) {
+    if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(pbKeyObject, dwKeyObject);
         return -1;
     }
@@ -1723,20 +1746,20 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
     dwIV = 0;
     dwCtrLength = 0;
 
-    if (type.useIV || type.ctrMode) {
+    if(type.useIV || type.ctrMode) {
         pbIVCopy = malloc(dwBlockLength);
-        if (!pbIVCopy) {
+        if(!pbIVCopy) {
             BCryptDestroyKey(hKey);
             _libssh2_wincng_safe_free(pbKeyObject, dwKeyObject);
             return -1;
         }
         memcpy(pbIVCopy, iv, dwBlockLength);
 
-        if (type.ctrMode) {
+        if(type.ctrMode) {
             pbCtr = pbIVCopy;
             dwCtrLength = dwBlockLength;
         }
-        else if (type.useIV) {
+        else if(type.useIV) {
             pbIV = pbIVCopy;
             dwIV = dwBlockLength;
         }
@@ -1768,42 +1791,47 @@ _libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
 
     cbInput = (unsigned long)blocklen;
 
-    if (type.ctrMode) {
+    if(type.ctrMode) {
         pbInput = ctx->pbCtr;
-    } else {
+    }
+    else {
         pbInput = block;
     }
 
-    if (encrypt || type.ctrMode) {
+    if(encrypt || type.ctrMode) {
         ret = BCryptEncrypt(ctx->hKey, pbInput, cbInput, NULL,
                             ctx->pbIV, ctx->dwIV, NULL, 0, &cbOutput, 0);
-    } else {
+    }
+    else {
         ret = BCryptDecrypt(ctx->hKey, pbInput, cbInput, NULL,
                             ctx->pbIV, ctx->dwIV, NULL, 0, &cbOutput, 0);
     }
-    if (BCRYPT_SUCCESS(ret)) {
+    if(BCRYPT_SUCCESS(ret)) {
         pbOutput = malloc(cbOutput);
-        if (pbOutput) {
-            if (encrypt || type.ctrMode) {
+        if(pbOutput) {
+            if(encrypt || type.ctrMode) {
                 ret = BCryptEncrypt(ctx->hKey, pbInput, cbInput, NULL,
                                     ctx->pbIV, ctx->dwIV,
                                     pbOutput, cbOutput, &cbOutput, 0);
-            } else {
+            }
+            else {
                 ret = BCryptDecrypt(ctx->hKey, pbInput, cbInput, NULL,
                                     ctx->pbIV, ctx->dwIV,
                                     pbOutput, cbOutput, &cbOutput, 0);
             }
-            if (BCRYPT_SUCCESS(ret)) {
-                if (type.ctrMode) {
+            if(BCRYPT_SUCCESS(ret)) {
+                if(type.ctrMode) {
                     _libssh2_xor_data(block, block, pbOutput, blocklen);
                     _libssh2_aes_ctr_increment(ctx->pbCtr, ctx->dwCtrLength);
-                } else {
+                }
+                else {
                     memcpy(block, pbOutput, cbOutput);
                 }
             }
 
             _libssh2_wincng_safe_free(pbOutput, cbOutput);
-        } else
+        }
+        else
             ret = STATUS_NO_MEMORY;
     }
 
@@ -1841,7 +1869,7 @@ _libssh2_wincng_bignum_init(void)
     _libssh2_bn *bignum;
 
     bignum = (_libssh2_bn *)malloc(sizeof(_libssh2_bn));
-    if (bignum) {
+    if(bignum) {
         bignum->bignum = NULL;
         bignum->length = 0;
     }
@@ -1854,20 +1882,20 @@ _libssh2_wincng_bignum_resize(_libssh2_bn *bn, unsigned long length)
 {
     unsigned char *bignum;
 
-    if (!bn)
+    if(!bn)
         return -1;
 
-    if (length == bn->length)
+    if(length == bn->length)
         return 0;
 
 #ifdef LIBSSH2_CLEAR_MEMORY
-    if (bn->bignum && bn->length > 0 && length < bn->length) {
+    if(bn->bignum && bn->length > 0 && length < bn->length) {
         SecureZeroMemory(bn->bignum + length, bn->length - length);
     }
 #endif
 
     bignum = realloc(bn->bignum, length);
-    if (!bignum)
+    if(!bignum)
         return -1;
 
     bn->bignum = bignum;
@@ -1882,16 +1910,16 @@ _libssh2_wincng_bignum_rand(_libssh2_bn *rnd, int bits, int top, int bottom)
     unsigned char *bignum;
     unsigned long length;
 
-    if (!rnd)
+    if(!rnd)
         return -1;
 
     length = (unsigned long)(ceil((float)bits / 8) * sizeof(unsigned char));
-    if (_libssh2_wincng_bignum_resize(rnd, length))
+    if(_libssh2_wincng_bignum_resize(rnd, length))
         return -1;
 
     bignum = rnd->bignum;
 
-    if (_libssh2_wincng_random(bignum, length))
+    if(_libssh2_wincng_random(bignum, length))
         return -1;
 
     /* calculate significant bits in most significant byte */
@@ -1901,13 +1929,13 @@ _libssh2_wincng_bignum_rand(_libssh2_bn *rnd, int bits, int top, int bottom)
     bignum[0] &= (1 << (8 - bits)) - 1;
 
     /* set some special last bits in most significant byte */
-    if (top == 0)
+    if(top == 0)
         bignum[0] |= (1 << (7 - bits));
-    else if (top == 1)
+    else if(top == 1)
         bignum[0] |= (3 << (6 - bits));
 
     /* make odd by setting first bit in least significant byte */
-    if (bottom)
+    if(bottom)
         bignum[length - 1] |= 1;
 
     return 0;
@@ -1925,14 +1953,14 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
     unsigned long keylen, offset, length;
     int ret;
 
-    if (!r || !a || !p || !m)
+    if(!r || !a || !p || !m)
         return -1;
 
     offset = sizeof(BCRYPT_RSAKEY_BLOB);
     keylen = offset + p->length + m->length;
 
     key = malloc(keylen);
-    if (!key)
+    if(!key)
         return -1;
 
 
@@ -1954,14 +1982,14 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
                               BCRYPT_RSAPUBLIC_BLOB, &hKey, key, keylen,
                               BCRYPT_NO_KEY_VALIDATION);
 
-    if (BCRYPT_SUCCESS(ret)) {
+    if(BCRYPT_SUCCESS(ret)) {
         ret = BCryptEncrypt(hKey, a->bignum, a->length, NULL, NULL, 0,
                             NULL, 0, &length, BCRYPT_PAD_NONE);
-        if (BCRYPT_SUCCESS(ret)) {
-            if (!_libssh2_wincng_bignum_resize(r, length)) {
+        if(BCRYPT_SUCCESS(ret)) {
+            if(!_libssh2_wincng_bignum_resize(r, length)) {
                 length = max(a->length, length);
                 bignum = malloc(length);
-                if (bignum) {
+                if(bignum) {
                     offset = length - a->length;
                     memset(bignum, 0, offset);
                     memcpy(bignum + offset, a->bignum, a->length);
@@ -1972,12 +2000,14 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
 
                     _libssh2_wincng_safe_free(bignum, length);
 
-                    if (BCRYPT_SUCCESS(ret)) {
+                    if(BCRYPT_SUCCESS(ret)) {
                         _libssh2_wincng_bignum_resize(r, offset);
                     }
-                } else
+                }
+                else
                     ret = STATUS_NO_MEMORY;
-            } else
+            }
+            else
                 ret = STATUS_NO_MEMORY;
         }
 
@@ -1994,20 +2024,20 @@ _libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word)
 {
     unsigned long offset, number, bits, length;
 
-    if (!bn)
+    if(!bn)
         return -1;
 
     bits = 0;
     number = word;
-    while (number >>= 1)
+    while(number >>= 1)
         bits++;
 
     length = (unsigned long) (ceil(((double)(bits + 1)) / 8.0) *
                               sizeof(unsigned char));
-    if (_libssh2_wincng_bignum_resize(bn, length))
+    if(_libssh2_wincng_bignum_resize(bn, length))
         return -1;
 
-    for (offset = 0; offset < length; offset++)
+    for(offset = 0; offset < length; offset++)
         bn->bignum[offset] = (word >> (offset * 8)) & 0xff;
 
     return 0;
@@ -2019,19 +2049,19 @@ _libssh2_wincng_bignum_bits(const _libssh2_bn *bn)
     unsigned char number;
     unsigned long offset, length, bits;
 
-    if (!bn)
+    if(!bn)
         return 0;
 
     length = bn->length - 1;
 
     offset = 0;
-    while (!(*(bn->bignum + offset)) && (offset < length))
+    while(!(*(bn->bignum + offset)) && (offset < length))
         offset++;
 
     bits = (length - offset) * 8;
     number = bn->bignum[offset];
 
-    while (number >>= 1)
+    while(number >>= 1)
         bits++;
 
     bits++;
@@ -2046,10 +2076,10 @@ _libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
     unsigned char *bignum;
     unsigned long offset, length, bits;
 
-    if (!bn || !bin || !len)
+    if(!bn || !bin || !len)
         return;
 
-    if (_libssh2_wincng_bignum_resize(bn, len))
+    if(_libssh2_wincng_bignum_resize(bn, len))
         return;
 
     memcpy(bn->bignum, bin, len);
@@ -2059,7 +2089,7 @@ _libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
                               sizeof(unsigned char));
 
     offset = bn->length - length;
-    if (offset > 0) {
+    if(offset > 0) {
         memmove(bn->bignum, bn->bignum + offset, length);
 
 #ifdef LIBSSH2_CLEAR_MEMORY
@@ -2067,7 +2097,7 @@ _libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
 #endif
 
         bignum = realloc(bn->bignum, length);
-        if (bignum) {
+        if(bignum) {
             bn->bignum = bignum;
             bn->length = length;
         }
@@ -2077,7 +2107,7 @@ _libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
 void
 _libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin)
 {
-    if (bin && bn && bn->bignum && bn->length > 0) {
+    if(bin && bn && bn->bignum && bn->length > 0) {
         memcpy(bin, bn->bignum, bn->length);
     }
 }
@@ -2085,8 +2115,8 @@ _libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin)
 void
 _libssh2_wincng_bignum_free(_libssh2_bn *bn)
 {
-    if (bn) {
-        if (bn->bignum) {
+    if(bn) {
+        if(bn->bignum) {
             _libssh2_wincng_safe_free(bn->bignum, bn->length);
             bn->bignum = NULL;
         }
@@ -2111,9 +2141,9 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
                      _libssh2_bn *g, _libssh2_bn *p, int group_order)
 {
     /* Generate x and e */
-    if (_libssh2_wincng_bignum_rand(*dhctx, group_order * 8 - 1, 0, -1))
+    if(_libssh2_wincng_bignum_rand(*dhctx, group_order * 8 - 1, 0, -1))
         return -1;
-    if (_libssh2_wincng_bignum_mod_exp(public, g, *dhctx, p))
+    if(_libssh2_wincng_bignum_mod_exp(public, g, *dhctx, p))
         return -1;
     return 0;
 }