Reformat tests/gss-threads

1 files changed, 193 insertions, 193 deletions

diff --git a/src/tests/gss-threads/gss-server.c b/src/tests/gss-threads/gss-server.c
index 532ee86a62..515ff4ca85 100644
--- a/src/tests/gss-threads/gss-server.c
+++ b/src/tests/gss-threads/gss-server.c
@@ -73,14 +73,16 @@
 #include <strings.h>
 #endif
 
-static void usage()
+static void
+usage()
 {
     fprintf(stderr, "Usage: gss-server [-port port] [-verbose] [-once]");
 #ifdef _WIN32
     fprintf(stderr, " [-threads num]");
 #endif
     fprintf(stderr, "\n");
-    fprintf(stderr, "       [-inetd] [-export] [-logfile file] service_name\n");
+    fprintf(stderr, "       [-inetd] [-export] [-logfile file] "
+            "service_name\n");
     exit(1);
 }
 
@@ -107,9 +109,8 @@ int verbose = 0;
  * fails, an error message is displayed and -1 is returned; otherwise,
  * 0 is returned.
  */
-static int server_acquire_creds(service_name, server_creds)
-    char *service_name;
-    gss_cred_id_t *server_creds;
+static int
+server_acquire_creds(char *service_name, gss_cred_id_t *server_creds)
 {
     gss_buffer_desc name_buf;
     gss_name_t server_name;
@@ -118,7 +119,7 @@ static int server_acquire_creds(service_name, server_creds)
     name_buf.value = service_name;
     name_buf.length = strlen(name_buf.value) + 1;
     maj_stat = gss_import_name(&min_stat, &name_buf,
-                               (gss_OID) gss_nt_service_name, &server_name);
+                               (gss_OID)gss_nt_service_name, &server_name);
     if (maj_stat != GSS_S_COMPLETE) {
         display_status("importing name", maj_stat, min_stat);
         return -1;
@@ -132,7 +133,7 @@ static int server_acquire_creds(service_name, server_creds)
         return -1;
     }
 
-    (void) gss_release_name(&min_stat, &server_name);
+    (void)gss_release_name(&min_stat, &server_name);
 
     return 0;
 }
@@ -160,33 +161,30 @@ static int server_acquire_creds(service_name, server_creds)
  * in client_name and 0 is returned.  If unsuccessful, an error
  * message is displayed and -1 is returned.
  */
-static int server_establish_context(s, server_creds, context, client_name,
-                                    ret_flags)
-    int s;
-    gss_cred_id_t server_creds;
-    gss_ctx_id_t *context;
-    gss_buffer_t client_name;
-    OM_uint32 *ret_flags;
+static int
+server_establish_context(int s, gss_cred_id_t server_creds,
+                         gss_ctx_id_t *context, gss_buffer_t client_name,
+                         OM_uint32 *ret_flags)
 {
-    gss_buffer_desc send_tok, recv_tok;
+    gss_buffer_desc send_tok, recv_tok, oid_name;
     gss_name_t client;
     gss_OID doid;
     OM_uint32 maj_stat, min_stat, acc_sec_min_stat;
-    gss_buffer_desc    oid_name;
     int token_flags;
 
     if (recv_token(s, &token_flags, &recv_tok) < 0)
         return -1;
 
     if (recv_tok.value) {
-        free (recv_tok.value);
+        free(recv_tok.value);
         recv_tok.value = NULL;
     }
 
-    if (! (token_flags & TOKEN_NOOP)) {
-        if (logfile)
+    if (!(token_flags & TOKEN_NOOP)) {
+        if (logfile) {
             fprintf(logfile, "Expected NOOP token, got %d token instead\n",
                     token_flags);
+        }
         return -1;
     }
 
@@ -198,24 +196,18 @@ static int server_establish_context(s, server_creds, context, client_name,
                 return -1;
 
             if (verbose && logfile) {
-                fprintf(logfile, "Received token (size=%d): \n", (int) recv_tok.length);
+                fprintf(logfile, "Received token (size=%d): \n",
+                        (int)recv_tok.length);
                 print_token(&recv_tok);
             }
 
-            maj_stat =
-                gss_accept_sec_context(&acc_sec_min_stat,
-                                       context,
-                                       server_creds,
-                                       &recv_tok,
-                                       GSS_C_NO_CHANNEL_BINDINGS,
-                                       &client,
-                                       &doid,
-                                       &send_tok,
-                                       ret_flags,
-                                       NULL,         /* ignore time_rec */
-                                       NULL);        /* ignore del_cred_handle */
-
-            if(recv_tok.value) {
+            maj_stat = gss_accept_sec_context(&acc_sec_min_stat, context,
+                                              server_creds, &recv_tok,
+                                              GSS_C_NO_CHANNEL_BINDINGS,
+                                              &client, &doid, &send_tok,
+                                              ret_flags, NULL, NULL);
+
+            if (recv_tok.value) {
                 free(recv_tok.value);
                 recv_tok.value = NULL;
             }
@@ -224,7 +216,7 @@ static int server_establish_context(s, server_creds, context, client_name,
                 if (verbose && logfile) {
                     fprintf(logfile,
                             "Sending accept_sec_context token (size=%d):\n",
-                            (int) send_tok.length);
+                            (int)send_tok.length);
                     print_token(&send_tok);
                 }
                 if (send_token(s, TOKEN_CONTEXT, &send_tok) < 0) {
@@ -233,14 +225,16 @@ static int server_establish_context(s, server_creds, context, client_name,
                     return -1;
                 }
 
-                (void) gss_release_buffer(&min_stat, &send_tok);
+                (void)gss_release_buffer(&min_stat, &send_tok);
             }
-            if (maj_stat!=GSS_S_COMPLETE && maj_stat!=GSS_S_CONTINUE_NEEDED) {
+            if (maj_stat != GSS_S_COMPLETE &&
+                maj_stat != GSS_S_CONTINUE_NEEDED) {
                 display_status("accepting context", maj_stat,
                                acc_sec_min_stat);
-                if (*context != GSS_C_NO_CONTEXT)
+                if (*context != GSS_C_NO_CONTEXT) {
                     gss_delete_sec_context(&min_stat, context,
                                            GSS_C_NO_BUFFER);
+                }
                 return -1;
             }
 
@@ -263,8 +257,8 @@ static int server_establish_context(s, server_creds, context, client_name,
                 return -1;
             }
             fprintf(logfile, "Accepted connection using mechanism OID %.*s.\n",
-                    (int) oid_name.length, (char *) oid_name.value);
-            (void) gss_release_buffer(&min_stat, &oid_name);
+                    (int)oid_name.length, (char *)oid_name.value);
+            (void)gss_release_buffer(&min_stat, &oid_name);
         }
 
         maj_stat = gss_display_name(&min_stat, client, client_name, &doid);
@@ -277,8 +271,7 @@ static int server_establish_context(s, server_creds, context, client_name,
             display_status("releasing name", maj_stat, min_stat);
             return -1;
         }
-    }
-    else {
+    } else {
         client_name->length = *ret_flags = 0;
 
         if (logfile)
@@ -304,41 +297,41 @@ static int server_establish_context(s, server_creds, context, client_name,
  * A listening socket on the specified port and created and returned.
  * On error, an error message is displayed and -1 is returned.
  */
-static int create_socket(port)
-    u_short port;
+static int
+create_socket(u_short port)
 {
     struct sockaddr_in saddr;
-    int s;
-    int on = 1;
+    int s, on = 1;
 
     saddr.sin_family = AF_INET;
     saddr.sin_port = htons(port);
     saddr.sin_addr.s_addr = INADDR_ANY;
 
-    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    s = socket(AF_INET, SOCK_STREAM, 0);
+    if (s < 0) {
         perror("creating socket");
         return -1;
     }
-    /* Let the socket be reused right away */
-    (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
-    if (bind(s, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) {
+    /* Let the socket be reused right away. */
+    (void)setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
+    if (bind(s, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
         perror("binding socket");
-        (void) close(s);
+        (void)close(s);
         return -1;
     }
     if (listen(s, 5) < 0) {
         perror("listening on socket");
-        (void) close(s);
+        (void)close(s);
         return -1;
     }
     return s;
 }
 
-static float timeval_subtract(tv1, tv2)
-    struct timeval *tv1, *tv2;
+static float
+timeval_subtract(struct timeval *tv1, struct timeval *tv2)
 {
     return ((tv1->tv_sec - tv2->tv_sec) +
-            ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
+            ((float)(tv1->tv_usec - tv2->tv_usec)) / 1000000);
 }
 
 /*
@@ -346,32 +339,32 @@ static float timeval_subtract(tv1, tv2)
  * DO NOT REMOVE THIS UNTIL A BETTER TEST HAS BEEN WRITTEN, THOUGH.
  *                                      -TYT
  */
-static int test_import_export_context(context)
-    gss_ctx_id_t *context;
+static int
+test_import_export_context(gss_ctx_id_t *context)
 {
-    OM_uint32       min_stat, maj_stat;
+    OM_uint32 min_stat, maj_stat;
     gss_buffer_desc context_token, copied_token;
     struct timeval tm1, tm2;
 
-    /*
-     * Attempt to save and then restore the context.
-     */
+    /* Attempt to save and then restore the context. */
     gettimeofday(&tm1, (struct timezone *)0);
     maj_stat = gss_export_sec_context(&min_stat, context, &context_token);
     if (maj_stat != GSS_S_COMPLETE) {
         display_status("exporting context", maj_stat, min_stat);
         return 1;
     }
-    gettimeofday(&tm2, (struct timezone *)0);
-    if (verbose && logfile)
+    gettimeofday(&tm2, NULL);
+    if (verbose && logfile) {
         fprintf(logfile, "Exported context: %d bytes, %7.4f seconds\n",
-                (int) context_token.length,
-                timeval_subtract(&tm2, &tm1));
+                (int)context_token.length, timeval_subtract(&tm2, &tm1));
+    }
     copied_token.length = context_token.length;
     copied_token.value = malloc(context_token.length);
     if (copied_token.value == 0) {
-        if (logfile)
-            fprintf(logfile, "Couldn't allocate memory to copy context token.\n");
+        if (logfile) {
+            fprintf(logfile, "Couldn't allocate memory to copy context "
+                    "token.\n");
+        }
         return 1;
     }
     memcpy(copied_token.value, context_token.value, copied_token.length);
@@ -381,11 +374,12 @@ static int test_import_export_context(context)
         return 1;
     }
     free(copied_token.value);
-    gettimeofday(&tm1, (struct timezone *)0);
-    if (verbose && logfile)
+    gettimeofday(&tm1, NULL);
+    if (verbose && logfile) {
         fprintf(logfile, "Importing context: %7.4f seconds\n",
                 timeval_subtract(&tm1, &tm2));
-    (void) gss_release_buffer(&min_stat, &context_token);
+    }
+    (void)gss_release_buffer(&min_stat, &context_token);
     return 0;
 }
 
@@ -415,47 +409,44 @@ static int test_import_export_context(context)
  *
  * If any error occurs, -1 is returned.
  */
-static int sign_server(s, server_creds, export)
-    int s;
-    gss_cred_id_t server_creds;
-    int export;
+static int
+sign_server(int s, gss_cred_id_t server_creds, int export)
 {
     gss_buffer_desc client_name, xmit_buf, msg_buf;
     gss_ctx_id_t context;
     OM_uint32 maj_stat, min_stat;
-    int i, conf_state, ret_flags;
-    char        *cp;
-    int token_flags;
+    int i, conf_state, ret_flags, token_flags;
+    char *cp;
 
     /* Establish a context with the client */
-    if (server_establish_context(s, server_creds, &context,
-                                 &client_name, &ret_flags) < 0)
-        return(-1);
+    if (server_establish_context(s, server_creds, &context, &client_name,
+                                 &ret_flags) < 0)
+        return -1;
 
     if (context == GSS_C_NO_CONTEXT) {
         printf("Accepted unauthenticated connection.\n");
-    }
-    else {
-        printf("Accepted connection: \"%.*s\"\n",
-               (int) client_name.length, (char *) client_name.value);
-        (void) gss_release_buffer(&min_stat, &client_name);
+    } else {
+        printf("Accepted connection: \"%.*s\"\n", (int)client_name.length,
+               (char *)client_name.value);
+        (void)gss_release_buffer(&min_stat, &client_name);
 
         if (export) {
-            for (i=0; i < 3; i++)
+            for (i = 0; i < 3; i++) {
                 if (test_import_export_context(&context))
                     return -1;
+            }
         }
     }
 
     do {
         /* Receive the message token */
         if (recv_token(s, &token_flags, &xmit_buf) < 0)
-            return(-1);
+            return -1;
 
         if (token_flags & TOKEN_NOOP) {
             if (logfile)
                 fprintf(logfile, "NOOP token\n");
-            if(xmit_buf.value) {
+            if (xmit_buf.value) {
                 free(xmit_buf.value);
                 xmit_buf.value = 0;
             }
@@ -467,48 +458,49 @@ static int sign_server(s, server_creds, export)
             print_token(&xmit_buf);
         }
 
-        if ((context == GSS_C_NO_CONTEXT) &&
-            (    token_flags & (TOKEN_WRAPPED|TOKEN_ENCRYPTED|TOKEN_SEND_MIC))) {
-            if (logfile)
-                fprintf(logfile,
-                        "Unauthenticated client requested authenticated services!\n");
-            if(xmit_buf.value) {
-                free (xmit_buf.value);
+        if (context == GSS_C_NO_CONTEXT &&
+            (token_flags &
+             (TOKEN_WRAPPED | TOKEN_ENCRYPTED | TOKEN_SEND_MIC))) {
+            if (logfile) {
+                fprintf(logfile, "Unauthenticated client requested "
+                        "authenticated services!\n");
+            }
+            if (xmit_buf.value) {
+                free(xmit_buf.value);
                 xmit_buf.value = 0;
             }
-            return(-1);
+            return -1;
         }
 
         if (token_flags & TOKEN_WRAPPED) {
             maj_stat = gss_unwrap(&min_stat, context, &xmit_buf, &msg_buf,
-                                  &conf_state, (gss_qop_t *) NULL);
+                                  &conf_state, NULL);
             if (maj_stat != GSS_S_COMPLETE) {
                 display_status("unsealing message", maj_stat, min_stat);
-                if(xmit_buf.value) {
-                    free (xmit_buf.value);
+                if (xmit_buf.value) {
+                    free(xmit_buf.value);
                     xmit_buf.value = 0;
                 }
-                return(-1);
-            } else if (! conf_state && (token_flags & TOKEN_ENCRYPTED)) {
+                return -1;
+            } else if (!conf_state && (token_flags & TOKEN_ENCRYPTED)) {
                 fprintf(stderr, "Warning!  Message not encrypted.\n");
             }
 
-            if(xmit_buf.value) {
-                free (xmit_buf.value);
+            if (xmit_buf.value) {
+                free(xmit_buf.value);
                 xmit_buf.value = 0;
             }
-        }
-        else {
+        } else {
             msg_buf = xmit_buf;
         }
 
         if (logfile) {
             fprintf(logfile, "Received message: ");
             cp = msg_buf.value;
-            if ((isprint((int) cp[0]) || isspace((int) cp[0])) &&
-                (isprint((int) cp[1]) || isspace((int) cp[1]))) {
-                fprintf(logfile, "\"%.*s\"\n", (int) msg_buf.length,
-                        (char *) msg_buf.value);
+            if ((isprint((int)cp[0]) || isspace((int)cp[0])) &&
+                (isprint((int)cp[1]) || isspace((int)cp[1]))) {
+                fprintf(logfile, "\"%.*s\"\n", (int)msg_buf.length,
+                        (char *)msg_buf.value);
             } else {
                 fprintf(logfile, "\n");
                 print_token(&msg_buf);
@@ -516,51 +508,50 @@ static int sign_server(s, server_creds, export)
         }
 
         if (token_flags & TOKEN_SEND_MIC) {
-            /* Produce a signature block for the message */
+            /* Produce a signature block for the message. */
             maj_stat = gss_get_mic(&min_stat, context, GSS_C_QOP_DEFAULT,
                                    &msg_buf, &xmit_buf);
             if (maj_stat != GSS_S_COMPLETE) {
                 display_status("signing message", maj_stat, min_stat);
-                return(-1);
+                return -1;
             }
 
-            if(msg_buf.value) {
-                free (msg_buf.value);
+            if (msg_buf.value) {
+                free(msg_buf.value);
                 msg_buf.value = 0;
             }
 
-            /* Send the signature block to the client */
+            /* Send the signature block to the client. */
             if (send_token(s, TOKEN_MIC, &xmit_buf) < 0)
-                return(-1);
+                return -1;
 
-            if(xmit_buf.value) {
-                free (xmit_buf.value);
+            if (xmit_buf.value) {
+                free(xmit_buf.value);
                 xmit_buf.value = 0;
             }
-        }
-        else {
-            if(msg_buf.value) {
-                free (msg_buf.value);
+        } else {
+            if (msg_buf.value) {
+                free(msg_buf.value);
                 msg_buf.value = 0;
             }
             if (send_token(s, TOKEN_NOOP, empty_token) < 0)
-                return(-1);
+                return -1;
         }
     } while (1 /* loop will break if NOOP received */);
 
     if (context != GSS_C_NO_CONTEXT) {
-        /* Delete context */
+        /* Delete context. */
         maj_stat = gss_delete_sec_context(&min_stat, &context, NULL);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("deleting context", maj_stat, min_stat);
-            return(-1);
+            return -1;
         }
     }
 
     if (logfile)
         fflush(logfile);
 
-    return(0);
+    return 0;
 }
 
 static int max_threads = 1;
@@ -571,36 +562,35 @@ static HANDLE hMutex = NULL;
 static HANDLE hEvent = NULL;
 
 void
-InitHandles(void)
+init_handles(void)
 {
     hMutex = CreateMutex(NULL, FALSE, NULL);
     hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 }
 
 void
-CleanupHandles(void)
+cleanup_handles(void)
 {
     CloseHandle(hMutex);
     CloseHandle(hEvent);
 }
 
 BOOL
-WaitAndIncrementThreadCounter(void)
+wait_and_increment_thread_counter(void)
 {
     for (;;) {
         if (WaitForSingleObject(hMutex, INFINITE) == WAIT_OBJECT_0) {
-            if ( thread_count < max_threads ) {
+            if (thread_count < max_threads) {
                 thread_count++;
                 ReleaseMutex(hMutex);
                 return TRUE;
             } else {
                 ReleaseMutex(hMutex);
 
-                if (WaitForSingleObject(hEvent, INFINITE) == WAIT_OBJECT_0) {
+                if (WaitForSingleObject(hEvent, INFINITE) == WAIT_OBJECT_0)
                     continue;
-                } else {
+                else
                     return FALSE;
-                }
             }
         } else {
             return FALSE;
@@ -609,10 +599,10 @@ WaitAndIncrementThreadCounter(void)
 }
 
 BOOL
-DecrementAndSignalThreadCounter(void)
+decrement_and_signal_thread_counter(void)
 {
     if (WaitForSingleObject(hMutex, INFINITE) == WAIT_OBJECT_0) {
-        if ( thread_count == max_threads )
+        if (thread_count == max_threads)
             SetEvent(hEvent);
         thread_count--;
         ReleaseMutex(hMutex);
@@ -621,15 +611,18 @@ DecrementAndSignalThreadCounter(void)
         return FALSE;
     }
 }
+
 #else /* assume pthread */
+
 static pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t counter_cond = PTHREAD_COND_INITIALIZER;
 int counter = 0;
 
 static int
-WaitAndIncrementThreadCounter(void)
+wait_and_increment_thread_counter(void)
 {
     int err;
+
     err = pthread_mutex_lock(&counter_mutex);
     if (err) {
         perror("pthread_mutex_lock");
@@ -647,10 +640,12 @@ WaitAndIncrementThreadCounter(void)
     pthread_mutex_unlock(&counter_mutex);
     return 1;
 }
+
 static void
-DecrementAndSignalThreadCounter(void)
+decrement_and_signal_thread_counter(void)
 {
     int err;
+
     err = pthread_mutex_lock(&counter_mutex);
     if (err) {
         perror("pthread_mutex_lock");
@@ -661,37 +656,35 @@ DecrementAndSignalThreadCounter(void)
     counter--;
     pthread_mutex_unlock(&counter_mutex);
 }
+
 #endif
 
 struct _work_plan {
-    int             s;
-    gss_cred_id_t   server_creds;
-    int             export;
+    int s;
+    gss_cred_id_t server_creds;
+    int export;
 };
 
 static void *
-worker_bee(void * param)
+worker_bee(void *param)
 {
-    struct _work_plan *work = (struct _work_plan *) param;
+    struct _work_plan *work = param;
 
-    /* this return value is not checked, because there's
-     * not really anything to do if it fails
-     */
+    /* This return value is not checked, because there's not really anything to
+     * do if it fails. */
     sign_server(work->s, work->server_creds, work->export);
     closesocket(work->s);
     free(work);
 
 #if defined _WIN32 || 1
-    if ( max_threads > 1 )
-        DecrementAndSignalThreadCounter();
+    if (max_threads > 1)
+        decrement_and_signal_thread_counter();
 #endif
-    return 0;
+    return NULL;
 }
 
 int
-main(argc, argv)
-    int argc;
-    char **argv;
+main(int argc, char **argv)
 {
     char *service_name;
     gss_cred_id_t server_creds;
@@ -704,21 +697,22 @@ main(argc, argv)
     signal(SIGPIPE, SIG_IGN);
     logfile = stdout;
     display_file = stdout;
-    argc--; argv++;
+    argc--;
+    argv++;
     while (argc) {
         if (strcmp(*argv, "-port") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             port = atoi(*argv);
-        }
-#if defined _WIN32 || 1
-        else if (strcmp(*argv, "-threads") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+        } else if (strcmp(*argv, "-threads") == 0) {
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             max_threads = atoi(*argv);
-        }
-#endif
-        else if (strcmp(*argv, "-verbose") == 0) {
+        } else if (strcmp(*argv, "-verbose") == 0) {
             verbose = 1;
         } else if (strcmp(*argv, "-once") == 0) {
             once = 1;
@@ -727,16 +721,18 @@ main(argc, argv)
         } else if (strcmp(*argv, "-export") == 0) {
             export = 1;
         } else if (strcmp(*argv, "-logfile") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
-            /* Gross hack, but it makes it unnecessary to add an
-               extra argument to disable logging, and makes the code
-               more efficient because it doesn't actually write data
-               to /dev/null. */
-            if (! strcmp(*argv, "/dev/null")) {
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
+            /*
+             * Gross hack, but it makes it unnecessary to add an extra argument
+             * to disable logging, and makes the code more efficient because it
+             * doesn't actually write data to /dev/null.
+             */
+            if (!strcmp(*argv, "/dev/null")) {
                 logfile = display_file = NULL;
-            }
-            else {
+            } else {
                 logfile = fopen(*argv, "a");
                 display_file = logfile;
                 if (!logfile) {
@@ -744,9 +740,11 @@ main(argc, argv)
                     exit(1);
                 }
             }
-        } else
+        } else {
             break;
-        argc--; argv++;
+        }
+        argc--;
+        argv++;
     }
     if (argc != 1)
         usage();
@@ -760,10 +758,12 @@ main(argc, argv)
         max_threads = 1;
     }
 
-    if (max_threads > 1 && do_inetd)
-        fprintf(stderr, "warning: one thread may be used in conjunction with inetd\n");
+    if (max_threads > 1 && do_inetd) {
+        fprintf(stderr, "warning: one thread may be used in conjunction "
+                "with inetd\n");
+    }
 
-    InitHandles();
+    init_handles();
 #endif
 
     service_name = *argv;
@@ -780,20 +780,22 @@ main(argc, argv)
     } else {
         int stmp;
 
-        if ((stmp = create_socket(port)) >= 0) {
+        stmp = create_socket(port);
+        if (stmp >= 0) {
             if (listen(stmp, max_threads == 1 ? 0 : max_threads) < 0)
                 perror("listening on socket");
 
             do {
                 struct _work_plan * work = malloc(sizeof(struct _work_plan));
 
-                if ( work == NULL ) {
+                if (work == NULL) {
                     fprintf(stderr, "fatal error: out of memory");
                     break;
                 }
 
                 /* Accept a TCP connection */
-                if ((work->s = accept(stmp, NULL, 0)) < 0) {
+                work->s = accept(stmp, NULL, 0);
+                if (work->s < 0) {
                     perror("accepting connection");
                     continue;
                 }
@@ -802,13 +804,11 @@ main(argc, argv)
                 work->export = export;
 
                 if (max_threads == 1) {
-                    worker_bee((void *)work);
-                }
-#if defined _WIN32 || 1
-                else {
-                    if ( WaitAndIncrementThreadCounter() ) {
+                    worker_bee(work);
+                } else {
+                    if (wait_and_increment_thread_counter()) {
 #ifdef _WIN32
-                        uintptr_t handle = _beginthread(worker_bee, 0, (void *)work);
+                        uintptr_t handle = _beginthread(worker_bee, 0, work);
                         if (handle == (uintptr_t)-1) {
                             closesocket(work->s);
                             free(work);
@@ -816,37 +816,37 @@ main(argc, argv)
 #else
                         int err;
                         pthread_t thr;
-                        err = pthread_create(&thr, 0, (void *(*)(void *))worker_bee,
-                                             (void *) work);
+                        err = pthread_create(&thr, 0, worker_bee, work);
                         if (err) {
                             perror("pthread_create");
                             closesocket(work->s);
                             free(work);
                         }
-                        (void) pthread_detach(thr);
+                        (void)pthread_detach(thr);
 #endif
                     } else {
-                        fprintf(stderr, "fatal error incrementing thread counter");
+                        fprintf(stderr, "fatal error incrementing thread "
+                                "counter");
                         closesocket(work->s);
                         free(work);
                         break;
                     }
                 }
-#endif
             } while (!once);
 
             closesocket(stmp);
         }
     }
 
-    (void) gss_release_cred(&min_stat, &server_creds);
+    (void)gss_release_cred(&min_stat, &server_creds);
 
 #ifdef _WIN32
-    CleanupHandles();
+    cleanup_handles();
 #else
-    if (max_threads > 1)
+    if (max_threads > 1) {
         while (1)
-            sleep (999999);
+            sleep(999999);
+    }
 #endif
 
     return 0;