Modernize deprecated APIs, replace VLAs, adopt uint256_to_str()

- signal() -> sigaction() (13 calls in main.c, ncui.c, fuzz-parse.c)
- atoi()/atol() -> strtol() (4 sites)
- usleep() -> nanosleep() (main.c)
- localtime()/gmtime() -> _r variants (4 sites in util.c, ncui.c)
- asctime() -> strftime() (util.c)
- gettimeofday() -> clock_gettime() (2 sites in util.c)
- VLAs -> safe_malloc (base58.c, script.c)
- Adopt uint256_to_str() at ~30 call sites, removing char hashStr[80] boilerplate
- Make uint256_to_str() thread-safe with _Thread_local
- Batch getdata tx requests: 1 message instead of N (peer_handle_inv)

Author: mx4

apps/cli/main.c

@@ -6,6 +6,7 @@
 #include <fcntl.h>
 #include <string.h>
 #include <signal.h>
+#include <time.h>
 #include <pthread.h>
 #include <curl/curl.h>
 #include <termios.h>
@@ -74,7 +75,9 @@ bool bitc_testing = 0;
 static void
 bitc_signal_int_default(void)
 {
-   signal(SIGINT, SIG_DFL);
+   struct sigaction sa = { .sa_handler = SIG_DFL };
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGINT, &sa, NULL);
 }
 
 
@@ -104,14 +107,22 @@ bitc_signal_handler(int sig)
 static void
 bitc_signal_install(void)
 {
-   signal(SIGINT, bitc_sigint_handler);
-
-   signal(SIGSEGV, bitc_signal_handler);
-   signal(SIGBUS,  bitc_signal_handler);
-   signal(SIGILL,  bitc_signal_handler);
-
-   signal(SIGPIPE, SIG_IGN);
-   signal(SIGHUP,  SIG_IGN);
+   struct sigaction sa;
+
+   sa = (struct sigaction){ .sa_handler = bitc_sigint_handler };
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGINT, &sa, NULL);
+
+   sa = (struct sigaction){ .sa_handler = bitc_signal_handler };
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGSEGV, &sa, NULL);
+   sigaction(SIGBUS,  &sa, NULL);
+   sigaction(SIGILL,  &sa, NULL);
+
+   sa = (struct sigaction){ .sa_handler = SIG_IGN };
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGPIPE, &sa, NULL);
+   sigaction(SIGHUP,  &sa, NULL);
 }
 
 
@@ -1143,10 +1154,10 @@ int main(int argc, char *argv[])
       case 'c': configPath = optarg;     break;
       case 'C': btc->connectHost = optarg; break;
       case 'S': btc->syncAndExit = 1;    break;
-      case 'x': btc->stopAfterHeight = atoi(optarg); break;
+      case 'x': btc->stopAfterHeight = (int)strtol(optarg, NULL, 10); break;
       case 'd': withui = 0;              break;
       case 'e': encrypt = 1;             break;
-      case 'n': maxPeers = atoi(optarg); break;
+      case 'n': maxPeers = (int)strtol(optarg, NULL, 10); break;
       case 'p': getpassword = 1;         break;
       case 't': testStr = optarg;        break;
       case 'T': btc->testnet = 1;        break;
@@ -1162,7 +1173,10 @@ int main(int argc, char *argv[])
 
    if (btc->testnet) {
       printf("Using testnet.\n");
-      usleep(500 * 1000);
+      {
+         struct timespec ts = { .tv_sec = 0, .tv_nsec = 500 * 1000 * 1000 };
+         nanosleep(&ts, NULL);
+      }
    }
 
    log_set_level(1);

apps/cli/ncui.c

@@ -460,13 +460,18 @@ ncui_signal_cb(int sig)
     * possible (and in fact very common) to receive a signal while we're in the
     * middle of processing one.
     */
-   signal(SIGWINCH, SIG_IGN);
+   struct sigaction sa = { .sa_handler = SIG_IGN };
+
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGWINCH, &sa, NULL);
 
    ncui_get_term_size(&y, &x);
    resizeterm(y, x);
    ncui_redraw();
 
-   signal(SIGWINCH, ncui_signal_cb);
+   sa = (struct sigaction){ .sa_handler = ncui_signal_cb };
+   sigemptyset(&sa.sa_mask);
+   sigaction(SIGWINCH, &sa, NULL);
 }
 
 
@@ -582,12 +587,12 @@ ncui_status_update(bool update)
 static void
 ncui_update_time_str(void)
 {
-   struct tm *tmp;
+   struct tm tm_buf;
    time_t t;
 
    t = time(NULL);
-   tmp = localtime(&t);
-   strftime(btc->ui->timeStr, sizeof btc->ui->timeStr, "%T", tmp);
+   localtime_r(&t, &tm_buf);
+   strftime(btc->ui->timeStr, sizeof btc->ui->timeStr, "%T", &tm_buf);
 }
 
 
@@ -1739,7 +1744,6 @@ ncui_blocklist_update(void)
    ASSERT(mutex_islocked(btcui->lock));
 
    while (btcui->blockConsIdx != btcui->blockProdIdx) {
-      char hashStr[80];
       uint256 *hash;
       uint32 timestamp;
       int height;
@@ -1752,7 +1756,6 @@ ncui_blocklist_update(void)
       height    =  btcui->blocks[btcui->blockConsIdx].height;
       timestamp =  btcui->blocks[btcui->blockConsIdx].timestamp;
 
-      uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
       ts = print_time_local_short(timestamp);
       orphan = last != -1 && height != last + 1;
 
@@ -1766,7 +1769,7 @@ ncui_blocklist_update(void)
       mvwaddch(win,  0, 8, ACS_VLINE);
       mvwprintw(win, 0, 10, "%s", ts);
       mvwaddch(win,  0, 26, ACS_VLINE);
-      mvwprintw(win, 0, 28, "%s", hashStr);
+      mvwprintw(win, 0, 28, "%s", uint256_to_str(hash));
       free(ts);
       panel->num_lines = MIN(panel->max_lines, panel->num_lines + 1);
       last = height;
@@ -2121,12 +2124,10 @@ ncui_dashboard_latest_blocks(WINDOW *win,
       uint256 *hash    = &btcui->blocks[idx].hash;
       int height       =  btcui->blocks[idx].height;
       time_t timestamp =  btcui->blocks[idx].timestamp;
-      char hashStr[80];
       char *ts;
       bool orphan;
 
       ts = print_time_local(timestamp, "%T");
-      uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
 
       orphan = last != -1 && height != last - 1 && (last - height) < 100;
       wattron(win, orphan ? PAIR_RED : PAIR_YELLOW);
@@ -2136,7 +2137,7 @@ ncui_dashboard_latest_blocks(WINDOW *win,
       mvwprintw(win, y, 10, "%s", ts);
       mvwaddch(win,  y, 19, ACS_VLINE);
       wattron(win, A_DIM);
-      mvwprintw(win, y, 21, "%s", hashStr);
+      mvwprintw(win, y, 21, "%s", uint256_to_str(hash));
       wattroff(win, A_DIM);
       y++;
       free(ts);
@@ -2390,12 +2391,9 @@ ncui_dashboard_header(WINDOW *win,
    mvwprintw(win, y, 1, "block:   ");
 
    if (btcui->numBlocks > 0) {
-      char hashStr[80];
 
-      uint256_snprintf_reverse(hashStr, sizeof hashStr,
-                               &btcui->blocks[btcui->blockProdIdx].hash);
       wattron(win,A_BOLD);
-      mvwprintw(win, y, 10, "%s", hashStr);
+      mvwprintw(win, y, 10, "%s", uint256_to_str(&btcui->blocks[btcui->blockProdIdx].hash));
       wattroff(win,A_BOLD);
    }
    y++;
@@ -2601,7 +2599,11 @@ ncui_init(void)
    ncui = safe_calloc(1, sizeof *ncui);
    btc->ui = ncui;
 
-   signal(SIGWINCH, ncui_signal_cb);
+   {
+      struct sigaction sa = { .sa_handler = ncui_signal_cb };
+      sigemptyset(&sa.sa_mask);
+      sigaction(SIGWINCH, &sa, NULL);
+   }
    ncui_ncurses_init();
    panic_register_cb(ncui_on_panic_cb, NULL);
    ncui_panel_init();

apps/test/fuzz-parse.c

@@ -120,9 +120,15 @@ main(int argc, char **argv)
 
    log_init("/tmp/fuzzharness.log");
    btc = calloc(1, sizeof *btc);
-   signal(SIGSEGV, crash_handler);
-   signal(SIGBUS,  crash_handler);
-   signal(SIGABRT, crash_handler);
+   {
+      struct sigaction sa;
+
+      sa = (struct sigaction){ .sa_handler = crash_handler };
+      sigemptyset(&sa.sa_mask);
+      sigaction(SIGSEGV, &sa, NULL);
+      sigaction(SIGBUS,  &sa, NULL);
+      sigaction(SIGABRT, &sa, NULL);
+   }
 
    /* replay a single input: ./fuzz-parse --hex deadbeef... */
    if (argc > 2 && strcmp(argv[1], "--hex") == 0) {
@@ -141,7 +147,7 @@ main(int argc, char **argv)
       return 0;
    }
 
-   iters = argc > 1 ? atol(argv[1]) : 300000;
+   iters = argc > 1 ? strtol(argv[1], NULL, 10) : 300000;
    for (i = 0; i < iters; i++) {
       size_t len = gen(base + (uint32)i * 2654435761u, g_bytes);
       g_iter = i;

core/base58.c

@@ -235,8 +235,8 @@ base58_encode(const void *buf,
               size_t len)
 {
    const uint8 *buf0 = (uint8 *)buf;
-   char str[len * 138 / 100 + 1];
-   char rev[len + 1];
+   char *str = safe_malloc(len * 138 / 100 + 1);
+   char *rev = safe_malloc(len + 1);
    char *s = NULL;
    size_t strLen = 0;
    BN_CTX *ctx;
@@ -260,7 +260,7 @@ base58_encode(const void *buf,
 
    str_copyreverse(rev, buf0, len);
    rev[len] = 0;
-   base58_setvch(bn, rev, sizeof rev);
+   base58_setvch(bn, rev, len + 1);
    s = NULL;
    ASSERT(!BN_is_zero(bn));
 
@@ -288,6 +288,8 @@ base58_encode(const void *buf,
    str_copyreverse(s, str, strLen);
 
 err:
+   free(str);
+   free(rev);
    BN_free(bn58);
    BN_free(bn0);
    BN_free(bn);

core/block-store.c

@@ -214,11 +214,9 @@ blockstore_get_block_height(struct blockstore *bs,
    mutex_lock(bs->lock);
 
 s = hashtable_lookup(bs->hash_blk, hash, sizeof *hash, (void **)&be);
-    if (s == 0) {
-       char hashStr[80];
+if (s == 0) {
 
-      uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
-      Panic(LGPFX" block %s not found.\n", hashStr);
+      Panic(LGPFX" block %s not found.\n", uint256_to_str(hash));
    }
 
    height = be->height;
@@ -321,15 +319,13 @@ blockstore_set_chain_links(struct blockstore *bs,
                            struct blockentry *be)
 {
    struct blockentry *prev;
-   char hashStr[80];
    uint256 hash;
    int height;
    bool s;
 
    mutex_lock(bs->lock);
 
    hash256_calc(&be->header, sizeof be->header, &hash);
-   uint256_snprintf_reverse(hashStr, sizeof hashStr, &hash);
 
    if (be->height >= 0) {
       struct blockentry *li;
@@ -338,13 +334,12 @@ blockstore_set_chain_links(struct blockstore *bs,
        * entries from now on need to be made orphans.
        */
 
-      log_info(LGPFX" Reached block %s\n", hashStr);
+      log_info(LGPFX" Reached block %s\n", uint256_to_str(&hash));
 
       li = be->next;
       while (li) {
          hash256_calc(&li->header, sizeof li->header, &hash);
-         uint256_snprintf_reverse(hashStr, sizeof hashStr, &hash);
-         log_info(LGPFX" moving #%d %s from blk -> orphan\n", li->height, hashStr);
+         log_info(LGPFX" moving #%d %s from blk -> orphan\n", li->height, uint256_to_str(&hash));
          s = hashtable_remove(bs->hash_blk, &hash, sizeof hash);
          ASSERT(s);
          li->height = -1;
@@ -363,7 +358,7 @@ blockstore_set_chain_links(struct blockstore *bs,
 
    be->height = 1 + blockstore_set_chain_links(bs, prev);
 
-   log_info(LGPFX" moving #%d %s from orphan -> blk\n", be->height, hashStr);
+   log_info(LGPFX" moving #%d %s from orphan -> blk\n", be->height, uint256_to_str(&hash));
 
    prev->next = be;
    be->prev = prev;
@@ -507,15 +502,13 @@ blockstore_add_entry(struct blockstore *bs,
 
       memcpy(&bs->best_hash, hash, sizeof *hash);
    } else {
-      char hashStr[80];
       uint32 count;
 
       be->height = -1;
       count = hashtable_getnumentries(bs->hash_orphans);
 
-      uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
       log_info(LGPFX" block %s orphaned. %u orphan%s total.\n",
-          hashStr, count, count > 1 ? "s" : "");
+          uint256_to_str(hash), count, count > 1 ? "s" : "");
 
       s = hashtable_insert(bs->hash_orphans, hash, sizeof *hash, be);
       ASSERT(s);
@@ -823,11 +816,9 @@ blockset_open_file(struct blockstore *blockStore,
 
    ts = time_get() - ts;
 
-   char hashStr[80];
    char *latStr;
 
-   uint256_snprintf_reverse(hashStr, sizeof hashStr, &blockStore->best_hash);
-   log_info(LGPFX" loaded blocks up to %s\n", hashStr);
+   log_info(LGPFX" loaded blocks up to %s\n", uint256_to_str(&blockStore->best_hash));
    latStr = print_latency(ts);
    log_info(LGPFX" this took %s\n", latStr);
    free(latStr);
@@ -1041,15 +1032,12 @@ blockstore_get_hash_from_birth(const struct blockstore *bs,
 
    for (e = bs->best_chain; e != bs->genesis; e = e->prev)  {
       if (e->header.timestamp < birth) {
-         char hashStr[80];
          char *s;
          uint64 ts = birth;
 
          hash256_calc(&e->header, sizeof e->header, hash);
-
-         uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
          s = print_time_local(birth, "%c");
-         log_info(LGPFX" birth %llu (%s) --> block %s.\n", ts, s, hashStr);
+         log_info(LGPFX" birth %llu (%s) --> block %s.\n", ts, s, uint256_to_str(hash));
          free(s);
          return;
       }
@@ -1253,10 +1241,8 @@ blockstore_get_block_timestamp(const struct blockstore *bs,
 
    be = blockstore_lookup(bs, hash);
    if (be == NULL) {
-      char hashStr[80];
 
-      uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
-      Panic(LGPFX" block %s not found.\n", hashStr);
+      Panic(LGPFX" block %s not found.\n", uint256_to_str(hash));
    }
 
    ts = be->header.timestamp;

core/hash.h

@@ -131,8 +131,8 @@ bool uint256_from_str(const char *str, uint256 *hash);
 static inline const char *
 uint256_to_str(const uint256 *h)
 {
-   static char buf[4][80];
-   static int idx;
+   static _Thread_local char buf[4][80];
+   static _Thread_local int idx;
    char *b = buf[idx++ & 3];
    uint256_snprintf_reverse(b, 80, h);
    return b;