indent with 'indent -nut -bli0 -fca' command

1 files changed, 247 insertions, 191 deletions

diff --git a/nanohttp/nanohttp-socket.c b/nanohttp/nanohttp-socket.c
index 684585c..ee69561 100644
--- a/nanohttp/nanohttp-socket.c
+++ b/nanohttp/nanohttp-socket.c
@@ -1,5 +1,5 @@
 /******************************************************************
-*  $Id: nanohttp-socket.c,v 1.41 2006/01/06 16:17:36 snowdrop Exp $
+*  $Id: nanohttp-socket.c,v 1.42 2006/01/10 11:21:55 snowdrop Exp $
 *
 * CSOAP Project:  A http client/server library in C
 * Copyright (C) 2003  Ferhat Ayaz
@@ -26,16 +26,16 @@
 #include <nanohttp/nanohttp-ssl.h>
 
 #ifdef WIN32
-  #include "wsockcompat.h"
-  #include <winsock2.h>
-  #include <process.h>
-  
-  #ifndef __MINGW32__
-    typedef int ssize_t;
-  #endif
-  
+#include "wsockcompat.h"
+#include <winsock2.h>
+#include <process.h>
+
+#ifndef __MINGW32__
+typedef int ssize_t;
+#endif
+
 #else
-  #include <fcntl.h>
+#include <fcntl.h>
 #endif
 
 #ifdef HAVE_CONFIG_H
@@ -78,7 +78,7 @@
 
 
 #ifdef HAVE_SSL
-SSL_CTX* SSLctx = NULL;
+SSL_CTX *SSLctx = NULL;
 char *SSLCert = NULL;
 char *SSLPass = NULL;
 char *SSLCA = NULL;
@@ -121,19 +121,22 @@ hsocket_module_destroy ()
 FUNCTION: hsocket_init
 ----------------------------------------------------*/
 herror_t
-hsocket_init (hsocket_t * sock )
+hsocket_init (hsocket_t * sock)
 {
-  log_verbose1("Starting hsocket init");
+  log_verbose1 ("Starting hsocket init");
   /* just set the descriptor to -1 */
   sock->sock = -1;
 #ifdef HAVE_SSL
   sock->ssl = NULL;
-  if(SSLCert || SSLCertLess){
-	  log_verbose1("calling init ctx");
-      SSLctx=initialize_ctx( SSLCert,SSLPass,SSLCA);
-      if(SSLctx==NULL){
-            return herror_new("hsocket_init", HSOCKET_ERROR_CONNECT, "Unable to initialize SSL CTX" );
-      }
+  if (SSLCert || SSLCertLess)
+  {
+    log_verbose1 ("calling init ctx");
+    SSLctx = initialize_ctx (SSLCert, SSLPass, SSLCA);
+    if (SSLctx == NULL)
+    {
+      return herror_new ("hsocket_init", HSOCKET_ERROR_CONNECT,
+                         "Unable to initialize SSL CTX");
+    }
   }
 #endif
   return H_OK;
@@ -161,33 +164,40 @@ hsocket_open (hsocket_t * dsock, const char *hostname, int port)
 
   sock.sock = socket (AF_INET, SOCK_STREAM, 0);
   if (sock.sock <= 0)
-    return herror_new("hsocket_open", HSOCKET_ERROR_CREATE, "Socket error: %d", errno);
+    return herror_new ("hsocket_open", HSOCKET_ERROR_CREATE,
+                       "Socket error: %d", errno);
 
   /* Get host data */
   host = gethostbyname (hostname);
   if (host == NULL)
-    return herror_new("hsocket_open", HSOCKET_ERROR_GET_HOSTNAME, "Socket error: %d", errno);
+    return herror_new ("hsocket_open", HSOCKET_ERROR_GET_HOSTNAME,
+                       "Socket error: %d", errno);
 
   ip = inet_ntoa (*(struct in_addr *) *host->h_addr_list);
   address.sin_addr.s_addr = inet_addr (ip);
 
   /* set server addresss */
   address.sin_family = host->h_addrtype;
-  address.sin_port = htons((unsigned short)port);
+  address.sin_port = htons ((unsigned short) port);
 
   /* connect to the server */
-  if (connect (sock.sock, (struct sockaddr *) &address, sizeof (address)) != 0)
-    return herror_new("hsocket_open", HSOCKET_ERROR_CONNECT, "Socket error: %d", errno);
+  if (connect (sock.sock, (struct sockaddr *) &address, sizeof (address)) !=
+      0)
+    return herror_new ("hsocket_open", HSOCKET_ERROR_CONNECT,
+                       "Socket error: %d", errno);
 
 #ifdef HAVE_SSL
-  if( !SSLctx ){
+  if (!SSLctx)
+  {
 #endif
-    log_verbose1("Using HTTP");
+    log_verbose1 ("Using HTTP");
     dsock->sock = sock.sock;
 #ifdef HAVE_SSL
-  } else {
-    log_verbose1("Using HTTPS");
-    dsock->ssl = init_ssl(SSLctx, sock.sock, SSL_CLIENT);
+  }
+  else
+  {
+    log_verbose1 ("Using HTTPS");
+    dsock->ssl = init_ssl (SSLctx, sock.sock, SSL_CLIENT);
   }
 #endif
   return H_OK;
@@ -201,28 +211,31 @@ hsocket_bind (hsocket_t * dsock, int port)
 {
   hsocket_t sock;
   struct sockaddr_in addr;
-  int opt=1;
+  int opt = 1;
 
   /* create socket */
   sock.sock = socket (AF_INET, SOCK_STREAM, 0);
   if (sock.sock == -1)
   {
     log_error3 ("Can not create socket: '%s'", "Socket error: %d", errno);
-    return herror_new("hsocket_bind", HSOCKET_ERROR_CREATE, "Socket error: %d", errno);
+    return herror_new ("hsocket_bind", HSOCKET_ERROR_CREATE,
+                       "Socket error: %d", errno);
   }
 
-  setsockopt( sock.sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) );
+  setsockopt (sock.sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
   /* bind socket */
   addr.sin_family = AF_INET;
-  addr.sin_port = htons ((unsigned short)port); /* short, network byte order */
+  addr.sin_port = htons ((unsigned short) port);        /* short, network
+                                                           byte order */
   addr.sin_addr.s_addr = INADDR_ANY;
-  memset (&(addr.sin_zero), '\0', 8);   /* zero the rest of the
-                                         * struct */
+  memset (&(addr.sin_zero), '\0', 8);   /* zero the rest of the struct */
 
-  if (bind (sock.sock, (struct sockaddr *) &addr, sizeof (struct sockaddr)) == -1)
+  if (bind (sock.sock, (struct sockaddr *) &addr, sizeof (struct sockaddr)) ==
+      -1)
   {
     log_error3 ("Can not bind: '%s'", "Socket error: %d", errno);
-    return herror_new("hsocket_bind", HSOCKET_ERROR_BIND, "Socket error: %d", errno);
+    return herror_new ("hsocket_bind", HSOCKET_ERROR_BIND, "Socket error: %d",
+                       errno);
   }
   dsock->sock = sock.sock;
   return H_OK;
@@ -239,28 +252,34 @@ hsocket_accept (hsocket_t sock, hsocket_t * dest)
   struct sockaddr_in addr;
 
   if (sock.sock <= 0)
-	return herror_new("hsocket_accept", HSOCKET_ERROR_NOT_INITIALIZED, 
-	 "Called hsocket_listen() before initializing!");
+    return herror_new ("hsocket_accept", HSOCKET_ERROR_NOT_INITIALIZED,
+                       "Called hsocket_listen() before initializing!");
 
   asize = sizeof (struct sockaddr_in);
 #ifdef WIN32
   while (1)
   {
     sockfd.sock = accept (sock.sock, (struct sockaddr *) &addr, &asize);
-    if (sockfd.sock == INVALID_SOCKET)   {
+    if (sockfd.sock == INVALID_SOCKET)
+    {
       if (WSAGetLastError () != WSAEWOULDBLOCK)
-		return herror_new("hsocket_accept", HSOCKET_ERROR_ACCEPT, "Socket error: %d", errno);
-    } else  {
+        return herror_new ("hsocket_accept", HSOCKET_ERROR_ACCEPT,
+                           "Socket error: %d", errno);
+    }
+    else
+    {
       break;
     }
   }
-#else 
+#else
 /* TODO (#1#): why not a loop like in win32? */
   sockfd.sock = accept (sock.sock, (struct sockaddr *) &addr, &asize);
-  if (sockfd.sock == -1) {
-		return herror_new("hsocket_accept", HSOCKET_ERROR_ACCEPT, "Socket error: %d", errno);
+  if (sockfd.sock == -1)
+  {
+    return herror_new ("hsocket_accept", HSOCKET_ERROR_ACCEPT,
+                       "Socket error: %d", errno);
   }
-#endif 
+#endif
 /* TODO (#1#): Write to access.log file */
 
   log_verbose3 ("accept new socket (%d) from '%s'", sockfd.sock,
@@ -277,21 +296,22 @@ herror_t
 hsocket_listen (hsocket_t sock)
 {
   if (sock.sock <= 0)
-	return herror_new("hsocket_listen", HSOCKET_ERROR_NOT_INITIALIZED, 
-	 "Called hsocket_listen() before initializing!");
+    return herror_new ("hsocket_listen", HSOCKET_ERROR_NOT_INITIALIZED,
+                       "Called hsocket_listen() before initializing!");
 
   if (listen (sock.sock, 15) == -1)
   {
     log_error3 ("Can not listen: '%s'", "Socket error: %d", errno);
-	return herror_new("hsocket_listen", HSOCKET_ERROR_LISTEN, "Socket error: %d", errno);
+    return herror_new ("hsocket_listen", HSOCKET_ERROR_LISTEN,
+                       "Socket error: %d", errno);
   }
 
   return H_OK;
 }
 
 #if 0
-static
-void _hsocket_wait_until_receive(hsocket_t sock)
+static void
+_hsocket_wait_until_receive (hsocket_t sock)
 {
   fd_set fds;
   struct timeval timeout;
@@ -300,15 +320,15 @@ void _hsocket_wait_until_receive(hsocket_t sock)
   timeout.tv_sec = 1;
   timeout.tv_usec = 0;
 
-  while (1) 
+  while (1)
   {
     log_verbose1 ("waiting until receive mode");
     /* zero and set file descriptior */
     FD_ZERO (&fds);
     FD_SET (sock, &fds);
-  
+
     /* select socket descriptor */
-    switch (select (sock + 1, &fds,  NULL, NULL, &timeout))
+    switch (select (sock + 1, &fds, NULL, NULL, &timeout))
     {
     case 0:
       /* descriptor is not ready */
@@ -344,31 +364,40 @@ hsocket_close (hsocket_t sock)
   _linger.l_linger = 30000;
   setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char*)&_linger, sizeof(struct linger));
 */
-   
+
 
 #ifdef WIN32
-  /*shutdown(sock,SD_RECEIVE);*/
-  
+  /* shutdown(sock,SD_RECEIVE); */
+
+
+  shutdown (sock.sock, SD_SEND);
+  while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+  {
+  };
+  closesocket (sock.sock);
 
-  shutdown(sock.sock, SD_SEND);
-  while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };  
-  closesocket(sock.sock);
-  
 #else
   /* XXX m. campbell - It seems like the while loop here needs this */
-  fcntl( sock.sock, F_SETFL, O_NONBLOCK);
+  fcntl (sock.sock, F_SETFL, O_NONBLOCK);
 #ifdef HAVE_SSL
-  if( sock.ssl ){
-    log_verbose1("Closing SSL");
-    ssl_cleanup(sock.ssl);
-    shutdown(sock.sock, SHUT_RDWR);
-    while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };  
+  if (sock.ssl)
+  {
+    log_verbose1 ("Closing SSL");
+    ssl_cleanup (sock.ssl);
+    shutdown (sock.sock, SHUT_RDWR);
+    while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+    {
+    };
     close (sock.sock);
-  }else {
+  }
+  else
+  {
 #endif
-      shutdown(sock.sock, SHUT_RDWR);
-      while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };  
-      close (sock.sock);
+    shutdown (sock.sock, SHUT_RDWR);
+    while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+    {
+    };
+    close (sock.sock);
 #ifdef HAVE_SSL
   }
 #endif
@@ -377,70 +406,80 @@ hsocket_close (hsocket_t sock)
 }
 
 #if 0
-static int _test_send_to_file(const char* filename, const byte_t* bytes,int n)
+static int
+_test_send_to_file (const char *filename, const byte_t * bytes, int n)
 {
-	int size;
-	FILE *f = fopen(filename, "ab");
-	if (!f) f = fopen(filename, "wb");
-	size= fwrite(bytes, 1, n, f);
-	fclose(f);
-	return size;
+  int size;
+  FILE *f = fopen (filename, "ab");
+  if (!f)
+    f = fopen (filename, "wb");
+  size = fwrite (bytes, 1, n, f);
+  fclose (f);
+  return size;
 }
 #endif
 /*--------------------------------------------------
 FUNCTION: hsocket_send
 ----------------------------------------------------*/
 herror_t
-hsocket_nsend (hsocket_t sock, const byte_t *bytes, int n)
+hsocket_nsend (hsocket_t sock, const byte_t * bytes, int n)
 {
   int size;
-  int total=0;
+  int total = 0;
 
-  log_verbose1( "Starting to send" );
+  log_verbose1 ("Starting to send");
 #ifdef HAVE_SSL
   if (sock.sock <= 0 && !sock.ssl)
 #else
   if (sock.sock <= 0)
 #endif
-	return herror_new("hsocket_nsend", HSOCKET_ERROR_NOT_INITIALIZED, 
-	 "Called hsocket_listen() before initializing!");
+    return herror_new ("hsocket_nsend", HSOCKET_ERROR_NOT_INITIALIZED,
+                       "Called hsocket_listen() before initializing!");
 
-  //log_verbose2( "SENDING %s", bytes );
+  // log_verbose2( "SENDING %s", bytes );
 
   /* TODO (#1#): check return value and send again until n bytes sent */
   while (1)
   {
 #ifdef HAVE_SSL
-    if(sock.ssl){
-        size = SSL_write(sock.ssl, bytes + total, n);
-    } else {
+    if (sock.ssl)
+    {
+      size = SSL_write (sock.ssl, bytes + total, n);
+    }
+    else
+    {
 #endif
-        size = send((int) sock.sock, bytes + total, n, 0);
+      size = send ((int) sock.sock, bytes + total, n, 0);
 #ifdef HAVE_SSL
     }
 #endif
-    log_verbose2("Sent %d", size );
-	 /* size = _test_send_to_file(filename, bytes, n);*/
+    log_verbose2 ("Sent %d", size);
+    /* size = _test_send_to_file(filename, bytes, n); */
 #ifdef WIN32
     if (size == INVALID_SOCKET)
-        if (WSAGetLastError () == WSAEWOULDBLOCK)
-          continue;
-        else       
-		return herror_new("hsocket_nsend", HSOCKET_ERROR_SEND, "Socket error: %d", errno);
+      if (WSAGetLastError () == WSAEWOULDBLOCK)
+        continue;
+      else
+        return herror_new ("hsocket_nsend", HSOCKET_ERROR_SEND,
+                           "Socket error: %d", errno);
 #else
-    if (size == -1){
+    if (size == -1)
+    {
 #ifdef HAVE_SSL
-        if(sock.ssl){
-            log_error1("Send error");
-            log_ssl_error(sock.ssl, size);
-        }
+      if (sock.ssl)
+      {
+        log_error1 ("Send error");
+        log_ssl_error (sock.ssl, size);
+      }
 #endif
-		return herror_new("hsocket_nsend", HSOCKET_ERROR_SEND, "Socket error: %d", errno);
+      return herror_new ("hsocket_nsend", HSOCKET_ERROR_SEND,
+                         "Socket error: %d", errno);
     }
 #endif
     n -= size;
-	total += size;
-    if (n<=0) break;
+    total += size;
+    if (n <= 0)
+      break;
   }
   return H_OK;
 }
@@ -458,7 +497,8 @@ hsocket_send (hsocket_t sock, const char *str)
   return: -1 is error. read bytes otherwise
 */
 herror_t
-hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *received)
+hsocket_read (hsocket_t sock, byte_t * buffer, int total, int force,
+              int *received)
 {
   int status;
   int totalRead;
@@ -469,72 +509,81 @@ hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *receive
 /*
   log_verbose3("Entering hsocket_read(total=%d,force=%d)", total, force);
 */
-  do {
+  do
+  {
 #ifdef HAVE_SSL
-    if(sock.ssl){
-        struct timeval timeout;
-        int i=0;
-        fd_set fds;
-        FD_ZERO (&fds);
-        FD_SET (sock.sock, &fds);
-        timeout.tv_sec = 10;
-        timeout.tv_usec = 0;
+    if (sock.ssl)
+    {
+      struct timeval timeout;
+      int i = 0;
+      fd_set fds;
+      FD_ZERO (&fds);
+      FD_SET (sock.sock, &fds);
+      timeout.tv_sec = 10;
+      timeout.tv_usec = 0;
 #ifdef WIN32
 #else
-        fcntl( sock.sock, F_SETFL, O_NONBLOCK);
-#endif
-        //    log_verbose1("START READ LOOP");
-        //do{
-        //log_verbose2("DEBUG A %d",i);
-        status = SSL_read(sock.ssl, &buffer[totalRead], total - totalRead);
-        if(status < 1){
-            int ret = select (sock.sock + 1, &fds, NULL, NULL, &timeout);
-            //log_verbose2("DEBUG %d",ret);
+      fcntl (sock.sock, F_SETFL, O_NONBLOCK);
+#endif
+      // log_verbose1("START READ LOOP");
+      // do{
+      // log_verbose2("DEBUG A %d",i);
+      status = SSL_read (sock.ssl, &buffer[totalRead], total - totalRead);
+      if (status < 1)
+      {
+        int ret = select (sock.sock + 1, &fds, NULL, NULL, &timeout);
+        // log_verbose2("DEBUG %d",ret);
 #ifdef WIN32
-			if (ret == SOCKET_ERROR) 
-			{
-				wsa_error = WSAGetLastError();
-				log_error2("WSAGetLastError()=%d", wsa_error);
-				return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
-		      
-			}
-#endif
-            if(ret==0){
-                log_verbose1("Socket timeout");
-                return herror_new("hsocket_read", HSOCKET_SSL_CLOSE, "Timeout");
-            } else {
-            //log_verbose1("DEBUG C");
-            status = SSL_read(sock.ssl, &buffer[totalRead], total - totalRead);
-            }
-            //log_verbose3("DEBUG D char: %d status: %d", 
-            //             buffer[totalRead], SSL_get_error(sock.ssl, status));
+        if (ret == SOCKET_ERROR)
+        {
+          wsa_error = WSAGetLastError ();
+          log_error2 ("WSAGetLastError()=%d", wsa_error);
+          return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+                             "Socket error: %d", errno);
+
+        }
+#endif
+        if (ret == 0)
+        {
+          log_verbose1 ("Socket timeout");
+          return herror_new ("hsocket_read", HSOCKET_SSL_CLOSE, "Timeout");
+        }
+        else
+        {
+          // log_verbose1("DEBUG C");
+          status = SSL_read (sock.ssl, &buffer[totalRead], total - totalRead);
         }
-        //} while( SSL_get_error(sock.ssl, status) == SSL_ERROR_WANT_READ);
+        // log_verbose3("DEBUG D char: %d status: %d", 
+        // buffer[totalRead], SSL_get_error(sock.ssl, status));
+      }
+      // } while( SSL_get_error(sock.ssl, status) == SSL_ERROR_WANT_READ);
 #ifdef WIN32
 #else
-        fcntl( sock.sock, F_SETFL, 0);
+      fcntl (sock.sock, F_SETFL, 0);
 #endif
-    } else {
+    }
+    else
+    {
 #else // HAVE_SSL
     {
-#endif //HAVE_SSL
-        status = recv(sock.sock, &buffer[totalRead], total - totalRead, 0);
+#endif // HAVE_SSL
+      status = recv (sock.sock, &buffer[totalRead], total - totalRead, 0);
 
 #ifdef WIN32
-        if (status == INVALID_SOCKET) 
+      if (status == INVALID_SOCKET)
+      {
+        wsa_error = WSAGetLastError ();
+        switch (wsa_error)
         {
-            wsa_error = WSAGetLastError();
-            switch (wsa_error)
-            {
-              case WSAEWOULDBLOCK: 
-             /* case WSAEALREADY:
-              case WSAEINPROGRESS:        */
-                 continue;
-              default:
-                 log_error2("WSAGetLastError()=%d", wsa_error);
-                return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
-            }
+        case WSAEWOULDBLOCK:
+          /* case WSAEALREADY: case WSAEINPROGRESS: */
+          continue;
+        default:
+          log_error2 ("WSAGetLastError()=%d", wsa_error);
+          return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+                             "Socket error: %d", errno);
         }
+      }
     }
 #else
     }
@@ -548,66 +597,75 @@ hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *receive
 */
 
 #ifdef HAVE_SSL
-    if( sock.ssl && status < 1 ){
+    if (sock.ssl && status < 1)
+    {
 
-        // XXX I'm not sure this err_syscall is right here...
-        if( SSL_get_shutdown( sock.ssl ) == SSL_RECEIVED_SHUTDOWN ||
-            SSL_get_error(sock.ssl, status) == SSL_ERROR_SYSCALL){
-            *received = NULL;;
-            return herror_new("hsocket_read", HSOCKET_SSL_CLOSE, "SSL Closed");
-        }
-        log_error2("Read error (%d)", status);
-        log_ssl_error( sock.ssl, status );
-        return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "SSL Error");
+      // XXX I'm not sure this err_syscall is right here...
+      if (SSL_get_shutdown (sock.ssl) == SSL_RECEIVED_SHUTDOWN ||
+          SSL_get_error (sock.ssl, status) == SSL_ERROR_SYSCALL)
+      {
+        *received = NULL;;
+        return herror_new ("hsocket_read", HSOCKET_SSL_CLOSE, "SSL Closed");
+      }
+      log_error2 ("Read error (%d)", status);
+      log_ssl_error (sock.ssl, status);
+      return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE, "SSL Error");
     }
 #endif
     if (status == -1)
-		return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
-#endif
-    
-    if (!force) {
-		*received = status;
-		/*
-		log_verbose3("Leaving !force (received=%d)(status=%d)", *received, status);
-		*/
-        return H_OK;
+      return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+                         "Socket error: %d", errno);
+#endif
+
+    if (!force)
+    {
+      *received = status;
+      /* 
+         log_verbose3("Leaving !force (received=%d)(status=%d)", *received,
+         status); */
+      return H_OK;
     }
-    
+
     totalRead += status;
 
-    if (totalRead == total) {
-		*received = totalRead;
-		/*
-		log_verbose4("Leaving totalRead == total (received=%d)(status=%d)(totalRead=%d)", *received, status, totalRead);
-		*/
-        return H_OK;
+    if (totalRead == total)
+    {
+      *received = totalRead;
+      /* 
+         log_verbose4("Leaving totalRead == total
+         (received=%d)(status=%d)(totalRead=%d)", *received, status,
+         totalRead); */
+      return H_OK;
     }
-  } while (1);
+  }
+  while (1);
 }
 
 
 herror_t
-hsocket_block(hsocket_t sock, int block)
+hsocket_block (hsocket_t sock, int block)
 {
 #ifdef WIN32
   unsigned long iMode;
 #endif
 
   if (sock.sock <= 0)
-	return herror_new("hsocket_block", HSOCKET_ERROR_NOT_INITIALIZED, 
-	 "Called hsocket_listen() before initializing!");
+    return herror_new ("hsocket_block", HSOCKET_ERROR_NOT_INITIALIZED,
+                       "Called hsocket_listen() before initializing!");
 
 #ifdef WIN32
 /*#define HSOCKET_BLOCKMODE 0
 #define HSOCKET_NONBLOCKMODE 1
 */
 
-  iMode = (block==0)?1:0; /* Non block mode */
-  if (ioctlsocket (sock.sock, FIONBIO, (u_long FAR *) & iMode) == INVALID_SOCKET)
+  iMode = (block == 0) ? 1 : 0; /* Non block mode */
+  if (ioctlsocket (sock.sock, FIONBIO, (u_long FAR *) & iMode) ==
+      INVALID_SOCKET)
   {
-    int err = WSAGetLastError();
+    int err = WSAGetLastError ();
     log_error2 ("ioctlsocket error %d", err);
-	return herror_new("hsocket_block", HSOCKET_ERROR_IOCTL, "Socket error: %d", err);
+    return herror_new ("hsocket_block", HSOCKET_ERROR_IOCTL,
+                       "Socket error: %d", err);
   }
 #else /* fcntl(sock, F_SETFL, O_NONBLOCK); */
 /* TODO (#1#): check for *nix the non blocking sockets */
@@ -615,5 +673,3 @@ hsocket_block(hsocket_t sock, int block)
 #endif
   return H_OK;
 }
-
-