From: Viktor Szakats <commit@vsz.me>
Date: Sun, 22 Sep 2024 15:48:17 +0000 (+0200)
Subject: tests/server: round of tidy-ups (part 2)
X-Git-Tag: curl-8_13_0~225
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=bc55b435afbb94c9c0e4b138d5375702c451a2ea;p=thirdparty%2Fcurl.git

tests/server: round of tidy-ups (part 2)

General tidy-ups, to identify and reduce duplications and potential
issues, while also making the server modules compile as a single binary.

- ensure unique symbols and no shadowing across server sources, by
  renaming variables.
- move globals common to multiple servers into shared `util` module.
- drop constants with a single use.
- undef macro before re-using them across server sources.
- move common functions into shared `util` module.
- drop redundant static declarations.
- disable IPv6 code when built without IPv6.
- start syncing the 3 almost identical copies of `sockdaemon` function.
- drop unused `timeval.h` header.
- drop `poll()` from `wait_ms()`, for macOS, following an earlier core
  update.
  Follow-up to c72cefea0fadaf4114a0036c86005ee5739ec30a #15096

Follow-up to 9213e4e497d575d2bc2c9265d40da6c5549f526d #16525
Cherry-picked from #15000
Closes #16609
---

diff --git a/tests/server/mqttd.c b/tests/server/mqttd.c
index 68c31e2bba..fb21f704a4 100644
--- a/tests/server/mqttd.c
+++ b/tests/server/mqttd.c
@@ -63,12 +63,6 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-#define DEFAULT_PORT 1883 /* MQTT default port */
-
-#ifndef DEFAULT_CONFIG
-#define DEFAULT_CONFIG "mqttd.config"
-#endif
-
 #define MQTT_MSG_CONNECT    0x10
 #define MQTT_MSG_CONNACK    0x20
 #define MQTT_MSG_PUBLISH    0x30
@@ -77,7 +71,7 @@
 #define MQTT_MSG_SUBACK     0x90
 #define MQTT_MSG_DISCONNECT 0xe0
 
-struct configurable {
+struct mqttd_configurable {
   unsigned char version; /* initial version byte in the request must match
                             this */
   bool publish_before_suback;
@@ -90,39 +84,23 @@ struct configurable {
 #define REQUEST_DUMP  "server.input"
 #define CONFIG_VERSION 5
 
-static struct configurable config;
-
-static const char *configfile = DEFAULT_CONFIG;
-static const char *logdir = "log";
-static char loglockfile[256];
-
-#ifdef USE_IPV6
-static bool use_ipv6 = FALSE;
-#endif
-static const char *ipv_inuse = "IPv4";
-static unsigned short port = DEFAULT_PORT;
+static struct mqttd_configurable m_config;
 
-static void resetdefaults(void)
+static void mqttd_resetdefaults(void)
 {
   logmsg("Reset to defaults");
-  config.version = CONFIG_VERSION;
-  config.publish_before_suback = FALSE;
-  config.short_publish = FALSE;
-  config.excessive_remaining = FALSE;
-  config.error_connack = 0;
-  config.testnum = 0;
+  m_config.version = CONFIG_VERSION;
+  m_config.publish_before_suback = FALSE;
+  m_config.short_publish = FALSE;
+  m_config.excessive_remaining = FALSE;
+  m_config.error_connack = 0;
+  m_config.testnum = 0;
 }
 
-static unsigned char byteval(char *value)
-{
-  unsigned long num = strtoul(value, NULL, 10);
-  return num & 0xff;
-}
-
-static void getconfig(void)
+static void mqttd_getconfig(void)
 {
   FILE *fp = fopen(configfile, FOPEN_READTEXT);
-  resetdefaults();
+  mqttd_resetdefaults();
   if(fp) {
     char buffer[512];
     logmsg("parse config file");
@@ -131,28 +109,28 @@ static void getconfig(void)
       char value[32];
       if(2 == sscanf(buffer, "%31s %31s", key, value)) {
         if(!strcmp(key, "version")) {
-          config.version = byteval(value);
-          logmsg("version [%d] set", config.version);
+          m_config.version = byteval(value);
+          logmsg("version [%d] set", m_config.version);
         }
         else if(!strcmp(key, "PUBLISH-before-SUBACK")) {
           logmsg("PUBLISH-before-SUBACK set");
-          config.publish_before_suback = TRUE;
+          m_config.publish_before_suback = TRUE;
         }
         else if(!strcmp(key, "short-PUBLISH")) {
           logmsg("short-PUBLISH set");
-          config.short_publish = TRUE;
+          m_config.short_publish = TRUE;
         }
         else if(!strcmp(key, "error-CONNACK")) {
-          config.error_connack = byteval(value);
-          logmsg("error-CONNACK = %d", config.error_connack);
+          m_config.error_connack = byteval(value);
+          logmsg("error-CONNACK = %d", m_config.error_connack);
         }
         else if(!strcmp(key, "Testnum")) {
-          config.testnum = atoi(value);
-          logmsg("testnum = %d", config.testnum);
+          m_config.testnum = atoi(value);
+          logmsg("testnum = %d", m_config.testnum);
         }
         else if(!strcmp(key, "excessive-remaining")) {
           logmsg("excessive-remaining set");
-          config.excessive_remaining = TRUE;
+          m_config.excessive_remaining = TRUE;
         }
       }
     }
@@ -163,25 +141,6 @@ static void getconfig(void)
   }
 }
 
-static void loghex(unsigned char *buffer, ssize_t len)
-{
-  char data[12000];
-  ssize_t i;
-  unsigned char *ptr = buffer;
-  char *optr = data;
-  ssize_t width = 0;
-  int left = sizeof(data);
-
-  for(i = 0; i < len && (left >= 0); i++) {
-    msnprintf(optr, left, "%02x", ptr[i]);
-    width += 2;
-    optr += 2;
-    left -= 2;
-  }
-  if(width)
-    logmsg("'%s'", data);
-}
-
 typedef enum {
   FROM_CLIENT,
   FROM_SERVER
@@ -218,7 +177,7 @@ static int connack(FILE *dump, curl_socket_t fd)
   };
   ssize_t rc;
 
-  packet[3] = config.error_connack;
+  packet[3] = m_config.error_connack;
 
   rc = swrite(fd, (char *)packet, sizeof(packet));
   if(rc > 0) {
@@ -343,7 +302,7 @@ static size_t encode_length(size_t packetlen,
 }
 
 
-static size_t decode_length(unsigned char *buf,
+static size_t decode_length(unsigned char *buffer,
                             size_t buflen, size_t *lenbytes)
 {
   size_t len = 0;
@@ -352,7 +311,7 @@ static size_t decode_length(unsigned char *buf,
   unsigned char encoded = 0x80;
 
   for(i = 0; (i < buflen) && (encoded & 0x80); i++) {
-    encoded = buf[i];
+    encoded = buffer[i];
     len += (encoded & 0x7f) * mult;
     mult *= 0x80;
   }
@@ -379,7 +338,7 @@ static int publish(FILE *dump,
   unsigned char rembuffer[4];
   size_t encodedlen;
 
-  if(config.excessive_remaining) {
+  if(m_config.excessive_remaining) {
     /* manually set illegal remaining length */
     rembuffer[0] = 0xff;
     rembuffer[1] = 0xff;
@@ -410,7 +369,7 @@ static int publish(FILE *dump,
   memcpy(&packet[payloadindex], payload, payloadlen);
 
   sendamount = packetlen;
-  if(config.short_publish)
+  if(m_config.short_publish)
     sendamount -= 2;
 
   rc = swrite(fd, (char *)packet, sendamount);
@@ -493,9 +452,9 @@ static curl_socket_t mqttit(curl_socket_t fd)
   if(!dump)
     goto end;
 
-  getconfig();
+  mqttd_getconfig();
 
-  testno = config.testnum;
+  testno = m_config.testnum;
 
   if(testno)
     logmsg("Found test number %ld", testno);
@@ -627,7 +586,7 @@ static curl_socket_t mqttit(curl_socket_t fd)
       stream = test2fopen(testno, logdir);
       error = getpart(&data, &datalen, "reply", "data", stream);
       if(!error) {
-        if(!config.publish_before_suback) {
+        if(!m_config.publish_before_suback) {
           if(suback(dump, fd, packet_id)) {
             logmsg("failed sending SUBACK");
             free(data);
@@ -640,7 +599,7 @@ static curl_socket_t mqttit(curl_socket_t fd)
           goto end;
         }
         free(data);
-        if(config.publish_before_suback) {
+        if(m_config.publish_before_suback) {
           if(suback(dump, fd, packet_id)) {
             logmsg("failed sending SUBACK");
             goto end;
@@ -698,7 +657,7 @@ end:
   if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must
   accept()
 */
-static bool incoming(curl_socket_t listenfd)
+static bool mqttd_incoming(curl_socket_t listenfd)
 {
   fd_set fds_read;
   fd_set fds_write;
@@ -776,8 +735,9 @@ static bool incoming(curl_socket_t listenfd)
   return TRUE;
 }
 
-static curl_socket_t sockdaemon(curl_socket_t sock,
-                                unsigned short *listenport)
+static curl_socket_t mqttd_sockdaemon(curl_socket_t sock,
+                                      unsigned short *listenport,
+                                      bool bind_only)
 {
   /* passive daemon style */
   srvr_sockaddr_union_t listener;
@@ -802,7 +762,9 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
         rc = wait_ms(delay);
         if(rc) {
           /* should not happen */
-          logmsg("wait_ms() failed with error (%d)", rc);
+          error = errno;
+          logmsg("wait_ms() failed with error (%d) %s",
+                 error, strerror(error));
           sclose(sock);
           return CURL_SOCKET_BAD;
         }
@@ -896,6 +858,12 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
     }
   }
 
+  /* bindonly option forces no listening */
+  if(bind_only) {
+    logmsg("instructed to bind port without listening");
+    return sock;
+  }
+
   /* start accepting connections */
   rc = listen(sock, 5);
   if(0 != rc) {
@@ -916,13 +884,15 @@ int main(int argc, char *argv[])
   curl_socket_t msgsock = CURL_SOCKET_BAD;
   int wrotepidfile = 0;
   int wroteportfile = 0;
-  const char *pidname = ".mqttd.pid";
-  const char *portname = ".mqttd.port";
   bool juggle_again;
   int error;
   int arg = 1;
 
+  pidname = ".mqttd.pid";
+  portname = ".mqttd.port";
   serverlogfile = "log/mqttd.log";
+  configfile = "mqttd.config";
+  server_port = 1883; /* MQTT default port */
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -986,7 +956,7 @@ int main(int argc, char *argv[])
                   argv[arg]);
           return 0;
         }
-        port = util_ultous(ulnum);
+        server_port = util_ultous(ulnum);
         arg++;
       }
     }
@@ -1036,7 +1006,7 @@ int main(int argc, char *argv[])
 
   {
     /* passive daemon style */
-    sock = sockdaemon(sock, &port);
+    sock = mqttd_sockdaemon(sock, &server_port, FALSE);
     if(CURL_SOCKET_BAD == sock) {
       goto mqttd_cleanup;
     }
@@ -1044,20 +1014,20 @@ int main(int argc, char *argv[])
   }
 
   logmsg("Running %s version", ipv_inuse);
-  logmsg("Listening on port %hu", port);
+  logmsg("Listening on port %hu", server_port);
 
   wrotepidfile = write_pidfile(pidname);
   if(!wrotepidfile) {
     goto mqttd_cleanup;
   }
 
-  wroteportfile = write_portfile(portname, port);
+  wroteportfile = write_portfile(portname, server_port);
   if(!wroteportfile) {
     goto mqttd_cleanup;
   }
 
   do {
-    juggle_again = incoming(sock);
+    juggle_again = mqttd_incoming(sock);
   } while(juggle_again);
 
 mqttd_cleanup:
diff --git a/tests/server/resolve.c b/tests/server/resolve.c
index 0a0c884b94..02e87b0355 100644
--- a/tests/server/resolve.c
+++ b/tests/server/resolve.c
@@ -50,9 +50,6 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-static bool use_ipv6 = FALSE;
-static const char *ipv_inuse = "IPv4";
-
 int main(int argc, char *argv[])
 {
   int arg = 1;
@@ -71,14 +68,21 @@ int main(int argc, char *argv[])
       return 0;
     }
     else if(!strcmp("--ipv6", argv[arg])) {
+#if defined(CURLRES_IPV6)
       ipv_inuse = "IPv6";
       use_ipv6 = TRUE;
       arg++;
+#else
+      puts("IPv6 support has been disabled in this program");
+      return 1;
+#endif
     }
     else if(!strcmp("--ipv4", argv[arg])) {
       /* for completeness, we support this option as well */
       ipv_inuse = "IPv4";
+#if defined(CURLRES_IPV6)
       use_ipv6 = FALSE;
+#endif
       arg++;
     }
     else {
@@ -127,13 +131,8 @@ int main(int argc, char *argv[])
       freeaddrinfo(ai);
   }
 #else
-  if(use_ipv6) {
-    puts("IPv6 support has been disabled in this program");
-    return 1;
-  }
-  else {
-    /* gethostbyname() resolve */
-    struct hostent *he;
+  {
+    struct hostent *he;  /* gethostbyname() resolve */
 
 #ifdef __AMIGA__
     he = gethostbyname((unsigned char *)host);
diff --git a/tests/server/rtspd.c b/tests/server/rtspd.c
index 33fcd5689e..9389c3cf70 100644
--- a/tests/server/rtspd.c
+++ b/tests/server/rtspd.c
@@ -56,19 +56,15 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-#ifdef USE_IPV6
-static bool use_ipv6 = FALSE;
-#endif
-static const char *ipv_inuse = "IPv4";
-static int serverlogslocked = 0;
-
+#undef REQBUFSIZ
 #define REQBUFSIZ 150000
 
-static long prevtestno = -1;    /* previous test number we served */
-static long prevpartno = -1;    /* previous part number we served */
-static bool prevbounce = FALSE; /* instructs the server to override the
-                                   requested part number to prevpartno + 1 when
-                                   prevtestno and current test are the same */
+static long rtspd_prevtestno = -1;    /* previous test number we served */
+static long rtspd_prevpartno = -1;    /* previous part number we served */
+static bool rtspd_prevbounce = FALSE; /* instructs the server to override the
+                                         requested part number to
+                                         prevpartno + 1 when prevtestno and
+                                         current test are the same */
 
 #define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
 #define RCMD_IDLE      1 /* told to sit idle */
@@ -85,7 +81,7 @@ typedef enum {
 #define SET_RTP_PKT_LEN(p,l) (((p)[2] = (char)(((l) >> 8) & 0xFF)), \
                               ((p)[3] = (char)((l) & 0xFF)))
 
-struct httprequest {
+struct rtspd_httprequest {
   char reqbuf[REQBUFSIZ]; /* buffer area for the incoming request */
   size_t checkindex; /* where to start checking of the request */
   size_t offset;     /* size of the incoming request */
@@ -112,14 +108,6 @@ struct httprequest {
   size_t rtp_buffersize;
 };
 
-static int ProcessRequest(struct httprequest *req);
-static void storerequest(char *reqbuf, size_t totalsize);
-
-#define DEFAULT_PORT 8999
-
-static const char *logdir = "log";
-static char loglockfile[256];
-
 #define RTSPDVERSION "curl test suite RTSP server/0.1"
 
 #define REQUEST_DUMP  "server.input"
@@ -145,7 +133,7 @@ static char loglockfile[256];
 
 
 /* sent as reply to a QUIT */
-static const char *docquit =
+static const char *docquit_rtsp =
 "HTTP/1.1 200 Goodbye" END_OF_HEADERS;
 
 /* sent as reply to a CONNECT */
@@ -179,7 +167,7 @@ static const char *doc404_RTSP = "RTSP/1.0 404 Not Found\r\n"
 #define RTP_DATA_SIZE 12
 static const char *RTP_DATA = "$_1234\n\0Rsdf";
 
-static int ProcessRequest(struct httprequest *req)
+static int rtspd_ProcessRequest(struct rtspd_httprequest *req)
 {
   char *line = &req->reqbuf[req->checkindex];
   bool chunked = FALSE;
@@ -189,7 +177,7 @@ static int ProcessRequest(struct httprequest *req)
   int prot_major, prot_minor;
   char *end = strstr(line, END_OF_HEADERS);
 
-  logmsg("ProcessRequest() called with testno %ld and line [%s]",
+  logmsg("rtspd_ProcessRequest() called with testno %ld and line [%s]",
          req->testno, line);
 
   /* try to figure out the request characteristics as soon as possible, but
@@ -418,10 +406,10 @@ static int ProcessRequest(struct httprequest *req)
 
   if(!end) {
     /* we don't have a complete request yet! */
-    logmsg("ProcessRequest returned without a complete request");
+    logmsg("rtspd_ProcessRequest returned without a complete request");
     return 0; /* not complete yet */
   }
-  logmsg("ProcessRequest found a complete request");
+  logmsg("rtspd_ProcessRequest found a complete request");
 
   if(req->pipe)
     /* we do have a full set, advance the checkindex to after the end of the
@@ -573,7 +561,7 @@ static int ProcessRequest(struct httprequest *req)
 }
 
 /* store the entire request in a file */
-static void storerequest(char *reqbuf, size_t totalsize)
+static void rtspd_storerequest(char *reqbuf, size_t totalsize)
 {
   int res;
   int error = 0;
@@ -627,7 +615,7 @@ storerequest_cleanup:
 }
 
 /* return 0 on success, non-zero on failure */
-static int get_request(curl_socket_t sock, struct httprequest *req)
+static int rtspd_get_request(curl_socket_t sock, struct rtspd_httprequest *req)
 {
   int error;
   int fail = 0;
@@ -695,7 +683,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
     if(fail) {
       /* dump the request received so far to the external file */
       reqbuf[req->offset] = '\0';
-      storerequest(reqbuf, req->offset);
+      rtspd_storerequest(reqbuf, req->offset);
       return 1;
     }
 
@@ -704,7 +692,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
     req->offset += (size_t)got;
     reqbuf[req->offset] = '\0';
 
-    done_processing = ProcessRequest(req);
+    done_processing = rtspd_ProcessRequest(req);
     if(got_exit_signal)
       return 1;
     if(done_processing && req->pipe) {
@@ -730,7 +718,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
     reqbuf[req->offset] = '\0';
 
   /* dump the request to an external file */
-  storerequest(reqbuf, req->pipelining ? req->checkindex : req->offset);
+  rtspd_storerequest(reqbuf, req->pipelining ? req->checkindex : req->offset);
   if(got_exit_signal)
     return 1;
 
@@ -738,7 +726,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
 }
 
 /* returns -1 on failure */
-static int send_doc(curl_socket_t sock, struct httprequest *req)
+static int rtspd_send_doc(curl_socket_t sock, struct rtspd_httprequest *req)
 {
   ssize_t written;
   size_t count;
@@ -791,7 +779,7 @@ static int send_doc(curl_socket_t sock, struct httprequest *req)
     switch(req->testno) {
     case DOCNUMBER_QUIT:
       logmsg("Replying to QUIT");
-      buffer = docquit;
+      buffer = docquit_rtsp;
       break;
     case DOCNUMBER_WERULEZ:
       /* we got a "friends?" question, reply back that we sure are */
@@ -890,11 +878,11 @@ static int send_doc(curl_socket_t sock, struct httprequest *req)
     logmsg("connection close instruction \"swsclose\" found in response");
   }
   if(strstr(buffer, "swsbounce")) {
-    prevbounce = TRUE;
+    rtspd_prevbounce = TRUE;
     logmsg("enable \"swsbounce\" in the next request");
   }
   else
-    prevbounce = FALSE;
+    rtspd_prevbounce = FALSE;
 
   dump = fopen(responsedump, "ab");
   if(!dump) {
@@ -1016,8 +1004,8 @@ static int send_doc(curl_socket_t sock, struct httprequest *req)
   free(cmd);
   req->open = persistent;
 
-  prevtestno = req->testno;
-  prevpartno = req->partno;
+  rtspd_prevtestno = req->testno;
+  rtspd_prevpartno = req->partno;
 
   return 0;
 }
@@ -1031,17 +1019,17 @@ int main(int argc, char *argv[])
   int wrotepidfile = 0;
   int wroteportfile = 0;
   int flag;
-  unsigned short port = DEFAULT_PORT;
-  const char *pidname = ".rtsp.pid";
-  const char *portname = NULL; /* none by default */
-  struct httprequest req;
+  unsigned short port = 8999;
+  struct rtspd_httprequest req;
   int rc;
   int error;
   int arg = 1;
 
   memset(&req, 0, sizeof(req));
 
+  pidname = ".rtsp.pid";
   serverlogfile = "log/rtspd.log";
+  serverlogslocked = 0;
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -1284,9 +1272,9 @@ int main(int argc, char *argv[])
     }
 #endif
 
-    /* initialization of httprequest struct is done in get_request(), but due
-       to pipelining treatment the pipelining struct field must be initialized
-       previously to FALSE every time a new connection arrives. */
+    /* initialization of httprequest struct is done in rtspd_get_request(),
+       but due to pipelining treatment the pipelining struct field must be
+       initialized previously to FALSE every time a new connection arrives. */
 
     req.pipelining = FALSE;
 
@@ -1294,24 +1282,24 @@ int main(int argc, char *argv[])
       if(got_exit_signal)
         break;
 
-      if(get_request(msgsock, &req))
+      if(rtspd_get_request(msgsock, &req))
         /* non-zero means error, break out of loop */
         break;
 
-      if(prevbounce) {
+      if(rtspd_prevbounce) {
         /* bounce treatment requested */
-        if(req.testno == prevtestno) {
-          req.partno = prevpartno + 1;
+        if(req.testno == rtspd_prevtestno) {
+          req.partno = rtspd_prevpartno + 1;
           logmsg("BOUNCE part number to %ld", req.partno);
         }
         else {
-          prevbounce = FALSE;
-          prevtestno = -1;
-          prevpartno = -1;
+          rtspd_prevbounce = FALSE;
+          rtspd_prevtestno = -1;
+          rtspd_prevpartno = -1;
         }
       }
 
-      send_doc(msgsock, &req);
+      rtspd_send_doc(msgsock, &req);
       if(got_exit_signal)
         break;
 
diff --git a/tests/server/sockfilt.c b/tests/server/sockfilt.c
index 75d592a2de..7f4784cb10 100644
--- a/tests/server/sockfilt.c
+++ b/tests/server/sockfilt.c
@@ -114,20 +114,14 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-#define DEFAULT_PORT 8999
-
 /* buffer is this excessively large only to be able to support things like
   test 1003 which tests exceedingly large server response lines */
 #define BUFFER_SIZE 17010
 
 static bool verbose = FALSE;
-static bool bind_only = FALSE;
-#ifdef USE_IPV6
-static bool use_ipv6 = FALSE;
-#endif
-static const char *ipv_inuse = "IPv4";
-static unsigned short port = DEFAULT_PORT;
-static unsigned short connectport = 0; /* if non-zero, we activate this mode */
+static bool s_bind_only = FALSE;
+static unsigned short server_connectport = 0; /* if non-zero,
+                                                 we activate this mode */
 
 enum sockmode {
   PASSIVE_LISTEN,    /* as a server waiting for connections */
@@ -1126,7 +1120,8 @@ static bool juggle(curl_socket_t *sockfdp,
     else if(!memcmp("PORT", buffer, 4)) {
       /* Question asking us what PORT number we are listening to.
          Replies to PORT with "IPv[num]/[port]" */
-      msnprintf((char *)buffer, sizeof(buffer), "%s/%hu\n", ipv_inuse, port);
+      msnprintf((char *)buffer, sizeof(buffer), "%s/%hu\n",
+                ipv_inuse, server_port);
       buffer_len = (ssize_t)strlen((char *)buffer);
       msnprintf(data, sizeof(data), "PORT\n%04zx\n", buffer_len);
       if(!write_stdout(data, 10))
@@ -1231,8 +1226,9 @@ static bool juggle(curl_socket_t *sockfdp,
 #endif
 }
 
-static curl_socket_t sockdaemon(curl_socket_t sock,
-                                unsigned short *listenport)
+static curl_socket_t sockfilt_sockdaemon(curl_socket_t sock,
+                                         unsigned short *listenport,
+                                         bool bind_only)
 {
   /* passive daemon style */
   srvr_sockaddr_union_t listener;
@@ -1380,8 +1376,6 @@ int main(int argc, char *argv[])
   curl_socket_t msgsock = CURL_SOCKET_BAD;
   int wrotepidfile = 0;
   int wroteportfile = 0;
-  const char *pidname = ".sockfilt.pid";
-  const char *portname = NULL; /* none by default */
   bool juggle_again;
   int rc;
   int error;
@@ -1389,7 +1383,9 @@ int main(int argc, char *argv[])
   enum sockmode mode = PASSIVE_LISTEN; /* default */
   const char *addr = NULL;
 
+  pidname = ".sockfilt.pid";
   serverlogfile = "log/sockfilt.log";
+  server_port = 8999;
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -1437,7 +1433,7 @@ int main(int argc, char *argv[])
       arg++;
     }
     else if(!strcmp("--bindonly", argv[arg])) {
-      bind_only = TRUE;
+      s_bind_only = TRUE;
       arg++;
     }
     else if(!strcmp("--port", argv[arg])) {
@@ -1445,7 +1441,7 @@ int main(int argc, char *argv[])
       if(argc > arg) {
         char *endptr;
         unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
-        port = util_ultous(ulnum);
+        server_port = util_ultous(ulnum);
         arg++;
       }
     }
@@ -1462,7 +1458,7 @@ int main(int argc, char *argv[])
                   argv[arg]);
           return 0;
         }
-        connectport = util_ultous(ulnum);
+        server_connectport = util_ultous(ulnum);
         arg++;
       }
     }
@@ -1518,7 +1514,7 @@ int main(int argc, char *argv[])
     goto sockfilt_cleanup;
   }
 
-  if(connectport) {
+  if(server_connectport) {
     /* Active mode, we should connect to the given port number */
     mode = ACTIVE;
 #ifdef USE_IPV6
@@ -1526,7 +1522,7 @@ int main(int argc, char *argv[])
 #endif
       memset(&me.sa4, 0, sizeof(me.sa4));
       me.sa4.sin_family = AF_INET;
-      me.sa4.sin_port = htons(connectport);
+      me.sa4.sin_port = htons(server_connectport);
       me.sa4.sin_addr.s_addr = INADDR_ANY;
       if(!addr)
         addr = "127.0.0.1";
@@ -1538,7 +1534,7 @@ int main(int argc, char *argv[])
     else {
       memset(&me.sa6, 0, sizeof(me.sa6));
       me.sa6.sin6_family = AF_INET6;
-      me.sa6.sin6_port = htons(connectport);
+      me.sa6.sin6_port = htons(server_connectport);
       if(!addr)
         addr = "::1";
       Curl_inet_pton(AF_INET6, addr, &me.sa6.sin6_addr);
@@ -1549,7 +1545,7 @@ int main(int argc, char *argv[])
     if(rc) {
       error = SOCKERRNO;
       logmsg("Error connecting to port %hu (%d) %s",
-             connectport, error, sstrerror(error));
+             server_connectport, error, sstrerror(error));
       write_stdout("FAIL\n", 5);
       goto sockfilt_cleanup;
     }
@@ -1558,7 +1554,7 @@ int main(int argc, char *argv[])
   }
   else {
     /* passive daemon style */
-    sock = sockdaemon(sock, &port);
+    sock = sockfilt_sockdaemon(sock, &server_port, s_bind_only);
     if(CURL_SOCKET_BAD == sock) {
       write_stdout("FAIL\n", 5);
       goto sockfilt_cleanup;
@@ -1568,12 +1564,12 @@ int main(int argc, char *argv[])
 
   logmsg("Running %s version", ipv_inuse);
 
-  if(connectport)
-    logmsg("Connected to port %hu", connectport);
-  else if(bind_only)
-    logmsg("Bound without listening on port %hu", port);
+  if(server_connectport)
+    logmsg("Connected to port %hu", server_connectport);
+  else if(s_bind_only)
+    logmsg("Bound without listening on port %hu", server_port);
   else
-    logmsg("Listening on port %hu", port);
+    logmsg("Listening on port %hu", server_port);
 
   wrotepidfile = write_pidfile(pidname);
   if(!wrotepidfile) {
@@ -1581,7 +1577,7 @@ int main(int argc, char *argv[])
     goto sockfilt_cleanup;
   }
   if(portname) {
-    wroteportfile = write_portfile(portname, port);
+    wroteportfile = write_portfile(portname, server_port);
     if(!wroteportfile) {
       write_stdout("FAIL\n", 5);
       goto sockfilt_cleanup;
diff --git a/tests/server/socksd.c b/tests/server/socksd.c
index 173a94cdd2..7afdea8d78 100644
--- a/tests/server/socksd.c
+++ b/tests/server/socksd.c
@@ -85,20 +85,10 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-#define DEFAULT_PORT 8905
-
-#ifndef DEFAULT_REQFILE
-#define DEFAULT_REQFILE "log/socksd-request.log"
-#endif
-
-#ifndef DEFAULT_CONFIG
-#define DEFAULT_CONFIG "socksd.config"
-#endif
-
 static const char *backendaddr = "127.0.0.1";
 static unsigned short backendport = 0; /* default is use client's */
 
-struct configurable {
+struct socksd_configurable {
   unsigned char version; /* initial version byte in the request must match
                             this */
   unsigned char nmethods_min; /* minimum number of nmethods to expect */
@@ -123,34 +113,24 @@ struct configurable {
 #define CONFIG_ADDR backendaddr
 #define CONFIG_CONNECTREP 0
 
-static struct configurable config;
-
-static const char *reqlogfile = DEFAULT_REQFILE;
-static const char *configfile = DEFAULT_CONFIG;
+static struct socksd_configurable s_config;
 
-static const char *socket_type = "IPv4";
-static unsigned short port = DEFAULT_PORT;
+static const char *reqlogfile = "log/socksd-request.log";
 
-static void resetdefaults(void)
+static void socksd_resetdefaults(void)
 {
   logmsg("Reset to defaults");
-  config.version = CONFIG_VERSION;
-  config.nmethods_min = CONFIG_NMETHODS_MIN;
-  config.nmethods_max = CONFIG_NMETHODS_MAX;
-  config.responseversion = CONFIG_RESPONSEVERSION;
-  config.responsemethod = CONFIG_RESPONSEMETHOD;
-  config.reqcmd = CONFIG_REQCMD;
-  config.connectrep = CONFIG_CONNECTREP;
-  config.port = CONFIG_PORT;
-  strcpy(config.addr, CONFIG_ADDR);
-  strcpy(config.user, "user");
-  strcpy(config.password, "password");
-}
-
-static unsigned char byteval(char *value)
-{
-  unsigned long num = strtoul(value, NULL, 10);
-  return num & 0xff;
+  s_config.version = CONFIG_VERSION;
+  s_config.nmethods_min = CONFIG_NMETHODS_MIN;
+  s_config.nmethods_max = CONFIG_NMETHODS_MAX;
+  s_config.responseversion = CONFIG_RESPONSEVERSION;
+  s_config.responsemethod = CONFIG_RESPONSEMETHOD;
+  s_config.reqcmd = CONFIG_REQCMD;
+  s_config.connectrep = CONFIG_CONNECTREP;
+  s_config.port = CONFIG_PORT;
+  strcpy(s_config.addr, CONFIG_ADDR);
+  strcpy(s_config.user, "user");
+  strcpy(s_config.password, "password");
 }
 
 static unsigned short shortval(char *value)
@@ -159,12 +139,10 @@ static unsigned short shortval(char *value)
   return num & 0xffff;
 }
 
-static int socket_domain = AF_INET;
-
-static void getconfig(void)
+static void socksd_getconfig(void)
 {
   FILE *fp = fopen(configfile, FOPEN_READTEXT);
-  resetdefaults();
+  socksd_resetdefaults();
   if(fp) {
     char buffer[512];
     logmsg("parse config file");
@@ -173,32 +151,32 @@ static void getconfig(void)
       char value[260];
       if(2 == sscanf(buffer, "%31s %259s", key, value)) {
         if(!strcmp(key, "version")) {
-          config.version = byteval(value);
-          logmsg("version [%d] set", config.version);
+          s_config.version = byteval(value);
+          logmsg("version [%d] set", s_config.version);
         }
         else if(!strcmp(key, "nmethods_min")) {
-          config.nmethods_min = byteval(value);
-          logmsg("nmethods_min [%d] set", config.nmethods_min);
+          s_config.nmethods_min = byteval(value);
+          logmsg("nmethods_min [%d] set", s_config.nmethods_min);
         }
         else if(!strcmp(key, "nmethods_max")) {
-          config.nmethods_max = byteval(value);
-          logmsg("nmethods_max [%d] set", config.nmethods_max);
+          s_config.nmethods_max = byteval(value);
+          logmsg("nmethods_max [%d] set", s_config.nmethods_max);
         }
         else if(!strcmp(key, "backend")) {
-          strcpy(config.addr, value);
-          logmsg("backend [%s] set", config.addr);
+          strcpy(s_config.addr, value);
+          logmsg("backend [%s] set", s_config.addr);
         }
         else if(!strcmp(key, "backendport")) {
-          config.port = shortval(value);
-          logmsg("backendport [%d] set", config.port);
+          s_config.port = shortval(value);
+          logmsg("backendport [%d] set", s_config.port);
         }
         else if(!strcmp(key, "user")) {
-          strcpy(config.user, value);
-          logmsg("user [%s] set", config.user);
+          strcpy(s_config.user, value);
+          logmsg("user [%s] set", s_config.user);
         }
         else if(!strcmp(key, "password")) {
-          strcpy(config.password, value);
-          logmsg("password [%s] set", config.password);
+          strcpy(s_config.password, value);
+          logmsg("password [%s] set", s_config.password);
         }
         /* Methods:
            o  X'00' NO AUTHENTICATION REQUIRED
@@ -206,12 +184,12 @@ static void getconfig(void)
            o  X'02' USERNAME/PASSWORD
         */
         else if(!strcmp(key, "method")) {
-          config.responsemethod = byteval(value);
-          logmsg("method [%d] set", config.responsemethod);
+          s_config.responsemethod = byteval(value);
+          logmsg("method [%d] set", s_config.responsemethod);
         }
         else if(!strcmp(key, "response")) {
-          config.connectrep = byteval(value);
-          logmsg("response [%d] set", config.connectrep);
+          s_config.connectrep = byteval(value);
+          logmsg("response [%d] set", s_config.connectrep);
         }
       }
     }
@@ -219,25 +197,6 @@ static void getconfig(void)
   }
 }
 
-static void loghex(unsigned char *buffer, ssize_t len)
-{
-  char data[1200];
-  ssize_t i;
-  unsigned char *ptr = buffer;
-  char *optr = data;
-  ssize_t width = 0;
-  int left = sizeof(data);
-
-  for(i = 0; i < len && (left >= 0); i++) {
-    msnprintf(optr, left, "%02x", ptr[i]);
-    width += 2;
-    optr += 2;
-    left -= 2;
-  }
-  if(width)
-    logmsg("'%s'", data);
-}
-
 /* RFC 1928, SOCKS5 byte index */
 #define SOCKS5_VERSION 0
 #define SOCKS5_NMETHODS 1 /* number of methods that is listed */
@@ -303,13 +262,13 @@ static curl_socket_t socks4(curl_socket_t fd,
     logmsg("SOCKS4 connect message too short: %zd", rc);
     return CURL_SOCKET_BAD;
   }
-  if(!config.port)
+  if(!s_config.port)
     s4port = (unsigned short)((buffer[SOCKS4_DSTPORT] << 8) |
                               (buffer[SOCKS4_DSTPORT + 1]));
   else
-    s4port = config.port;
+    s4port = s_config.port;
 
-  connfd = socksconnect(s4port, config.addr);
+  connfd = socksconnect(s4port, s_config.addr);
   if(connfd == CURL_SOCKET_BAD) {
     /* failed */
     cd = 91;
@@ -353,7 +312,7 @@ static curl_socket_t sockit(curl_socket_t fd)
   curl_socket_t connfd = CURL_SOCKET_BAD;
   unsigned short s5port;
 
-  getconfig();
+  socksd_getconfig();
 
   rc = recv(fd, (char *)buffer, sizeof(buffer), 0);
   if(rc <= 0) {
@@ -372,14 +331,14 @@ static curl_socket_t sockit(curl_socket_t fd)
     return CURL_SOCKET_BAD;
   }
 
-  if(buffer[SOCKS5_VERSION] != config.version) {
-    logmsg("VERSION byte not %d", config.version);
+  if(buffer[SOCKS5_VERSION] != s_config.version) {
+    logmsg("VERSION byte not %d", s_config.version);
     return CURL_SOCKET_BAD;
   }
-  if((buffer[SOCKS5_NMETHODS] < config.nmethods_min) ||
-     (buffer[SOCKS5_NMETHODS] > config.nmethods_max)) {
+  if((buffer[SOCKS5_NMETHODS] < s_config.nmethods_min) ||
+     (buffer[SOCKS5_NMETHODS] > s_config.nmethods_max)) {
     logmsg("NMETHODS byte not within %d - %d ",
-           config.nmethods_min, config.nmethods_max);
+           s_config.nmethods_min, s_config.nmethods_max);
     return CURL_SOCKET_BAD;
   }
   /* after NMETHODS follows that many bytes listing the methods the client
@@ -391,8 +350,8 @@ static curl_socket_t sockit(curl_socket_t fd)
   logmsg("Incoming request deemed fine!");
 
   /* respond with two bytes: VERSION + METHOD */
-  response[0] = config.responseversion;
-  response[1] = config.responsemethod;
+  response[0] = s_config.responseversion;
+  response[1] = s_config.responsemethod;
   rc = (send)(fd, (char *)response, 2, 0);
   if(rc != 2) {
     logmsg("Sending response failed!");
@@ -411,7 +370,7 @@ static curl_socket_t sockit(curl_socket_t fd)
   logmsg("READ %zd bytes", rc);
   loghex(buffer, rc);
 
-  if(config.responsemethod == 2) {
+  if(s_config.responsemethod == 2) {
     /* RFC 1929 authentication
        +----+------+----------+------+----------+
        |VER | ULEN |  UNAME   | PLEN |  PASSWD  |
@@ -440,10 +399,10 @@ static curl_socket_t sockit(curl_socket_t fd)
       logmsg("Too short packet for ulen %d plen %d: %zd", ulen, plen, rc);
       return CURL_SOCKET_BAD;
     }
-    if((ulen != strlen(config.user)) ||
-       (plen != strlen(config.password)) ||
-       memcmp(&buffer[SOCKS5_UNAME], config.user, ulen) ||
-       memcmp(&buffer[SOCKS5_UNAME + ulen + 1], config.password, plen)) {
+    if((ulen != strlen(s_config.user)) ||
+       (plen != strlen(s_config.password)) ||
+       memcmp(&buffer[SOCKS5_UNAME], s_config.user, ulen) ||
+       memcmp(&buffer[SOCKS5_UNAME + ulen + 1], s_config.password, plen)) {
       /* no match! */
       logmsg("mismatched credentials!");
       login = FALSE;
@@ -475,18 +434,18 @@ static curl_socket_t sockit(curl_socket_t fd)
     return CURL_SOCKET_BAD;
   }
 
-  if(buffer[SOCKS5_VERSION] != config.version) {
-    logmsg("Request VERSION byte not %d", config.version);
+  if(buffer[SOCKS5_VERSION] != s_config.version) {
+    logmsg("Request VERSION byte not %d", s_config.version);
     return CURL_SOCKET_BAD;
   }
   /* 1 == CONNECT */
-  if(buffer[SOCKS5_REQCMD] != config.reqcmd) {
-    logmsg("Request COMMAND byte not %d", config.reqcmd);
+  if(buffer[SOCKS5_REQCMD] != s_config.reqcmd) {
+    logmsg("Request COMMAND byte not %d", s_config.reqcmd);
     return CURL_SOCKET_BAD;
   }
   /* reserved, should be zero */
   if(buffer[SOCKS5_RESERVED]) {
-    logmsg("Request COMMAND byte not %d", config.reqcmd);
+    logmsg("Request COMMAND byte not %d", s_config.reqcmd);
     return CURL_SOCKET_BAD;
   }
   /* ATYP:
@@ -550,26 +509,26 @@ static curl_socket_t sockit(curl_socket_t fd)
     }
   }
 
-  if(!config.port) {
+  if(!s_config.port) {
     unsigned char *portp = &buffer[SOCKS5_DSTADDR + len];
     s5port = (unsigned short)((portp[0] << 8) | (portp[1]));
   }
   else
-    s5port = config.port;
+    s5port = s_config.port;
 
-  if(!config.connectrep)
-    connfd = socksconnect(s5port, config.addr);
+  if(!s_config.connectrep)
+    connfd = socksconnect(s5port, s_config.addr);
 
   if(connfd == CURL_SOCKET_BAD) {
     /* failed */
     rep = 1;
   }
   else {
-    rep = config.connectrep;
+    rep = s_config.connectrep;
   }
 
   /* */
-  response[SOCKS5_VERSION] = config.responseversion;
+  response[SOCKS5_VERSION] = s_config.responseversion;
 
   /*
     o  REP    Reply field:
@@ -663,7 +622,7 @@ static int tunnel(struct perclient *cp, fd_set *fds)
   if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must
   accept()
 */
-static bool incoming(curl_socket_t listenfd)
+static bool socksd_incoming(curl_socket_t listenfd)
 {
   fd_set fds_read;
   fd_set fds_write;
@@ -799,12 +758,10 @@ static bool incoming(curl_socket_t listenfd)
   return TRUE;
 }
 
-static curl_socket_t sockdaemon(curl_socket_t sock,
-                                unsigned short *listenport
-#ifdef USE_UNIX_SOCKETS
-        , const char *unix_socket
-#endif
-        )
+static curl_socket_t socksd_sockdaemon(curl_socket_t sock,
+                                       unsigned short *listenport,
+                                       const char *unix_socket,
+                                       bool bind_only)
 {
   /* passive daemon style */
   srvr_sockaddr_union_t listener;
@@ -816,6 +773,10 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
   int attempt = 0;
   int error = 0;
 
+#ifndef USE_UNIX_SOCKETS
+  (void)unix_socket;
+#endif
+
   do {
     attempt++;
     flag = 1;
@@ -938,6 +899,12 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
     }
   }
 
+  /* bindonly option forces no listening */
+  if(bind_only) {
+    logmsg("instructed to bind port without listening");
+    return sock;
+  }
+
   /* start accepting connections */
   rc = listen(sock, 5);
   if(0 != rc) {
@@ -958,18 +925,19 @@ int main(int argc, char *argv[])
   curl_socket_t msgsock = CURL_SOCKET_BAD;
   int wrotepidfile = 0;
   int wroteportfile = 0;
-  const char *pidname = ".socksd.pid";
-  const char *portname = NULL; /* none by default */
   bool juggle_again;
   int error;
   int arg = 1;
 
-#ifdef USE_UNIX_SOCKETS
   const char *unix_socket = NULL;
+#ifdef USE_UNIX_SOCKETS
   bool unlink_socket = false;
 #endif
 
+  pidname = ".socksd.pid";
   serverlogfile = "log/socksd.log";
+  configfile = "socksd.config";
+  server_port = 8905;
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -1054,7 +1022,7 @@ int main(int argc, char *argv[])
       if(argc > arg) {
         char *endptr;
         unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
-        port = util_ultous(ulnum);
+        server_port = util_ultous(ulnum);
         arg++;
       }
     }
@@ -1099,11 +1067,7 @@ int main(int argc, char *argv[])
 
   {
     /* passive daemon style */
-    sock = sockdaemon(sock, &port
-#ifdef USE_UNIX_SOCKETS
-            , unix_socket
-#endif
-            );
+    sock = socksd_sockdaemon(sock, &server_port, unix_socket, FALSE);
     if(CURL_SOCKET_BAD == sock) {
       goto socks5_cleanup;
     }
@@ -1120,7 +1084,7 @@ int main(int argc, char *argv[])
     logmsg("Listening on Unix socket %s", unix_socket);
   else
 #endif
-  logmsg("Listening on port %hu", port);
+  logmsg("Listening on port %hu", server_port);
 
   wrotepidfile = write_pidfile(pidname);
   if(!wrotepidfile) {
@@ -1128,14 +1092,14 @@ int main(int argc, char *argv[])
   }
 
   if(portname) {
-    wroteportfile = write_portfile(portname, port);
+    wroteportfile = write_portfile(portname, server_port);
     if(!wroteportfile) {
       goto socks5_cleanup;
     }
   }
 
   do {
-    juggle_again = incoming(sock);
+    juggle_again = socksd_incoming(sock);
   } while(juggle_again);
 
 socks5_cleanup:
diff --git a/tests/server/sws.c b/tests/server/sws.c
index 3d88cb2cf9..7e29d1ca52 100644
--- a/tests/server/sws.c
+++ b/tests/server/sws.c
@@ -58,26 +58,26 @@
 /* include memdebug.h last */
 #include "memdebug.h"
 
-static int socket_domain = AF_INET;
 static bool use_gopher = FALSE;
-static int serverlogslocked = 0;
 static bool is_proxy = FALSE;
 
+#undef REQBUFSIZ
 #define REQBUFSIZ (2*1024*1024)
 
 #define MAX_SLEEP_TIME_MS 250
 
-static long prevtestno = -1;    /* previous test number we served */
-static long prevpartno = -1;    /* previous part number we served */
-static bool prevbounce = FALSE; /* instructs the server to override the
-                                   requested part number to prevpartno + 1 when
-                                   prevtestno and current test are the same */
+static long sws_prevtestno = -1;    /* previous test number we served */
+static long sws_prevpartno = -1;    /* previous part number we served */
+static bool sws_prevbounce = FALSE; /* instructs the server to override the
+                                       requested part number to
+                                       prevpartno + 1 when prevtestno and
+                                       current test are the same */
 
 #define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
 #define RCMD_IDLE      1 /* told to sit idle */
 #define RCMD_STREAM    2 /* told to stream */
 
-struct httprequest {
+struct sws_httprequest {
   char reqbuf[REQBUFSIZ]; /* buffer area for the incoming request */
   bool connect_request; /* if a CONNECT */
   unsigned short connect_port; /* the port number CONNECT used */
@@ -101,7 +101,7 @@ struct httprequest {
                      - skip bytes. */
   int rcmd;       /* doing a special command, see defines above */
   int prot_version;  /* HTTP version * 10 */
-  int callcount;  /* times ProcessRequest() gets called */
+  int callcount;  /* times sws_ProcessRequest() gets called */
   bool skipall;   /* skip all incoming data */
   bool noexpect;  /* refuse Expect: (don't read the body) */
   bool connmon;   /* monitor the state of the connection, log disconnects */
@@ -117,14 +117,6 @@ struct httprequest {
 static curl_socket_t all_sockets[MAX_SOCKETS];
 static size_t num_sockets = 0;
 
-static int ProcessRequest(struct httprequest *req);
-static void storerequest(const char *reqbuf, size_t totalsize);
-
-#define DEFAULT_PORT 8999
-
-static const char *logdir = "log";
-static char loglockfile[256];
-
 #define SWSVERSION "curl test suite HTTP server/0.1"
 
 #define REQUEST_DUMP  "server.input"
@@ -136,8 +128,7 @@ static char loglockfile[256];
 #define RESPONSE_PROXY_DUMP "proxy.response"
 
 /* file in which additional instructions may be found */
-#define DEFAULT_CMDFILE "log/server.cmd"
-static const char *cmdfile = DEFAULT_CMDFILE;
+static const char *cmdfile = "log/server.cmd";
 
 /* very-big-path support */
 #define MAXDOCNAMELEN 140000
@@ -174,7 +165,7 @@ static const char *cmdfile = DEFAULT_CMDFILE;
 static const char *end_of_headers = END_OF_HEADERS;
 
 /* sent as reply to a QUIT */
-static const char *docquit =
+static const char *docquit_sws =
 "HTTP/1.1 200 Goodbye" END_OF_HEADERS;
 
 /* send back this on 404 file not found */
@@ -212,7 +203,7 @@ static bool socket_domain_is_ip(void)
 #endif
 
 /* parse the file on disk that might have a test number for us */
-static int parse_cmdfile(struct httprequest *req)
+static int parse_cmdfile(struct sws_httprequest *req)
 {
   FILE *f = fopen(cmdfile, FOPEN_READTEXT);
   if(f) {
@@ -230,7 +221,7 @@ static int parse_cmdfile(struct httprequest *req)
 }
 
 /* based on the testno, parse the correct server commands */
-static int parse_servercmd(struct httprequest *req)
+static int sws_parse_servercmd(struct sws_httprequest *req)
 {
   FILE *stream;
   int error;
@@ -334,7 +325,7 @@ static int parse_servercmd(struct httprequest *req)
   return 0; /* OK! */
 }
 
-static int ProcessRequest(struct httprequest *req)
+static int sws_ProcessRequest(struct sws_httprequest *req)
 {
   char *line = &req->reqbuf[req->checkindex];
   bool chunked = FALSE;
@@ -515,7 +506,7 @@ static int ProcessRequest(struct httprequest *req)
         req->testno = DOCNUMBER_404;
       }
       else
-        parse_servercmd(req);
+        sws_parse_servercmd(req);
     }
     else if((req->offset >= 3)) {
       unsigned char *l = (unsigned char *)line;
@@ -544,7 +535,7 @@ static int ProcessRequest(struct httprequest *req)
   }
 
   /* find and parse <servercmd> for this test */
-  parse_servercmd(req);
+  sws_parse_servercmd(req);
 
   if(use_gopher) {
     /* when using gopher we cannot check the request until the entire
@@ -757,7 +748,7 @@ static int ProcessRequest(struct httprequest *req)
 }
 
 /* store the entire request in a file */
-static void storerequest(const char *reqbuf, size_t totalsize)
+static void sws_storerequest(const char *reqbuf, size_t totalsize)
 {
   int res;
   int error = 0;
@@ -811,7 +802,7 @@ storerequest_cleanup:
            dumpfile, errno, strerror(errno));
 }
 
-static void init_httprequest(struct httprequest *req)
+static void init_httprequest(struct sws_httprequest *req)
 {
   req->checkindex = 0;
   req->offset = 0;
@@ -838,11 +829,11 @@ static void init_httprequest(struct httprequest *req)
   req->upgrade_request = 0;
 }
 
-static int send_doc(curl_socket_t sock, struct httprequest *req);
+static int sws_send_doc(curl_socket_t sock, struct sws_httprequest *req);
 
 /* returns 1 if the connection should be serviced again immediately, 0 if there
    is no data waiting, or < 0 if it should be closed */
-static int get_request(curl_socket_t sock, struct httprequest *req)
+static int sws_get_request(curl_socket_t sock, struct sws_httprequest *req)
 {
   int fail = 0;
   char *reqbuf = req->reqbuf;
@@ -852,11 +843,11 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
   if(req->upgrade_request) {
     /* upgraded connection, work it differently until end of connection */
     logmsg("Upgraded connection, this is no longer HTTP/1");
-    send_doc(sock, req);
+    sws_send_doc(sock, req);
 
     /* dump the request received so far to the external file */
     reqbuf[req->offset] = '\0';
-    storerequest(reqbuf, req->offset);
+    sws_storerequest(reqbuf, req->offset);
     req->offset = 0;
 
     /* read websocket traffic */
@@ -906,7 +897,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
       logmsg("log the websocket traffic");
       /* dump the incoming websocket traffic to the external file */
       reqbuf[req->offset] = '\0';
-      storerequest(reqbuf, req->offset);
+      sws_storerequest(reqbuf, req->offset);
       req->offset = 0;
     }
     init_httprequest(req);
@@ -945,7 +936,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
     if(fail) {
       /* dump the request received so far to the external file */
       reqbuf[req->offset] = '\0';
-      storerequest(reqbuf, req->offset);
+      sws_storerequest(reqbuf, req->offset);
       return -1;
     }
 
@@ -954,7 +945,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
     req->offset += (size_t)got;
     reqbuf[req->offset] = '\0';
 
-    req->done_processing = ProcessRequest(req);
+    req->done_processing = sws_ProcessRequest(req);
     if(got_exit_signal)
       return -1;
   }
@@ -976,7 +967,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
 
   /* at the end of a request dump it to an external file */
   if(fail || req->done_processing)
-    storerequest(reqbuf, req->offset);
+    sws_storerequest(reqbuf, req->offset);
   if(got_exit_signal)
     return -1;
 
@@ -984,7 +975,7 @@ static int get_request(curl_socket_t sock, struct httprequest *req)
 }
 
 /* returns -1 on failure */
-static int send_doc(curl_socket_t sock, struct httprequest *req)
+static int sws_send_doc(curl_socket_t sock, struct sws_httprequest *req)
 {
   ssize_t written;
   size_t count;
@@ -1036,7 +1027,7 @@ static int send_doc(curl_socket_t sock, struct httprequest *req)
     switch(req->testno) {
     case DOCNUMBER_QUIT:
       logmsg("Replying to QUIT");
-      buffer = docquit;
+      buffer = docquit_sws;
       break;
     case DOCNUMBER_WERULEZ:
       /* we got a "friends?" question, reply back that we sure are */
@@ -1130,11 +1121,11 @@ static int send_doc(curl_socket_t sock, struct httprequest *req)
     logmsg("connection close instruction \"swsclose\" found in response");
   }
   if(strstr(buffer, "swsbounce")) {
-    prevbounce = TRUE;
+    sws_prevbounce = TRUE;
     logmsg("enable \"swsbounce\" in the next request");
   }
   else
-    prevbounce = FALSE;
+    sws_prevbounce = FALSE;
 
   dump = fopen(responsedump, "ab");
   if(!dump) {
@@ -1204,8 +1195,8 @@ retry:
     logmsg("Sending response failed. Only (%zu bytes) of (%zu bytes) "
            "were sent",
            responsesize-count, responsesize);
-    prevtestno = req->testno;
-    prevpartno = req->partno;
+    sws_prevtestno = req->testno;
+    sws_prevpartno = req->partno;
     free(ptr);
     free(cmd);
     return -1;
@@ -1252,8 +1243,8 @@ retry:
   free(cmd);
   req->open = use_gopher ? FALSE : persistent;
 
-  prevtestno = req->testno;
-  prevpartno = req->partno;
+  sws_prevtestno = req->testno;
+  sws_prevpartno = req->partno;
 
   return 0;
 }
@@ -1586,7 +1577,7 @@ static void http_connect(curl_socket_t *infdp,
         /* a new connection on listener socket (most likely from client) */
         curl_socket_t datafd = accept(rootfd, NULL, NULL);
         if(datafd != CURL_SOCKET_BAD) {
-          static struct httprequest *req2;
+          static struct sws_httprequest *req2;
           int err = 0;
           if(!req2) {
             req2 = malloc(sizeof(*req2));
@@ -1606,7 +1597,7 @@ static void http_connect(curl_socket_t *infdp,
 #endif
           init_httprequest(req2);
           while(!req2->done_processing) {
-            err = get_request(datafd, req2);
+            err = sws_get_request(datafd, req2);
             if(err < 0) {
               /* this socket must be closed, done or not */
               break;
@@ -1615,7 +1606,7 @@ static void http_connect(curl_socket_t *infdp,
 
           /* skip this and close the socket if err < 0 */
           if(err >= 0) {
-            err = send_doc(datafd, req2);
+            err = sws_send_doc(datafd, req2);
             if(!err && req2->connect_request) {
               /* sleep to prevent triggering libcurl known bug #39. */
               for(loop = 2; (loop > 0) && !got_exit_signal; loop--)
@@ -1849,7 +1840,7 @@ http_connect_cleanup:
   *infdp = CURL_SOCKET_BAD;
 }
 
-static void http_upgrade(struct httprequest *req)
+static void http_upgrade(struct sws_httprequest *req)
 {
   (void)req;
   logmsg("Upgraded to ... %u", req->upgrade_request);
@@ -1938,7 +1929,8 @@ static curl_socket_t accept_connection(curl_socket_t sock)
 
 /* returns 1 if the connection should be serviced again immediately, 0 if there
    is no data waiting, or < 0 if it should be closed */
-static int service_connection(curl_socket_t msgsock, struct httprequest *req,
+static int service_connection(curl_socket_t msgsock,
+                              struct sws_httprequest *req,
                               curl_socket_t listensock,
                               const char *connecthost,
                               int keepalive_secs)
@@ -1947,27 +1939,27 @@ static int service_connection(curl_socket_t msgsock, struct httprequest *req,
     return -1;
 
   while(!req->done_processing) {
-    int rc = get_request(msgsock, req);
+    int rc = sws_get_request(msgsock, req);
     if(rc <= 0) {
       /* Nothing further to read now, possibly because the socket was closed */
       return rc;
     }
   }
 
-  if(prevbounce) {
+  if(sws_prevbounce) {
     /* bounce treatment requested */
-    if(req->testno == prevtestno) {
-      req->partno = prevpartno + 1;
+    if(req->testno == sws_prevtestno) {
+      req->partno = sws_prevpartno + 1;
       logmsg("BOUNCE part number to %ld", req->partno);
     }
     else {
-      prevbounce = FALSE;
-      prevtestno = -1;
-      prevpartno = -1;
+      sws_prevbounce = FALSE;
+      sws_prevtestno = -1;
+      sws_prevpartno = -1;
     }
   }
 
-  send_doc(msgsock, req);
+  sws_send_doc(msgsock, req);
   if(got_exit_signal)
     return -1;
 
@@ -2019,19 +2011,16 @@ int main(int argc, char *argv[])
   int wrotepidfile = 0;
   int wroteportfile = 0;
   int flag;
-  unsigned short port = DEFAULT_PORT;
+  unsigned short port = 8999;
 #ifdef USE_UNIX_SOCKETS
   const char *unix_socket = NULL;
   bool unlink_socket = false;
 #endif
-  const char *pidname = ".http.pid";
-  const char *portname = ".http.port";
-  struct httprequest *req = NULL;
+  struct sws_httprequest *req = NULL;
   int rc = 0;
   int error;
   int arg = 1;
   const char *connecthost = "127.0.0.1";
-  const char *socket_type = "IPv4";
   char port_str[11];
   const char *location_str = port_str;
   int keepalive_secs = 5;
@@ -2040,7 +2029,10 @@ int main(int argc, char *argv[])
   /* a default CONNECT port is basically pointless but still ... */
   size_t socket_idx;
 
+  pidname = ".http.pid";
+  portname = ".http.port";
   serverlogfile = "log/sws.log";
+  serverlogslocked = 0;
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -2337,8 +2329,8 @@ int main(int argc, char *argv[])
   if(!wroteportfile)
     goto sws_cleanup;
 
-  /* initialization of httprequest struct is done before get_request(), but
-     the pipelining struct field must be initialized previously to FALSE
+  /* initialization of httprequest struct is done before sws_get_request(),
+     but the pipelining struct field must be initialized previously to FALSE
      every time a new connection arrives. */
 
   init_httprequest(req);
@@ -2440,7 +2432,7 @@ int main(int argc, char *argv[])
 
             if(req->connmon) {
               const char *keepopen = "[DISCONNECT]\n";
-              storerequest(keepopen, strlen(keepopen));
+              sws_storerequest(keepopen, strlen(keepopen));
             }
 
             if(!req->open)
diff --git a/tests/server/tftpd.c b/tests/server/tftpd.c
index a3166dfe0d..b57223a278 100644
--- a/tests/server/tftpd.c
+++ b/tests/server/tftpd.c
@@ -152,8 +152,6 @@ struct bf {
 
 #define REQUEST_DUMP  "server.input"
 
-#define DEFAULT_PORT 8999 /* UDP */
-
 /*****************************************************************************
 *                              GLOBAL VARIABLES                              *
 *****************************************************************************/
@@ -185,7 +183,7 @@ static int current;     /* index of buffer in use */
 static int newline = 0;    /* fillbuf: in middle of newline expansion */
 static int prevchar = -1;  /* putbuf: previous char (cr check) */
 
-static tftphdr_storage_t buf;
+static tftphdr_storage_t trsbuf;
 static tftphdr_storage_t ackbuf;
 
 static srvr_sockaddr_union_t from;
@@ -196,18 +194,8 @@ static curl_socket_t peer = CURL_SOCKET_BAD;
 static unsigned int timeout;
 static unsigned int maxtimeout = 5 * TIMEOUT;
 
-#ifdef USE_IPV6
-static bool use_ipv6 = FALSE;
-#endif
-static const char *ipv_inuse = "IPv4";
-
-static const char *logdir = "log";
-static char loglockfile[256];
-static const char *pidname = ".tftpd.pid";
-static const char *portname = NULL; /* none by default */
-static int serverlogslocked = 0;
-static int wrotepidfile = 0;
-static int wroteportfile = 0;
+static int tftpd_wrotepidfile = 0;
+static int tftpd_wroteportfile = 0;
 
 #ifdef HAVE_SIGSETJMP
 static sigjmp_buf timeoutbuf;
@@ -282,12 +270,12 @@ static void timer(int signum)
 
   timeout += rexmtval;
   if(timeout >= maxtimeout) {
-    if(wrotepidfile) {
-      wrotepidfile = 0;
+    if(tftpd_wrotepidfile) {
+      tftpd_wrotepidfile = 0;
       unlink(pidname);
     }
-    if(wroteportfile) {
-      wroteportfile = 0;
+    if(tftpd_wroteportfile) {
+      tftpd_wroteportfile = 0;
       unlink(portname);
     }
     if(serverlogslocked) {
@@ -549,7 +537,7 @@ int main(int argc, char **argv)
   struct tftphdr *tp;
   ssize_t n = 0;
   int arg = 1;
-  unsigned short port = DEFAULT_PORT;
+  unsigned short port = 8999; /* UDP */
   curl_socket_t sock = CURL_SOCKET_BAD;
   int flag;
   int rc;
@@ -559,7 +547,9 @@ int main(int argc, char **argv)
 
   memset(&test, 0, sizeof(test));
 
+  pidname = ".tftpd.pid";
   serverlogfile = "log/tftpd.log";
+  serverlogslocked = 0;
 
   while(argc > arg) {
     if(!strcmp("--version", argv[arg])) {
@@ -743,15 +733,15 @@ int main(int argc, char **argv)
     }
   }
 
-  wrotepidfile = write_pidfile(pidname);
-  if(!wrotepidfile) {
+  tftpd_wrotepidfile = write_pidfile(pidname);
+  if(!tftpd_wrotepidfile) {
     result = 1;
     goto tftpd_cleanup;
   }
 
   if(portname) {
-    wroteportfile = write_portfile(portname, port);
-    if(!wroteportfile) {
+    tftpd_wroteportfile = write_portfile(portname, port);
+    if(!tftpd_wroteportfile) {
       result = 1;
       goto tftpd_cleanup;
     }
@@ -769,7 +759,7 @@ int main(int argc, char **argv)
     else
       fromlen = sizeof(from.sa6);
 #endif
-    n = (ssize_t)recvfrom(sock, &buf.storage[0], sizeof(buf.storage), 0,
+    n = (ssize_t)recvfrom(sock, &trsbuf.storage[0], sizeof(trsbuf.storage), 0,
                           &from.sa, &fromlen);
     if(got_exit_signal)
       break;
@@ -817,7 +807,7 @@ int main(int argc, char **argv)
 
     maxtimeout = 5*TIMEOUT;
 
-    tp = &buf.hdr;
+    tp = &trsbuf.hdr;
     tp->th_opcode = ntohs(tp->th_opcode);
     if(tp->th_opcode == opcode_RRQ || tp->th_opcode == opcode_WRQ) {
       memset(&test, 0, sizeof(test));
@@ -854,9 +844,9 @@ tftpd_cleanup:
   if(got_exit_signal)
     logmsg("signalled to die");
 
-  if(wrotepidfile)
+  if(tftpd_wrotepidfile)
     unlink(pidname);
-  if(wroteportfile)
+  if(tftpd_wroteportfile)
     unlink(portname);
 
   if(serverlogslocked) {
@@ -916,7 +906,7 @@ static int do_tftp(struct testcase *test, struct tftphdr *tp, ssize_t size)
   filename = cp;
   do {
     bool endofit = true;
-    while(cp < &buf.storage[size]) {
+    while(cp < &trsbuf.storage[size]) {
       if(*cp == '\0') {
         endofit = false;
         break;
@@ -929,7 +919,7 @@ static int do_tftp(struct testcase *test, struct tftphdr *tp, ssize_t size)
 
     /* before increasing pointer, make sure it is still within the legal
        space */
-    if((cp + 1) < &buf.storage[size]) {
+    if((cp + 1) < &trsbuf.storage[size]) {
       ++cp;
       if(first) {
         /* store the mode since we need it later */
@@ -1003,7 +993,7 @@ static int do_tftp(struct testcase *test, struct tftphdr *tp, ssize_t size)
 }
 
 /* Based on the testno, parse the correct server commands. */
-static int parse_servercmd(struct testcase *req)
+static int tftpd_parse_servercmd(struct testcase *req)
 {
   FILE *stream;
   int error;
@@ -1117,7 +1107,7 @@ static int validate_access(struct testcase *test,
 
     test->testno = testno;
 
-    (void)parse_servercmd(test);
+    (void)tftpd_parse_servercmd(test);
 
     stream = test2fopen(testno, logdir);
 
@@ -1324,7 +1314,7 @@ send_ack:
   alarm(rexmtval);
 #endif
   /* normally times out and quits */
-  n = sread(peer, &buf.storage[0], sizeof(buf.storage));
+  n = sread(peer, &trsbuf.storage[0], sizeof(trsbuf.storage));
 #ifdef HAVE_ALARM
   alarm(0);
 #endif
@@ -1354,7 +1344,7 @@ static void nak(int error)
   int length;
   struct errmsg *pe;
 
-  tp = &buf.hdr;
+  tp = &trsbuf.hdr;
   tp->th_opcode = htons(opcode_ERROR);
   tp->th_code = htons((unsigned short)error);
   for(pe = errmsgs; pe->e_code >= 0; pe++)
@@ -1370,6 +1360,6 @@ static void nak(int error)
    * report from glibc with FORTIFY_SOURCE */
   memcpy(tp->th_msg, pe->e_msg, length + 1);
   length += 5;
-  if(swrite(peer, &buf.storage[0], length) != length)
+  if(swrite(peer, &trsbuf.storage[0], length) != length)
     logmsg("nak: fail\n");
 }
diff --git a/tests/server/util.c b/tests/server/util.c
index 9508ddf128..dc28ef1a0c 100644
--- a/tests/server/util.c
+++ b/tests/server/util.c
@@ -36,11 +36,6 @@
 #ifdef HAVE_NETDB_H
 #include <netdb.h>
 #endif
-#ifdef HAVE_POLL_H
-#include <poll.h>
-#elif defined(HAVE_SYS_POLL_H)
-#include <sys/poll.h>
-#endif
 
 #ifdef MSDOS
 #include <dos.h>  /* delay() */
@@ -53,10 +48,23 @@
 #include "curlx.h" /* from the private lib dir */
 #include "getpart.h"
 #include "util.h"
-#include "timeval.h"
 #include "timediff.h"
 
-const char *serverlogfile = NULL;  /* needs init from main() */
+/* need init from main() */
+const char *pidname = NULL;
+const char *portname = NULL; /* none by default */
+const char *serverlogfile = NULL;
+int serverlogslocked;
+const char *configfile = NULL;
+const char *logdir = "log";
+char loglockfile[256];
+#ifdef USE_IPV6
+bool use_ipv6 = FALSE;
+#endif
+const char *ipv_inuse = "IPv4";
+unsigned short server_port = 0;
+const char *socket_type = "IPv4";
+int socket_domain = AF_INET;
 
 static struct timeval tvnow(void);
 
@@ -137,6 +145,31 @@ void logmsg(const char *msg, ...)
   }
 }
 
+void loghex(unsigned char *buffer, ssize_t len)
+{
+  char data[12000];
+  ssize_t i;
+  unsigned char *ptr = buffer;
+  char *optr = data;
+  ssize_t width = 0;
+  int left = sizeof(data);
+
+  for(i = 0; i < len && (left >= 0); i++) {
+    msnprintf(optr, left, "%02x", ptr[i]);
+    width += 2;
+    optr += 2;
+    left -= 2;
+  }
+  if(width)
+    logmsg("'%s'", data);
+}
+
+unsigned char byteval(char *value)
+{
+  unsigned long num = strtoul(value, NULL, 10);
+  return num & 0xff;
+}
+
 #ifdef _WIN32
 /* use instead of perror() on generic Windows */
 static void win32_perror(const char *msg)
@@ -239,13 +272,6 @@ static long timediff(struct timeval newer, struct timeval older)
  */
 int wait_ms(int timeout_ms)
 {
-#if !defined(MSDOS) && !defined(USE_WINSOCK)
-#ifndef HAVE_POLL
-  struct timeval pending_tv;
-#endif
-  struct timeval initial_tv;
-  int pending_ms;
-#endif
   int r = 0;
 
   if(!timeout_ms)
@@ -259,26 +285,27 @@ int wait_ms(int timeout_ms)
 #elif defined(USE_WINSOCK)
   Sleep((DWORD)timeout_ms);
 #else
-  pending_ms = timeout_ms;
-  initial_tv = tvnow();
-  do {
-    int error;
-#ifdef HAVE_POLL
-    r = poll(NULL, 0, pending_ms);
-#else
-    pending_tv.tv_sec = pending_ms / 1000;
-    pending_tv.tv_usec = (pending_ms % 1000) * 1000;
-    r = select(0, NULL, NULL, NULL, &pending_tv);
-#endif /* HAVE_POLL */
-    if(r != -1)
-      break;
-    error = errno;
-    if(error && (error != EINTR))
-      break;
-    pending_ms = timeout_ms - (int)timediff(tvnow(), initial_tv);
-    if(pending_ms <= 0)
-      break;
-  } while(r == -1);
+  /* avoid using poll() for this since it behaves incorrectly with no sockets
+     on Apple operating systems */
+  {
+    struct timeval pending_tv;
+    struct timeval initial_tv = tvnow();
+    int pending_ms = timeout_ms;
+    do {
+      int error;
+      pending_tv.tv_sec = pending_ms / 1000;
+      pending_tv.tv_usec = (pending_ms % 1000) * 1000;
+      r = select(0, NULL, NULL, NULL, &pending_tv);
+      if(r != -1)
+        break;
+      error = errno;
+      if(error && (error != EINTR))
+        break;
+      pending_ms = timeout_ms - (int)timediff(tvnow(), initial_tv);
+      if(pending_ms <= 0)
+        break;
+    } while(r == -1);
+  }
 #endif /* USE_WINSOCK */
   if(r)
     r = -1;
diff --git a/tests/server/util.h b/tests/server/util.h
index 0b112d24b4..aed144d6e3 100644
--- a/tests/server/util.h
+++ b/tests/server/util.h
@@ -51,14 +51,27 @@ enum {
 
 char *data_to_hex(char *data, size_t len);
 void logmsg(const char *msg, ...) CURL_PRINTF(1, 2);
+void loghex(unsigned char *buffer, ssize_t len);
+unsigned char byteval(char *value);
 
 #define SERVERLOGS_LOCKDIR "lock"  /* within logdir */
 
-/* global variable, where to find the 'data' dir */
-extern const char *path;
-
-/* global variable, log file name */
-extern const char *serverlogfile;
+/* global variables */
+extern const char *path;  /* where to find the 'data' dir */
+extern const char *pidname;
+extern const char *portname;
+extern const char *serverlogfile;  /* log file name */
+extern int serverlogslocked;
+extern const char *configfile;
+extern const char *logdir;
+extern char loglockfile[256];
+#ifdef USE_IPV6
+extern bool use_ipv6;
+#endif
+extern const char *ipv_inuse;
+extern unsigned short server_port;
+extern const char *socket_type;
+extern int socket_domain;
 
 #ifdef _WIN32
 int win32_init(void);