Reformat tests/gss-threads

4 files changed, 632 insertions, 662 deletions

diff --git a/src/tests/gss-threads/gss-client.c b/src/tests/gss-threads/gss-client.c
index e66f15442b..b25b689a00 100644
--- a/src/tests/gss-threads/gss-client.c
+++ b/src/tests/gss-threads/gss-client.c
@@ -71,7 +71,8 @@
 
 static int verbose = 1;
 
-static void usage()
+static void
+usage()
 {
     fprintf(stderr, "Usage: gss-client [-port port] [-mech mechanism] [-d]\n");
     fprintf(stderr, "       [-seq] [-noreplay] [-nomutual]");
@@ -101,13 +102,13 @@ static void usage()
  * message is displayed and -1 is returned.
  */
 struct sockaddr_in saddr;
-static int get_server_info(host, port)
-    char *host;
-    u_short port;
+static int
+get_server_info(char *host, u_short port)
 {
     struct hostent *hp;
 
-    if ((hp = gethostbyname(host)) == NULL) {
+    hp = gethostbyname(host);
+    if (hp == NULL) {
         fprintf(stderr, "Unknown host: %s\n", host);
         return -1;
     }
@@ -136,17 +137,19 @@ static int get_server_info(host, port)
  * opened and connected.  If an error occurs, an error message is
  * displayed and -1 is returned.
  */
-static int connect_to_server()
+static int
+connect_to_server()
 {
     int s;
 
-    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    s = socket(AF_INET, SOCK_STREAM, 0);
+    if (s < 0) {
         perror("creating socket");
         return -1;
     }
     if (connect(s, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
         perror("connecting to server");
-        (void) closesocket(s);
+        (void)closesocket(s);
         return -1;
     }
     return s;
@@ -160,12 +163,12 @@ static int connect_to_server()
  *
  * Arguments:
  *
- *      s                   (r) an established TCP connection to the service
- *      service_name(r) the ASCII service name of the service
+ *      s               (r) an established TCP connection to the service
+ *      service_name    (r) the ASCII service name of the service
  *      gss_flags       (r) GSS-API delegation flag (if any)
  *      auth_flag       (r) whether to actually do authentication
- *  v1_format   (r) whether the v1 sample protocol should be used
- *      oid                 (r) OID of the mechanism to use
+ *      v1_format       (r) whether the v1 sample protocol should be used
+ *      oid             (r) OID of the mechanism to use
  *      context         (w) the established GSS-API context
  *      ret_flags       (w) the returned flags from init_sec_context
  *
@@ -183,16 +186,10 @@ static int connect_to_server()
  * unsuccessful, the GSS-API error messages are displayed on stderr
  * and -1 is returned.
  */
-static int client_establish_context(s, service_name, gss_flags, auth_flag,
-                                    v1_format, oid, gss_context, ret_flags)
-    int s;
-    char *service_name;
-    gss_OID oid;
-    OM_uint32 gss_flags;
-    int auth_flag;
-    int v1_format;
-    gss_ctx_id_t *gss_context;
-    OM_uint32 *ret_flags;
+static int
+client_establish_context(int s, char *service_name, OM_uint32 gss_flags,
+                         int auth_flag, int v1_format, gss_OID oid,
+                         gss_ctx_id_t *gss_context, OM_uint32 *ret_flags)
 {
     if (auth_flag) {
         gss_buffer_desc send_tok, recv_tok, *token_ptr;
@@ -205,17 +202,18 @@ static int client_establish_context(s, service_name, gss_flags, auth_flag,
          * local variable space.
          */
         send_tok.value = service_name;
-        send_tok.length = strlen(service_name) ;
+        send_tok.length = strlen(service_name);
         maj_stat = gss_import_name(&min_stat, &send_tok,
-                                   (gss_OID) gss_nt_service_name, &target_name);
+                                   (gss_OID)gss_nt_service_name, &target_name);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("parsing name", maj_stat, min_stat);
             return -1;
         }
 
         if (!v1_format) {
-            if (send_token(s, TOKEN_NOOP|TOKEN_CONTEXT_NEXT, empty_token) < 0) {
-                (void) gss_release_name(&min_stat, &target_name);
+            if (send_token(s, TOKEN_NOOP | TOKEN_CONTEXT_NEXT,
+                           empty_token) < 0) {
+                (void)gss_release_name(&min_stat, &target_name);
                 return -1;
             }
         }
@@ -240,31 +238,24 @@ static int client_establish_context(s, service_name, gss_flags, auth_flag,
         *gss_context = GSS_C_NO_CONTEXT;
 
         do {
-            maj_stat =
-                gss_init_sec_context(&init_sec_min_stat,
-                                     GSS_C_NO_CREDENTIAL,
-                                     gss_context,
-                                     target_name,
-                                     oid,
-                                     gss_flags,
-                                     0,
-                                     NULL,   /* no channel bindings */
-                                     token_ptr,
-                                     NULL,   /* ignore mech type */
-                                     &send_tok,
-                                     ret_flags,
-                                     NULL);  /* ignore time_rec */
+            maj_stat = gss_init_sec_context(&init_sec_min_stat,
+                                            GSS_C_NO_CREDENTIAL, gss_context,
+                                            target_name, oid, gss_flags, 0,
+                                            NULL, token_ptr, NULL, &send_tok,
+                                            ret_flags, NULL);
 
             if (token_ptr != GSS_C_NO_BUFFER)
-                free (recv_tok.value);
+                free(recv_tok.value);
 
             if (send_tok.length != 0) {
-                if (verbose)
+                if (verbose) {
                     printf("Sending init_sec_context token (size=%d)...",
-                           (int) send_tok.length);
-                if (send_token(s, v1_format?0:TOKEN_CONTEXT, &send_tok) < 0) {
-                    (void) gss_release_buffer(&min_stat, &send_tok);
-                    (void) gss_release_name(&min_stat, &target_name);
+                           (int)send_tok.length);
+                }
+                if (send_token(s, v1_format ? 0 : TOKEN_CONTEXT,
+                               &send_tok) < 0) {
+                    (void)gss_release_buffer(&min_stat, &send_tok);
+                    (void)gss_release_name(&min_stat, &target_name);
                     if (*gss_context != GSS_C_NO_CONTEXT) {
                         gss_delete_sec_context(&min_stat, gss_context,
                                                GSS_C_NO_BUFFER);
@@ -273,15 +264,17 @@ static int client_establish_context(s, service_name, gss_flags, auth_flag,
                     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("initializing context", maj_stat,
                                init_sec_min_stat);
-                (void) gss_release_name(&min_stat, &target_name);
-                if (*gss_context != GSS_C_NO_CONTEXT)
+                (void)gss_release_name(&min_stat, &target_name);
+                if (*gss_context != GSS_C_NO_CONTEXT) {
                     gss_delete_sec_context(&min_stat, gss_context,
                                            GSS_C_NO_BUFFER);
+                }
                 return -1;
             }
 
@@ -289,7 +282,7 @@ static int client_establish_context(s, service_name, gss_flags, auth_flag,
                 if (verbose)
                     printf("continue needed...");
                 if (recv_token(s, &token_flags, &recv_tok) < 0) {
-                    (void) gss_release_name(&min_stat, &target_name);
+                    (void)gss_release_name(&min_stat, &target_name);
                     return -1;
                 }
                 token_ptr = &recv_tok;
@@ -298,24 +291,22 @@ static int client_establish_context(s, service_name, gss_flags, auth_flag,
                 printf("\n");
         } while (maj_stat == GSS_S_CONTINUE_NEEDED);
 
-        (void) gss_release_name(&min_stat, &target_name);
-    }
-    else {
-        if (send_token(s, TOKEN_NOOP, empty_token) < 0)
+        (void)gss_release_name(&min_stat, &target_name);
+    } else if (send_token(s, TOKEN_NOOP, empty_token) < 0) {
             return -1;
     }
 
     return 0;
 }
 
-static void read_file(file_name, in_buf)
-    char                *file_name;
-    gss_buffer_t        in_buf;
+static void
+read_file(char *file_name, gss_buffer_t in_buf)
 {
     int fd, count;
     struct stat stat_buf;
 
-    if ((fd = open(file_name, O_RDONLY, 0)) < 0) {
+    fd = open(file_name, O_RDONLY, 0);
+    if (fd < 0) {
         perror("open");
         fprintf(stderr, "Couldn't open file %s\n", file_name);
         exit(2);
@@ -331,23 +322,25 @@ static void read_file(file_name, in_buf)
         return;
     }
 
-    if ((in_buf->value = malloc(in_buf->length)) == 0) {
+    in_buf->value = malloc(in_buf->length);
+    if (in_buf->value == NULL) {
         fprintf(stderr, "Couldn't allocate %d byte buffer for reading file\n",
-                (int) in_buf->length);
+                (int)in_buf->length);
         exit(4);
     }
 
-    /* this code used to check for incomplete reads, but you can't get
-       an incomplete read on any file for which fstat() is meaningful */
+    /* This code used to check for incomplete reads, but you can't get
+     * an incomplete read on any file for which fstat() is meaningful. */
 
     count = read(fd, in_buf->value, in_buf->length);
     if (count < 0) {
         perror("read");
         exit(5);
     }
-    if (count < in_buf->length)
+    if (count < in_buf->length) {
         fprintf(stderr, "Warning, only read in %d bytes, expected %d\n",
-                count, (int) in_buf->length);
+                count, (int)in_buf->length);
+    }
 }
 
 /*
@@ -378,246 +371,223 @@ static void read_file(file_name, in_buf)
  * seals msg in a GSS-API token with gss_wrap, sends it to the server,
  * reads back a GSS-API signature block for msg from the server, and
  * verifies it with gss_verify.  -1 is returned if any step fails,
- * otherwise 0 is returned.  */
-static int call_server(host, port, oid, service_name, gss_flags, auth_flag,
-                       wrap_flag, encrypt_flag, mic_flag, v1_format, msg, use_file,
-                       mcount)
-    char *host;
-    u_short port;
-    gss_OID oid;
-    char *service_name;
-    OM_uint32 gss_flags;
-    int auth_flag, wrap_flag, encrypt_flag, mic_flag;
-    int v1_format;
-    char *msg;
-    int use_file;
-    int mcount;
+ * otherwise 0 is returned.
+ */
+static int
+call_server(char *host, u_short port, gss_OID oid, char *service_name,
+            OM_uint32 gss_flags, int auth_flag, int wrap_flag,
+            int encrypt_flag, int mic_flag, int v1_format, char *msg,
+            int use_file, int mcount)
 {
     gss_ctx_id_t context;
-    gss_buffer_desc in_buf, out_buf;
-    int s, state;
-    OM_uint32 ret_flags;
-    OM_uint32 maj_stat, min_stat;
-    gss_name_t         src_name, targ_name;
-    gss_buffer_desc    sname, tname;
-    OM_uint32          lifetime;
-    gss_OID            mechanism, name_type;
-    int                is_local;
-    OM_uint32          context_flags;
-    int                is_open;
-    gss_qop_t          qop_state;
-    gss_OID_set        mech_names;
-    gss_buffer_desc    oid_name;
-    size_t     i;
-    int token_flags;
-
-    /* Open connection */
-    if ((s = connect_to_server()) < 0)
+    gss_buffer_desc in_buf, out_buf, sname, tname, oid_name;
+    int s, state, is_local, is_open, flags, token_flags;
+    OM_uint32 ret_flags, maj_stat, min_stat, lifetime, context_flags;
+    gss_name_t src_name, targ_name;
+    gss_OID mechanism, name_type;
+    gss_qop_t qop_state;
+    gss_OID_set mech_names;
+    size_t i;
+
+    /* Open connection. */
+    s = connect_to_server();
+    if (s < 0)
         return -1;
 
-    /* Establish context */
+    /* Establish context. */
     if (client_establish_context(s, service_name, gss_flags, auth_flag,
-                                 v1_format, oid, &context,
-                                 &ret_flags) < 0) {
-        (void) closesocket(s);
+                                 v1_format, oid, &context, &ret_flags) < 0) {
+        (void)closesocket(s);
         return -1;
     }
 
     if (auth_flag && verbose) {
-        /* display the flags */
+        /* Display the flags. */
         display_ctx_flags(ret_flags);
 
-        /* Get context information */
-        maj_stat = gss_inquire_context( &min_stat, context,
-                                        &src_name, &targ_name, &lifetime,
-                                        &mechanism, &context_flags,
-                                        &is_local,
-                                        &is_open);
+        /* Get context information. */
+        maj_stat = gss_inquire_context(&min_stat, context, &src_name,
+                                       &targ_name, &lifetime, &mechanism,
+                                       &context_flags, &is_local, &is_open);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("inquiring context", maj_stat, min_stat);
             return -1;
         }
 
-        maj_stat = gss_display_name(&min_stat, src_name, &sname,
-                                    &name_type);
+        maj_stat = gss_display_name(&min_stat, src_name, &sname, &name_type);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("displaying source name", maj_stat, min_stat);
             return -1;
         }
-        maj_stat = gss_display_name(&min_stat, targ_name, &tname,
-                                    (gss_OID *) NULL);
+        maj_stat = gss_display_name(&min_stat, targ_name, &tname, NULL);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("displaying target name", maj_stat, min_stat);
             return -1;
         }
         printf("\"%.*s\" to \"%.*s\", lifetime %d, flags %x, %s, %s\n",
-               (int) sname.length, (char *) sname.value,
-               (int) tname.length, (char *) tname.value, lifetime,
-               context_flags,
-               (is_local) ? "locally initiated" : "remotely initiated",
-               (is_open) ? "open" : "closed");
-
-        (void) gss_release_name(&min_stat, &src_name);
-        (void) gss_release_name(&min_stat, &targ_name);
-        (void) gss_release_buffer(&min_stat, &sname);
-        (void) gss_release_buffer(&min_stat, &tname);
-
-        maj_stat = gss_oid_to_str(&min_stat,
-                                  name_type,
-                                  &oid_name);
+               (int)sname.length, (char *)sname.value,
+               (int)tname.length, (char *)tname.value, lifetime, context_flags,
+               is_local ? "locally initiated" : "remotely initiated",
+               is_open ? "open" : "closed");
+
+        (void)gss_release_name(&min_stat, &src_name);
+        (void)gss_release_name(&min_stat, &targ_name);
+        (void)gss_release_buffer(&min_stat, &sname);
+        (void)gss_release_buffer(&min_stat, &tname);
+
+        maj_stat = gss_oid_to_str(&min_stat, name_type, &oid_name);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("converting oid->string", maj_stat, min_stat);
             return -1;
         }
-        printf("Name type of source name is %.*s.\n",
-               (int) oid_name.length, (char *) oid_name.value);
-        (void) gss_release_buffer(&min_stat, &oid_name);
+        printf("Name type of source name is %.*s.\n", (int)oid_name.length,
+               (char *)oid_name.value);
+        (void)gss_release_buffer(&min_stat, &oid_name);
 
-        /* Now get the names supported by the mechanism */
-        maj_stat = gss_inquire_names_for_mech(&min_stat,
-                                              mechanism,
+        /* Now get the names supported by the mechanism. */
+        maj_stat = gss_inquire_names_for_mech(&min_stat, mechanism,
                                               &mech_names);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("inquiring mech names", maj_stat, min_stat);
             return -1;
         }
 
-        maj_stat = gss_oid_to_str(&min_stat,
-                                  mechanism,
-                                  &oid_name);
+        maj_stat = gss_oid_to_str(&min_stat, mechanism, &oid_name);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("converting oid->string", maj_stat, min_stat);
             return -1;
         }
-        printf("Mechanism %.*s supports %d names\n",
-               (int) oid_name.length, (char *) oid_name.value,
-               (int) mech_names->count);
-        (void) gss_release_buffer(&min_stat, &oid_name);
-
-        for (i=0; i<mech_names->count; i++) {
-            maj_stat = gss_oid_to_str(&min_stat,
-                                      &mech_names->elements[i],
+        printf("Mechanism %.*s supports %d names\n", (int)oid_name.length,
+               (char *)oid_name.value, (int)mech_names->count);
+        (void)gss_release_buffer(&min_stat, &oid_name);
+
+        for (i = 0; i < mech_names->count; i++) {
+            maj_stat = gss_oid_to_str(&min_stat, &mech_names->elements[i],
                                       &oid_name);
             if (maj_stat != GSS_S_COMPLETE) {
                 display_status("converting oid->string", maj_stat, min_stat);
                 return -1;
             }
-            printf("  %d: %.*s\n", (int) i,
-                   (int) oid_name.length, (char *) oid_name.value);
+            printf("  %d: %.*s\n", (int)i, (int)oid_name.length,
+                   (char *)oid_name.value);
 
-            (void) gss_release_buffer(&min_stat, &oid_name);
+            (void)gss_release_buffer(&min_stat, &oid_name);
         }
-        (void) gss_release_oid_set(&min_stat, &mech_names);
+        (void)gss_release_oid_set(&min_stat, &mech_names);
     }
 
     if (use_file) {
         read_file(msg, &in_buf);
     } else {
-        /* Seal the message */
+        /* Seal the message. */
         in_buf.value = msg;
         in_buf.length = strlen(msg);
     }
 
     for (i = 0; i < mcount; i++) {
         if (wrap_flag) {
-            maj_stat = gss_wrap(&min_stat, context, encrypt_flag, GSS_C_QOP_DEFAULT,
-                                &in_buf, &state, &out_buf);
+            maj_stat = gss_wrap(&min_stat, context, encrypt_flag,
+                                GSS_C_QOP_DEFAULT, &in_buf, &state, &out_buf);
             if (maj_stat != GSS_S_COMPLETE) {
                 display_status("wrapping message", maj_stat, min_stat);
-                (void) closesocket(s);
-                (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
+                (void)closesocket(s);
+                (void)gss_delete_sec_context(&min_stat, &context,
+                                             GSS_C_NO_BUFFER);
                 return -1;
-            } else if (encrypt_flag && ! state) {
+            } else if (encrypt_flag && !state) {
                 fprintf(stderr, "Warning!  Message not encrypted.\n");
             }
-        }
-        else {
+        } else {
             out_buf = in_buf;
         }
 
-        /* Send to server */
-        if (send_token(s, (v1_format?0
-                           :(TOKEN_DATA |
-                             (wrap_flag ? TOKEN_WRAPPED : 0) |
-                             (encrypt_flag ? TOKEN_ENCRYPTED : 0) |
-                             (mic_flag ? TOKEN_SEND_MIC : 0))), &out_buf) < 0) {
-            (void) closesocket(s);
-            (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
+        /* Send to server. */
+        flags = 0;
+        if (!v1_format) {
+            flags = TOKEN_DATA | (wrap_flag ? TOKEN_WRAPPED : 0) |
+                (encrypt_flag ? TOKEN_ENCRYPTED : 0) |
+                (mic_flag ? TOKEN_SEND_MIC : 0);
+        }
+        if (send_token(s, flags, &out_buf) < 0) {
+            (void)closesocket(s);
+            (void)gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
             return -1;
         }
         if (out_buf.value != in_buf.value)
-            (void) gss_release_buffer(&min_stat, &out_buf);
+            (void)gss_release_buffer(&min_stat, &out_buf);
 
-        /* Read signature block into out_buf */
+        /* Read signature block into out_buf. */
         if (recv_token(s, &token_flags, &out_buf) < 0) {
-            (void) closesocket(s);
-            (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
+            (void)closesocket(s);
+            (void)gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
             return -1;
         }
 
         if (mic_flag) {
-            /* Verify signature block */
-            maj_stat = gss_verify_mic(&min_stat, context, &in_buf,
-                                      &out_buf, &qop_state);
+            /* Verify signature block. */
+            maj_stat = gss_verify_mic(&min_stat, context, &in_buf, &out_buf,
+                                      &qop_state);
             if (maj_stat != GSS_S_COMPLETE) {
                 display_status("verifying signature", maj_stat, min_stat);
-                (void) closesocket(s);
-                (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
+                (void)closesocket(s);
+                (void)gss_delete_sec_context(&min_stat, &context,
+                                             GSS_C_NO_BUFFER);
                 return -1;
             }
 
             if (verbose)
                 printf("Signature verified.\n");
-        }
-        else {
-            if (verbose)
-                printf("Response received.\n");
+        } else if (verbose) {
+            printf("Response received.\n");
         }
 
-        free (out_buf.value);
+        free(out_buf.value);
     }
 
     if (use_file)
         free(in_buf.value);
 
-    /* Send NOOP */
+    /* Send NOOP. */
     if (!v1_format)
-        (void) send_token(s, TOKEN_NOOP, empty_token);
+        (void)send_token(s, TOKEN_NOOP, empty_token);
 
     if (auth_flag) {
-        /* Delete context */
+        /* Delete context. */
         maj_stat = gss_delete_sec_context(&min_stat, &context, &out_buf);
         if (maj_stat != GSS_S_COMPLETE) {
             display_status("deleting context", maj_stat, min_stat);
-            (void) closesocket(s);
-            (void) gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
+            (void)closesocket(s);
+            (void)gss_delete_sec_context(&min_stat, &context, GSS_C_NO_BUFFER);
             return -1;
         }
 
-        (void) gss_release_buffer(&min_stat, &out_buf);
+        (void)gss_release_buffer(&min_stat, &out_buf);
     }
 
-    (void) closesocket(s);
+    (void)closesocket(s);
     return 0;
 }
 
-static void parse_oid(char *mechanism, gss_OID *oid)
+static void
+parse_oid(char *mechanism, gss_OID *oid)
 {
-    char        *mechstr = 0, *cp;
+    char *mechstr = 0, *cp;
     gss_buffer_desc tok;
     OM_uint32 maj_stat, min_stat;
 
-    if (isdigit((int) mechanism[0])) {
+    if (isdigit((int)mechanism[0])) {
         if (asprintf(&mechstr, "{ %s }", mechanism) < 0) {
             fprintf(stderr, "Couldn't allocate mechanism scratch!\n");
             return;
         }
-        for (cp = mechstr; *cp; cp++)
+        for (cp = mechstr; *cp; cp++) {
             if (*cp == '.')
                 *cp = ' ';
+        }
         tok.value = mechstr;
-    } else
+    } else {
         tok.value = mechanism;
+    }
     tok.length = strlen(tok.value);
     maj_stat = gss_str_to_oid(&min_stat, &tok, oid);
     if (maj_stat != GSS_S_COMPLETE) {
@@ -636,36 +606,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;
@@ -674,7 +643,7 @@ WaitAndIncrementThreadCounter(void)
 }
 
 BOOL
-DecrementAndSignalThreadCounter(void)
+decrement_and_signal_thread_counter(void)
 {
     if (WaitForSingleObject(hMutex, INFINITE) == WAIT_OBJECT_0) {
         if (thread_count == max_threads)
@@ -686,15 +655,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");
@@ -712,10 +684,12 @@ WaitAndIncrementThreadCounter(void)
     pthread_mutex_unlock(&counter_mutex);
     return 1;
 }
+
 static void
-DecrementAndSignalThreadCounter(void)
+decrement_and_signal_thread_counter(void)
 {
     int err;
+
     sleep(1);
     err = pthread_mutex_lock(&counter_mutex);
     if (err) {
@@ -727,6 +701,7 @@ DecrementAndSignalThreadCounter(void)
     counter--;
     pthread_mutex_unlock(&counter_mutex);
 }
+
 #endif
 
 static char *service_name, *server_host, *msg;
@@ -739,23 +714,25 @@ static gss_OID oid = GSS_C_NULL_OID;
 static int mcount = 1, ccount = 1;
 static int auth_flag, wrap_flag, encrypt_flag, mic_flag, v1_format;
 
-static void worker_bee(void * unused)
+static void *
+worker_bee(void *unused)
 {
     printf("worker bee!\n");
     if (call_server(server_host, port, oid, service_name,
                     gss_flags, auth_flag, wrap_flag, encrypt_flag, mic_flag,
-                    v1_format, msg, use_file, mcount) < 0)
-        if ( max_threads == 1 )
+                    v1_format, msg, use_file, mcount) < 0) {
+        if (max_threads == 1)
             exit(6);
+    }
 
-    if ( max_threads > 1 )
-        DecrementAndSignalThreadCounter();
+    if (max_threads > 1)
+        decrement_and_signal_thread_counter();
     free(unused);
+    return NULL;
 }
 
-int main(argc, argv)
-    int argc;
-    char **argv;
+int
+main(int argc, char **argv)
 {
     int i;
 
@@ -764,25 +741,28 @@ int main(argc, argv)
     v1_format = 0;
 
     /* Parse arguments. */
-    argc--; argv++;
+    argc--;
+    argv++;
     while (argc) {
         if (strcmp(*argv, "-port") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             port = atoi(*argv);
         } else if (strcmp(*argv, "-mech") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             mechanism = *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, "-d") == 0) {
+        } else if (strcmp(*argv, "-d") == 0) {
             gss_flags |= GSS_C_DELEG_FLAG;
         } else if (strcmp(*argv, "-seq") == 0) {
             gss_flags |= GSS_C_SEQUENCE_FLAG;
@@ -795,15 +775,21 @@ int main(argc, argv)
         } else if (strcmp(*argv, "-q") == 0) {
             verbose = 0;
         } else if (strcmp(*argv, "-ccount") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             ccount = atoi(*argv);
-            if (ccount <= 0) usage();
+            if (ccount <= 0)
+                usage();
         } else if (strcmp(*argv, "-mcount") == 0) {
-            argc--; argv++;
-            if (!argc) usage();
+            argc--;
+            argv++;
+            if (!argc)
+                usage();
             mcount = atoi(*argv);
-            if (mcount < 0) usage();
+            if (mcount < 0)
+                usage();
         } else if (strcmp(*argv, "-na") == 0) {
             auth_flag = wrap_flag = encrypt_flag = mic_flag = 0;
         } else if (strcmp(*argv, "-nw") == 0) {
@@ -814,9 +800,11 @@ int main(argc, argv)
             mic_flag = 0;
         } else  if (strcmp(*argv, "-v1") == 0) {
             v1_format = 1;
-        } else
+        } else {
             break;
-        argc--; argv++;
+        }
+        argc--;
+        argv++;
     }
     if (argc != 3)
         usage();
@@ -827,8 +815,8 @@ int main(argc, argv)
         max_threads = 1;
     }
 
-    InitHandles();
-    SetEnvironmentVariable("KERBEROSLOGIN_NEVER_PROMPT","1");
+    init_handles();
+    SetEnvironmentVariable("KERBEROSLOGIN_NEVER_PROMPT", "1");
 #endif
 
     server_host = *argv++;
@@ -838,31 +826,28 @@ int main(argc, argv)
     if (mechanism)
         parse_oid(mechanism, &oid);
 
-    if (get_server_info(server_host, port) < 0) {
+    if (get_server_info(server_host, port) < 0)
         exit(1);
-    }
 
-    if ( max_threads == 1 ) {
-        for (i = 0; i < ccount; i++) {
+    if (max_threads == 1) {
+        for (i = 0; i < ccount; i++)
             worker_bee(0);
-        }
     } else {
         for (i = 0; i < ccount; i++) {
-            if ( WaitAndIncrementThreadCounter() ) {
+            if (wait_and_increment_thread_counter()) {
 #ifdef _WIN32
-                uintptr_t handle = _beginthread(worker_bee, 0, (void *)0);
-                if (handle == (uintptr_t)-1) {
+                uintptr_t handle = _beginthread(worker_bee, 0, (void *)NULL);
+                if (handle == (uintptr_t)-1)
                     exit(7);
-                }
 #else
                 int err;
                 pthread_t thr;
-                err = pthread_create(&thr, 0, (void *(*)(void *))worker_bee, malloc(12));
+                err = pthread_create(&thr, 0, worker_bee, malloc(12));
                 if (err) {
                     perror("pthread_create");
                     exit(7);
                 }
-                (void) pthread_detach(thr);
+                (void)pthread_detach(thr);
 #endif
             } else {
                 exit(8);
@@ -871,10 +856,10 @@ int main(argc, argv)
     }
 
     if (oid != GSS_C_NULL_OID)
-        (void) gss_release_oid(&min_stat, &oid);
+        (void)gss_release_oid(&min_stat, &oid);
 
 #ifdef _WIN32
-    CleanupHandles();
+    cleanup_handles();
 #else
     if (max_threads > 1)
         sleep(10);
diff --git a/src/tests/gss-threads/gss-misc.c b/src/tests/gss-threads/gss-misc.c
index 4fdbde31cd..670288e377 100644
--- a/src/tests/gss-threads/gss-misc.c
+++ b/src/tests/gss-threads/gss-misc.c
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
  * Copyright 1994 by OpenVision Technologies, Inc.
  *
@@ -80,32 +81,33 @@ extern char *malloc();
 
 FILE *display_file;
 
-gss_buffer_desc empty_token_buf = { 0, (void *) "" };
+gss_buffer_desc empty_token_buf = { 0, (void *)"" };
 gss_buffer_t empty_token = &empty_token_buf;
 
-static void display_status_1
-	(char *m, OM_uint32 code, int type);
+static void display_status_1(char *m, OM_uint32 code, int type);
 
-static int write_all(int fildes, char *buf, unsigned int nbyte)
+static int
+write_all(int fildes, char *buf, unsigned int nbyte)
 {
-     int ret;
-     char *ptr;
-
-     for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {
-	  ret = send(fildes, ptr, nbyte, 0);
-	  if (ret < 0) {
-	       if (errno == EINTR)
-		    continue;
-	       return(ret);
-	  } else if (ret == 0) {
-	       return(ptr-buf);
-	  }
-     }
-
-     return(ptr-buf);
+    int ret;
+    char *ptr;
+
+    for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {
+        ret = send(fildes, ptr, nbyte, 0);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            return ret;
+        } else if (ret == 0) {
+            return ptr - buf;
+        }
+    }
+
+    return ptr - buf;
 }
 
-static int read_all(int fildes, char *buf, unsigned int nbyte)
+static int
+read_all(int fildes, char *buf, unsigned int nbyte)
 {
     int ret;
     char *ptr;
@@ -118,20 +120,20 @@ static int read_all(int fildes, char *buf, unsigned int nbyte)
     tv.tv_usec = 0;
 
     for (ptr = buf; nbyte; ptr += ret, nbyte -= ret) {
-	if (select(FD_SETSIZE, &rfds, NULL, NULL, &tv) <= 0
-	    || !FD_ISSET(fildes, &rfds))
-	    return(ptr-buf);
-	ret = recv(fildes, ptr, nbyte, 0);
-	if (ret < 0) {
-	    if (errno == EINTR)
-		continue;
-	    return(ret);
-	} else if (ret == 0) {
-	    return(ptr-buf);
-	}
+        if (select(FD_SETSIZE, &rfds, NULL, NULL, &tv) <= 0 ||
+            !FD_ISSET(fildes, &rfds))
+            return ptr - buf;
+        ret = recv(fildes, ptr, nbyte, 0);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            return ret;
+        } else if (ret == 0) {
+            return ptr - buf;
+        }
     }
 
-    return(ptr-buf);
+    return ptr - buf;
 }
 
 /*
@@ -141,9 +143,9 @@ static int read_all(int fildes, char *buf, unsigned int nbyte)
  *
  * Arguments:
  *
- * 	s		(r) an open file descriptor
- *	flags		(r) the flags to write
- * 	tok		(r) the token to write
+ *      s               (r) an open file descriptor
+ *      flags           (r) the flags to write
+ *      tok             (r) the token to write
  *
  * Returns: 0 on success, -1 on failure
  *
@@ -155,50 +157,49 @@ static int read_all(int fildes, char *buf, unsigned int nbyte)
  * written to the file descriptor s.  It returns 0 on success, and -1
  * if an error occurs or if it could not write all the data.
  */
-int send_token(s, flags, tok)
-     int s;
-     int flags;
-     gss_buffer_t tok;
+int
+send_token(int s, int flags, gss_buffer_t tok)
 {
-     int ret;
-     unsigned char char_flags = (unsigned char) flags;
-     unsigned char lenbuf[4];
-
-     if (char_flags) {
-	 ret = write_all(s, (char *)&char_flags, 1);
-	 if (ret != 1) {
-	     perror("sending token flags");
-	     return -1;
-	 }
-     }
-     if (tok->length > 0xffffffffUL)
-	 abort();
-     store_32_be(tok->length, lenbuf);
-     ret = write_all(s, lenbuf, 4);
-     if (ret < 0) {
-	  perror("sending token length");
-	  return -1;
-     } else if (ret != 4) {
-	 if (display_file)
-	     fprintf(display_file,
-		     "sending token length: %d of %d bytes written\n",
-		     ret, 4);
-	  return -1;
-     }
-
-     ret = write_all(s, tok->value, tok->length);
-     if (ret < 0) {
-	  perror("sending token data");
-	  return -1;
-     } else if (ret != tok->length) {
-	 if (display_file)
-	     fprintf(display_file,
-		     "sending token data: %d of %d bytes written\n",
-		     ret, (int) tok->length);
-	 return -1;
-     }
-
-     return 0;
+    int ret;
+    unsigned char char_flags = (unsigned char)flags;
+    unsigned char lenbuf[4];
+
+    if (char_flags) {
+        ret = write_all(s, (char *)&char_flags, 1);
+        if (ret != 1) {
+            perror("sending token flags");
+            return -1;
+        }
+    }
+    if (tok->length > 0xffffffffUL)
+        abort();
+    store_32_be(tok->length, lenbuf);
+    ret = write_all(s, lenbuf, 4);
+    if (ret < 0) {
+        perror("sending token length");
+        return -1;
+    } else if (ret != 4) {
+        if (display_file) {
+            fprintf(display_file,
+                    "sending token length: %d of %d bytes written\n", ret, 4);
+        }
+        return -1;
+    }
+
+    ret = write_all(s, tok->value, tok->length);
+    if (ret < 0) {
+        perror("sending token data");
+        return -1;
+    } else if (ret != tok->length) {
+        if (display_file) {
+            fprintf(display_file,
+                    "sending token data: %d of %d bytes written\n",
+                    ret, (int)tok->length);
+        }
+        return -1;
+    }
+
+    return 0;
 }
 
 /*
@@ -208,9 +209,9 @@ int send_token(s, flags, tok)
  *
  * Arguments:
  *
- * 	s		(r) an open file descriptor
- *	flags		(w) the read flags
- * 	tok		(w) the read token
+ *      s               (r) an open file descriptor
+ *      flags           (w) the read flags
+ *      tok             (w) the read token
  *
  * Returns: 0 on success, -1 on failure
  *
@@ -224,104 +225,96 @@ int send_token(s, flags, tok)
  * should be freed with gss_release_buffer.  It returns 0 on success,
  * and -1 if an error occurs or if it could not read all the data.
  */
-int recv_token(s, flags, tok)
-     int s;
-     int *flags;
-     gss_buffer_t tok;
+int
+recv_token(int s, int *flags, gss_buffer_t tok)
 {
-     int ret;
-     unsigned char char_flags;
-     unsigned char lenbuf[4];
-
-     ret = read_all(s, (char *) &char_flags, 1);
-     if (ret < 0) {
-       perror("reading token flags");
-       return -1;
-     } else if (! ret) {
-       if (display_file)
-	 fputs("reading token flags: 0 bytes read\n", display_file);
-       return -1;
-     } else {
-       *flags = (int) char_flags;
-     }
-
-     if (char_flags == 0 ) {
-     lenbuf[0] = 0;
-     ret = read_all(s, &lenbuf[1], 3);
-     if (ret < 0) {
-	 perror("reading token length");
-	 return -1;
-     } else if (ret != 3) {
-	 if (display_file)
-	     fprintf(display_file,
-		     "reading token length: %d of %d bytes read\n",
-		     ret, 3);
-	 return -1;
-     }
-     }
-     else {
-       ret = read_all(s, lenbuf, 4);
-       if (ret < 0) {
-	 perror("reading token length");
-	 return -1;
-       } else if (ret != 4) {
-	 if (display_file)
-	   fprintf(display_file,
-		   "reading token length: %d of %d bytes read\n",
-		   ret, 4);
-	 return -1;
-       }
-     }
-
-     tok->length = ((lenbuf[0] << 24)
-		    | (lenbuf[1] << 16)
-		    | (lenbuf[2] << 8)
-		    | lenbuf[3]);
-     tok->value = (char *) malloc(tok->length ? tok->length : 1);
-     if (tok->length && tok->value == NULL) {
-	 if (display_file)
-	     fprintf(display_file,
-		     "Out of memory allocating token data\n");
-	  return -1;
-     }
-
-     ret = read_all(s, (char *) tok->value, tok->length);
-     if (ret < 0) {
-	  perror("reading token data");
-	  free(tok->value);
-	  return -1;
-     } else if (ret != tok->length) {
-	  fprintf(stderr, "sending token data: %d of %d bytes written\n",
-		  ret, (int) tok->length);
-	  free(tok->value);
-	  return -1;
-     }
-
-     return 0;
+    int ret;
+    unsigned char char_flags;
+    unsigned char lenbuf[4];
+
+    ret = read_all(s, (char *)&char_flags, 1);
+    if (ret < 0) {
+        perror("reading token flags");
+        return -1;
+    } else if (!ret) {
+        if (display_file)
+            fputs("reading token flags: 0 bytes read\n", display_file);
+        return -1;
+    } else {
+        *flags = char_flags;
+    }
+
+    if (char_flags == 0) {
+        lenbuf[0] = 0;
+        ret = read_all(s, &lenbuf[1], 3);
+        if (ret < 0) {
+            perror("reading token length");
+            return -1;
+        } else if (ret != 3) {
+            if (display_file) {
+                fprintf(display_file,
+                        "reading token length: %d of %d bytes read\n", ret, 3);
+            }
+            return -1;
+        }
+    } else {
+        ret = read_all(s, lenbuf, 4);
+        if (ret < 0) {
+            perror("reading token length");
+            return -1;
+        } else if (ret != 4) {
+            if (display_file) {
+                fprintf(display_file,
+                        "reading token length: %d of %d bytes read\n", ret, 4);
+            }
+            return -1;
+        }
+    }
+
+    tok->length = ((lenbuf[0] << 24) | (lenbuf[1] << 16) | (lenbuf[2] << 8) |
+                   lenbuf[3]);
+    tok->value = malloc(tok->length ? tok->length : 1);
+    if (tok->length && tok->value == NULL) {
+        if (display_file)
+            fprintf(display_file, "Out of memory allocating token data\n");
+        return -1;
+    }
+
+    ret = read_all(s, (char *)tok->value, tok->length);
+    if (ret < 0) {
+        perror("reading token data");
+        free(tok->value);
+        return -1;
+    } else if (ret != tok->length) {
+        fprintf(stderr, "sending token data: %d of %d bytes written\n",
+                ret, (int)tok->length);
+        free(tok->value);
+        return -1;
+    }
+
+    return 0;
 }
 
-static void display_status_1(m, code, type)
-     char *m;
-     OM_uint32 code;
-     int type;
+static void
+display_status_1(char *m, OM_uint32 code, int type)
 {
-     OM_uint32 maj_stat, min_stat;
-     gss_buffer_desc msg;
-     OM_uint32 msg_ctx;
-
-     msg_ctx = 0;
-     while (1) {
-	  maj_stat = gss_display_status(&min_stat, code,
-				       type, GSS_C_NULL_OID,
-				       &msg_ctx, &msg);
-	  if (display_file)
-	      fprintf(display_file, "GSS-API error %s: %s\n", m,
-		      (char *)msg.value);
-	  (void) gss_release_buffer(&min_stat, &msg);
-
-	  if (!msg_ctx)
-	       break;
-     }
+    OM_uint32 maj_stat, min_stat;
+    gss_buffer_desc msg;
+    OM_uint32 msg_ctx;
+
+    msg_ctx = 0;
+    while (1) {
+        maj_stat = gss_display_status(&min_stat, code, type, GSS_C_NULL_OID,
+                                      &msg_ctx, &msg);
+        if (display_file) {
+            fprintf(display_file, "GSS-API error %s: %s\n", m,
+                    (char *)msg.value);
+        }
+        (void)gss_release_buffer(&min_stat, &msg);
+
+        if (!msg_ctx)
+            break;
+    }
 }
 
 /*
@@ -331,9 +324,9 @@ static void display_status_1(m, code, type)
  *
  * Arguments:
  *
- * 	msg		a string to be displayed with the message
- * 	maj_stat	the GSS-API major status code
- * 	min_stat	the GSS-API minor status code
+ *      msg             a string to be displayed with the message
+ *      maj_stat        the GSS-API major status code
+ *      min_stat        the GSS-API minor status code
  *
  * Effects:
  *
@@ -341,24 +334,22 @@ static void display_status_1(m, code, type)
  * displayed on stderr, each preceeded by "GSS-API error <msg>: " and
  * followed by a newline.
  */
-void display_status(msg, maj_stat, min_stat)
-     char *msg;
-     OM_uint32 maj_stat;
-     OM_uint32 min_stat;
+void
+display_status(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat)
 {
-     display_status_1(msg, maj_stat, GSS_C_GSS_CODE);
-     display_status_1(msg, min_stat, GSS_C_MECH_CODE);
+    display_status_1(msg, maj_stat, GSS_C_GSS_CODE);
+    display_status_1(msg, min_stat, GSS_C_MECH_CODE);
 }
 
 /*
  * Function: display_ctx_flags
  *
  * Purpose: displays the flags returned by context initation in
- *	    a human-readable form
+ *          a human-readable form
  *
  * Arguments:
  *
- * 	int		ret_flags
+ *      int             ret_flags
  *
  * Effects:
  *
@@ -366,36 +357,36 @@ void display_status(msg, maj_stat, min_stat)
  * stdout, preceded by "context flag: " and followed by a newline
  */
 
-void display_ctx_flags(flags)
-     OM_uint32 flags;
+void
+display_ctx_flags(OM_uint32 flags)
 {
-     if (flags & GSS_C_DELEG_FLAG)
-	  fprintf(display_file, "context flag: GSS_C_DELEG_FLAG\n");
-     if (flags & GSS_C_MUTUAL_FLAG)
-	  fprintf(display_file, "context flag: GSS_C_MUTUAL_FLAG\n");
-     if (flags & GSS_C_REPLAY_FLAG)
-	  fprintf(display_file, "context flag: GSS_C_REPLAY_FLAG\n");
-     if (flags & GSS_C_SEQUENCE_FLAG)
-	  fprintf(display_file, "context flag: GSS_C_SEQUENCE_FLAG\n");
-     if (flags & GSS_C_CONF_FLAG )
-	  fprintf(display_file, "context flag: GSS_C_CONF_FLAG \n");
-     if (flags & GSS_C_INTEG_FLAG )
-	  fprintf(display_file, "context flag: GSS_C_INTEG_FLAG \n");
+    if (flags & GSS_C_DELEG_FLAG)
+        fprintf(display_file, "context flag: GSS_C_DELEG_FLAG\n");
+    if (flags & GSS_C_MUTUAL_FLAG)
+        fprintf(display_file, "context flag: GSS_C_MUTUAL_FLAG\n");
+    if (flags & GSS_C_REPLAY_FLAG)
+        fprintf(display_file, "context flag: GSS_C_REPLAY_FLAG\n");
+    if (flags & GSS_C_SEQUENCE_FLAG)
+        fprintf(display_file, "context flag: GSS_C_SEQUENCE_FLAG\n");
+    if (flags & GSS_C_CONF_FLAG)
+        fprintf(display_file, "context flag: GSS_C_CONF_FLAG \n");
+    if (flags & GSS_C_INTEG_FLAG)
+        fprintf(display_file, "context flag: GSS_C_INTEG_FLAG \n");
 }
 
-void print_token(tok)
-     gss_buffer_t tok;
+void
+print_token(gss_buffer_t tok)
 {
     size_t i;
     unsigned char *p = tok->value;
 
     if (!display_file)
-	return;
-    for (i=0; i < tok->length; i++, p++) {
-	fprintf(display_file, "%02x ", *p);
-	if ((i % 16) == 15) {
-	    fprintf(display_file, "\n");
-	}
+        return;
+    for (i = 0; i < tok->length; i++, p++) {
+        fprintf(display_file, "%02x ", *p);
+        if (i % 16 == 15) {
+            fprintf(display_file, "\n");
+        }
     }
     fprintf(display_file, "\n");
     fflush(display_file);
@@ -405,15 +396,18 @@ void print_token(tok)
 #include <sys\timeb.h>
 #include <time.h>
 
-int gettimeofday (struct timeval *tv, void *ignore_tz)
+int
+gettimeofday(struct timeval *tv, void *ignore_tz)
 {
     struct _timeb tb;
+
     _tzset();
     _ftime(&tb);
     if (tv) {
-	tv->tv_sec = tb.time;
-	tv->tv_usec = tb.millitm * 1000;
+        tv->tv_sec = tb.time;
+        tv->tv_usec = tb.millitm * 1000;
     }
     return 0;
 }
+
 #endif /* _WIN32 */
diff --git a/src/tests/gss-threads/gss-misc.h b/src/tests/gss-threads/gss-misc.h
index 77d8190f94..1ed8fb6c4c 100644
--- a/src/tests/gss-threads/gss-misc.h
+++ b/src/tests/gss-threads/gss-misc.h
@@ -20,10 +20,6 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/*
- * $Id$
- */
-
 #ifndef _GSSMISC_H_
 #define _GSSMISC_H_
 
@@ -32,16 +28,11 @@
 
 extern FILE *display_file;
 
-int send_token
-	(int s, int flags, gss_buffer_t tok);
-int recv_token
-	(int s, int *flags, gss_buffer_t tok);
-void display_status
-	(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat);
-void display_ctx_flags
-	(OM_uint32 flags);
-void print_token
-	(gss_buffer_t tok);
+int send_token(int s, int flags, gss_buffer_t tok);
+int recv_token(int s, int *flags, gss_buffer_t tok);
+void display_status(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat);
+void display_ctx_flags(OM_uint32 flags);
+void print_token(gss_buffer_t tok);
 
 /* Token types */
 #define TOKEN_NOOP		(1<<0)
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;