/* ------------------------------------------------------------ */

/*

HTTrack Website Copier, Offline Browser for Windows and Unix

Copyright (C) 2026 Xavier Roche and other contributors

SPDX-License-Identifier: GPL-3.0-or-later

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>.

Ethical use: we kindly ask that you NOT use this software to harvest email

addresses or to collect any other private information about people. Doing so

would dishonor our work and waste the many hours we have spent on it.

Please visit our Website: http://www.httrack.com

*/

/* ------------------------------------------------------------ */

/* File: htsopt_selftest.c subroutines:                         */

/*       self-tests for options, aliases and the log callback   */

/* Author: Xavier Roche                                         */

/* ------------------------------------------------------------ */

#include "htsselftest_int.h"

#include <limits.h>

#include <stdint.h>

/* What the build's optional features came out as, so a test gates on the binary

   rather than on the platform it guessed from. */

static int st_features(httrackp *opt, int argc, char **argv) {

  (void) opt;

  (void) argc;

  (void) argv;

  printf("brotli %d\n", HTS_USEBROTLI ? 1 : 0);

  printf("zstd %d\n", HTS_USEZSTD ? 1 : 0);

#if (defined(__linux) && defined(HAVE_BACKTRACE))

  printf("backtrace 1\n");

#else

  printf("backtrace 0\n");

#endif

#if (defined(HTS_USEICONV) && (HTS_USEICONV == 0))

  printf("iconv 0\n");

#else

  printf("iconv 1\n");

#endif

#ifdef HTS_CRASH_TEST

  printf("crashtest 1\n");

#else

  printf("crashtest 0\n");

#endif

  /* The kernel, not the build, decides whether MPTCP can be opened. */

  printf("mptcp %d\n", hts_mptcp_available() ? 1 : 0);

  printf("mptcpinfo %d\n", hts_mptcp_reports() ? 1 : 0);

  return 0;

}

// -#test=footerfmt <template>: expand a -%F footer with fixed values (drives

// tests/01_engine-footerfmt.test). Also asserts the published field names and

// the overflow/zero-size returns the CLI cap keeps out of reach.

static int st_footerfmt(httrackp *opt, int argc, char **argv) {

  // Spelled out, not read back from the engine: these ten are the published

  // contract front ends validate their templates against.

  static const char *const names[] = {

      "addr",    "path", "url",     "date",   "lastmodified",

      "version", "mime", "charset", "status", "size"};

  // Filled by id, as htsparse.c does, so the .test's expected strings pin each

  // name to its enum slot; a positional list would not see them drift apart.

  const char *values[HTS_FOOTER_FIELD_COUNT] = {NULL};

  size_t i;

  char out[1024];

  char tiny[4];

  (void) opt;

  values[HTS_FOOTER_ADDR] = "host.example";

  values[HTS_FOOTER_PATH] = "/dir/page.html";

  values[HTS_FOOTER_URL] = "http://host.example/dir/page.html";

  values[HTS_FOOTER_DATE] = "DATE";

  values[HTS_FOOTER_LASTMODIFIED] = "LASTMOD";

  values[HTS_FOOTER_VERSION] = "VER";

  values[HTS_FOOTER_MIME] = "text/html";

  values[HTS_FOOTER_CHARSET] = "utf-8";

  values[HTS_FOOTER_STATUS] = "200";

  values[HTS_FOOTER_SIZE] = "1234";

  for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) {

    assertf(hts_footer_field_ok(names[i]) == HTS_TRUE);

  }

  assertf(!hts_footer_field_ok(NULL));

  assertf(!hts_footer_field_ok(""));

  assertf(!hts_footer_field_ok("nosuchfield"));

  // A prefix or a longer name must not match, or "{addr}" and "{addrx}" would

  // validate alike.

  assertf(!hts_footer_field_ok("add"));

  assertf(!hts_footer_field_ok("addrx"));

  // Matching is exact: the expander is case-sensitive, so a validator that

  // accepted "{ADDR}" would green-light a template the crawl emits verbatim.

  assertf(!hts_footer_field_ok("Addr"));

  // Overflow (named and legacy) and a zero-size buffer must return <0, never

  // truncate silently or write out of bounds.

  assertf(hts_footer_format(tiny, sizeof(tiny), "{addr}", values) < 0);

  assertf(hts_footer_format(tiny, sizeof(tiny), "a %s b", values) < 0);

  assertf(hts_footer_format(out, 0, "", values) < 0);

  // An empty template yields an empty, terminated string.

  assertf(hts_footer_format(out, sizeof(out), "", values) == 1 &&

          out[0] == '\0');

  if (argc < 1) {

    fprintf(stderr, "footerfmt: needs a template\n");

    return 1;

  }

  if (hts_footer_format(out, sizeof(out), argv[0], values) < 0) {

    fprintf(stderr, "footerfmt: overflow\n");

    return 1;

  }

  printf("%s\n", out);

  return 0;

}

// hts_split_cmdline(): the vector must grow with the argument count, and a

// quote inside a value must not end the argument and hand -V to the parser.

static int st_cmdlinesplit(httrackp *opt, int argc, char **argv) {

  char line[512];

  char **args;

  int nargs = 0;

  (void) opt;

  (void) argc;

  (void) argv;

  // control: every separator splits, and argv[0] is the program name

  strcpybuff(line, "httrack http://x/ --quiet\t-c8\n-O out");

  args = hts_split_cmdline(line, &nargs);

  assertf(args != NULL && nargs == 6);

  assertf(args[nargs] == NULL); // callers may walk to the terminator

  assertf(strcmp(args[0], "httrack") == 0);

  assertf(strcmp(args[1], "http://x/") == 0);

  assertf(strcmp(args[2], "--quiet") == 0);

  assertf(strcmp(args[3], "-c8") == 0);

  assertf(strcmp(args[4], "-O") == 0);

  assertf(strcmp(args[5], "out") == 0);

  freet(args);

  // the template pads with whitespace: empty arguments are kept (the engine

  // skips them), so the count is one per separator

  strcpybuff(line, "httrack  --quiet");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 3 && args[1][0] == '\0');

  assertf(strcmp(args[2], "--quiet") == 0);

  freet(args);

  // a quoted run keeps both its spaces and its quotes: the engine unquotes

  strcpybuff(line, "httrack --user-agent \"Mozilla 5.0\" -c8");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 4);

  assertf(strcmp(args[2], "\"Mozilla 5.0\"") == 0);

  assertf(strcmp(args[3], "-c8") == 0);

  freet(args);

  // an escaped quote is a literal quote, not the end of the argument: the

  // engine strips only the outer pair

  strcpybuff(line, "httrack --user-agent \"x\\\" -V \\\"touch /tmp/pwn\" -c8");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 4);

  assertf(strcmp(args[2], "\"x\" -V \"touch /tmp/pwn\"") == 0);

  assertf(strcmp(args[3], "-c8") == 0);

  freet(args);

  // \\ is a literal backslash, so a Windows path survives

  strcpybuff(line, "httrack --path \"C:\\\\dir\\\\sub\"");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 3);

  assertf(strcmp(args[2], "\"C:\\dir\\sub\"") == 0);

  freet(args);

  // outside a quoted run a backslash is literal: the url and wildcard-filter

  // fields, which the wizard cannot quote, read as before

  strcpybuff(line, "httrack -*\\** +*.png");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 3);

  assertf(strcmp(args[1], "-*\\**") == 0);

  assertf(strcmp(args[2], "+*.png") == 0);

  freet(args);

  // a quoted run leaves slots unused, so the terminator has to be written and

  // not inherited: size the vector from a full line first, so freeing it hands

  // the same chunk back with stale pointers in those slots

  strcpybuff(line, "httrack a b c d e");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 6);

  freet(args);

  strcpybuff(line, "httrack \"a b c d e\"");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 2);

  assertf(args[nargs] == NULL);

  freet(args);

  // an unterminated quote protects the rest of the line, as one argument

  strcpybuff(line, "httrack --footer \"unbalanced -V x");

  args = hts_split_cmdline(line, &nargs);

  assertf(nargs == 3);

  assertf(strcmp(args[2], "\"unbalanced -V x") == 0);

  freet(args);

  // past the 1024 entries the vector used to hold: distinct arguments, so a

  // write beyond the allocation cannot read back as the expected parse

  {

    const int n = 2000;

    const size_t size = 16 * (size_t) n + 16;

    char *big = malloct(size);

    size_t pos = 0;

    int i;

    assertf(big != NULL);

    pos = (size_t) snprintf(big, size, "httrack");

    assertf(pos < size);

    for (i = 0; i < n; i++) {

      // snprintf returns what it wanted to write, so accumulating it blind

      // would let the next size argument wrap

      const int len = snprintf(big + pos, size - pos, " a%d", i);

      assertf(len > 0 && (size_t) len < size - pos);

      pos += (size_t) len;

    }

    args = hts_split_cmdline(big, &nargs);

    assertf(args != NULL && nargs == n + 1);

    assertf(args[nargs] == NULL);

    for (i = 0; i < n; i++) {

      char expect[16];

      snprintf(expect, sizeof(expect), "a%d", i);

      assertf(strcmp(args[i + 1], expect) == 0);

    }

    freet(args);

    freet(big);

  }

  printf("cmdline-split self-test OK\n");

  return 0;

}

static int st_copyopt(httrackp *opt, int argc, char **argv) {

  httrackp *from = hts_create_opt();

  httrackp *to = hts_create_opt();

  int err = 0;

  (void) opt;

  (void) argc;

  (void) argv;

  /* from-values differ from both the to-values and the hts_create_opt()

     defaults (nearlink FALSE, errpage/parseall TRUE), so a copy that no-ops or

     just resets to defaults is caught too, not only the unsigned-guard bug. */

  from->retry = 7; /* int field: positive control */

  to->retry = 0;

  from->nearlink = HTS_TRUE;

  to->nearlink = HTS_FALSE;

  from->errpage = HTS_FALSE;

  to->errpage = HTS_TRUE;

  from->parseall = HTS_FALSE;

  to->parseall = HTS_TRUE;

  copy_htsopt(from, to);

  if (to->retry != 7)

    err = 1;

  if (to->nearlink != HTS_TRUE)

    err = 1;

  if (to->errpage != HTS_FALSE)

    err = 1;

  if (to->parseall != HTS_FALSE)

    err = 1;

  /* HTS_DEFAULT (-1) is "unspecified": copy_htsopt must skip it, leaving the

     target intact. Only a signed (int-backed) field can hold -1, so this also

     guards the type against regressing to an unsigned hts_boolean. */

  from->parseall = HTS_DEFAULT;

  to->parseall = HTS_TRUE;

  copy_htsopt(from, to);

  if (to->parseall != HTS_TRUE)

    err = 1;

  /* String field: a non-empty source deep-copies across, an empty source

     leaves the target intact (StringNotEmpty guard). Covers the exported

     copy_htsopt String path that no crawl test reaches. */

  StringCopy(from->cookies_file, "/tmp/jar.txt");

  StringCopy(to->cookies_file, "");

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->cookies_file), "/tmp/jar.txt") != 0)

    err = 1;

  StringCopy(from->cookies_file, "");

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->cookies_file), "/tmp/jar.txt") != 0)

    err = 1;

  /* warc_file: same String deep-copy path as cookies_file */

  StringCopy(from->warc_file, "run.warc.gz");

  StringCopy(to->warc_file, "");

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->warc_file), "run.warc.gz") != 0)

    err = 1;

  /* accept_kinds deep-copies, and an explicit -%a or -%l carries its flag. */

  StringCopy(from->accept_kinds, "image=a/b");

  StringCopy(from->accept, "x/y");

  from->accept_given = HTS_TRUE;

  StringCopy(from->lang_iso, "fr");

  from->lang_given = HTS_TRUE;

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->accept_kinds), "image=a/b") != 0 ||

      strcmp(StringBuff(to->accept), "x/y") != 0 || !to->accept_given ||

      strcmp(StringBuff(to->lang_iso), "fr") != 0 || !to->lang_given)

    err = 1;

  /* A default -%a or -%l never overwrites an explicit one. */

  StringCopy(from->accept, HTS_ACCEPT_LEGACY);

  from->accept_given = HTS_FALSE;

  StringCopy(from->lang_iso, HTS_ACCEPT_LANGUAGE_LEGACY);

  from->lang_given = HTS_FALSE;

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->accept), "x/y") != 0 || !to->accept_given ||

      strcmp(StringBuff(to->lang_iso), "fr") != 0 || !to->lang_given)

    err = 1;

  /* An explicit -%a or -%l equal to the built-in value still overwrites. */

  from->accept_given = HTS_TRUE;

  from->lang_given = HTS_TRUE;

  copy_htsopt(from, to);

  if (strcmp(StringBuff(to->accept), HTS_ACCEPT_LEGACY) != 0 ||

      strcmp(StringBuff(to->lang_iso), HTS_ACCEPT_LANGUAGE_LEGACY) != 0)

    err = 1;

  from->changes = HTS_TRUE;

  to->changes = HTS_FALSE;

  copy_htsopt(from, to);

  if (to->changes != HTS_TRUE)

    err = 1;

  /* single_file pair: the cap is guarded by >0, so an unset source must not

     overwrite the default the target already carries */

  from->single_file = HTS_TRUE;

  from->single_file_max_size = 4096;

  to->single_file = HTS_FALSE;

  to->single_file_max_size = SINGLEFILE_DEFAULT_MAX_SIZE;

  copy_htsopt(from, to);

  if (!to->single_file || to->single_file_max_size != 4096)

    err = 1;

  from->single_file_max_size = 0;

  copy_htsopt(from, to);

  if (to->single_file_max_size != 4096)

    err = 1;

  /* sitemap pair: the flag latches on, the URL takes the String deep copy */

  from->sitemap = HTS_TRUE;

  StringCopy(from->sitemap_url, "http://h.test/sitemap.xml");

  to->sitemap = HTS_FALSE;

  StringCopy(to->sitemap_url, "");

  copy_htsopt(from, to);

  if (!to->sitemap ||

      strcmp(StringBuff(to->sitemap_url), "http://h.test/sitemap.xml") != 0)

    err = 1;

  from->sitemap = HTS_FALSE;

  StringCopy(from->sitemap_url, "");

  copy_htsopt(from, to);

  if (!to->sitemap ||

      strcmp(StringBuff(to->sitemap_url), "http://h.test/sitemap.xml") != 0)

    err = 1;

  /* #185 pause pair: copied when enabled (max>0), the 0 sentinel skips */

  from->pause_min_ms = 5000;

  from->pause_max_ms = 10000;

  to->pause_min_ms = to->pause_max_ms = 0;

  copy_htsopt(from, to);

  if (to->pause_min_ms != 5000 || to->pause_max_ms != 10000)

    err = 1;

  from->pause_min_ms = from->pause_max_ms = 0;

  copy_htsopt(from, to);

  if (to->pause_min_ms != 5000 || to->pause_max_ms != 10000)

    err = 1;

  /* max_retry_after: 0 is a real setting (no wait), so only a negative skips */

  from->max_retry_after = 0;

  to->max_retry_after = 60;

  copy_htsopt(from, to);

  if (to->max_retry_after != 0)

    err = 1;

  from->max_retry_after = -1;

  copy_htsopt(from, to);

  if (to->max_retry_after != 0)

    err = 1;

  hts_free_opt(from);

  hts_free_opt(to);

  printf("copy-htsopt: %s\n", err ? "FAIL" : "OK");

  return err;

}

/* A run with no log file must still count its errors (#1681). */

static int st_logcounters(httrackp *opt, int argc, char **argv) {

  httrackp *o = hts_create_opt();

  const hts_stat_struct *stats;

  int err = 0;

  (void) opt;

  (void) argc;

  (void) argv;

  /* -Q sets no log file and default verbosity. */

  o->log = NULL;

  o->errlog = NULL;

  o->debug = LOG_NOTICE;

  hts_log_print(o, LOG_ERROR, "first");

  /* LOG_ERRNO rides in the high bits and must not shift the level. */

  hts_log_print(o, LOG_ERROR | LOG_ERRNO, "second");

  hts_log_print(o, LOG_WARNING, "third");

  hts_log_print(o, LOG_WARNING, "fourth");

  hts_log_print(o, LOG_WARNING, "fifth");

  hts_log_print(o, LOG_NOTICE, "sixth");

  /* Three distinct totals, so a swapped counter cannot pass. */

  stats = hts_get_stats(o);

  if (stats == NULL || stats->stat_errors != 2 || stats->stat_warnings != 3 ||

      stats->stat_infos != 1)

    err = 1;

  /* Polling hts_get_stats() must not increment the count. */

  stats = hts_get_stats(o);

  if (stats == NULL || stats->stat_errors != 2)

    err = 1;

  /* LOG_INFO is above the default verbosity, so it is not counted. */

  hts_log_print(o, LOG_INFO, "seventh");

  stats = hts_get_stats(o);

  if (stats == NULL || stats->stat_infos != 1)

    err = 1;

  /* Raising the verbosity lets the same level through. */

  o->debug = LOG_INFO;

  hts_log_print(o, LOG_INFO, "eighth");

  stats = hts_get_stats(o);

  if (stats == NULL || stats->stat_infos != 2)

    err = 1;

  /* A panic is fatal, so it counts as an error rather than as nothing. */

  hts_log_print(o, LOG_PANIC, "ninth");

  stats = hts_get_stats(o);

  if (stats == NULL || stats->stat_errors != 3)

    err = 1;

  hts_free_opt(o);

  printf("log-counters: %s\n", err ? "FAIL" : "OK");

  return err;

}

/* The note is built twice from one buffer, so a caller reusing it must never

   read the previous mirror's text back out of a silent run. */

static int st_upperlinksnote(httrackp *opt, int argc, char **argv) {

  httrackp *from = hts_create_opt();

  httrackp *to = hts_create_opt();

  char note[256];

  int err = 0;

  (void) opt;

  (void) argc;

  (void) argv;

  strcpybuff(note, "stale");

  if (hts_upper_links_note(to, note, sizeof(note)) || note[0] != '\0')

    err = 1; /* a fresh opt refused nothing, and must empty the buffer */

  to->upper_links_refused = HTS_TRUE;

  if (!hts_upper_links_note(to, note, sizeof(note)) ||

      strstr(note, "-B") == NULL)

    err = 1; /* the note must name the option that lifts the refusal */

  to->upper_links_refused = HTS_FALSE;

  if (hts_upper_links_note(to, note, sizeof(note)) || note[0] != '\0')

    err = 1;

  /* the flag never travels onto another opt */

  from->upper_links_refused = HTS_TRUE;

  copy_htsopt(from, to);

  if (to->upper_links_refused)

    err = 1;

  hts_free_opt(from);

  hts_free_opt(to);

  printf("upper-links-note: %s\n", err ? "FAIL" : "OK");

  return err;

}

/* The handler below pins the enumerator NAME; these pin the NUMBERS, which are

   ABI in the installed htsopt.h and are what -C prints. */

HTS_STATIC_ASSERT(HTS_CACHE_NONE == 0, cache_none_is_0);

HTS_STATIC_ASSERT(HTS_CACHE_PRIORITY == 1, cache_priority_is_1);

HTS_STATIC_ASSERT(HTS_CACHE_TEST_UPDATE == 2, cache_test_update_is_2);

/* -C's own default (no -C given) is C1 cache-priority, not the C2 test-update

   the man page and this enum's comment claimed for a long time. */

static int st_cachedefault(httrackp *opt, int argc, char **argv) {

  httrackp *const fresh = hts_create_opt();

  int err = 0;

  (void) opt;

  (void) argc;

  (void) argv;

  if (fresh->cache != HTS_CACHE_PRIORITY)

    err = 1;

  hts_free_opt(fresh);

  printf("cache-default: %s\n", err ? "FAIL" : "OK");

  return err;

}

static char st_log_callback_seen[256];

static HTS_PRINTF_FUN(3, 0) void st_log_callback(httrackp *opt, int type,

                                                 const char *format,

                                                 va_list args) {

  (void) opt;

  (void) type;

  (void) vsnprintf(st_log_callback_seen, sizeof(st_log_callback_seen), format,

                   args);

}

/* The callback must not consume the va_list the log file's vfprintf() needs. */

static int st_logcallback(httrackp *opt, int argc, char **argv) {

  static const char want[] = "42 sentinel";

  static const char want_filtered[] = "7 filtered";

  char BIGSTK seen[sizeof(st_log_callback_seen)];

  char BIGSTK line[256];

  FILE *fp;

  int rc = 1;

  (void) argc;

  (void) argv;

  fp = tmpfile();

  if (fp == NULL) {

    fprintf(stderr, "logcallback: tmpfile() failed\n");

    return 1;

  }

  opt->log = fp;

  opt->debug = LOG_NOTICE;

  st_log_callback_seen[0] = '\0';

  hts_set_log_vprint_callback(st_log_callback);

  hts_log_print(opt, LOG_NOTICE, "%d %s", 42, "sentinel");

  hts_set_log_vprint_callback(NULL);

  opt->log = NULL;

  strcpybuff(seen, st_log_callback_seen);

  rewind(fp);

  if (fgets(line, (int) sizeof(line), fp) == NULL) {

    fprintf(stderr, "logcallback: log file is empty, nothing was written\n");

    fclose(fp);

    return 1;

  }

  fclose(fp);

  /* The callback runs above the level filter and without a log file at all;

     the front-ends that install one usually have no opt->log open. */

  st_log_callback_seen[0] = '\0';

  hts_set_log_vprint_callback(st_log_callback);

  hts_log_print(opt, LOG_DEBUG, "%d %s", 7, "filtered");

  hts_set_log_vprint_callback(NULL);

  /* Same arguments both ways; the file line carries a level prefix. */

  if (strcmp(seen, want) != 0)

    fprintf(stderr, "logcallback: callback got '%s' want '%s'\n", seen, want);

  else if (strstr(line, want) == NULL)

    fprintf(stderr, "logcallback: log file got '%s' want it to carry '%s'\n",

            line, want);

  else if (strcmp(st_log_callback_seen, want_filtered) != 0)

    fprintf(stderr, "logcallback: unfiltered callback got '%s' want '%s'\n",

            st_log_callback_seen, want_filtered);

  else

    rc = 0;

  if (rc == 0)

    printf("logcallback self-test OK\n");

  return rc;

}

#ifdef HTS_CRASH_TEST

static char st_crash_seen[256];

static int st_crash_level;

static hts_boolean st_crash_had_opt;

static HTS_PRINTF_FUN(3, 0) void st_crash_log(httrackp *opt, int type,

                                              const char *format,

                                              va_list args) {

  st_crash_had_opt = opt != NULL ? HTS_TRUE : HTS_FALSE;

  st_crash_level = type;

  (void) vsnprintf(st_crash_seen, sizeof(st_crash_seen), format, args);

}

static FILE *st_crash_fp;

static HTS_PRINTF_FUN(3, 0) void st_crash_file_log(httrackp *opt, int type,

                                                   const char *format,

                                                   va_list args) {

  (void) opt;

  (void) type;

  vfprintf(st_crash_fp, format, args);

  fputc('\n', st_crash_fp);

  /* Flushed line by line, because the caller below is about to fault. */

  fflush(st_crash_fp);

}

/* See htscrashtest.h for why both channels carry the marker. Given a file, arm

   a real -#c fault and write what the log callback receives there: that run

   crashes, which is the path httrack-android recovers. */

static int st_crashannounce(httrackp *opt, int argc, char **argv) {

  static const char want[] = "crash announce 42";

  int rc = 1;

  (void) opt;

  if (argc >= 1) {

    st_crash_fp = fopen(argv[0], "wb");

    if (st_crash_fp == NULL) {

      fprintf(stderr, "crashannounce: cannot write %s\n", argv[0]);

      return 1;

    }

    hts_set_log_vprint_callback(st_crash_file_log);

    (void) hts_crash_test("dnssegv");

    hts_crash_test_worker(HTS_CRASH_WORKER_DNS);

    /* Only a handler that swallowed the fault gets here, so hand the log

       channel back rather than funnelling a later case into this file. */

    hts_set_log_vprint_callback(NULL);

    fclose(st_crash_fp);

    st_crash_fp = NULL;

    fprintf(stderr, "crashannounce: the armed fault did not crash\n");

    return 1;

  }

  hts_set_log_vprint_callback(st_crash_log);

  /* The engine must not need an opt to reach the front end here. */

  hts_crash_test_announce("crash announce %d", 42);

  hts_set_log_vprint_callback(NULL);

  if (strcmp(st_crash_seen, want) != 0)

    fprintf(stderr, "crashannounce: callback got '%s' want '%s'\n",

            st_crash_seen, want);

  else if (st_crash_level != LOG_ERROR)

    fprintf(stderr, "crashannounce: logged at level %d, want %d (LOG_ERROR)\n",

            st_crash_level, (int) LOG_ERROR);

  else if (st_crash_had_opt)

    fprintf(stderr, "crashannounce: the callback was handed an opt\n");

  else

    rc = 0;

  if (rc == 0)

    printf("crashannounce self-test OK\n");

  return rc;

}

#endif

/* The short form optalias_check() emits for the option words, both joined by a

   space when it returns two, or NULL when it refuses them; *used counts the

   words consumed and warn takes the message an accepted option still drew. */

static const char *st_optalias_expand(char *dest, size_t dest_size,

                                      const char *word, const char *next,

                                      int *used, char *warn, size_t warn_size) {

  char BIGSTK out[2][HTS_CDLMAXSIZE];

  char *outv[2] = {out[0], out[1]};

  const char *argv[2];

  char error[256];

  const int argc = next != NULL ? 2 : 1;

  int outc = 0;

  argv[0] = word;

  argv[1] = next;

  out[0][0] = out[1][0] = dest[0] = warn[0] = '\0';

  *used = optalias_check(argc, argv, 0, &outc, outv, sizeof(out[0]), error,

                         sizeof(error));

  if (*used == 0) {

    assertf(error[0] != '\0'); /* a refusal has to say why */

    return NULL;

  }

  strlcpybuff(warn, error, warn_size);

  assertf(outc >= 1 && outc <= 2);

  strlcpybuff(dest, out[0], dest_size);

  if (outc == 2) {

    strlcatbuff(dest, " ", dest_size);

    strlcatbuff(dest, out[1], dest_size);

  }

  return dest;

}

/* Long-option value handling (#1195): a value the option's class did not take

   was dropped, so --index=0 read back as the enabling bare --index. */

static int st_optalias(httrackp *opt, int argc, char **argv) {

  char got[HTS_CDLMAXSIZE * 2], warn[256];

  int i, used, params = 0;

  (void) opt;

  /* -list gives 282 the whole table: the rows to try against the engine's

     own parser, and the class of every name the wizard writes a value to */

  if (argc == 1 && strcmp(argv[0], "-list") == 0) {

    for (i = 0; optalias_value(i)[0] != '\0'; i++)

      printf("%s %s\n", opttype_value(i), optalias_value(i));

    return 0;

  }

  if (argc >= 1) {

    const char *const out = st_optalias_expand(got, sizeof(got), argv[0],

                                               argc >= 2 ? argv[1] : NULL,

                                               &used, warn, sizeof(warn));

    printf("%s\n", out != NULL ? out : "(refused)");

    return out != NULL ? 0 : 1;

  }

#define EXPANDS(want, word, next)                                              \

  do {                                                                         \

    const char *const out__ = st_optalias_expand(                              \

        got, sizeof(got), (word), (next), &used, warn, sizeof(warn));          \

    assertf(out__ != NULL && strcmp(out__, (want)) == 0);                      \

    assertf(warn[0] == '\0');                                                  \

  } while (0)

/* accepted, expanding to WANT, but drawing a warning on the way */

#define WARNS(want, word, next)                                                \

  do {                                                                         \

    const char *const out__ = st_optalias_expand(                              \

        got, sizeof(got), (word), (next), &used, warn, sizeof(warn));          \

    assertf(out__ != NULL && strcmp(out__, (want)) == 0);                      \

    assertf(warn[0] != '\0');                                                  \

  } while (0)

#define REFUSES(word, next)                                                    \

  assertf(st_optalias_expand(got, sizeof(got), (word), (next), &used, warn,    \

                             sizeof(warn)) == NULL)

  /* -I0 has always disabled the index; now the long form can say it too */

  EXPANDS("-I0", "--index=0", NULL);

  EXPANDS("-I0", "--index=off", NULL);

  EXPANDS("-I0", "--noindex", NULL);

  EXPANDS("-I", "--index=1", NULL);

  EXPANDS("-I", "--index=on", NULL);

  /* detached, as a config file writes it ("index off"), and never a URL */

  EXPANDS("-I0", "--index", "off");

  assertf(used == 2);

  EXPANDS("-I", "--index", "http://foo/");

  assertf(used == 1);

  EXPANDS("-I", "--index", NULL);

  assertf(used == 1);

  /* -I takes 0 alone, so an out-of-range value is an error, not a bare -I */

  REFUSES("--index=2", NULL);

  REFUSES("--index=yes", NULL);

  /* a numeric level reaches the short form whole */

  EXPANDS("-%I0", "--search-index=0", NULL);

  EXPANDS("-%I2", "--search-index=2", NULL);

  EXPANDS("-%v2", "--display=2", NULL);

  EXPANDS("-%N0", "--delayed-type-check=0", NULL);

  EXPANDS("-o0", "--generate-errors=0", NULL);

  REFUSES("--display=full", NULL);

  REFUSES("--display=99999999999999999999", NULL);

  /* three rows were "param", a class that demands a following token: the URL

     after --purge-old became its value, and =1 died on "invalid option 1" */

  EXPANDS("-X", "--purge-old", NULL);

  EXPANDS("-X", "--purge-old", "http://foo/");

  assertf(used == 1);

  EXPANDS("-X0", "--purge-old=0", NULL);

  EXPANDS("-X", "--purge-old=1", NULL);

  EXPANDS("-X0", "--purge-old", "0");

  assertf(used == 2);

  EXPANDS("-X", "--purge-old", "1");

  EXPANDS("-X0", "--nopurge-old", NULL);

  EXPANDS("-%f0", "--httpproxy-ftp=0", NULL);

  EXPANDS("-%f", "--httpproxy-ftp=1", NULL);

  EXPANDS("-%P0", "--extended-parsing=0", NULL);

  EXPANDS("-%P", "--extended-parsing=1", NULL);

  /* a flag that takes no value refuses one rather than dropping it */

  REFUSES("--mirror=0", NULL);

  REFUSES("--nomirror", NULL);

  REFUSES("--warc=0", NULL);

  REFUSES("--single-file=s", NULL);

  /* ...and so does a compound alias, whose value would land in the cluster */

  REFUSES("--spider=0", NULL);

  /* an alias whose own name begins with "no" is not a negation */

  EXPANDS("-%T0", "--no-utf8-conversion", NULL);

  EXPANDS("-y0", "--no-background-on-suspend", NULL);

  EXPANDS("-%T", "--utf8-conversion", NULL);

  /* the --wide-/--tiny- prefix glues the --wide/--tiny connection count onto

     the plain clusters, and is refused wherever the glue would be misread */

  EXPANDS("-wc32", "--wide-mirror", NULL);

  assertf(used == 1);

  EXPANDS("-wc1", "--tiny-mirror", NULL);

  EXPANDS("-p0C0I0tc32", "--wide-spider", NULL);

  EXPANDS("-qgc1", "--tiny-get", NULL);

  EXPANDS("-Xc32", "--wide-purge-old", NULL);

  EXPANDS("-o2c1", "--tiny-generate-errors", "2");

  assertf(used == 2);

  /* elsewhere the alias applies without the count, and says so */

  WARNS("-O /tmp", "--wide-path", "/tmp"); /* the value is a word of its own */

  WARNS("+*.gif", "--tiny-allow", "*.gif");

  WARNS("--clean", "--wide-clean", NULL); /* a long form */

  WARNS("-c8", "--wide-sockets", "8");    /* -c8 already: 8 or 32? */

  WARNS("-c32", "--tiny-wide", NULL);     /* -c32 already: 32 or 1? */

  WARNS("-N1", "--wide-structure", "1");  /* -N takes a template */

  WARNS("-%r", "--wide-warc", NULL);      /* -%rc is --warc-cdx, not -%r -c */

  WARNS("-#h", "--wide-version", NULL);   /* -#h is matched as a whole word */

  WARNS("-h", "--tiny-help", NULL);

  /* the value-taking classes are untouched */

  EXPANDS("-C0", "--cache=0", NULL);

  EXPANDS("-C0", "--nocache", NULL);

  EXPANDS("-C2", "--cache", "2");

  EXPANDS("-P proxy:8080", "--proxy", "proxy:8080");

  EXPANDS("+*.gif", "--allow", "*.gif");

  /* #1426, both directions and table-wide over the "param" rows */

  for (i = 0; optalias_value(i)[0] != '\0'; i++) {

    const int p = optalias_find(optalias_value(i));

    char word[HTS_CDLMAXSIZE], want[HTS_CDLMAXSIZE];

    if (strcmp(opttype_value(p), "param") != 0)

      continue;

    params++;

    snprintf(word, sizeof(word), "--%s=yes", optalias_value(i));

    REFUSES(word, NULL);

    snprintf(word, sizeof(word), "--%s=none", optalias_value(i));

    REFUSES(word, NULL);

    snprintf(word, sizeof(word), "--%s=OFF", optalias_value(i));

    REFUSES(word, NULL);

    snprintf(word, sizeof(word), "--%s", optalias_value(i));

    REFUSES(word, "http://foo/");

    /* control: a number, and the on/off mapping, still pass in silence */

    snprintf(word, sizeof(word), "--%s=2", optalias_value(i));

    snprintf(want, sizeof(want), "%s2", optreal_value(p));

    EXPANDS(want, word, NULL);

    snprintf(word, sizeof(word), "--%s=off", optalias_value(i));

    snprintf(want, sizeof(want), "%s0", optreal_value(p));

    EXPANDS(want, word, NULL);

    snprintf(word, sizeof(word), "--%s=on", optalias_value(i));

    EXPANDS(optreal_value(p), word, NULL);

    /* #1437, table-wide too: the bound is the destination's magnitude, so

       padding rides through and a run past every destination does not */

    snprintf(word, sizeof(word), "--%s=00000000000000000002",

             optalias_value(i));

    snprintf(want, sizeof(want), "%s00000000000000000002", optreal_value(p));

    EXPANDS(want, word, NULL);

    snprintf(word, sizeof(word), "--%s=2147483647", optalias_value(i));

    snprintf(want, sizeof(want), "%s2147483647", optreal_value(p));

    EXPANDS(want, word, NULL);