First pass at applying KNF to the OpenSSL code, which almost makes it

readable. This pass is whitespace only and can readily be verified using
tr and md5.

1 files changed, 503 insertions, 522 deletions

diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c
index bd43307456..d739452580 100644
--- a/src/lib/libcrypto/bio/b_sock.c
+++ b/src/lib/libcrypto/bio/b_sock.c
@@ -85,7 +85,7 @@ NETDB_DEFINE_CONTEXT
 #endif
 
 #if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
-static int wsa_init_done=0;
+static int wsa_init_done = 0;
 #endif
 
 /*
@@ -100,36 +100,36 @@ static int wsa_init_done=0;
 #endif
 
 #if 0
-static unsigned long BIO_ghbn_hits=0L;
-static unsigned long BIO_ghbn_miss=0L;
+static unsigned long BIO_ghbn_hits = 0L;
+static unsigned long BIO_ghbn_miss = 0L;
 
 #define GHBN_NUM        4
-static struct ghbn_cache_st
-        {
+static struct ghbn_cache_st {
         char name[129];
         struct hostent *ent;
         unsigned long order;
-        } ghbn_cache[GHBN_NUM];
+} ghbn_cache[GHBN_NUM];
 #endif
 
-static int get_ip(const char *str,unsigned char *ip);
+static int get_ip(const char *str, unsigned char *ip);
 #if 0
 static void ghbn_free(struct hostent *a);
 static struct hostent *ghbn_dup(struct hostent *a);
 #endif
-int BIO_get_host_ip(const char *str, unsigned char *ip)
-        {
+
+int
+BIO_get_host_ip(const char *str, unsigned char *ip)
+{
         int i;
         int err = 1;
         int locked = 0;
         struct hostent *he;
 
-        i=get_ip(str,ip);
-        if (i < 0)
-                {
-                BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);
+        i = get_ip(str, ip);
+        if (i < 0) {
+                BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS);
                 goto err;
-                }
+        }
 
         /* At this point, we have something that is most probably correct
            in some way, so let's init the socket. */
@@ -138,172 +138,169 @@ int BIO_get_host_ip(const char *str, unsigned char *ip)
 
         /* If the string actually contained an IP address, we need not do
            anything more */
-        if (i > 0) return(1);
+        if (i > 0)
+                return (1);
 
         /* do a gethostbyname */
         CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
         locked = 1;
-        he=BIO_gethostbyname(str);
-        if (he == NULL)
-                {
-                BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
+        he = BIO_gethostbyname(str);
+        if (he == NULL) {
+                BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP);
                 goto err;
-                }
+        }
 
         /* cast to short because of win16 winsock definition */
-        if ((short)he->h_addrtype != AF_INET)
-                {
-                BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
+        if ((short)he->h_addrtype != AF_INET) {
+                BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
                 goto err;
-                }
-        for (i=0; i<4; i++)
-                ip[i]=he->h_addr_list[0][i];
+        }
+        for (i = 0; i < 4; i++)
+                ip[i] = he->h_addr_list[0][i];
         err = 0;
 
- err:
+err:
         if (locked)
                 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
-        if (err)
-                {
-                ERR_add_error_data(2,"host=",str);
+        if (err) {
+                ERR_add_error_data(2, "host=", str);
                 return 0;
-                }
-        else
+        } else
                 return 1;
-        }
+}
 
-int BIO_get_port(const char *str, unsigned short *port_ptr)
-        {
+int
+BIO_get_port(const char *str, unsigned short *port_ptr)
+{
         int i;
         struct servent *s;
 
-        if (str == NULL)
-                {
-                BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED);
-                return(0);
-                }
-        i=atoi(str);
+        if (str == NULL) {
+                BIOerr(BIO_F_BIO_GET_PORT, BIO_R_NO_PORT_DEFINED);
+                return (0);
+        }
+        i = atoi(str);
         if (i != 0)
-                *port_ptr=(unsigned short)i;
-        else
-                {
+                *port_ptr = (unsigned short)i;
+        else {
                 CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
                 /* Note: under VMS with SOCKETSHR, it seems like the first
                  * parameter is 'char *', instead of 'const char *'
                  */
 #ifndef CONST_STRICT
-                s=getservbyname((char *)str,"tcp");
+                s = getservbyname((char *)str, "tcp");
 #else
-                s=getservbyname(str,"tcp");
+                s = getservbyname(str, "tcp");
 #endif
-                if(s != NULL)
-                        *port_ptr=ntohs((unsigned short)s->s_port);
+                if (s != NULL)
+                        *port_ptr = ntohs((unsigned short)s->s_port);
                 CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
-                if(s == NULL)
-                        {
-                        if (strcmp(str,"http") == 0)
-                                *port_ptr=80;
-                        else if (strcmp(str,"telnet") == 0)
-                                *port_ptr=23;
-                        else if (strcmp(str,"socks") == 0)
-                                *port_ptr=1080;
-                        else if (strcmp(str,"https") == 0)
-                                *port_ptr=443;
-                        else if (strcmp(str,"ssl") == 0)
-                                *port_ptr=443;
-                        else if (strcmp(str,"ftp") == 0)
-                                *port_ptr=21;
-                        else if (strcmp(str,"gopher") == 0)
-                                *port_ptr=70;
+                if (s == NULL) {
+                        if (strcmp(str, "http") == 0)
+                                *port_ptr = 80;
+                        else if (strcmp(str, "telnet") == 0)
+                                *port_ptr = 23;
+                        else if (strcmp(str, "socks") == 0)
+                                *port_ptr = 1080;
+                        else if (strcmp(str, "https") == 0)
+                                *port_ptr = 443;
+                        else if (strcmp(str, "ssl") == 0)
+                                *port_ptr = 443;
+                        else if (strcmp(str, "ftp") == 0)
+                                *port_ptr = 21;
+                        else if (strcmp(str, "gopher") == 0)
+                                *port_ptr = 70;
 #if 0
-                        else if (strcmp(str,"wais") == 0)
-                                *port_ptr=21;
-#endif
-                        else
-                                {
-                                SYSerr(SYS_F_GETSERVBYNAME,errno);
-                                ERR_add_error_data(3,"service='",str,"'");
-                                return(0);
-                                }
+                        else if (strcmp(str, "wais") == 0)
+                                *port_ptr = 21;
+#endif
+                        else {
+                                SYSerr(SYS_F_GETSERVBYNAME, errno);
+                                ERR_add_error_data(3, "service = '", str, "'");
+                                return (0);
                         }
                 }
-        return(1);
         }
+        return (1);
+}
 
-int BIO_sock_error(int sock)
-        {
-        int j,i;
+int
+BIO_sock_error(int sock)
+{
+        int j, i;
         int size;
-                 
+
 #if defined(OPENSSL_SYS_BEOS_R5)
         return 0;
 #endif
-                 
-        size=sizeof(int);
+
+        size = sizeof(int);
         /* Note: under Windows the third parameter is of type (char *)
          * whereas under other systems it is (void *) if you don't have
          * a cast it will choke the compiler: if you do have a cast then
          * you can either go for (char *) or (void *).
          */
-        i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size);
+        i = getsockopt(sock, SOL_SOCKET, SO_ERROR,(void *)&j,(void *)&size);
         if (i < 0)
-                return(1);
+                return (1);
         else
-                return(j);
-        }
+                return (j);
+}
 
 #if 0
-long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
-        {
+long
+BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
+{
         int i;
         char **p;
 
-        switch (cmd)
-                {
+        switch (cmd) {
         case BIO_GHBN_CTRL_HITS:
-                return(BIO_ghbn_hits);
+                return (BIO_ghbn_hits);
                 /* break; */
         case BIO_GHBN_CTRL_MISSES:
-                return(BIO_ghbn_miss);
+                return (BIO_ghbn_miss);
                 /* break; */
         case BIO_GHBN_CTRL_CACHE_SIZE:
-                return(GHBN_NUM);
+                return (GHBN_NUM);
                 /* break; */
         case BIO_GHBN_CTRL_GET_ENTRY:
-                if ((iarg >= 0) && (iarg <GHBN_NUM) &&
-                        (ghbn_cache[iarg].order > 0))
-                        {
-                        p=(char **)parg;
-                        if (p == NULL) return(0);
-                        *p=ghbn_cache[iarg].name;
-                        ghbn_cache[iarg].name[128]='\0';
-                        return(1);
-                        }
-                return(0);
+                if ((iarg >= 0) && (iarg < GHBN_NUM) &&
+                    (ghbn_cache[iarg].order > 0)) {
+                        p = (char **)parg;
+                        if (p == NULL)
+                                return (0);
+                        *p = ghbn_cache[iarg].name;
+                        ghbn_cache[iarg].name[128] = '\0';
+                        return (1);
+                }
+                return (0);
                 /* break; */
         case BIO_GHBN_CTRL_FLUSH:
-                for (i=0; i<GHBN_NUM; i++)
-                        ghbn_cache[i].order=0;
+                for (i = 0; i < GHBN_NUM; i++)
+                        ghbn_cache[i].order = 0;
                 break;
         default:
-                return(0);
-                }
-        return(1);
+                return (0);
         }
+        return (1);
+}
 #endif
 
 #if 0
-static struct hostent *ghbn_dup(struct hostent *a)
-        {
+static struct hostent
+*ghbn_dup(struct hostent *a)
+{
         struct hostent *ret;
-        int i,j;
+        int i, j;
 
         MemCheck_off();
-        ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
-        if (ret == NULL) return(NULL);
-        memset(ret,0,sizeof(struct hostent));
+        ret = (struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
+        if (ret == NULL)
+                return (NULL);
+        memset(ret, 0, sizeof(struct hostent));
 
-        for (i=0; a->h_aliases[i] != NULL; i++)
+        for (i = 0; a->h_aliases[i] != NULL; i++)
                 ;
         i++;
         ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
@@ -311,69 +308,66 @@ static struct hostent *ghbn_dup(struct hostent *a)
                 goto err;
         memset(ret->h_aliases, 0, i*sizeof(char *));
 
-        for (i=0; a->h_addr_list[i] != NULL; i++)
+        for (i = 0; a->h_addr_list[i] != NULL; i++)
                 ;
         i++;
-        ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));
+        ret->h_addr_list = (char **)OPENSSL_malloc(i*sizeof(char *));
         if (ret->h_addr_list == NULL)
                 goto err;
         memset(ret->h_addr_list, 0, i*sizeof(char *));
 
-        j=strlen(a->h_name)+1;
-        if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;
-        memcpy((char *)ret->h_name,a->h_name,j);
-        for (i=0; a->h_aliases[i] != NULL; i++)
-                {
-                j=strlen(a->h_aliases[i])+1;
-                if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;
-                memcpy(ret->h_aliases[i],a->h_aliases[i],j);
-                }
-        ret->h_length=a->h_length;
-        ret->h_addrtype=a->h_addrtype;
-        for (i=0; a->h_addr_list[i] != NULL; i++)
-                {
-                if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
+        j = strlen(a->h_name) + 1;
+        if ((ret->h_name = OPENSSL_malloc(j)) == NULL) goto err;
+                memcpy((char *)ret->h_name, a->h_name, j);
+        for (i = 0; a->h_aliases[i] != NULL; i++) {
+                j = strlen(a->h_aliases[i]) + 1;
+                if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL) goto err;
+                        memcpy(ret->h_aliases[i], a->h_aliases[i], j);
+        }
+        ret->h_length = a->h_length;
+        ret->h_addrtype = a->h_addrtype;
+        for (i = 0; a->h_addr_list[i] != NULL; i++) {
+                if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL)
                         goto err;
-                memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
-                }
-        if (0)
-                {
-err:    
+                memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length);
+        }
+        if (0) {
+err:
                 if (ret != NULL)
                         ghbn_free(ret);
-                ret=NULL;
-                }
-        MemCheck_on();
-        return(ret);
+                ret = NULL;
         }
+        MemCheck_on();
+        return (ret);
+}
 
-static void ghbn_free(struct hostent *a)
-        {
+static void
+ghbn_free(struct hostent *a)
+{
         int i;
 
-        if(a == NULL)
-            return;
+        if (a == NULL)
+                return;
 
-        if (a->h_aliases != NULL)
-                {
-                for (i=0; a->h_aliases[i] != NULL; i++)
+        if (a->h_aliases != NULL) {
+                for (i = 0; a->h_aliases[i] != NULL; i++)
                         OPENSSL_free(a->h_aliases[i]);
                 OPENSSL_free(a->h_aliases);
-                }
-        if (a->h_addr_list != NULL)
-                {
-                for (i=0; a->h_addr_list[i] != NULL; i++)
+        }
+        if (a->h_addr_list != NULL) {
+                for (i = 0; a->h_addr_list[i] != NULL; i++)
                         OPENSSL_free(a->h_addr_list[i]);
                 OPENSSL_free(a->h_addr_list);
-                }
-        if (a->h_name != NULL) OPENSSL_free(a->h_name);
-        OPENSSL_free(a);
         }
+        if (a->h_name != NULL)
+                OPENSSL_free(a->h_name);
+        OPENSSL_free(a);
+}
 
 #endif
 
-struct hostent *BIO_gethostbyname(const char *name)
-        {
+struct hostent
+*BIO_gethostbyname(const char *name) {
 #if 1
         /* Caching gethostbyname() results forever is wrong,
          * so we have to let the true gethostbyname() worry about this */
@@ -384,8 +378,8 @@ struct hostent *BIO_gethostbyname(const char *name)
 #endif
 #else
         struct hostent *ret;
-        int i,lowi=0,j;
-        unsigned long low= (unsigned long)-1;
+        int i, lowi = 0, j;
+        unsigned long low = (unsigned long) - 1;
 
 
 #  if 0
@@ -395,42 +389,37 @@ struct hostent *BIO_gethostbyname(const char *name)
          */
         CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
 #  endif
-        j=strlen(name);
-        if (j < 128)
-                {
-                for (i=0; i<GHBN_NUM; i++)
-                        {
-                        if (low > ghbn_cache[i].order)
-                                {
-                                low=ghbn_cache[i].order;
-                                lowi=i;
-                                }
-                        if (ghbn_cache[i].order > 0)
-                                {
-                                if (strncmp(name,ghbn_cache[i].name,128) == 0)
+        j = strlen(name);
+        if (j < 128) {
+                for (i = 0; i < GHBN_NUM; i++) {
+                        if (low > ghbn_cache[i].order) {
+                                low = ghbn_cache[i].order;
+                                lowi = i;
+                        }
+                        if (ghbn_cache[i].order > 0) {
+                                if (strncmp(name, ghbn_cache[i].name, 128) == 0)
                                         break;
-                                }
                         }
                 }
-        else
-                i=GHBN_NUM;
+        } else
+                i = GHBN_NUM;
 
         if (i == GHBN_NUM) /* no hit*/
-                {
+        {
                 BIO_ghbn_miss++;
                 /* Note: under VMS with SOCKETSHR, it seems like the first
                  * parameter is 'char *', instead of 'const char *'
                  */
 #  ifndef CONST_STRICT
-                ret=gethostbyname((char *)name);
+                ret = gethostbyname((char *)name);
 #  else
-                ret=gethostbyname(name);
+                ret = gethostbyname(name);
 #  endif
 
                 if (ret == NULL)
                         goto end;
                 if (j > 128) /* too big to cache */
-                        {
+                {
 #  if 0
                         /* If we were trying to make this function thread-safe (which
                          * is bound to fail), we'd have to give up in this case
@@ -438,118 +427,113 @@ struct hostent *BIO_gethostbyname(const char *name)
                         ret = NULL;
 #  endif
                         goto end;
-                        }
+                }
 
                 /* else add to cache */
                 if (ghbn_cache[lowi].ent != NULL)
                         ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
                 ghbn_cache[lowi].name[0] = '\0';
 
-                if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL)
-                        {
-                        BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE);
+                if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) {
+                        BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE);
                         goto end;
-                        }
-                strncpy(ghbn_cache[lowi].name,name,128);
-                ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits;
                 }
-        else
-                {
+                strncpy(ghbn_cache[lowi].name, name, 128);
+                ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits;
+        } else {
                 BIO_ghbn_hits++;
-                ret= ghbn_cache[i].ent;
-                ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits;
-                }
+                ret = ghbn_cache[i].ent;
+                ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits;
+        }
 end:
 #  if 0
         CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
 #  endif
-        return(ret);
+        return (ret);
 #endif
-        }
+}
 
 
-int BIO_sock_init(void)
-        {
+int
+BIO_sock_init(void)
+{
 #ifdef OPENSSL_SYS_WINDOWS
         static struct WSAData wsa_state;
 
-        if (!wsa_init_done)
-                {
+        if (!wsa_init_done) {
                 int err;
-          
-                wsa_init_done=1;
-                memset(&wsa_state,0,sizeof(wsa_state));
+
+                wsa_init_done = 1;
+                memset(&wsa_state, 0, sizeof(wsa_state));
                 /* Not making wsa_state available to the rest of the
                  * code is formally wrong. But the structures we use
                  * are [beleived to be] invariable among Winsock DLLs,
                  * while API availability is [expected to be] probed
                  * at run-time with DSO_global_lookup. */
-                if (WSAStartup(0x0202,&wsa_state)!=0)
-                        {
-                        err=WSAGetLastError();
-                        SYSerr(SYS_F_WSASTARTUP,err);
-                        BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
-                        return(-1);
-                        }
+                if (WSAStartup(0x0202, &wsa_state) != 0) {
+                        err = WSAGetLastError();
+                        SYSerr(SYS_F_WSASTARTUP, err);
+                        BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
+                        return (-1);
                 }
+        }
 #endif /* OPENSSL_SYS_WINDOWS */
 #ifdef WATT32
         extern int _watt_do_exit;
-        _watt_do_exit = 0;    /* don't make sock_init() call exit() */
+        _watt_do_exit = 0;
+        /* don't make sock_init() call exit() */
         if (sock_init())
                 return (-1);
 #endif
 
 #if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
-    WORD wVerReq;
-    WSADATA wsaData;
-    int err;
-
-    if (!wsa_init_done)
-    {
-        wsa_init_done=1;
-        wVerReq = MAKEWORD( 2, 0 );
-        err = WSAStartup(wVerReq,&wsaData);
-        if (err != 0)
-        {
-            SYSerr(SYS_F_WSASTARTUP,err);
-            BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
-            return(-1);
-                        }
+        WORD wVerReq;
+        WSADATA wsaData;
+        int err;
+
+        if (!wsa_init_done) {
+                wsa_init_done = 1;
+                wVerReq = MAKEWORD( 2, 0 );
+                err = WSAStartup(wVerReq, &wsaData);
+                if (err != 0) {
+                        SYSerr(SYS_F_WSASTARTUP, err);
+                        BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
+                        return (-1);
                 }
+        }
 #endif
 
-        return(1);
-        }
+        return (1);
+}
 
-void BIO_sock_cleanup(void)
-        {
+void
+BIO_sock_cleanup(void)
+{
 #ifdef OPENSSL_SYS_WINDOWS
-        if (wsa_init_done)
-                {
-                wsa_init_done=0;
+        if (wsa_init_done) {
+                wsa_init_done = 0;
 #if 0           /* this call is claimed to be non-present in Winsock2 */
                 WSACancelBlockingCall();
 #endif
                 WSACleanup();
-                }
+        }
 #elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
-   if (wsa_init_done)
-        {
-        wsa_init_done=0;
-        WSACleanup();
-                }
-#endif
+        if (wsa_init_done) {
+                wsa_init_done = 0;
+                WSACleanup();
         }
+#endif
+}
 
 #if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
 
-int BIO_socket_ioctl(int fd, long type, void *arg)
-        {
+int
+BIO_socket_ioctl(int fd, long type, void *arg)
+{
         int i;
 
 #ifdef __DJGPP__
-        i=ioctl(fd,type,(char *)arg);
+        i = ioctl(fd, type,(char *)arg);
 #else
 # if defined(OPENSSL_SYS_VMS)
         /* 2011-02-18 SMS.
@@ -574,402 +558,399 @@ int BIO_socket_ioctl(int fd, long type, void *arg)
 #  define ARG arg
 # endif /* defined(OPENSSL_SYS_VMS) [else] */
 
-        i=ioctl(fd,type,ARG);
+        i = ioctl(fd, type, ARG);
 #endif /* __DJGPP__ */
         if (i < 0)
-                SYSerr(SYS_F_IOCTLSOCKET,errno);
-        return(i);
-        }
+                SYSerr(SYS_F_IOCTLSOCKET, errno);
+        return (i);
+}
 #endif /* __VMS_VER */
 
 /* The reason I have implemented this instead of using sscanf is because
  * Visual C 1.52c gives an unresolved external when linking a DLL :-( */
-static int get_ip(const char *str, unsigned char ip[4])
-        {
+static int
+get_ip(const char *str, unsigned char ip[4])
+{
         unsigned int tmp[4];
-        int num=0,c,ok=0;
+        int num = 0, c, ok = 0;
 
-        tmp[0]=tmp[1]=tmp[2]=tmp[3]=0;
+        tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
 
-        for (;;)
-                {
+        for (;;) {
                 c= *(str++);
-                if ((c >= '0') && (c <= '9'))
-                        {
-                        ok=1;
-                        tmp[num]=tmp[num]*10+c-'0';
-                        if (tmp[num] > 255) return(0);
-                        }
-                else if (c == '.')
-                        {
-                        if (!ok) return(-1);
-                        if (num == 3) return(0);
+                if ((c >= '0') && (c <= '9')) {
+                        ok = 1;
+                        tmp[num] = tmp[num]*10 + c-'0';
+                        if (tmp[num] > 255)
+                                return (0);
+                } else if (c == '.') {
+                        if (!ok)
+                                return (-1);
+                        if (num == 3)
+                                return (0);
                         num++;
-                        ok=0;
-                        }
-                else if (c == '\0' && (num == 3) && ok)
-                        break;
+                        ok = 0;
+                } else if (c == '\0' && (num == 3) && ok)
+                break;
                 else
-                        return(0);
-                }
-        ip[0]=tmp[0];
-        ip[1]=tmp[1];
-        ip[2]=tmp[2];
-        ip[3]=tmp[3];
-        return(1);
+                        return (0);
         }
-
-int BIO_get_accept_socket(char *host, int bind_mode)
-        {
-        int ret=0;
+        ip[0] = tmp[0];
+        ip[1] = tmp[1];
+        ip[2] = tmp[2];
+        ip[3] = tmp[3];
+        return (1);
+}
+
+int
+BIO_get_accept_socket(char *host, int bind_mode)
+{
+        int ret = 0;
         union {
                 struct sockaddr sa;
                 struct sockaddr_in sa_in;
 #if OPENSSL_USE_IPV6
                 struct sockaddr_in6 sa_in6;
 #endif
-        } server,client;
-        int s=-1,cs,addrlen;
+        } server, client;
+        int s = -1, cs, addrlen;
         unsigned char ip[4];
         unsigned short port;
-        char *str=NULL,*e;
-        char *h,*p;
+        char *str = NULL, *e;
+        char *h, *p;
         unsigned long l;
         int err_num;
 
-        if (BIO_sock_init() != 1) return(-1);
+        if (BIO_sock_init() != 1)
+                return (-1);
 
-        if ((str=BUF_strdup(host)) == NULL) return(-1);
+        if ((str = BUF_strdup(host)) == NULL)
+                return (-1);
 
-        h=p=NULL;
-        h=str;
-        for (e=str; *e; e++)
-                {
-                if (*e == ':')
-                        {
-                        p=e;
-                        }
-                else if (*e == '/')
-                        {
-                        *e='\0';
+        h = p = NULL;
+        h = str;
+        for (e = str; *e; e++) {
+                if (*e == ':') {
+                        p = e;
+                } else if (*e == '/') {
+                        *e = '\0';
                         break;
-                        }
                 }
-        if (p)  *p++='\0';      /* points at last ':', '::port' is special [see below] */
-        else    p=h,h=NULL;
+        }
+        if (p)
+                *p++='\0';      /* points at last ':', '::port' is special [see below] */
+        else
+                p = h, h = NULL;
 
 #ifdef EAI_FAMILY
         do {
-        static union {  void *p;
-                        int (WSAAPI *f)(const char *,const char *,
-                                 const struct addrinfo *,
-                                 struct addrinfo **);
-                        } p_getaddrinfo = {NULL};
-        static union {  void *p;
+                static union {
+                        void *p;
+                        int (WSAAPI *f)(const char *, const char *,
+                        const struct addrinfo *,
+                        struct addrinfo **);
+                } p_getaddrinfo = {NULL};
+                static union {
+                        void *p;
                         void (WSAAPI *f)(struct addrinfo *);
-                        } p_freeaddrinfo = {NULL};
-        struct addrinfo *res,hint;
-
-        if (p_getaddrinfo.p==NULL)
-                {
-                if ((p_getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL ||
-                    (p_freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL)
-                        p_getaddrinfo.p=(void*)-1;
-                }
-        if (p_getaddrinfo.p==(void *)-1) break;
-
-        /* '::port' enforces IPv6 wildcard listener. Some OSes,
-         * e.g. Solaris, default to IPv6 without any hint. Also
-         * note that commonly IPv6 wildchard socket can service
-         * IPv4 connections just as well...  */
-        memset(&hint,0,sizeof(hint));
-        hint.ai_flags = AI_PASSIVE;
-        if (h)
-                {
-                if (strchr(h,':'))
-                        {
-                        if (h[1]=='\0') h=NULL;
+                } p_freeaddrinfo = {NULL};
+                struct addrinfo *res, hint;
+
+                if (p_getaddrinfo.p == NULL) {
+                        if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo"))==NULL ||
+                            (p_freeaddrinfo.p = DSO_global_lookup("freeaddrinfo"))==NULL)
+                        p_getaddrinfo.p = (void*) - 1;
+                }
+                if (p_getaddrinfo.p == (void *) - 1) break;
+
+                /* '::port' enforces IPv6 wildcard listener. Some OSes,
+                 * e.g. Solaris, default to IPv6 without any hint. Also
+                 * note that commonly IPv6 wildchard socket can service
+                 * IPv4 connections just as well...  */
+                memset(&hint, 0, sizeof(hint));
+                hint.ai_flags = AI_PASSIVE;
+                if (h) {
+                        if (strchr(h, ':')) {
+                                if (h[1] == '\0')
+                                        h = NULL;
 #if OPENSSL_USE_IPV6
-                        hint.ai_family = AF_INET6;
+                                hint.ai_family = AF_INET6;
 #else
-                        h=NULL;
+                                h = NULL;
 #endif
-                        }
-                else if (h[0]=='*' && h[1]=='\0')
-                        {
-                        hint.ai_family = AF_INET;
-                        h=NULL;
+                        } else if (h[0] == '*' && h[1] == '\0') {
+                                hint.ai_family = AF_INET;
+                                h = NULL;
                         }
                 }
 
-        if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break;
+                if ((*p_getaddrinfo.f)(h, p, &hint, &res))
+                        break;
 
-        addrlen = res->ai_addrlen<=sizeof(server) ?
-                        res->ai_addrlen :
-                        sizeof(server);
-        memcpy(&server, res->ai_addr, addrlen);
+                addrlen = res->ai_addrlen <= sizeof(server) ?
+                    res->ai_addrlen : sizeof(server);
+                memcpy(&server, res->ai_addr, addrlen);
 
-        (*p_freeaddrinfo.f)(res);
-        goto again;
+                (*p_freeaddrinfo.f)(res);
+                goto again;
         } while (0);
 #endif
 
-        if (!BIO_get_port(p,&port)) goto err;
+        if (!BIO_get_port(p, &port))
+                goto err;
 
-        memset((char *)&server,0,sizeof(server));
-        server.sa_in.sin_family=AF_INET;
-        server.sa_in.sin_port=htons(port);
+        memset((char *)&server, 0, sizeof(server));
+        server.sa_in.sin_family = AF_INET;
+        server.sa_in.sin_port = htons(port);
         addrlen = sizeof(server.sa_in);
 
-        if (h == NULL || strcmp(h,"*") == 0)
-                server.sa_in.sin_addr.s_addr=INADDR_ANY;
-        else
-                {
-                if (!BIO_get_host_ip(h,&(ip[0]))) goto err;
-                l=(unsigned long)
-                        ((unsigned long)ip[0]<<24L)|
-                        ((unsigned long)ip[1]<<16L)|
-                        ((unsigned long)ip[2]<< 8L)|
-                        ((unsigned long)ip[3]);
-                server.sa_in.sin_addr.s_addr=htonl(l);
-                }
+        if (h == NULL || strcmp(h, "*") == 0)
+                server.sa_in.sin_addr.s_addr = INADDR_ANY;
+        else {
+                if (!BIO_get_host_ip(h, &(ip[0])))
+                        goto err;
+                l = (unsigned long)
+                    ((unsigned long)ip[0]<<24L)|
+                    ((unsigned long)ip[1]<<16L)|
+                    ((unsigned long)ip[2]<< 8L)|
+                    ((unsigned long)ip[3]);
+                server.sa_in.sin_addr.s_addr = htonl(l);
+        }
 
 again:
-        s=socket(server.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
-        if (s == -1)
-                {
-                SYSerr(SYS_F_SOCKET,errno);
-                ERR_add_error_data(3,"port='",host,"'");
-                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);
+        s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
+        if (s == -1) {
+                SYSerr(SYS_F_SOCKET, errno);
+                ERR_add_error_data(3, "port = '", host, "'");
+                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
                 goto err;
-                }
+        }
 
 #ifdef SO_REUSEADDR
-        if (bind_mode == BIO_BIND_REUSEADDR)
-                {
-                int i=1;
+        if (bind_mode == BIO_BIND_REUSEADDR) {
+                int i = 1;
 
-                ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i));
-                bind_mode=BIO_BIND_NORMAL;
-                }
+                ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&i, sizeof(i));
+                bind_mode = BIO_BIND_NORMAL;
+        }
 #endif
-        if (bind(s,&server.sa,addrlen) == -1)
-                {
+        if (bind(s, &server.sa, addrlen) == -1) {
 #ifdef SO_REUSEADDR
-                err_num=errno;
+                err_num = errno;
                 if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
 #ifdef OPENSSL_SYS_WINDOWS
                         /* Some versions of Windows define EADDRINUSE to
                          * a dummy value.
                          */
-                        (err_num == WSAEADDRINUSE))
+                (err_num == WSAEADDRINUSE))
 #else
-                        (err_num == EADDRINUSE))
+                (err_num == EADDRINUSE))
 #endif
-                        {
+                {
                         client = server;
-                        if (h == NULL || strcmp(h,"*") == 0)
-                                {
+                        if (h == NULL || strcmp(h, "*") == 0) {
 #if OPENSSL_USE_IPV6
-                                if (client.sa.sa_family == AF_INET6)
-                                        {
-                                        memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr));
-                                        client.sa_in6.sin6_addr.s6_addr[15]=1;
-                                        }
-                                else
-#endif
-                                if (client.sa.sa_family == AF_INET)
-                                        {
-                                        client.sa_in.sin_addr.s_addr=htonl(0x7F000001);
-                                        }
-                                else    goto err;
-                                }
-                        cs=socket(client.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
-                        if (cs != -1)
-                                {
+                                if (client.sa.sa_family == AF_INET6) {
+                                        memset(&client.sa_in6.sin6_addr, 0, sizeof(client.sa_in6.sin6_addr));
+                                        client.sa_in6.sin6_addr.s6_addr[15] = 1;
+                                } else
+#endif
+                                if (client.sa.sa_family == AF_INET) {
+                                        client.sa_in.sin_addr.s_addr = htonl(0x7F000001);
+                                } else
+                                        goto err;
+                        }
+                        cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
+                        if (cs != -1) {
                                 int ii;
-                                ii=connect(cs,&client.sa,addrlen);
+                                ii = connect(cs, &client.sa, addrlen);
                                 close(cs);
-                                if (ii == -1)
-                                        {
-                                        bind_mode=BIO_BIND_REUSEADDR;
+                                if (ii == -1) {
+                                        bind_mode = BIO_BIND_REUSEADDR;
                                         close(s);
                                         goto again;
-                                        }
-                                /* else error */
                                 }
-                        /* else error */
+                                /* else error */
                         }
+                        /* else error */
+                }
 #endif
-                SYSerr(SYS_F_BIND,err_num);
-                ERR_add_error_data(3,"port='",host,"'");
-                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET);
+                SYSerr(SYS_F_BIND, err_num);
+                ERR_add_error_data(3, "port = '", host, "'");
+                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET);
                 goto err;
-                }
-        if (listen(s,MAX_LISTEN) == -1)
-                {
-                SYSerr(SYS_F_BIND,errno);
-                ERR_add_error_data(3,"port='",host,"'");
-                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET);
+        }
+        if (listen(s, MAX_LISTEN) == -1) {
+                SYSerr(SYS_F_BIND, errno);
+                ERR_add_error_data(3, "port = '", host, "'");
+                BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET);
                 goto err;
-                }
-        ret=1;
+        }
+        ret = 1;
 err:
-        if (str != NULL) OPENSSL_free(str);
-        if ((ret == 0) && (s != -1))
-                {
+        if (str != NULL)
+                OPENSSL_free(str);
+        if ((ret == 0) && (s != -1)) {
                 close(s);
-                s= -1;
-                }
-        return(s);
+                s = -1;
         }
+        return (s);
+}
 
-int BIO_accept(int sock, char **addr)
-        {
-        int ret=-1;
+int
+BIO_accept(int sock, char **addr)
+{
+        int ret = -1;
         unsigned long l;
         unsigned short port;
         char *p;
 
         struct {
-        /*
-         * As for following union. Trouble is that there are platforms
-         * that have socklen_t and there are platforms that don't, on
-         * some platforms socklen_t is int and on some size_t. So what
-         * one can do? One can cook #ifdef spaghetti, which is nothing
-         * but masochistic. Or one can do union between int and size_t.
-         * One naturally does it primarily for 64-bit platforms where
-         * sizeof(int) != sizeof(size_t). But would it work? Note that
-         * if size_t member is initialized to 0, then later int member
-         * assignment naturally does the job on little-endian platforms
-         * regardless accept's expectations! What about big-endians?
-         * If accept expects int*, then it works, and if size_t*, then
-         * length value would appear as unreasonably large. But this
-         * won't prevent it from filling in the address structure. The
-         * trouble of course would be if accept returns more data than
-         * actual buffer can accomodate and overwrite stack... That's
-         * where early OPENSSL_assert comes into picture. Besides, the
-         * only 64-bit big-endian platform found so far that expects
-         * size_t* is HP-UX, where stack grows towards higher address.
-         * <appro>
-         */
-        union { size_t s; int i; } len;
-        union {
-                struct sockaddr sa;
-                struct sockaddr_in sa_in;
+                /*
+                 * As for following union. Trouble is that there are platforms
+                 * that have socklen_t and there are platforms that don't, on
+                 * some platforms socklen_t is int and on some size_t. So what
+                 * one can do? One can cook #ifdef spaghetti, which is nothing
+                 * but masochistic. Or one can do union between int and size_t.
+                 * One naturally does it primarily for 64-bit platforms where
+                 * sizeof(int) != sizeof(size_t). But would it work? Note that
+                 * if size_t member is initialized to 0, then later int member
+                 * assignment naturally does the job on little-endian platforms
+                 * regardless accept's expectations! What about big-endians?
+                 * If accept expects int*, then it works, and if size_t*, then
+                 * length value would appear as unreasonably large. But this
+                 * won't prevent it from filling in the address structure. The
+                 * trouble of course would be if accept returns more data than
+                 * actual buffer can accomodate and overwrite stack... That's
+                 * where early OPENSSL_assert comes into picture. Besides, the
+                 * only 64-bit big-endian platform found so far that expects
+                 * size_t* is HP-UX, where stack grows towards higher address.
+                 * <appro>
+                 */
+                union {
+                        size_t s;
+                        int i;
+                } len;
+                union {
+                        struct sockaddr sa;
+                        struct sockaddr_in sa_in;
 #if OPENSSL_USE_IPV6
-                struct sockaddr_in6 sa_in6;
+                        struct sockaddr_in6 sa_in6;
 #endif
                 } from;
         } sa;
 
-        sa.len.s=0;
-        sa.len.i=sizeof(sa.from);
-        memset(&sa.from,0,sizeof(sa.from));
-        ret=accept(sock,&sa.from.sa,(void *)&sa.len);
-        if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0)
-                {
-                OPENSSL_assert(sa.len.s<=sizeof(sa.from));
+        sa.len.s = 0;
+        sa.len.i = sizeof(sa.from);
+        memset(&sa.from, 0, sizeof(sa.from));
+        ret = accept(sock, &sa.from.sa,(void *)&sa.len);
+        if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
+                OPENSSL_assert(sa.len.s <= sizeof(sa.from));
                 sa.len.i = (int)sa.len.s;
                 /* use sa.len.i from this point */
-                }
-        if (ret == -1)
-                {
-                if(BIO_sock_should_retry(ret)) return -2;
-                SYSerr(SYS_F_ACCEPT,errno);
-                BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR);
+        }
+        if (ret == -1) {
+                if (BIO_sock_should_retry(ret)) return -2;
+                        SYSerr(SYS_F_ACCEPT, errno);
+                BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR);
                 goto end;
-                }
+        }
 
-        if (addr == NULL) goto end;
+        if (addr == NULL)
+                goto end;
 
 #ifdef EAI_FAMILY
         do {
-        char   h[NI_MAXHOST],s[NI_MAXSERV];
-        size_t nl;
-        static union {  void *p;
-                        int (WSAAPI *f)(const struct sockaddr *,size_t/*socklen_t*/,
-                                 char *,size_t,char *,size_t,int);
-                        } p_getnameinfo = {NULL};
-                        /* 2nd argument to getnameinfo is specified to
-                         * be socklen_t. Unfortunately there is a number
-                         * of environments where socklen_t is not defined.
-                         * As it's passed by value, it's safe to pass it
-                         * as size_t... <appro> */
-
-        if (p_getnameinfo.p==NULL)
-                {
-                if ((p_getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL)
-                        p_getnameinfo.p=(void*)-1;
+                char   h[NI_MAXHOST], s[NI_MAXSERV];
+                size_t nl;
+                static union {
+                        void *p;
+                        int (WSAAPI *f)(const struct sockaddr *,
+                            size_t/*socklen_t*/, char *, size_t,
+                            char *, size_t, int);
+                } p_getnameinfo = {NULL};
+                /* 2nd argument to getnameinfo is specified to
+                 * be socklen_t. Unfortunately there is a number
+                 * of environments where socklen_t is not defined.
+                 * As it's passed by value, it's safe to pass it
+                 * as size_t... <appro> */
+
+                if (p_getnameinfo.p == NULL) {
+                        if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL)
+                                p_getnameinfo.p = (void*) - 1;
+                }
+                if (p_getnameinfo.p == (void *) - 1)
+                        break;
+
+                if ((*p_getnameinfo.f)(&sa.from.sa, sa.len.i, h, sizeof(h),
+                    s, sizeof(s), NI_NUMERICHOST|NI_NUMERICSERV))
+                        break;
+                nl = strlen(h) + strlen(s) + 2;
+                p = *addr;
+                if (p) {
+                        *p = '\0';
+                        p = OPENSSL_realloc(p, nl);
+                } else {
+                        p = OPENSSL_malloc(nl);
+                }
+                if (p == NULL) {
+                        BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
+                        goto end;
                 }
-        if (p_getnameinfo.p==(void *)-1) break;
-
-        if ((*p_getnameinfo.f)(&sa.from.sa,sa.len.i,h,sizeof(h),s,sizeof(s),
-            NI_NUMERICHOST|NI_NUMERICSERV)) break;
-        nl = strlen(h)+strlen(s)+2;
-        p = *addr;
-        if (p)  { *p = '\0'; p = OPENSSL_realloc(p,nl); }
-        else    { p = OPENSSL_malloc(nl);               }
-        if (p==NULL)
-                {
-                BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
+                *addr = p;
+                (void) snprintf(*addr, nl, "%s:%s", h, s);
                 goto end;
-                }
-        *addr = p;
-        (void) snprintf(*addr,nl,"%s:%s",h,s);
-        goto end;
-        } while(0);
-#endif
-        if (sa.from.sa.sa_family != AF_INET) goto end;
-        l=ntohl(sa.from.sa_in.sin_addr.s_addr);
-        port=ntohs(sa.from.sa_in.sin_port);
-        if (*addr == NULL)
-                {
-                if ((p=OPENSSL_malloc(24)) == NULL)
-                        {
-                        BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
+        } while (0);
+#endif
+        if (sa.from.sa.sa_family != AF_INET)
+                goto end;
+        l = ntohl(sa.from.sa_in.sin_addr.s_addr);
+        port = ntohs(sa.from.sa_in.sin_port);
+        if (*addr == NULL) {
+                if ((p = OPENSSL_malloc(24)) == NULL) {
+                        BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
                         goto end;
-                        }
-                *addr=p;
                 }
-        (void) snprintf(*addr,24,"%d.%d.%d.%d:%d",
-                     (unsigned char)(l>>24L)&0xff,
-                     (unsigned char)(l>>16L)&0xff,
-                     (unsigned char)(l>> 8L)&0xff,
-                     (unsigned char)(l     )&0xff,
-                     port);
-end:
-        return(ret);
+                *addr = p;
         }
+        (void) snprintf(*addr, 24, "%d.%d.%d.%d:%d",
+            (unsigned char)(l >> 24L) & 0xff, (unsigned char)(l >> 16L) & 0xff,
+            (unsigned char)(l >> 8L) & 0xff, (unsigned char)(l) & 0xff, port);
 
-int BIO_set_tcp_ndelay(int s, int on)
-        {
-        int ret=0;
+end:
+        return (ret);
+}
+
+int
+BIO_set_tcp_ndelay(int s, int on)
+{
+        int ret = 0;
 #if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
         int opt;
 
 #ifdef SOL_TCP
-        opt=SOL_TCP;
+        opt = SOL_TCP;
 #else
 #ifdef IPPROTO_TCP
-        opt=IPPROTO_TCP;
+        opt = IPPROTO_TCP;
 #endif
 #endif
-        
-        ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on));
+
+        ret = setsockopt(s, opt, TCP_NODELAY,(char *)&on, sizeof(on));
 #endif
-        return(ret == 0);
-        }
+        return (ret == 0);
+}
 
-int BIO_socket_nbio(int s, int mode)
-        {
-        int ret= -1;
+int
+BIO_socket_nbio(int s, int mode)
+{
+        int ret = -1;
         int l;
 
-        l=mode;
+        l = mode;
 #ifdef FIONBIO
-        ret=BIO_socket_ioctl(s,FIONBIO,&l);
+        ret = BIO_socket_ioctl(s, FIONBIO, &l);
 #endif
-        return(ret == 0);
-        }
+        return (ret == 0);
+}
 #endif