18 files changed, 122 insertions, 122 deletions

diff --git a/Makefile b/Makefile
index 87c20e2..d9b8690 100644
--- a/Makefile
+++ b/Makefile
@@ -68,8 +68,8 @@ CFLAGS+=-I$(LIBOWFAT_HEADERS) -DGIT_VERSION=$(GIT_VERSION) -Wall -pipe -pthread
 LDFLAGS+=-L$(LIBOWFAT_LIBRARY) -lowfat -pthread
 
 BINARY =opentracker
-HEADERS=trackerlogic.h scan_urlencoded_query.h ot_batch.h ot_buf.h ot_fdstate.h ot_hex.h ot_ip.h ot_config.h ot_scan.h ot_socket.h ot_mutex.h ot_random.h ot_stats.h ot_vector.h ot_clean.h ot_udp.h ot_iovec.h ot_fullscrape.h ot_accesslist.h ot_http.h ot_livesync.h ot_rijndael.h
-SOURCES=opentracker.c trackerlogic.c scan_urlencoded_query.c ot_batch.c ot_buf.c ot_fdstate.c ot_hex.c ot_ip.c ot_config.c ot_scan.c ot_socket.c ot_mutex.c ot_random.c ot_stats.c ot_vector.c ot_clean.c ot_udp.c ot_iovec.c ot_fullscrape.c ot_accesslist.c ot_http.c ot_livesync.c ot_rijndael.c
+HEADERS=trackerlogic.h ot_urlencoded.h ot_batch.h ot_buf.h ot_fdstate.h ot_hex.h ot_ip.h ot_config.h ot_scan.h ot_socket.h ot_mutex.h ot_random.h ot_stats.h ot_vector.h ot_clean.h ot_udp.h ot_iovec.h ot_fullscrape.h ot_accesslist.h ot_http.h ot_livesync.h ot_rijndael.h
+SOURCES=opentracker.c trackerlogic.c ot_urlencoded.c ot_batch.c ot_buf.c ot_fdstate.c ot_hex.c ot_ip.c ot_config.c ot_scan.c ot_socket.c ot_mutex.c ot_random.c ot_stats.c ot_vector.c ot_clean.c ot_udp.c ot_iovec.c ot_fullscrape.c ot_accesslist.c ot_http.c ot_livesync.c ot_rijndael.c
 SOURCES_proxy=proxy.c ot_batch.c ot_fdstate.c ot_vector.c ot_mutex.c ot_random.c ot_scan.c ot_ip.c ot_socket.c
 
 OBJECTS = $(SOURCES:%.c=%.o)
@@ -119,8 +119,8 @@ $(OBJECTS_proxy_debug): $(HEADERS)
 # has to. tests/stubs.c supplies the few symbols those modules reference but
 # the tests never reach.
 TESTBIN=tests/runner
-TEST_SOURCES=tests/runner.c tests/test.c tests/stubs.c tests/t_scan_urlencoded_query.c tests/t_iovec.c tests/t_vector.c tests/t_random.c tests/t_hex.c tests/t_accesslist.c tests/t_scan.c tests/t_buf.c tests/t_ip.c tests/t_socket.c tests/t_mutex.c tests/t_batch.c tests/t_fdstate.c
-TEST_UNITS=scan_urlencoded_query.c ot_batch.c ot_fdstate.c ot_buf.c ot_ip.c ot_socket.c ot_iovec.c ot_vector.c ot_random.c ot_hex.c ot_scan.c ot_accesslist.c ot_mutex.c
+TEST_SOURCES=tests/runner.c tests/test.c tests/stubs.c tests/t_urlencoded.c tests/t_iovec.c tests/t_vector.c tests/t_random.c tests/t_hex.c tests/t_accesslist.c tests/t_scan.c tests/t_buf.c tests/t_ip.c tests/t_socket.c tests/t_mutex.c tests/t_batch.c tests/t_fdstate.c
+TEST_UNITS=ot_urlencoded.c ot_batch.c ot_fdstate.c ot_buf.c ot_ip.c ot_socket.c ot_iovec.c ot_vector.c ot_random.c ot_hex.c ot_scan.c ot_accesslist.c ot_mutex.c
 TEST_HEADERS=tests/test.h $(HEADERS)
 # Tests reach code that sits behind feature flags, so the units under test are
 # built with those features enabled. A test binary is not a production binary.
diff --git a/opentracker.c b/opentracker.c
index 0f0b314..f0f6404 100644
--- a/opentracker.c
+++ b/opentracker.c
@@ -375,7 +375,7 @@ void load_state(const char *const state_filename) {
   while (fgets(inbuf, sizeof(inbuf), state_filehandle)) {
     size_t i;
 
-    if (!hex_tohash(infohash, inbuf))
+    if (!hex_to_hash(infohash, inbuf))
       continue;
     i = 2 * sizeof(ot_hash);
 
diff --git a/ot_accesslist.c b/ot_accesslist.c
index ef845d6..79a11a5 100644
--- a/ot_accesslist.c
+++ b/ot_accesslist.c
@@ -110,7 +110,7 @@ size_t accesslist_parse_hashes(ot_hash *dest, size_t capacity, const char *buf,
   size_t      count = 0;
 
   while (count < capacity && end - offs >= 40) {
-    if (hex_tohash(dest[count], offs)) {
+    if (hex_to_hash(dest[count], offs)) {
       offs += 40;
 
       if (offs == end || !hex_isdigit((unsigned char)*offs))
@@ -308,7 +308,7 @@ static void     *accesslist_adddel_worker(const char *fifoname, ot_accesslist *_
       if (linelen < 41)
         continue;
 
-      if (!hex_tohash(info_hash, line))
+      if (!hex_to_hash(info_hash, line))
         continue;
 
       /* From now on we modify g_accesslist_add and g_accesslist_delete, so prevent the
diff --git a/ot_fullscrape.c b/ot_fullscrape.c
index 788e574..0dee5c2 100644
--- a/ot_fullscrape.c
+++ b/ot_fullscrape.c
@@ -25,7 +25,7 @@
 #include "ot_fullscrape.h"
 #include "ot_iovec.h"
 #include "ot_mutex.h"
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 #include "trackerlogic.h"
 
 /* Fetch full scrape info for all torrents
@@ -105,12 +105,12 @@ static char * fullscrape_write_one( ot_tasktype mode, char *r, ot_torrent *torre
 
     break;
   case TASK_FULLSCRAPE_TPB_ASCII:
-    hex_fromhash(r, *hash);
+    hex_from_hash(r, *hash);
     r += 2 * sizeof(ot_hash);
     r += sprintf(r, ":%zd:%zd\n", seed_count, peer_count - seed_count);
     break;
   case TASK_FULLSCRAPE_TPB_ASCII_PLUS:
-    hex_fromhash(r, *hash);
+    hex_from_hash(r, *hash);
     r += 2 * sizeof(ot_hash);
     r += sprintf(r, ":%zd:%zd:%zd\n", seed_count, peer_count - seed_count, down_count);
     break;
@@ -126,7 +126,7 @@ static char * fullscrape_write_one( ot_tasktype mode, char *r, ot_torrent *torre
     r += sprintf(r, ":%zd:%zd\n", seed_count, peer_count - seed_count);
     break;
   case TASK_FULLSCRAPE_TRACKERSTATE:
-    hex_fromhash(r, *hash);
+    hex_from_hash(r, *hash);
     r += 2 * sizeof(ot_hash);
     r += sprintf(r, ":%zd:%zd\n", torrent->peer_list6->base, down_count);
     break;
@@ -296,7 +296,7 @@ static void fullscrape_make_gzip(int taskid, ot_tasktype mode) {
       iovector.iov_base = malloc(OT_SCRAPE_CHUNK_SIZE);
 
       if (!iovector.iov_base) {
-        fprintf(stderr, "Problem with iovec_fix_increase_or_free\n");
+        fprintf(stderr, "Problem with iovec_next_chunk\n");
         deflateEnd(&strm);
         return;
       }
@@ -422,7 +422,7 @@ static void fullscrape_make_zstd(int taskid, ot_tasktype mode) {
       iovector.iov_base = malloc(OT_SCRAPE_CHUNK_SIZE);
 
       if (!iovector.iov_base) {
-        fprintf(stderr, "Problem with iovec_fix_increase_or_free\n");
+        fprintf(stderr, "Problem with iovec_next_chunk\n");
         ZSTD_freeCCtx(zstream);
         return;
       }
diff --git a/ot_hex.c b/ot_hex.c
index 9581951..2bf69c4 100644
--- a/ot_hex.c
+++ b/ot_hex.c
@@ -23,7 +23,7 @@ int hex_value(int c) {
 
 int hex_isdigit(int c) { return hex_value(c) >= 0; }
 
-char *hex_fromhash(char *dest, const uint8_t *hash) {
+char *hex_from_hash(char *dest, const uint8_t *hash) {
   static const char digits[] = "0123456789ABCDEF";
   char             *d        = dest;
   size_t            i;
@@ -36,7 +36,7 @@ char *hex_fromhash(char *dest, const uint8_t *hash) {
   return dest;
 }
 
-int hex_tohash(ot_hash hash, const char *src) {
+int hex_to_hash(ot_hash hash, const char *src) {
   uint8_t decoded[sizeof(ot_hash)];
   size_t  i;
 
diff --git a/ot_hex.h b/ot_hex.h
index 3b45b61..28eddf5 100644
--- a/ot_hex.h
+++ b/ot_hex.h
@@ -12,12 +12,12 @@
 
 /* Write hash as forty upper case hex digits followed by a terminating zero.
    dest must have room for forty one bytes. Returns dest. */
-char *hex_fromhash(char *dest, const uint8_t *hash);
+char *hex_from_hash(char *dest, const uint8_t *hash);
 
 /* Read forty hex digits from src into hash. Returns non-zero on success.
    On failure hash is left untouched and no byte of src beyond the offending
    character is read, so src need not be forty characters long. */
-int   hex_tohash(ot_hash hash, const char *src);
+int   hex_to_hash(ot_hash hash, const char *src);
 
 /* Non-zero if c is a hexadecimal digit, in either case. */
 int   hex_isdigit(int c);
diff --git a/ot_http.c b/ot_http.c
index 6bf343c..6c3332c 100644
--- a/ot_http.c
+++ b/ot_http.c
@@ -27,7 +27,7 @@
 #include "ot_scan.h"
 #include "ot_fdstate.h"
 #include "ot_stats.h"
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 #include "trackerlogic.h"
 
 #define OT_MAXMULTISCRAPE_COUNT 64
@@ -257,21 +257,21 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
 #endif
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_main, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_main, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     case -1:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "mode" */
-      if ((mode = scan_find_keywords(keywords_mode, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((mode = urlencoded_match_keyword(keywords_mode, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
       break;
     case 2: /* matched "format" */
-      if ((format = scan_find_keywords(keywords_format, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((format = urlencoded_match_keyword(keywords_format, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
       break;
     case 3:
@@ -418,18 +418,18 @@ static ssize_t http_handle_scrape(const int64_t sock, struct ot_workstruct *ws,
   }
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_scrape, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_scrape, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     default:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "info_hash" */
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, (char *)(multiscrape_buf + numwant++), SCAN_SEARCHPATH_VALUE) != (ssize_t)sizeof(ot_hash))
+      if (urlencoded_parse(&read_ptr, (char *)(multiscrape_buf + numwant++), SCAN_SEARCHPATH_VALUE) != (ssize_t)sizeof(ot_hash))
         HTTPERROR_400_PARAM;
       break;
     }
@@ -518,24 +518,24 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
   scanon                = 1;
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_announce, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_announce, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     case -1:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "port" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
       if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp) || (tmp > 0xffff))
         HTTPERROR_400_PARAM;
       port = htons(tmp);
       OT_SETPORT(&ws->peer, &port);
       break;
     case 2: /* matched "left" */
-      if ((len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
       if (scan_fixed_int(write_ptr, len, &tmp))
         tmp = 0;
@@ -543,7 +543,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
         OT_PEERFLAG(&ws->peer) |= PEER_FLAG_SEEDING;
       break;
     case 3: /* matched "event" */
-      switch (scan_find_keywords(keywords_announce_event, &read_ptr, SCAN_SEARCHPATH_VALUE)) {
+      switch (urlencoded_match_keyword(keywords_announce_event, &read_ptr, SCAN_SEARCHPATH_VALUE)) {
       case -1:
         HTTPERROR_400_PARAM;
       case 1: /* matched "completed" */
@@ -557,7 +557,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       }
       break;
     case 4: /* matched "numwant" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
       if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp))
         HTTPERROR_400_PARAM;
       if (tmp < 0)
@@ -567,7 +567,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       numwant = tmp;
       break;
     case 5: /* matched "compact" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
       if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp))
         HTTPERROR_400_PARAM;
       if (!tmp)
@@ -577,7 +577,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       if (ws->hash)
         HTTPERROR_400_DOUBLEHASH;
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
+      if (urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
         HTTPERROR_400_PARAM;
       ws->hash = (ot_hash *)write_ptr;
       break;
@@ -585,7 +585,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
     case 7: /* matched "ip" */
     {
       char *tmp_buf1 = ws->reply, *tmp_buf2 = ws->reply + 16;
-      len           = scan_urlencoded_query(&read_ptr, tmp_buf2, SCAN_SEARCHPATH_VALUE);
+      len           = urlencoded_parse(&read_ptr, tmp_buf2, SCAN_SEARCHPATH_VALUE);
       tmp_buf2[len] = 0;
       if ((len <= 0) || !ip_scan(tmp_buf2, tmp_buf1))
         HTTPERROR_400_PARAM;
@@ -601,7 +601,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       uint64_t     value;
       signed short parsed, bits;
 
-      len          = scan_urlencoded_query(&read_ptr, tmp_buf, SCAN_SEARCHPATH_VALUE);
+      len          = urlencoded_parse(&read_ptr, tmp_buf, SCAN_SEARCHPATH_VALUE);
       tmp_buf[len] = 0;
       if (len <= 0)
         HTTPERROR_400_PARAM;
@@ -630,7 +630,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
 #endif
     case 9: /* matched "peer_id" */
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
+      if (urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
         HTTPERROR_400_PARAM;
       ws->peer_id = write_ptr;
       break;
@@ -709,7 +709,7 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
      In reality we abandoned requiring the url to be correct. This now
      only decodes url encoded characters, we check for announces and
      scrapes by looking for "a*" or "sc" */
-  len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_PATH);
+  len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_PATH);
 
   /* If parsing returned an error, leave with not found */
   if (g_redirecturl && (len == -2))
diff --git a/ot_iovec.c b/ot_iovec.c
index cd5b9f9..2ee455c 100644
--- a/ot_iovec.c
+++ b/ot_iovec.c
@@ -12,7 +12,7 @@
 /* Opentracker */
 #include "ot_iovec.h"
 
-void *iovec_increase(size_t *iovec_entries, struct iovec **iovector, size_t new_alloc) {
+void *iovec_new_chunk(size_t *iovec_entries, struct iovec **iovector, size_t new_alloc) {
   void         *new_data;
   size_t        new_entries = 1 + *iovec_entries;
   struct iovec *new_vec     = realloc(*iovector, new_entries * sizeof(struct iovec));
@@ -62,7 +62,7 @@ void iovec_free(size_t *iovec_entries, struct iovec **iovector) {
   *iovec_entries = 0;
 }
 
-void iovec_fixlast(size_t *iovec_entries, struct iovec **iovector, void *last_ptr) {
+void iovec_trim_last(size_t *iovec_entries, struct iovec **iovector, void *last_ptr) {
   if (*iovec_entries) {
     char  *base      = (char *)((*iovector)[*iovec_entries - 1]).iov_base;
     size_t new_alloc = ((char *)last_ptr) - base;
@@ -72,12 +72,12 @@ void iovec_fixlast(size_t *iovec_entries, struct iovec **iovector, void *last_pt
   }
 }
 
-void *iovec_fix_increase_or_free(size_t *iovec_entries, struct iovec **iovector, void *last_ptr, size_t new_alloc) {
+void *iovec_next_chunk(size_t *iovec_entries, struct iovec **iovector, void *last_ptr, size_t new_alloc) {
   void *new_data;
 
-  iovec_fixlast(iovec_entries, iovector, last_ptr);
+  iovec_trim_last(iovec_entries, iovector, last_ptr);
 
-  if (!(new_data = iovec_increase(iovec_entries, iovector, new_alloc)))
+  if (!(new_data = iovec_new_chunk(iovec_entries, iovector, new_alloc)))
     iovec_free(iovec_entries, iovector);
 
   return new_data;
diff --git a/ot_iovec.h b/ot_iovec.h
index eb4365b..6f5a1d6 100644
--- a/ot_iovec.h
+++ b/ot_iovec.h
@@ -8,13 +8,13 @@
 
 #include <sys/uio.h>
 
-void  *iovec_increase(size_t *iovec_entries, struct iovec **iovector, size_t new_alloc);
+void  *iovec_new_chunk(size_t *iovec_entries, struct iovec **iovector, size_t new_alloc);
 void  *iovec_append(size_t *iovec_entries, struct iovec **iovector, struct iovec *append_iovector);
-void   iovec_fixlast(size_t *iovec_entries, struct iovec **iovector, void *last_ptr);
+void   iovec_trim_last(size_t *iovec_entries, struct iovec **iovector, void *last_ptr);
 void   iovec_free(size_t *iovec_entries, struct iovec **iovector);
 
 size_t iovec_length(const size_t *iovec_entries, const struct iovec **iovector);
 
-void  *iovec_fix_increase_or_free(size_t *iovec_entries, struct iovec **iovector, void *last_ptr, size_t new_alloc);
+void  *iovec_next_chunk(size_t *iovec_entries, struct iovec **iovector, void *last_ptr, size_t new_alloc);
 
 #endif
diff --git a/ot_stats.c b/ot_stats.c
index 6589aef..ceeb89d 100644
--- a/ot_stats.c
+++ b/ot_stats.c
@@ -345,15 +345,15 @@ size_t stats_top_txt(char *reply, size_t amount) {
   r += sprintf(r, "Top %zd torrents by peers:\n", amount);
   for (idx = 0; idx < amount; ++idx)
     if (top100c[idx].val)
-      r += sprintf(r, "\t%zd\t%s\n", top100c[idx].val, hex_fromhash(hex_out, top100c[idx].hash));
+      r += sprintf(r, "\t%zd\t%s\n", top100c[idx].val, hex_from_hash(hex_out, top100c[idx].hash));
   r += sprintf(r, "Top %zd torrents by seeds:\n", amount);
   for (idx = 0; idx < amount; ++idx)
     if (top100s[idx].val)
-      r += sprintf(r, "\t%zd\t%s\n", top100s[idx].val, hex_fromhash(hex_out, top100s[idx].hash));
+      r += sprintf(r, "\t%zd\t%s\n", top100s[idx].val, hex_from_hash(hex_out, top100s[idx].hash));
   r += sprintf(r, "Top %zd torrents by leechers:\n", amount);
   for (idx = 0; idx < amount; ++idx)
     if (top100l[idx].val)
-      r += sprintf(r, "\t%zd\t%s\n", top100l[idx].val, hex_fromhash(hex_out, top100l[idx].hash));
+      r += sprintf(r, "\t%zd\t%s\n", top100l[idx].val, hex_from_hash(hex_out, top100l[idx].hash));
 
   return r - reply;
 }
@@ -459,7 +459,7 @@ static void stats_return_fulllog(size_t *iovec_entries, struct iovec **iovector,
 
   while (loglist) {
     if (r + (loglist->size + 64) >= re) {
-      r = iovec_fix_increase_or_free(iovec_entries, iovector, r, 32 * OT_STATS_TMPSIZE);
+      r = iovec_next_chunk(iovec_entries, iovector, r, 32 * OT_STATS_TMPSIZE);
       if (!r)
         return;
       re = r + 32 * OT_STATS_TMPSIZE;
@@ -479,7 +479,7 @@ static void stats_return_fulllog(size_t *iovec_entries, struct iovec **iovector,
     free(loglist);
     loglist = llnext;
   }
-  iovec_fixlast(iovec_entries, iovector, r);
+  iovec_trim_last(iovec_entries, iovector, r);
 }
 #endif
 
@@ -570,7 +570,7 @@ static void stats_make(size_t *iovec_entries, struct iovec **iovector, ot_taskty
 
   *iovec_entries = 0;
   *iovector      = NULL;
-  if (!(r = iovec_increase(iovec_entries, iovector, OT_STATS_TMPSIZE)))
+  if (!(r = iovec_new_chunk(iovec_entries, iovector, OT_STATS_TMPSIZE)))
     return;
 
   switch (mode & TASK_TASK_MASK) {
@@ -587,13 +587,13 @@ static void stats_make(size_t *iovec_entries, struct iovec **iovector, ot_taskty
     r += stats_top_txt(r, 10);
     break;
   case TASK_STATS_TOP100:
-    r = iovec_fix_increase_or_free(iovec_entries, iovector, r, 4 * OT_STATS_TMPSIZE);
+    r = iovec_next_chunk(iovec_entries, iovector, r, 4 * OT_STATS_TMPSIZE);
     if (!r)
       return;
     r += stats_top_txt(r, 100);
     break;
   case TASK_STATS_EVERYTHING:
-    r = iovec_fix_increase_or_free(iovec_entries, iovector, r, OT_STATS_TMPSIZE + 64 * OT_PEER_TIMEOUT);
+    r = iovec_next_chunk(iovec_entries, iovector, r, OT_STATS_TMPSIZE + 64 * OT_PEER_TIMEOUT);
     if (!r)
       return;
     r += stats_return_everything(r);
@@ -612,7 +612,7 @@ static void stats_make(size_t *iovec_entries, struct iovec **iovector, ot_taskty
     iovec_free(iovec_entries, iovector);
     return;
   }
-  iovec_fixlast(iovec_entries, iovector, r);
+  iovec_trim_last(iovec_entries, iovector, r);
 }
 
 void stats_issue_event(ot_status_event event, PROTO_FLAG proto, uintptr_t event_data) {
@@ -651,9 +651,9 @@ void stats_issue_event(ot_status_event event, PROTO_FLAG proto, uintptr_t event_
       localtime_r(&ttt, &time_now);
       strftime(timestring, sizeof(timestring), "%FT%T%z", &time_now);
 
-      hex_fromhash(hash_hex, *ws->hash);
+      hex_from_hash(hash_hex, *ws->hash);
       if (ws->peer_id)
-        hex_fromhash(peerid_hex, (uint8_t *)ws->peer_id);
+        hex_from_hash(peerid_hex, (uint8_t *)ws->peer_id);
       else {
         *peerid_hex = 0;
       }
diff --git a/ot_sync.c b/ot_sync.c
index dc71ddd..5527c94 100644
--- a/ot_sync.c
+++ b/ot_sync.c
@@ -77,7 +77,7 @@ static void sync_make(size_t *iovec_entries, struct iovec **iovector) {
   /* Setup return vector... */
   *iovec_entries = 0;
   *iovector      = NULL;
-  if (!(r = iovec_increase(iovec_entries, iovector, OT_SYNC_CHUNK_SIZE)))
+  if (!(r = iovec_new_chunk(iovec_entries, iovector, OT_SYNC_CHUNK_SIZE)))
     return;
 
   /* ... and pointer to end of current output buffer.
@@ -105,7 +105,7 @@ static void sync_make(size_t *iovec_entries, struct iovec **iovector) {
 
         /* Allocate a fresh output buffer at the end of our buffers list
            release bucket and return, if that fails */
-        if (!(r = iovec_fix_increase_or_free(iovec_entries, iovector, r, OT_SYNC_CHUNK_SIZE)))
+        if (!(r = iovec_next_chunk(iovec_entries, iovector, r, OT_SYNC_CHUNK_SIZE)))
           return mutex_bucket_unlock(bucket);
 
         /* Adjust new end of output buffer */
@@ -131,7 +131,7 @@ static void sync_make(size_t *iovec_entries, struct iovec **iovector) {
   *r++ = 'e';
 
   /* Release unused memory in current output buffer */
-  iovec_fixlast(iovec_entries, iovector, r);
+  iovec_trim_last(iovec_entries, iovector, r);
 }
 
 /* This is the entry point into this worker thread
diff --git a/scan_urlencoded_query.c b/ot_urlencoded.c
index cfc8708..1ca6e81 100644
--- a/scan_urlencoded_query.c
+++ b/ot_urlencoded.c
@@ -4,7 +4,7 @@
    $id$ */
 
 /* Opentracker */
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 
 /* System */
 #include <string.h>
@@ -53,7 +53,7 @@ static unsigned char fromhex(unsigned char x) {
 }
 
 /* Skip the value of a param=value pair */
-void scan_urlencoded_skipvalue(char **string) {
+void urlencoded_skip_value(char **string) {
   const unsigned char *s = *(const unsigned char **)string;
   unsigned char        f;
 
@@ -63,16 +63,16 @@ void scan_urlencoded_skipvalue(char **string) {
     ;
 
   /* If we stopped at a hard terminator like \0 or \n, make the
-     next scan_urlencoded_query encounter it again */
+     next urlencoded_parse encounter it again */
   if (f & SCAN_SEARCHPATH_TERMINATOR)
     --s;
 
   *string = (char *)s;
 }
 
-int scan_find_keywords(const ot_keywords *keywords, char **string, SCAN_SEARCHPATH_FLAG flags) {
+int urlencoded_match_keyword(const ot_keywords *keywords, char **string, SCAN_SEARCHPATH_FLAG flags) {
   char   *deststring   = *string;
-  ssize_t match_length = scan_urlencoded_query(string, deststring, flags);
+  ssize_t match_length = urlencoded_parse(string, deststring, flags);
 
   if (match_length < 0)
     return match_length;
@@ -88,7 +88,7 @@ int scan_find_keywords(const ot_keywords *keywords, char **string, SCAN_SEARCHPA
   return -3;
 }
 
-ssize_t scan_urlencoded_query(char **string, char *deststring, SCAN_SEARCHPATH_FLAG flags) {
+ssize_t urlencoded_parse(char **string, char *deststring, SCAN_SEARCHPATH_FLAG flags) {
   const unsigned char *s = *(const unsigned char **)string;
   unsigned char       *d = (unsigned char *)deststring;
   unsigned char        b, c;
@@ -121,7 +121,7 @@ ssize_t scan_urlencoded_query(char **string, char *deststring, SCAN_SEARCHPATH_F
     if (d == (unsigned char *)deststring)
       return -2;
 
-    /* Else make the next call to scan_urlencoded_param encounter it again */
+    /* Else make the next call to urlencoded_parse encounter it again */
     --s;
     break;
   case '?':
diff --git a/scan_urlencoded_query.h b/ot_urlencoded.h
index 24e09fd..8147370 100644
--- a/scan_urlencoded_query.h
+++ b/ot_urlencoded.h
@@ -30,7 +30,7 @@ typedef enum {
               or -1 for parse error
               or -2 for terminator found
 */
-ssize_t scan_urlencoded_query(char **string, char *deststring, SCAN_SEARCHPATH_FLAG flags);
+ssize_t urlencoded_parse(char **string, char *deststring, SCAN_SEARCHPATH_FLAG flags);
 
 /* string     in: pointer to source
               out: pointer to next scan position
@@ -40,12 +40,12 @@ ssize_t scan_urlencoded_query(char **string, char *deststring, SCAN_SEARCHPATH_F
               or -2 for terminator found
               or -3 for no keyword matched
  */
-int     scan_find_keywords(const ot_keywords *keywords, char **string, SCAN_SEARCHPATH_FLAG flags);
+int     urlencoded_match_keyword(const ot_keywords *keywords, char **string, SCAN_SEARCHPATH_FLAG flags);
 
 /* string     in: pointer to value of a param=value pair to skip
               out: pointer to next scan position on return
 */
-void    scan_urlencoded_skipvalue(char **string);
+void    urlencoded_skip_value(char **string);
 
 /* data       pointer to len chars of string
  len        length of chars in data to parse
diff --git a/tests/runner.c b/tests/runner.c
index 335d83d..9e5c99f 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -14,7 +14,7 @@ struct module {
   void (*run)(void);
 };
 
-static const struct module modules[] = {{"scan_urlencoded_query", test_scan_urlencoded_query},
+static const struct module modules[] = {{"ot_urlencoded", test_urlencoded},
                                         {"ot_iovec", test_iovec},
                                         {"ot_vector", test_vector},
                                         {"ot_random", test_random},
diff --git a/tests/t_hex.c b/tests/t_hex.c
index 7cce8ac..a761737 100644
--- a/tests/t_hex.c
+++ b/tests/t_hex.c
@@ -18,7 +18,7 @@ static void case_encode(void) {
 
   test_case("a hash encodes to forty upper case digits and a terminator");
   memset(dest, 0x7f, sizeof(dest));
-  CHECK_PTR(hex_fromhash(dest, sample), dest);
+  CHECK_PTR(hex_from_hash(dest, sample), dest);
   CHECK_STR(dest, "000123456789ABCDEFFF10203040506070809" "0A0");
   CHECK_INT(strlen(dest), 40);
   CHECK_INT((unsigned char)dest[41], 0x7f);
@@ -28,7 +28,7 @@ static void case_decode(void) {
   ot_hash hash;
 
   test_case("forty digits decode back to the hash");
-  CHECK(hex_tohash(hash, "000123456789ABCDEFFF10203040506070809" "0A0"));
+  CHECK(hex_to_hash(hash, "000123456789ABCDEFFF10203040506070809" "0A0"));
   CHECK_MEM(hash, sample, sizeof(sample));
 }
 
@@ -41,8 +41,8 @@ static void case_round_trip(void) {
   for (i = 0; i < 256; ++i) {
     uint8_t probe[20];
     memset(probe, (uint8_t)i, sizeof(probe));
-    hex_fromhash(text, probe);
-    if (!hex_tohash(hash, text) || memcmp(hash, probe, sizeof(probe))) {
+    hex_from_hash(text, probe);
+    if (!hex_to_hash(hash, text) || memcmp(hash, probe, sizeof(probe))) {
       test_failf(__FILE__, __LINE__, "round trip failed for byte value %zu", i);
       return;
     }
@@ -54,8 +54,8 @@ static void case_decode_is_case_insensitive(void) {
   ot_hash upper, lower;
 
   test_case("lower case digits decode the same as upper case");
-  CHECK(hex_tohash(upper, "ABCDEF0123456789ABCDEF0123456789ABCDEF01"));
-  CHECK(hex_tohash(lower, "abcdef0123456789abcdef0123456789abcdef01"));
+  CHECK(hex_to_hash(upper, "ABCDEF0123456789ABCDEF0123456789ABCDEF01"));
+  CHECK(hex_to_hash(lower, "abcdef0123456789abcdef0123456789abcdef01"));
   CHECK_MEM(lower, upper, sizeof(ot_hash));
 }
 
@@ -63,18 +63,18 @@ static void case_rejects_non_digits(void) {
   ot_hash hash;
 
   test_case("a non hex character anywhere rejects the whole string");
-  CHECK_INT(hex_tohash(hash, "g00123456789ABCDEFFF102030405060708090A0"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF102030405060708090Ag"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEF:F102030405060708090A"), 0);
+  CHECK_INT(hex_to_hash(hash, "g00123456789ABCDEFFF102030405060708090A0"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF102030405060708090Ag"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEF:F102030405060708090A"), 0);
 }
 
 static void case_rejects_short_input(void) {
   ot_hash hash;
 
   test_case("a string shorter than forty digits is rejected");
-  CHECK_INT(hex_tohash(hash, ""), 0);
-  CHECK_INT(hex_tohash(hash, "00"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF102030405060708090A"), 0);
+  CHECK_INT(hex_to_hash(hash, ""), 0);
+  CHECK_INT(hex_to_hash(hash, "00"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF102030405060708090A"), 0);
 }
 
 static void case_leaves_hash_untouched_on_failure(void) {
@@ -82,7 +82,7 @@ static void case_leaves_hash_untouched_on_failure(void) {
 
   test_case("a rejected string leaves the destination untouched");
   memset(hash, 0x5a, sizeof(hash));
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF10203040506070809XX0"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF10203040506070809XX0"), 0);
   CHECK_MEM(hash, "\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a", sizeof(hash));
 }
 
@@ -96,7 +96,7 @@ static void case_stops_at_the_terminator(void) {
   memcpy(guarded, "0012", 4);
   guarded[4] = 0;
   memset(guarded + 5, 'f', 3);
-  CHECK_INT(hex_tohash(hash, guarded), 0);
+  CHECK_INT(hex_to_hash(hash, guarded), 0);
 }
 
 static void case_isdigit(void) {
diff --git a/tests/t_iovec.c b/tests/t_iovec.c
index 89f3fda..2553141 100644
--- a/tests/t_iovec.c
+++ b/tests/t_iovec.c
@@ -18,13 +18,13 @@ static void case_increase_and_length(void) {
   void         *first, *second;
 
   test_case("increase appends an entry and length is their sum");
-  first = iovec_increase(&entries, &vector, 100);
+  first = iovec_new_chunk(&entries, &vector, 100);
   CHECK(first != NULL);
   CHECK_INT(entries, 1);
   CHECK_INT(vector[0].iov_len, 100);
   CHECK_PTR(vector[0].iov_base, first);
 
-  second = iovec_increase(&entries, &vector, 50);
+  second = iovec_new_chunk(&entries, &vector, 50);
   CHECK(second != NULL);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[1].iov_len, 50);
@@ -38,8 +38,8 @@ static void case_free_resets(void) {
   struct iovec *vector  = NULL;
 
   test_case("free releases the entries and resets the vector");
-  CHECK(iovec_increase(&entries, &vector, 10) != NULL);
-  CHECK(iovec_increase(&entries, &vector, 10) != NULL);
+  CHECK(iovec_new_chunk(&entries, &vector, 10) != NULL);
+  CHECK(iovec_new_chunk(&entries, &vector, 10) != NULL);
   iovec_free(&entries, &vector);
   CHECK_INT(entries, 0);
   CHECK_PTR(vector, NULL);
@@ -52,12 +52,12 @@ static void case_fixlast_shrinks(void) {
   char         *block;
 
   test_case("fixlast trims the last entry to the bytes actually used");
-  CHECK(iovec_increase(&entries, &vector, 64) != NULL);
-  block = iovec_increase(&entries, &vector, 1000);
+  CHECK(iovec_new_chunk(&entries, &vector, 64) != NULL);
+  block = iovec_new_chunk(&entries, &vector, 1000);
   CHECK(block != NULL);
   memset(block, 'x', 20);
 
-  iovec_fixlast(&entries, &vector, block + 20);
+  iovec_trim_last(&entries, &vector, block + 20);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[1].iov_len, 20);
   CHECK_INT(iovec_length(&entries, (const struct iovec **)&vector), 84);
@@ -71,7 +71,7 @@ static void case_fixlast_on_empty(void) {
   struct iovec *vector  = NULL;
 
   test_case("fixlast on an empty vector does nothing");
-  iovec_fixlast(&entries, &vector, NULL);
+  iovec_trim_last(&entries, &vector, NULL);
   CHECK_INT(entries, 0);
   CHECK_PTR(vector, NULL);
 }
@@ -103,9 +103,9 @@ static void case_fix_increase(void) {
   char         *block;
 
   test_case("fix_increase trims the previous entry and adds a new one");
-  block = iovec_increase(&entries, &vector, 500);
+  block = iovec_new_chunk(&entries, &vector, 500);
   CHECK(block != NULL);
-  block = iovec_fix_increase_or_free(&entries, &vector, block + 30, 200);
+  block = iovec_next_chunk(&entries, &vector, block + 30, 200);
   CHECK(block != NULL);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[0].iov_len, 30);
diff --git a/tests/t_scan_urlencoded_query.c b/tests/t_urlencoded.c
index cb6c982..1239e6b 100644
--- a/tests/t_scan_urlencoded_query.c
+++ b/tests/t_urlencoded.c
@@ -7,7 +7,7 @@
 #include <string.h>
 
 /* Opentracker */
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 #include "test.h"
 
 /* The scanner returns the number of bytes written to the destination, or
@@ -23,7 +23,7 @@ static void case_path(void) {
   ssize_t n;
 
   test_case("path stops at the question mark");
-  n = scan_urlencoded_query(&p, dest, SCAN_PATH);
+  n = urlencoded_parse(&p, dest, SCAN_PATH);
   CHECK_INT(n, 9);
   dest[n] = 0;
   CHECK_STR(dest, "/announce");
@@ -37,22 +37,22 @@ static void case_param_and_value(void) {
   ssize_t n;
 
   test_case("parameter stops at '=', value stops at '&'");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, 9);
   dest[n] = 0;
   CHECK_STR(dest, "info_hash");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "abc");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, 4);
   dest[n] = 0;
   CHECK_STR(dest, "port");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 2);
   dest[n] = 0;
   CHECK_STR(dest, "80");
@@ -65,7 +65,7 @@ static void case_percent_decoding(void) {
   ssize_t n;
 
   test_case("percent escapes decode");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   CHECK_MEM(dest, "ABC", 3);
 }
@@ -79,7 +79,7 @@ static void case_binary_info_hash(void) {
   ssize_t       n;
 
   test_case("twenty byte binary value survives decoding");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 20);
   CHECK_MEM(dest, want, 20);
 }
@@ -90,7 +90,7 @@ static void case_in_place(void) {
   ssize_t n;
 
   test_case("decoding in place over the source is safe");
-  n = scan_urlencoded_query(&p, query, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, query, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 2);
   CHECK_MEM(query, "AB", 2);
 }
@@ -102,7 +102,7 @@ static void case_bad_escape(void) {
   ssize_t n;
 
   test_case("a non hexadecimal escape is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -113,7 +113,7 @@ static void case_truncated_escape(void) {
   ssize_t n;
 
   test_case("an escape cut short by the terminator is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -125,11 +125,11 @@ static void case_terminator(void) {
   ssize_t n;
 
   test_case("a hard terminator before any output reports end of input");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, -2);
 
   p = space;
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, -2);
 }
 
@@ -140,10 +140,10 @@ static void case_terminator_after_output(void) {
   ssize_t n;
 
   test_case("a hard terminator after output is left for the next call");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   CHECK_INT(*p, 0);
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -2);
 }
 
@@ -159,14 +159,14 @@ static void case_separators_are_contextual(void) {
   ssize_t n;
 
   test_case("a question mark is literal inside a value");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "a?b");
 
   test_case("an equals sign is literal inside a value");
   p = equals;
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "a=b");
@@ -179,7 +179,7 @@ static void case_ampersand_in_path(void) {
   ssize_t n;
 
   test_case("an ampersand in a path is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_PATH);
+  n = urlencoded_parse(&p, dest, SCAN_PATH);
   CHECK_INT(n, -1);
 }
 
@@ -190,7 +190,7 @@ static void case_raw_high_byte(void) {
   ssize_t n;
 
   test_case("an undecoded byte above ASCII is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -200,12 +200,12 @@ static void case_skipvalue(void) {
   char *p       = query;
 
   test_case("skipvalue steps over the value and its separator");
-  scan_urlencoded_skipvalue(&p);
+  urlencoded_skip_value(&p);
   CHECK_STR(p, "next=1");
 
   test_case("skipvalue leaves a hard terminator in place");
   p = bare;
-  scan_urlencoded_skipvalue(&p);
+  urlencoded_skip_value(&p);
   CHECK_INT(*p, 0);
 }
 
@@ -217,15 +217,15 @@ static void case_find_keywords(void) {
   char                    *p          = match;
 
   test_case("a known keyword returns its value");
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), 2);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), 2);
 
   test_case("an unknown keyword returns -3");
   p = nomatch;
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
 
   test_case("a prefix of a keyword does not match it");
   p = prefix;
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
 }
 
 static void case_fixed_int(void) {
@@ -328,7 +328,7 @@ static void case_fmt_decoder_disagrees_on_dollar(void) {
      encoder passes through unescaped, '$' is the only one the decoder then
      refuses, and it refuses the whole string rather than stopping short.
      Output of the urlencoded full scrape therefore does not round trip
-     through scan_urlencoded_query when a hash contains 0x24. Harmless today
+     through urlencoded_parse when a hash contains 0x24. Harmless today
      because only third party tooling reads that output. */
   const uint8_t src[]  = {'a', '$', 'b'};
   char          dest[16];
@@ -342,11 +342,11 @@ static void case_fmt_decoder_disagrees_on_dollar(void) {
   dest[n] = 0;
   CHECK_STR(dest, "a$b");
 
-  got = scan_urlencoded_query(&p, scanned, SCAN_SEARCHPATH_VALUE);
+  got = urlencoded_parse(&p, scanned, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(got, -1);
 }
 
-void test_scan_urlencoded_query(void) {
+void test_urlencoded(void) {
   case_path();
   case_param_and_value();
   case_percent_decoding();
diff --git a/tests/test.h b/tests/test.h
index bc8c3bd..cebd08a 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -76,7 +76,7 @@ extern unsigned long test_failures;
   } while (0)
 
 /* One entry point per module under test */
-void test_scan_urlencoded_query(void);
+void test_urlencoded(void);
 void test_iovec(void);
 void test_vector(void);
 void test_random(void);