src/test/testing_common.c

   1 /* Copyright (c) 2001-2004, Roger Dingledine.
   2  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   3  * Copyright (c) 2007-2021, The Tor Project, Inc. */
   4 /* See LICENSE for licensing information */
   5
   6 /**
   7  * \file test_common.c
   8  * \brief Common pieces to implement unit tests.
   9  **/
  10
  11 #define MAINLOOP_PRIVATE
  12 #include "orconfig.h"
  13 #include "core/or/or.h"
  14 #include "feature/control/control.h"
  15 #include "feature/control/control_events.h"
  16 #include "app/config/config.h"
  17 #include "lib/crypt_ops/crypto_dh.h"
  18 #include "lib/crypt_ops/crypto_ed25519.h"
  19 #include "lib/crypt_ops/crypto_rand.h"
  20 #include "feature/stats/predict_ports.h"
  21 #include "feature/stats/bwhist.h"
  22 #include "feature/stats/rephist.h"
  23 #include "lib/err/backtrace.h"
  24 #include "test/test.h"
  25 #include "core/or/channelpadding.h"
  26 #include "core/mainloop/mainloop.h"
  27 #include "lib/compress/compress.h"
  28 #include "lib/evloop/compat_libevent.h"
  29 #include "lib/crypt_ops/crypto_init.h"
  30 #include "lib/version/torversion.h"
  31 #include "app/main/subsysmgr.h"
  32
  33 #include <stdio.h>
  34 #ifdef HAVE_FCNTL_H
  35 #include <fcntl.h>
  36 #endif
  37 #ifdef HAVE_UNISTD_H
  38 #include <unistd.h>
  39 #endif
  40 #ifdef HAVE_SYS_STAT_H
  41 #include <sys/stat.h>
  42 #endif
  43
  44 #ifdef _WIN32
  45 /* For mkdir() */
  46 #include <direct.h>
  47 #else
  48 #include <dirent.h>
  49 #endif /* defined(_WIN32) */
  50
  51 /** Temporary directory (set up by setup_directory) under which we store all
  52  * our files during testing. */
  53 static char temp_dir[256];
  54 #ifdef _WIN32
  55 #define pid_t int
  56 #endif
  57 static pid_t temp_dir_setup_in_pid = 0;
  58
  59 /** Select and create the temporary directory we'll use to run our unit tests.
  60  * Store it in <b>temp_dir</b>.  Exit immediately if we can't create it.
  61  * idempotent. */
  62 static void
  63 setup_directory(void)
  64 {
  65   static int is_setup = 0;
  66   int r;
  67   char rnd[256], rnd32[256];
  68   if (is_setup) return;
  69
  70 /* Due to base32 limitation needs to be a multiple of 5. */
  71 #define RAND_PATH_BYTES 5
  72   crypto_rand(rnd, RAND_PATH_BYTES);
  73   base32_encode(rnd32, sizeof(rnd32), rnd, RAND_PATH_BYTES);
  74
  75 #ifdef _WIN32
  76   {
  77     char buf[MAX_PATH];
  78     const char *tmp = buf;
  79     const char *extra_backslash = "";
  80     /* If this fails, we're probably screwed anyway */
  81     if (!GetTempPathA(sizeof(buf),buf))
  82       tmp = "c:\\windows\\temp\\";
  83     if (strcmpend(tmp, "\\")) {
  84       /* According to MSDN, it should be impossible for GetTempPath to give us
  85        * an answer that doesn't end with \.  But let's make sure. */
  86       extra_backslash = "\\";
  87     }
  88     tor_snprintf(temp_dir, sizeof(temp_dir),
  89                  "%s%stor_test_%d_%s", tmp, extra_backslash,
  90                  (int)getpid(), rnd32);
  91     r = mkdir(temp_dir);
  92   }
  93 #elif defined(__ANDROID__)
  94   /* tor might not like the default perms, so create a subdir */
  95   tor_snprintf(temp_dir, sizeof(temp_dir),
  96                "/data/local/tmp/tor_%d_%d_%s",
  97                (int) getuid(), (int) getpid(), rnd32);
  98   r = mkdir(temp_dir, 0700);
  99   if (r) {
 100     fprintf(stderr, "Can't create directory %s:", temp_dir);
 101     perror("");
 102     exit(1);
 103   }
 104 #else /* !defined(_WIN32) */
 105   tor_snprintf(temp_dir, sizeof(temp_dir), "/tmp/tor_test_%d_%s",
 106                (int) getpid(), rnd32);
 107   r = mkdir(temp_dir, 0700);
 108   if (!r) {
 109     /* undo sticky bit so tests don't get confused. */
 110     r = chown(temp_dir, getuid(), getgid());
 111   }
 112 #endif /* defined(_WIN32) || ... */
 113   if (r) {
 114     fprintf(stderr, "Can't create directory %s:", temp_dir);
 115     perror("");
 116     exit(1);
 117   }
 118   is_setup = 1;
 119   temp_dir_setup_in_pid = getpid();
 120 }
 121
 122 /** Return a filename relative to our testing temporary directory, based on
 123  * name and suffix. If name is NULL, return the name of the testing temporary
 124  * directory. */
 125 static const char *
 126 get_fname_suffix(const char *name, const char *suffix)
 127 {
 128   static char buf[1024];
 129   setup_directory();
 130   if (!name)
 131     return temp_dir;
 132   tor_snprintf(buf,sizeof(buf),"%s%s%s%s%s", temp_dir, PATH_SEPARATOR, name,
 133                suffix ? "_" : "", suffix ? suffix : "");
 134   return buf;
 135 }
 136
 137 /** Return a filename relative to our testing temporary directory. If name is
 138  * NULL, return the name of the testing temporary directory. */
 139 const char *
 140 get_fname(const char *name)
 141 {
 142   return get_fname_suffix(name, NULL);
 143 }
 144
 145 /** Return a filename with a random suffix, relative to our testing temporary
 146  * directory. If name is NULL, return the name of the testing temporary
 147  * directory, without any suffix. */
 148 const char *
 149 get_fname_rnd(const char *name)
 150 {
 151   char rnd[256], rnd32[256];
 152   crypto_rand(rnd, RAND_PATH_BYTES);
 153   base32_encode(rnd32, sizeof(rnd32), rnd, RAND_PATH_BYTES);
 154   return get_fname_suffix(name, rnd32);
 155 }
 156
 157 /* Remove a directory and all of its subdirectories */
 158 static void
 159 rm_rf(const char *dir)
 160 {
 161   struct stat st;
 162   smartlist_t *elements;
 163
 164   elements = tor_listdir(dir);
 165   if (elements) {
 166     SMARTLIST_FOREACH_BEGIN(elements, const char *, cp) {
 167          char *tmp = NULL;
 168          tor_asprintf(&tmp, "%s"PATH_SEPARATOR"%s", dir, cp);
 169          if (0 == stat(tmp,&st) && (st.st_mode & S_IFDIR)) {
 170            rm_rf(tmp);
 171          } else {
 172            if (unlink(tmp)) {
 173              fprintf(stderr, "Error removing %s: %s\n", tmp, strerror(errno));
 174            }
 175          }
 176          tor_free(tmp);
 177     } SMARTLIST_FOREACH_END(cp);
 178     SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));
 179     smartlist_free(elements);
 180   }
 181   if (rmdir(dir))
 182     fprintf(stderr, "Error removing directory %s: %s\n", dir, strerror(errno));
 183 }
 184
 185 /** Remove all files stored under the temporary directory, and the directory
 186  * itself.  Called by atexit(). */
 187 static void
 188 remove_directory(void)
 189 {
 190   if (getpid() != temp_dir_setup_in_pid) {
 191     /* Only clean out the tempdir when the main process is exiting. */
 192     return;
 193   }
 194
 195   rm_rf(temp_dir);
 196 }
 197
 198 static void *
 199 passthrough_test_setup(const struct testcase_t *testcase)
 200 {
 201   /* Make sure the passthrough doesn't unintentionally fail or skip tests */
 202   tor_assert(testcase->setup_data);
 203   tor_assert(testcase->setup_data != (void*)TT_SKIP);
 204   return testcase->setup_data;
 205 }
 206 static int
 207 passthrough_test_cleanup(const struct testcase_t *testcase, void *ptr)
 208 {
 209   (void)testcase;
 210   (void)ptr;
 211   return 1;
 212 }
 213
 214 static void *
 215 ed25519_testcase_setup(const struct testcase_t *testcase)
 216 {
 217   crypto_ed25519_testing_force_impl(testcase->setup_data);
 218   return testcase->setup_data;
 219 }
 220 static int
 221 ed25519_testcase_cleanup(const struct testcase_t *testcase, void *ptr)
 222 {
 223   (void)testcase;
 224   (void)ptr;
 225   crypto_ed25519_testing_restore_impl();
 226   return 1;
 227 }
 228 const struct testcase_setup_t ed25519_test_setup = {
 229   ed25519_testcase_setup, ed25519_testcase_cleanup
 230 };
 231
 232 const struct testcase_setup_t passthrough_setup = {
 233   passthrough_test_setup, passthrough_test_cleanup
 234 };
 235
 236 static void
 237 an_assertion_failed(void)
 238 {
 239   tinytest_set_test_failed_();
 240 }
 241
 242 void tinytest_prefork(void);
 243 void tinytest_postfork(void);
 244 void
 245 tinytest_prefork(void)
 246 {
 247 #ifdef ENABLE_NSS
 248   free_pregenerated_keys();
 249 #endif
 250   subsystems_prefork();
 251 }
 252 void
 253 tinytest_postfork(void)
 254 {
 255   subsystems_postfork();
 256 #ifdef ENABLE_NSS
 257   init_pregenerated_keys();
 258 #endif
 259 }
 260
 261 static void
 262 log_callback_failure(int severity, log_domain_mask_t domain, const char *msg)
 263 {
 264   (void)msg;
 265   if (severity == LOG_ERR || (domain & LD_BUG)) {
 266     tinytest_set_test_failed_();
 267   }
 268 }
 269
 270 /** Main entry point for unit test code: parse the command line, and run
 271  * some unit tests. */
 272 int
 273 main(int c, const char **v)
 274 {
 275   or_options_t *options;
 276   char *errmsg = NULL;
 277   int i, i_out;
 278   int loglevel = LOG_ERR;
 279   int accel_crypto = 0;
 280
 281   subsystems_init();
 282
 283   options = options_new();
 284
 285   struct tor_libevent_cfg_t cfg;
 286   memset(&cfg, 0, sizeof(cfg));
 287   tor_libevent_initialize(&cfg);
 288
 289   control_initialize_event_queue();
 290
 291   /* Don't add default logs; the tests manage their own. */
 292   quiet_level = QUIET_SILENT;
 293
 294   unsigned num=1, den=1;
 295
 296   for (i_out = i = 1; i < c; ++i) {
 297     if (!strcmp(v[i], "--warn")) {
 298       loglevel = LOG_WARN;
 299     } else if (!strcmp(v[i], "--notice")) {
 300       loglevel = LOG_NOTICE;
 301     } else if (!strcmp(v[i], "--info")) {
 302       loglevel = LOG_INFO;
 303     } else if (!strcmp(v[i], "--debug")) {
 304       loglevel = LOG_DEBUG;
 305     } else if (!strcmp(v[i], "--accel")) {
 306       accel_crypto = 1;
 307     } else if (!strcmp(v[i], "--fraction")) {
 308       if (i+1 == c) {
 309         printf("--fraction needs an argument.\n");
 310         return 1;
 311       }
 312       const char *fracstr = v[++i];
 313       char ch;
 314       if (sscanf(fracstr, "%u/%u%c", &num, &den, &ch) != 2) {
 315         printf("--fraction expects a fraction as an input.\n");
 316       }
 317       if (den == 0 || num == 0 || num > den) {
 318         printf("--fraction expects a valid fraction as an input.\n");
 319       }
 320     } else {
 321       v[i_out++] = v[i];
 322     }
 323   }
 324   c = i_out;
 325
 326   {
 327     /* setup logs to stdout */
 328     log_severity_list_t s;
 329     memset(&s, 0, sizeof(s));
 330     set_log_severity_config(loglevel, LOG_ERR, &s);
 331     /* ALWAYS log bug warnings. */
 332     s.masks[SEVERITY_MASK_IDX(LOG_WARN)] |= LD_BUG;
 333     add_stream_log(&s, "", fileno(stdout));
 334   }
 335   {
 336     /* Setup logs that cause failure. */
 337     log_severity_list_t s;
 338     memset(&s, 0, sizeof(s));
 339     set_log_severity_config(LOG_ERR, LOG_ERR, &s);
 340     s.masks[SEVERITY_MASK_IDX(LOG_WARN)] |= LD_BUG;
 341     add_callback_log(&s, log_callback_failure);
 342   }
 343   flush_log_messages_from_startup();
 344   init_protocol_warning_severity_level();
 345
 346   options->command = CMD_RUN_UNITTESTS;
 347   if (crypto_global_init(accel_crypto, NULL, NULL)) {
 348     printf("Can't initialize crypto subsystem; exiting.\n");
 349     return 1;
 350   }
 351   if (crypto_seed_rng() < 0) {
 352     printf("Couldn't seed RNG; exiting.\n");
 353     return 1;
 354   }
 355   rep_hist_init();
 356   bwhist_init();
 357   setup_directory();
 358   initialize_mainloop_events();
 359   options_init(options);
 360   options->DataDirectory = tor_strdup(temp_dir);
 361   options->DataDirectory_option = tor_strdup(temp_dir);
 362   tor_asprintf(&options->KeyDirectory, "%s"PATH_SEPARATOR"keys",
 363                options->DataDirectory);
 364   options->CacheDirectory = tor_strdup(temp_dir);
 365   options->EntryStatistics = 1;
 366   if (set_options(options, &errmsg) < 0) {
 367     printf("Failed to set initial options: %s\n", errmsg);
 368     tor_free(errmsg);
 369     return 1;
 370   }
 371
 372   tor_set_failed_assertion_callback(an_assertion_failed);
 373
 374   init_pregenerated_keys();
 375
 376   channelpadding_new_consensus_params(NULL);
 377
 378   predicted_ports_init();
 379
 380   atexit(remove_directory);
 381
 382   /* Look for TOR_SKIP_TESTCASES: a space-separated list of tests to skip. */
 383   const char *skip_tests = getenv("TOR_SKIP_TESTCASES");
 384   if (skip_tests) {
 385     smartlist_t *skip = smartlist_new();
 386     smartlist_split_string(skip, skip_tests, NULL,
 387                            SPLIT_IGNORE_BLANK, -1);
 388     int n = 0;
 389     SMARTLIST_FOREACH_BEGIN(skip, char *, cp) {
 390       n += tinytest_skip(testgroups, cp);
 391       tor_free(cp);
 392     } SMARTLIST_FOREACH_END(cp);
 393     printf("Skipping %d testcases.\n", n);
 394     smartlist_free(skip);
 395   }
 396
 397   if (den != 1) {
 398     // count the tests. Linear but fast.
 399     unsigned n_tests = 0;
 400     struct testgroup_t *tg;
 401     struct testcase_t *tc;
 402     for (tg = testgroups; tg->prefix != NULL; ++tg) {
 403       for (tc = tg->cases; tc->name != NULL; ++tc) {
 404         ++n_tests;
 405       }
 406     }
 407     // Which tests should we run?  This can give iffy results if den is huge
 408     // but it doesn't actually matter in practice.
 409     unsigned tests_per_chunk = CEIL_DIV(n_tests, den);
 410     unsigned start_at = (num-1) * tests_per_chunk;
 411
 412     // Skip the tests that are outside of the range.
 413     unsigned idx = 0;
 414     for (tg = testgroups; tg->prefix != NULL; ++tg) {
 415       for (tc = tg->cases; tc->name != NULL; ++tc) {
 416         if (idx < start_at || idx >= start_at + tests_per_chunk) {
 417           tc->flags |= TT_SKIP;
 418         }
 419         ++idx;
 420       }
 421     }
 422   }
 423
 424   int have_failed = (tinytest_main(c, v, testgroups) != 0);
 425
 426   free_pregenerated_keys();
 427
 428   if (have_failed)
 429     return 1;
 430   else
 431     return 0;
 432 }