test.c
上传用户:awang829
上传日期:2019-07-14
资源大小:2356k
文件大小:163k
源码类别:

网络

开发平台:

Unix_Linux

  1. /* Copyright (c) 2001-2004, Roger Dingledine.
  2.  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3.  * Copyright (c) 2007-2009, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /* Ordinarily defined in tor_main.c; this bit is just here to provide one
  6.  * since we're not linking to tor_main.c */
  7. const char tor_svn_revision[] = "";
  8. /**
  9.  * file test.c
  10.  * brief Unit tests for many pieces of the lower level Tor modules.
  11.  **/
  12. #include "orconfig.h"
  13. #include <stdio.h>
  14. #ifdef HAVE_FCNTL_H
  15. #include <fcntl.h>
  16. #endif
  17. #ifdef MS_WINDOWS
  18. /* For mkdir() */
  19. #include <direct.h>
  20. #else
  21. #include <dirent.h>
  22. #endif
  23. /* These macros pull in declarations for some functions and structures that
  24.  * are typically file-private. */
  25. #define BUFFERS_PRIVATE
  26. #define CONFIG_PRIVATE
  27. #define CONTROL_PRIVATE
  28. #define CRYPTO_PRIVATE
  29. #define DIRSERV_PRIVATE
  30. #define DIRVOTE_PRIVATE
  31. #define GEOIP_PRIVATE
  32. #define MEMPOOL_PRIVATE
  33. #define ROUTER_PRIVATE
  34. #include "or.h"
  35. #include "test.h"
  36. #include "torgzip.h"
  37. #include "mempool.h"
  38. #include "memarea.h"
  39. #ifdef USE_DMALLOC
  40. #include <dmalloc.h>
  41. #include <openssl/crypto.h>
  42. #endif
  43. /** Set to true if any unit test has failed.  Mostly, this is set by the macros
  44.  * in test.h */
  45. int have_failed = 0;
  46. /** Temporary directory (set up by setup_directory) under which we store all
  47.  * our files during testing. */
  48. static char temp_dir[256];
  49. /** Select and create the temporary directory we'll use to run our unit tests.
  50.  * Store it in <b>temp_dir</b>.  Exit immediately if we can't create it.
  51.  * idempotent. */
  52. static void
  53. setup_directory(void)
  54. {
  55.   static int is_setup = 0;
  56.   int r;
  57.   if (is_setup) return;
  58. #ifdef MS_WINDOWS
  59.   // XXXX
  60.   tor_snprintf(temp_dir, sizeof(temp_dir),
  61.                "c:\windows\temp\tor_test_%d", (int)getpid());
  62.   r = mkdir(temp_dir);
  63. #else
  64.   tor_snprintf(temp_dir, sizeof(temp_dir), "/tmp/tor_test_%d", (int) getpid());
  65.   r = mkdir(temp_dir, 0700);
  66. #endif
  67.   if (r) {
  68.     fprintf(stderr, "Can't create directory %s:", temp_dir);
  69.     perror("");
  70.     exit(1);
  71.   }
  72.   is_setup = 1;
  73. }
  74. /** Return a filename relative to our testing temporary directory */
  75. static const char *
  76. get_fname(const char *name)
  77. {
  78.   static char buf[1024];
  79.   setup_directory();
  80.   tor_snprintf(buf,sizeof(buf),"%s/%s",temp_dir,name);
  81.   return buf;
  82. }
  83. /** Remove all files stored under the temporary directory, and the directory
  84.  * itself. */
  85. static void
  86. remove_directory(void)
  87. {
  88.   smartlist_t *elements = tor_listdir(temp_dir);
  89.   if (elements) {
  90.     SMARTLIST_FOREACH(elements, const char *, cp,
  91.        {
  92.          size_t len = strlen(cp)+strlen(temp_dir)+16;
  93.          char *tmp = tor_malloc(len);
  94.          tor_snprintf(tmp, len, "%s"PATH_SEPARATOR"%s", temp_dir, cp);
  95.          unlink(tmp);
  96.          tor_free(tmp);
  97.        });
  98.     SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));
  99.     smartlist_free(elements);
  100.   }
  101.   rmdir(temp_dir);
  102. }
  103. /** Define this if unit tests spend too much time generating public keys*/
  104. #undef CACHE_GENERATED_KEYS
  105. static crypto_pk_env_t *pregen_keys[5] = {NULL, NULL, NULL, NULL, NULL};
  106. #define N_PREGEN_KEYS ((int)(sizeof(pregen_keys)/sizeof(pregen_keys[0])))
  107. /** Generate and return a new keypair for use in unit tests.  If we're using
  108.  * the key cache optimization, we might reuse keys: we only guarantee that
  109.  * keys made with distinct values for <b>idx</b> are different.  The value of
  110.  * <b>idx</b> must be at least 0, and less than N_PREGEN_KEYS. */
  111. static crypto_pk_env_t *
  112. pk_generate(int idx)
  113. {
  114. #ifdef CACHE_GENERATED_KEYS
  115.   tor_assert(idx < N_PREGEN_KEYS);
  116.   if (! pregen_keys[idx]) {
  117.     pregen_keys[idx] = crypto_new_pk_env();
  118.     tor_assert(!crypto_pk_generate_key(pregen_keys[idx]));
  119.   }
  120.   return crypto_pk_dup_key(pregen_keys[idx]);
  121. #else
  122.   crypto_pk_env_t *result;
  123.   (void) idx;
  124.   result = crypto_new_pk_env();
  125.   tor_assert(!crypto_pk_generate_key(result));
  126.   return result;
  127. #endif
  128. }
  129. /** Free all storage used for the cached key optimization. */
  130. static void
  131. free_pregenerated_keys(void)
  132. {
  133.   unsigned idx;
  134.   for (idx = 0; idx < N_PREGEN_KEYS; ++idx) {
  135.     if (pregen_keys[idx]) {
  136.       crypto_free_pk_env(pregen_keys[idx]);
  137.       pregen_keys[idx] = NULL;
  138.     }
  139.   }
  140. }
  141. /** Run unit tests for buffers.c */
  142. static void
  143. test_buffers(void)
  144. {
  145.   char str[256];
  146.   char str2[256];
  147.   buf_t *buf = NULL, *buf2 = NULL;
  148.   const char *cp;
  149.   int j;
  150.   size_t r;
  151.   /****
  152.    * buf_new
  153.    ****/
  154.   if (!(buf = buf_new()))
  155.     test_fail();
  156.   //test_eq(buf_capacity(buf), 4096);
  157.   test_eq(buf_datalen(buf), 0);
  158.   /****
  159.    * General pointer frobbing
  160.    */
  161.   for (j=0;j<256;++j) {
  162.     str[j] = (char)j;
  163.   }
  164.   write_to_buf(str, 256, buf);
  165.   write_to_buf(str, 256, buf);
  166.   test_eq(buf_datalen(buf), 512);
  167.   fetch_from_buf(str2, 200, buf);
  168.   test_memeq(str, str2, 200);
  169.   test_eq(buf_datalen(buf), 312);
  170.   memset(str2, 0, sizeof(str2));
  171.   fetch_from_buf(str2, 256, buf);
  172.   test_memeq(str+200, str2, 56);
  173.   test_memeq(str, str2+56, 200);
  174.   test_eq(buf_datalen(buf), 56);
  175.   memset(str2, 0, sizeof(str2));
  176.   /* Okay, now we should be 512 bytes into the 4096-byte buffer.  If we add
  177.    * another 3584 bytes, we hit the end. */
  178.   for (j=0;j<15;++j) {
  179.     write_to_buf(str, 256, buf);
  180.   }
  181.   assert_buf_ok(buf);
  182.   test_eq(buf_datalen(buf), 3896);
  183.   fetch_from_buf(str2, 56, buf);
  184.   test_eq(buf_datalen(buf), 3840);
  185.   test_memeq(str+200, str2, 56);
  186.   for (j=0;j<15;++j) {
  187.     memset(str2, 0, sizeof(str2));
  188.     fetch_from_buf(str2, 256, buf);
  189.     test_memeq(str, str2, 256);
  190.   }
  191.   test_eq(buf_datalen(buf), 0);
  192.   buf_free(buf);
  193.   buf = NULL;
  194.   /* Okay, now make sure growing can work. */
  195.   buf = buf_new_with_capacity(16);
  196.   //test_eq(buf_capacity(buf), 16);
  197.   write_to_buf(str+1, 255, buf);
  198.   //test_eq(buf_capacity(buf), 256);
  199.   fetch_from_buf(str2, 254, buf);
  200.   test_memeq(str+1, str2, 254);
  201.   //test_eq(buf_capacity(buf), 256);
  202.   assert_buf_ok(buf);
  203.   write_to_buf(str, 32, buf);
  204.   //test_eq(buf_capacity(buf), 256);
  205.   assert_buf_ok(buf);
  206.   write_to_buf(str, 256, buf);
  207.   assert_buf_ok(buf);
  208.   //test_eq(buf_capacity(buf), 512);
  209.   test_eq(buf_datalen(buf), 33+256);
  210.   fetch_from_buf(str2, 33, buf);
  211.   test_eq(*str2, str[255]);
  212.   test_memeq(str2+1, str, 32);
  213.   //test_eq(buf_capacity(buf), 512);
  214.   test_eq(buf_datalen(buf), 256);
  215.   fetch_from_buf(str2, 256, buf);
  216.   test_memeq(str, str2, 256);
  217.   /* now try shrinking: case 1. */
  218.   buf_free(buf);
  219.   buf = buf_new_with_capacity(33668);
  220.   for (j=0;j<67;++j) {
  221.     write_to_buf(str,255, buf);
  222.   }
  223.   //test_eq(buf_capacity(buf), 33668);
  224.   test_eq(buf_datalen(buf), 17085);
  225.   for (j=0; j < 40; ++j) {
  226.     fetch_from_buf(str2, 255,buf);
  227.     test_memeq(str2, str, 255);
  228.   }
  229.   /* now try shrinking: case 2. */
  230.   buf_free(buf);
  231.   buf = buf_new_with_capacity(33668);
  232.   for (j=0;j<67;++j) {
  233.     write_to_buf(str,255, buf);
  234.   }
  235.   for (j=0; j < 20; ++j) {
  236.     fetch_from_buf(str2, 255,buf);
  237.     test_memeq(str2, str, 255);
  238.   }
  239.   for (j=0;j<80;++j) {
  240.     write_to_buf(str,255, buf);
  241.   }
  242.   //test_eq(buf_capacity(buf),33668);
  243.   for (j=0; j < 120; ++j) {
  244.     fetch_from_buf(str2, 255,buf);
  245.     test_memeq(str2, str, 255);
  246.   }
  247.   /* Move from buf to buf. */
  248.   buf_free(buf);
  249.   buf = buf_new_with_capacity(4096);
  250.   buf2 = buf_new_with_capacity(4096);
  251.   for (j=0;j<100;++j)
  252.     write_to_buf(str, 255, buf);
  253.   test_eq(buf_datalen(buf), 25500);
  254.   for (j=0;j<100;++j) {
  255.     r = 10;
  256.     move_buf_to_buf(buf2, buf, &r);
  257.     test_eq(r, 0);
  258.   }
  259.   test_eq(buf_datalen(buf), 24500);
  260.   test_eq(buf_datalen(buf2), 1000);
  261.   for (j=0;j<3;++j) {
  262.     fetch_from_buf(str2, 255, buf2);
  263.     test_memeq(str2, str, 255);
  264.   }
  265.   r = 8192; /*big move*/
  266.   move_buf_to_buf(buf2, buf, &r);
  267.   test_eq(r, 0);
  268.   r = 30000; /* incomplete move */
  269.   move_buf_to_buf(buf2, buf, &r);
  270.   test_eq(r, 13692);
  271.   for (j=0;j<97;++j) {
  272.     fetch_from_buf(str2, 255, buf2);
  273.     test_memeq(str2, str, 255);
  274.   }
  275.   buf_free(buf);
  276.   buf_free(buf2);
  277.   buf = buf2 = NULL;
  278.   buf = buf_new_with_capacity(5);
  279.   cp = "Testing. This is a moderately long Testing string.";
  280.   for (j = 0; cp[j]; j++)
  281.     write_to_buf(cp+j, 1, buf);
  282.   test_eq(0, buf_find_string_offset(buf, "Testing", 7));
  283.   test_eq(1, buf_find_string_offset(buf, "esting", 6));
  284.   test_eq(1, buf_find_string_offset(buf, "est", 3));
  285.   test_eq(39, buf_find_string_offset(buf, "ing str", 7));
  286.   test_eq(35, buf_find_string_offset(buf, "Testing str", 11));
  287.   test_eq(32, buf_find_string_offset(buf, "ng ", 3));
  288.   test_eq(43, buf_find_string_offset(buf, "string.", 7));
  289.   test_eq(-1, buf_find_string_offset(buf, "shrdlu", 6));
  290.   test_eq(-1, buf_find_string_offset(buf, "Testing thing", 13));
  291.   test_eq(-1, buf_find_string_offset(buf, "ngx", 3));
  292.   buf_free(buf);
  293.   buf = NULL;
  294. #if 0
  295.   {
  296.   int s;
  297.   int eof;
  298.   int i;
  299.   buf_t *buf2;
  300.   /****
  301.    * read_to_buf
  302.    ****/
  303.   s = open(get_fname("data"), O_WRONLY|O_CREAT|O_TRUNC, 0600);
  304.   write(s, str, 256);
  305.   close(s);
  306.   s = open(get_fname("data"), O_RDONLY, 0);
  307.   eof = 0;
  308.   errno = 0; /* XXXX */
  309.   i = read_to_buf(s, 10, buf, &eof);
  310.   printf("%sn", strerror(errno));
  311.   test_eq(i, 10);
  312.   test_eq(eof, 0);
  313.   //test_eq(buf_capacity(buf), 4096);
  314.   test_eq(buf_datalen(buf), 10);
  315.   test_memeq(str, (char*)_buf_peek_raw_buffer(buf), 10);
  316.   /* Test reading 0 bytes. */
  317.   i = read_to_buf(s, 0, buf, &eof);
  318.   //test_eq(buf_capacity(buf), 512*1024);
  319.   test_eq(buf_datalen(buf), 10);
  320.   test_eq(eof, 0);
  321.   test_eq(i, 0);
  322.   /* Now test when buffer is filled exactly. */
  323.   buf2 = buf_new_with_capacity(6);
  324.   i = read_to_buf(s, 6, buf2, &eof);
  325.   //test_eq(buf_capacity(buf2), 6);
  326.   test_eq(buf_datalen(buf2), 6);
  327.   test_eq(eof, 0);
  328.   test_eq(i, 6);
  329.   test_memeq(str+10, (char*)_buf_peek_raw_buffer(buf2), 6);
  330.   buf_free(buf2);
  331.   buf2 = NULL;
  332.   /* Now test when buffer is filled with more data to read. */
  333.   buf2 = buf_new_with_capacity(32);
  334.   i = read_to_buf(s, 128, buf2, &eof);
  335.   //test_eq(buf_capacity(buf2), 128);
  336.   test_eq(buf_datalen(buf2), 32);
  337.   test_eq(eof, 0);
  338.   test_eq(i, 32);
  339.   buf_free(buf2);
  340.   buf2 = NULL;
  341.   /* Now read to eof. */
  342.   test_assert(buf_capacity(buf) > 256);
  343.   i = read_to_buf(s, 1024, buf, &eof);
  344.   test_eq(i, (256-32-10-6));
  345.   test_eq(buf_capacity(buf), MAX_BUF_SIZE);
  346.   test_eq(buf_datalen(buf), 256-6-32);
  347.   test_memeq(str, (char*)_buf_peek_raw_buffer(buf), 10); /* XXX Check rest. */
  348.   test_eq(eof, 0);
  349.   i = read_to_buf(s, 1024, buf, &eof);
  350.   test_eq(i, 0);
  351.   test_eq(buf_capacity(buf), MAX_BUF_SIZE);
  352.   test_eq(buf_datalen(buf), 256-6-32);
  353.   test_eq(eof, 1);
  354.   }
  355. #endif
  356.  done:
  357.   if (buf)
  358.     buf_free(buf);
  359.   if (buf2)
  360.     buf_free(buf2);
  361. }
  362. /** Run unit tests for Diffie-Hellman functionality. */
  363. static void
  364. test_crypto_dh(void)
  365. {
  366.   crypto_dh_env_t *dh1 = crypto_dh_new();
  367.   crypto_dh_env_t *dh2 = crypto_dh_new();
  368.   char p1[DH_BYTES];
  369.   char p2[DH_BYTES];
  370.   char s1[DH_BYTES];
  371.   char s2[DH_BYTES];
  372.   ssize_t s1len, s2len;
  373.   test_eq(crypto_dh_get_bytes(dh1), DH_BYTES);
  374.   test_eq(crypto_dh_get_bytes(dh2), DH_BYTES);
  375.   memset(p1, 0, DH_BYTES);
  376.   memset(p2, 0, DH_BYTES);
  377.   test_memeq(p1, p2, DH_BYTES);
  378.   test_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
  379.   test_memneq(p1, p2, DH_BYTES);
  380.   test_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
  381.   test_memneq(p1, p2, DH_BYTES);
  382.   memset(s1, 0, DH_BYTES);
  383.   memset(s2, 0xFF, DH_BYTES);
  384.   s1len = crypto_dh_compute_secret(dh1, p2, DH_BYTES, s1, 50);
  385.   s2len = crypto_dh_compute_secret(dh2, p1, DH_BYTES, s2, 50);
  386.   test_assert(s1len > 0);
  387.   test_eq(s1len, s2len);
  388.   test_memeq(s1, s2, s1len);
  389.   {
  390.     /* XXXX Now fabricate some bad values and make sure they get caught,
  391.      * Check 0, 1, N-1, >= N, etc.
  392.      */
  393.   }
  394.  done:
  395.   crypto_dh_free(dh1);
  396.   crypto_dh_free(dh2);
  397. }
  398. /** Run unit tests for our random number generation function and its wrappers.
  399.  */
  400. static void
  401. test_crypto_rng(void)
  402. {
  403.   int i, j, allok;
  404.   char data1[100], data2[100];
  405.   /* Try out RNG. */
  406.   test_assert(! crypto_seed_rng(0));
  407.   crypto_rand(data1, 100);
  408.   crypto_rand(data2, 100);
  409.   test_memneq(data1,data2,100);
  410.   allok = 1;
  411.   for (i = 0; i < 100; ++i) {
  412.     uint64_t big;
  413.     char *host;
  414.     j = crypto_rand_int(100);
  415.     if (i < 0 || i >= 100)
  416.       allok = 0;
  417.     big = crypto_rand_uint64(U64_LITERAL(1)<<40);
  418.     if (big >= (U64_LITERAL(1)<<40))
  419.       allok = 0;
  420.     big = crypto_rand_uint64(U64_LITERAL(5));
  421.     if (big >= 5)
  422.       allok = 0;
  423.     host = crypto_random_hostname(3,8,"www.",".onion");
  424.     if (strcmpstart(host,"www.") ||
  425.         strcmpend(host,".onion") ||
  426.         strlen(host) < 13 ||
  427.         strlen(host) > 18)
  428.       allok = 0;
  429.     tor_free(host);
  430.   }
  431.   test_assert(allok);
  432.  done:
  433.   ;
  434. }
  435. /** Run unit tests for our AES functionality */
  436. static void
  437. test_crypto_aes(void)
  438. {
  439.   char *data1 = NULL, *data2 = NULL, *data3 = NULL;
  440.   crypto_cipher_env_t *env1 = NULL, *env2 = NULL;
  441.   int i, j;
  442.   data1 = tor_malloc(1024);
  443.   data2 = tor_malloc(1024);
  444.   data3 = tor_malloc(1024);
  445.   /* Now, test encryption and decryption with stream cipher. */
  446.   data1[0]='';
  447.   for (i = 1023; i>0; i -= 35)
  448.     strncat(data1, "Now is the time for all good onions", i);
  449.   memset(data2, 0, 1024);
  450.   memset(data3, 0, 1024);
  451.   env1 = crypto_new_cipher_env();
  452.   test_neq(env1, 0);
  453.   env2 = crypto_new_cipher_env();
  454.   test_neq(env2, 0);
  455.   j = crypto_cipher_generate_key(env1);
  456.   crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
  457.   crypto_cipher_encrypt_init_cipher(env1);
  458.   crypto_cipher_decrypt_init_cipher(env2);
  459.   /* Try encrypting 512 chars. */
  460.   crypto_cipher_encrypt(env1, data2, data1, 512);
  461.   crypto_cipher_decrypt(env2, data3, data2, 512);
  462.   test_memeq(data1, data3, 512);
  463.   test_memneq(data1, data2, 512);
  464.   /* Now encrypt 1 at a time, and get 1 at a time. */
  465.   for (j = 512; j < 560; ++j) {
  466.     crypto_cipher_encrypt(env1, data2+j, data1+j, 1);
  467.   }
  468.   for (j = 512; j < 560; ++j) {
  469.     crypto_cipher_decrypt(env2, data3+j, data2+j, 1);
  470.   }
  471.   test_memeq(data1, data3, 560);
  472.   /* Now encrypt 3 at a time, and get 5 at a time. */
  473.   for (j = 560; j < 1024-5; j += 3) {
  474.     crypto_cipher_encrypt(env1, data2+j, data1+j, 3);
  475.   }
  476.   for (j = 560; j < 1024-5; j += 5) {
  477.     crypto_cipher_decrypt(env2, data3+j, data2+j, 5);
  478.   }
  479.   test_memeq(data1, data3, 1024-5);
  480.   /* Now make sure that when we encrypt with different chunk sizes, we get
  481.      the same results. */
  482.   crypto_free_cipher_env(env2);
  483.   env2 = NULL;
  484.   memset(data3, 0, 1024);
  485.   env2 = crypto_new_cipher_env();
  486.   test_neq(env2, 0);
  487.   crypto_cipher_set_key(env2, crypto_cipher_get_key(env1));
  488.   crypto_cipher_encrypt_init_cipher(env2);
  489.   for (j = 0; j < 1024-16; j += 17) {
  490.     crypto_cipher_encrypt(env2, data3+j, data1+j, 17);
  491.   }
  492.   for (j= 0; j < 1024-16; ++j) {
  493.     if (data2[j] != data3[j]) {
  494.       printf("%d:  %dt%dn", j, (int) data2[j], (int) data3[j]);
  495.     }
  496.   }
  497.   test_memeq(data2, data3, 1024-16);
  498.   crypto_free_cipher_env(env1);
  499.   env1 = NULL;
  500.   crypto_free_cipher_env(env2);
  501.   env2 = NULL;
  502.   /* NIST test vector for aes. */
  503.   env1 = crypto_new_cipher_env(); /* IV starts at 0 */
  504.   crypto_cipher_set_key(env1, "x80x00x00x00x00x00x00x00"
  505.                               "x00x00x00x00x00x00x00x00");
  506.   crypto_cipher_encrypt_init_cipher(env1);
  507.   crypto_cipher_encrypt(env1, data1,
  508.                         "x00x00x00x00x00x00x00x00"
  509.                         "x00x00x00x00x00x00x00x00", 16);
  510.   test_memeq_hex(data1, "0EDD33D3C621E546455BD8BA1418BEC8");
  511.   /* Now test rollover.  All these values are originally from a python
  512.    * script. */
  513.   crypto_cipher_set_iv(env1, "x00x00x00x00x00x00x00x00"
  514.                              "xffxffxffxffxffxffxffxff");
  515.   memset(data2, 0,  1024);
  516.   crypto_cipher_encrypt(env1, data1, data2, 32);
  517.   test_memeq_hex(data1, "335fe6da56f843199066c14a00a40231"
  518.                         "cdd0b917dbc7186908a6bfb5ffd574d3");
  519.   crypto_cipher_set_iv(env1, "x00x00x00x00xffxffxffxff"
  520.                              "xffxffxffxffxffxffxffxff");
  521.   memset(data2, 0,  1024);
  522.   crypto_cipher_encrypt(env1, data1, data2, 32);
  523.   test_memeq_hex(data1, "e627c6423fa2d77832a02b2794094b73"
  524.                         "3e63c721df790d2c6469cc1953a3ffac");
  525.   crypto_cipher_set_iv(env1, "xffxffxffxffxffxffxffxff"
  526.                              "xffxffxffxffxffxffxffxff");
  527.   memset(data2, 0,  1024);
  528.   crypto_cipher_encrypt(env1, data1, data2, 32);
  529.   test_memeq_hex(data1, "2aed2bff0de54f9328efd070bf48f70a"
  530.                         "0EDD33D3C621E546455BD8BA1418BEC8");
  531.   /* Now check rollover on inplace cipher. */
  532.   crypto_cipher_set_iv(env1, "xffxffxffxffxffxffxffxff"
  533.                              "xffxffxffxffxffxffxffxff");
  534.   crypto_cipher_crypt_inplace(env1, data2, 64);
  535.   test_memeq_hex(data2, "2aed2bff0de54f9328efd070bf48f70a"
  536.                         "0EDD33D3C621E546455BD8BA1418BEC8"
  537.                         "93e2c5243d6839eac58503919192f7ae"
  538.                         "1908e67cafa08d508816659c2e693191");
  539.   crypto_cipher_set_iv(env1, "xffxffxffxffxffxffxffxff"
  540.                              "xffxffxffxffxffxffxffxff");
  541.   crypto_cipher_crypt_inplace(env1, data2, 64);
  542.   test_assert(tor_mem_is_zero(data2, 64));
  543.  done:
  544.   if (env1)
  545.     crypto_free_cipher_env(env1);
  546.   if (env2)
  547.     crypto_free_cipher_env(env2);
  548.   tor_free(data1);
  549.   tor_free(data2);
  550.   tor_free(data3);
  551. }
  552. /** Run unit tests for our SHA-1 functionality */
  553. static void
  554. test_crypto_sha(void)
  555. {
  556.   crypto_digest_env_t *d1 = NULL, *d2 = NULL;
  557.   int i;
  558.   char key[80];
  559.   char digest[20];
  560.   char data[50];
  561.   char d_out1[DIGEST_LEN], d_out2[DIGEST_LEN];
  562.   /* Test SHA-1 with a test vector from the specification. */
  563.   i = crypto_digest(data, "abc", 3);
  564.   test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
  565.   /* Test HMAC-SHA-1 with test cases from RFC2202. */
  566.   /* Case 1. */
  567.   memset(key, 0x0b, 20);
  568.   crypto_hmac_sha1(digest, key, 20, "Hi There", 8);
  569.   test_streq(hex_str(digest, 20),
  570.              "B617318655057264E28BC0B6FB378C8EF146BE00");
  571.   /* Case 2. */
  572.   crypto_hmac_sha1(digest, "Jefe", 4, "what do ya want for nothing?", 28);
  573.   test_streq(hex_str(digest, 20),
  574.              "EFFCDF6AE5EB2FA2D27416D5F184DF9C259A7C79");
  575.   /* Case 4. */
  576.   base16_decode(key, 25,
  577.                 "0102030405060708090a0b0c0d0e0f10111213141516171819", 50);
  578.   memset(data, 0xcd, 50);
  579.   crypto_hmac_sha1(digest, key, 25, data, 50);
  580.   test_streq(hex_str(digest, 20),
  581.              "4C9007F4026250C6BC8414F9BF50C86C2D7235DA");
  582.   /* Case . */
  583.   memset(key, 0xaa, 80);
  584.   crypto_hmac_sha1(digest, key, 80,
  585.                    "Test Using Larger Than Block-Size Key - Hash Key First",
  586.                    54);
  587.   test_streq(hex_str(digest, 20),
  588.              "AA4AE5E15272D00E95705637CE8A3B55ED402112");
  589.   /* Incremental digest code. */
  590.   d1 = crypto_new_digest_env();
  591.   test_assert(d1);
  592.   crypto_digest_add_bytes(d1, "abcdef", 6);
  593.   d2 = crypto_digest_dup(d1);
  594.   test_assert(d2);
  595.   crypto_digest_add_bytes(d2, "ghijkl", 6);
  596.   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
  597.   crypto_digest(d_out2, "abcdefghijkl", 12);
  598.   test_memeq(d_out1, d_out2, DIGEST_LEN);
  599.   crypto_digest_assign(d2, d1);
  600.   crypto_digest_add_bytes(d2, "mno", 3);
  601.   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
  602.   crypto_digest(d_out2, "abcdefmno", 9);
  603.   test_memeq(d_out1, d_out2, DIGEST_LEN);
  604.   crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
  605.   crypto_digest(d_out2, "abcdef", 6);
  606.   test_memeq(d_out1, d_out2, DIGEST_LEN);
  607.  done:
  608.   if (d1)
  609.     crypto_free_digest_env(d1);
  610.   if (d2)
  611.     crypto_free_digest_env(d2);
  612. }
  613. /** Run unit tests for our public key crypto functions */
  614. static void
  615. test_crypto_pk(void)
  616. {
  617.   crypto_pk_env_t *pk1 = NULL, *pk2 = NULL;
  618.   char *encoded = NULL;
  619.   char data1[1024], data2[1024], data3[1024];
  620.   size_t size;
  621.   int i, j, p, len;
  622.   /* Public-key ciphers */
  623.   pk1 = pk_generate(0);
  624.   pk2 = crypto_new_pk_env();
  625.   test_assert(pk1 && pk2);
  626.   test_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size));
  627.   test_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size));
  628.   test_eq(0, crypto_pk_cmp_keys(pk1, pk2));
  629.   test_eq(128, crypto_pk_keysize(pk1));
  630.   test_eq(128, crypto_pk_keysize(pk2));
  631.   test_eq(128, crypto_pk_public_encrypt(pk2, data1, "Hello whirled.", 15,
  632.                                         PK_PKCS1_OAEP_PADDING));
  633.   test_eq(128, crypto_pk_public_encrypt(pk1, data2, "Hello whirled.", 15,
  634.                                         PK_PKCS1_OAEP_PADDING));
  635.   /* oaep padding should make encryption not match */
  636.   test_memneq(data1, data2, 128);
  637.   test_eq(15, crypto_pk_private_decrypt(pk1, data3, data1, 128,
  638.                                         PK_PKCS1_OAEP_PADDING,1));
  639.   test_streq(data3, "Hello whirled.");
  640.   memset(data3, 0, 1024);
  641.   test_eq(15, crypto_pk_private_decrypt(pk1, data3, data2, 128,
  642.                                         PK_PKCS1_OAEP_PADDING,1));
  643.   test_streq(data3, "Hello whirled.");
  644.   /* Can't decrypt with public key. */
  645.   test_eq(-1, crypto_pk_private_decrypt(pk2, data3, data2, 128,
  646.                                         PK_PKCS1_OAEP_PADDING,1));
  647.   /* Try again with bad padding */
  648.   memcpy(data2+1, "XYZZY", 5);  /* This has fails ~ once-in-2^40 */
  649.   test_eq(-1, crypto_pk_private_decrypt(pk1, data3, data2, 128,
  650.                                         PK_PKCS1_OAEP_PADDING,1));
  651.   /* File operations: save and load private key */
  652.   test_assert(! crypto_pk_write_private_key_to_filename(pk1,
  653.                                                         get_fname("pkey1")));
  654.   /* failing case for read: can't read. */
  655.   test_assert(crypto_pk_read_private_key_from_filename(pk2,
  656.                                                    get_fname("xyzzy")) < 0);
  657.   write_str_to_file(get_fname("xyzzy"), "foobar", 6);
  658.   /* Failing case for read: no key. */
  659.   test_assert(crypto_pk_read_private_key_from_filename(pk2,
  660.                                                    get_fname("xyzzy")) < 0);
  661.   test_assert(! crypto_pk_read_private_key_from_filename(pk2,
  662.                                                          get_fname("pkey1")));
  663.   test_eq(15, crypto_pk_private_decrypt(pk2, data3, data1, 128,
  664.                                         PK_PKCS1_OAEP_PADDING,1));
  665.   /* Now try signing. */
  666.   strlcpy(data1, "Ossifrage", 1024);
  667.   test_eq(128, crypto_pk_private_sign(pk1, data2, data1, 10));
  668.   test_eq(10, crypto_pk_public_checksig(pk1, data3, data2, 128));
  669.   test_streq(data3, "Ossifrage");
  670.   /* Try signing digests. */
  671.   test_eq(128, crypto_pk_private_sign_digest(pk1, data2, data1, 10));
  672.   test_eq(20, crypto_pk_public_checksig(pk1, data3, data2, 128));
  673.   test_eq(0, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
  674.   test_eq(-1, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
  675.   /*XXXX test failed signing*/
  676.   /* Try encoding */
  677.   crypto_free_pk_env(pk2);
  678.   pk2 = NULL;
  679.   i = crypto_pk_asn1_encode(pk1, data1, 1024);
  680.   test_assert(i>0);
  681.   pk2 = crypto_pk_asn1_decode(data1, i);
  682.   test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
  683.   /* Try with hybrid encryption wrappers. */
  684.   crypto_rand(data1, 1024);
  685.   for (i = 0; i < 3; ++i) {
  686.     for (j = 85; j < 140; ++j) {
  687.       memset(data2,0,1024);
  688.       memset(data3,0,1024);
  689.       if (i == 0 && j < 129)
  690.         continue;
  691.       p = (i==0)?PK_NO_PADDING:
  692.         (i==1)?PK_PKCS1_PADDING:PK_PKCS1_OAEP_PADDING;
  693.       len = crypto_pk_public_hybrid_encrypt(pk1,data2,data1,j,p,0);
  694.       test_assert(len>=0);
  695.       len = crypto_pk_private_hybrid_decrypt(pk1,data3,data2,len,p,1);
  696.       test_eq(len,j);
  697.       test_memeq(data1,data3,j);
  698.     }
  699.   }
  700.   /* Try copy_full */
  701.   crypto_free_pk_env(pk2);
  702.   pk2 = crypto_pk_copy_full(pk1);
  703.   test_assert(pk2 != NULL);
  704.   test_neq_ptr(pk1, pk2);
  705.   test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
  706.  done:
  707.   if (pk1)
  708.     crypto_free_pk_env(pk1);
  709.   if (pk2)
  710.     crypto_free_pk_env(pk2);
  711.   tor_free(encoded);
  712. }
  713. /** Run unit tests for misc crypto functionality. */
  714. static void
  715. test_crypto(void)
  716. {
  717.   char *data1 = NULL, *data2 = NULL, *data3 = NULL;
  718.   int i, j, idx;
  719.   data1 = tor_malloc(1024);
  720.   data2 = tor_malloc(1024);
  721.   data3 = tor_malloc(1024);
  722.   test_assert(data1 && data2 && data3);
  723.   /* Base64 tests */
  724.   memset(data1, 6, 1024);
  725.   for (idx = 0; idx < 10; ++idx) {
  726.     i = base64_encode(data2, 1024, data1, idx);
  727.     test_assert(i >= 0);
  728.     j = base64_decode(data3, 1024, data2, i);
  729.     test_eq(j,idx);
  730.     test_memeq(data3, data1, idx);
  731.   }
  732.   strlcpy(data1, "Test string that contains 35 chars.", 1024);
  733.   strlcat(data1, " 2nd string that contains 35 chars.", 1024);
  734.   i = base64_encode(data2, 1024, data1, 71);
  735.   j = base64_decode(data3, 1024, data2, i);
  736.   test_eq(j, 71);
  737.   test_streq(data3, data1);
  738.   test_assert(data2[i] == '');
  739.   crypto_rand(data1, DIGEST_LEN);
  740.   memset(data2, 100, 1024);
  741.   digest_to_base64(data2, data1);
  742.   test_eq(BASE64_DIGEST_LEN, strlen(data2));
  743.   test_eq(100, data2[BASE64_DIGEST_LEN+2]);
  744.   memset(data3, 99, 1024);
  745.   test_eq(digest_from_base64(data3, data2), 0);
  746.   test_memeq(data1, data3, DIGEST_LEN);
  747.   test_eq(99, data3[DIGEST_LEN+1]);
  748.   test_assert(digest_from_base64(data3, "###") < 0);
  749.   /* Base32 tests */
  750.   strlcpy(data1, "5chrs", 1024);
  751.   /* bit pattern is:  [35 63 68 72 73] ->
  752.    *        [00110101 01100011 01101000 01110010 01110011]
  753.    * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
  754.    */
  755.   base32_encode(data2, 9, data1, 5);
  756.   test_streq(data2, "gvrwq4tt");
  757.   strlcpy(data1, "xFFxF5x6Dx44xAEx0Dx5CxC9x62xC4", 1024);
  758.   base32_encode(data2, 30, data1, 10);
  759.   test_streq(data2, "772w2rfobvomsywe");
  760.   /* Base16 tests */
  761.   strlcpy(data1, "6chrsxff", 1024);
  762.   base16_encode(data2, 13, data1, 6);
  763.   test_streq(data2, "3663687273FF");
  764.   strlcpy(data1, "f0d678affc000100", 1024);
  765.   i = base16_decode(data2, 8, data1, 16);
  766.   test_eq(i,0);
  767.   test_memeq(data2, "xf0xd6x78xafxfcx00x01x00",8);
  768.   /* now try some failing base16 decodes */
  769.   test_eq(-1, base16_decode(data2, 8, data1, 15)); /* odd input len */
  770.   test_eq(-1, base16_decode(data2, 7, data1, 16)); /* dest too short */
  771.   strlcpy(data1, "f0dz!8affc000100", 1024);
  772.   test_eq(-1, base16_decode(data2, 8, data1, 16));
  773.   tor_free(data1);
  774.   tor_free(data2);
  775.   tor_free(data3);
  776.   /* Add spaces to fingerprint */
  777.   {
  778.     data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
  779.     test_eq(strlen(data1), 40);
  780.     data2 = tor_malloc(FINGERPRINT_LEN+1);
  781.     add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
  782.     test_streq(data2, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
  783.     tor_free(data1);
  784.     tor_free(data2);
  785.   }
  786.   /* Check fingerprint */
  787.   {
  788.     test_assert(crypto_pk_check_fingerprint_syntax(
  789.                 "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"));
  790.     test_assert(!crypto_pk_check_fingerprint_syntax(
  791.                 "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 000"));
  792.     test_assert(!crypto_pk_check_fingerprint_syntax(
  793.                 "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
  794.     test_assert(!crypto_pk_check_fingerprint_syntax(
  795.                 "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 0000"));
  796.     test_assert(!crypto_pk_check_fingerprint_syntax(
  797.                 "ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 00000"));
  798.     test_assert(!crypto_pk_check_fingerprint_syntax(
  799.                 "ACD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
  800.   }
  801.  done:
  802.   tor_free(data1);
  803.   tor_free(data2);
  804.   tor_free(data3);
  805. }
  806. /** Run unit tests for our secret-to-key passphrase hashing functionality. */
  807. static void
  808. test_crypto_s2k(void)
  809. {
  810.   char buf[29];
  811.   char buf2[29];
  812.   char *buf3 = NULL;
  813.   int i;
  814.   memset(buf, 0, sizeof(buf));
  815.   memset(buf2, 0, sizeof(buf2));
  816.   buf3 = tor_malloc(65536);
  817.   memset(buf3, 0, 65536);
  818.   secret_to_key(buf+9, 20, "", 0, buf);
  819.   crypto_digest(buf2+9, buf3, 1024);
  820.   test_memeq(buf, buf2, 29);
  821.   memcpy(buf,"vrbacrda",8);
  822.   memcpy(buf2,"vrbacrda",8);
  823.   buf[8] = 96;
  824.   buf2[8] = 96;
  825.   secret_to_key(buf+9, 20, "12345678", 8, buf);
  826.   for (i = 0; i < 65536; i += 16) {
  827.     memcpy(buf3+i, "vrbacrda12345678", 16);
  828.   }
  829.   crypto_digest(buf2+9, buf3, 65536);
  830.   test_memeq(buf, buf2, 29);
  831.  done:
  832.   tor_free(buf3);
  833. }
  834. /** Helper: return a tristate based on comparing the strings in *<b>a</b> and
  835.  * *<b>b</b>. */
  836. static int
  837. _compare_strs(const void **a, const void **b)
  838. {
  839.   const char *s1 = *a, *s2 = *b;
  840.   return strcmp(s1, s2);
  841. }
  842. /** Helper: return a tristate based on comparing the strings in *<b>a</b> and
  843.  * *<b>b</b>, excluding a's first character, and ignoring case. */
  844. static int
  845. _compare_without_first_ch(const void *a, const void **b)
  846. {
  847.   const char *s1 = a, *s2 = *b;
  848.   return strcasecmp(s1+1, s2);
  849. }
  850. /** Test basic utility functionality. */
  851. static void
  852. test_util(void)
  853. {
  854.   struct timeval start, end;
  855.   struct tm a_time;
  856.   char timestr[RFC1123_TIME_LEN+1];
  857.   char buf[1024];
  858.   time_t t_res;
  859.   int i;
  860.   uint32_t u32;
  861.   uint16_t u16;
  862.   char *cp, *k, *v;
  863.   const char *str;
  864.   start.tv_sec = 5;
  865.   start.tv_usec = 5000;
  866.   end.tv_sec = 5;
  867.   end.tv_usec = 5000;
  868.   test_eq(0L, tv_udiff(&start, &end));
  869.   end.tv_usec = 7000;
  870.   test_eq(2000L, tv_udiff(&start, &end));
  871.   end.tv_sec = 6;
  872.   test_eq(1002000L, tv_udiff(&start, &end));
  873.   end.tv_usec = 0;
  874.   test_eq(995000L, tv_udiff(&start, &end));
  875.   end.tv_sec = 4;
  876.   test_eq(-1005000L, tv_udiff(&start, &end));
  877.   end.tv_usec = 999990;
  878.   start.tv_sec = 1;
  879.   start.tv_usec = 500;
  880.   /* The test values here are confirmed to be correct on a platform
  881.    * with a working timegm. */
  882.   a_time.tm_year = 2003-1900;
  883.   a_time.tm_mon = 7;
  884.   a_time.tm_mday = 30;
  885.   a_time.tm_hour = 6;
  886.   a_time.tm_min = 14;
  887.   a_time.tm_sec = 55;
  888.   test_eq((time_t) 1062224095UL, tor_timegm(&a_time));
  889.   a_time.tm_year = 2004-1900; /* Try a leap year, after feb. */
  890.   test_eq((time_t) 1093846495UL, tor_timegm(&a_time));
  891.   a_time.tm_mon = 1;          /* Try a leap year, in feb. */
  892.   a_time.tm_mday = 10;
  893.   test_eq((time_t) 1076393695UL, tor_timegm(&a_time));
  894.   format_rfc1123_time(timestr, 0);
  895.   test_streq("Thu, 01 Jan 1970 00:00:00 GMT", timestr);
  896.   format_rfc1123_time(timestr, (time_t)1091580502UL);
  897.   test_streq("Wed, 04 Aug 2004 00:48:22 GMT", timestr);
  898.   t_res = 0;
  899.   i = parse_rfc1123_time(timestr, &t_res);
  900.   test_eq(i,0);
  901.   test_eq(t_res, (time_t)1091580502UL);
  902.   test_eq(-1, parse_rfc1123_time("Wed, zz Aug 2004 99-99x99 GMT", &t_res));
  903.   tor_gettimeofday(&start);
  904.   /* Tests for corner cases of strl operations */
  905.   test_eq(5, strlcpy(buf, "Hello", 0));
  906.   strlcpy(buf, "Hello", sizeof(buf));
  907.   test_eq(10, strlcat(buf, "Hello", 5));
  908.   /* Test tor_strstrip() */
  909.   strlcpy(buf, "Testing 1 2 3", sizeof(buf));
  910.   tor_strstrip(buf, ",!");
  911.   test_streq(buf, "Testing 1 2 3");
  912.   strlcpy(buf, "!Testing 1 2 3?", sizeof(buf));
  913.   tor_strstrip(buf, "!? ");
  914.   test_streq(buf, "Testing123");
  915.   /* Test parse_addr_port */
  916.   cp = NULL; u32 = 3; u16 = 3;
  917.   test_assert(!parse_addr_port(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
  918.   test_streq(cp, "1.2.3.4");
  919.   test_eq(u32, 0x01020304u);
  920.   test_eq(u16, 0);
  921.   tor_free(cp);
  922.   test_assert(!parse_addr_port(LOG_WARN, "4.3.2.1:99", &cp, &u32, &u16));
  923.   test_streq(cp, "4.3.2.1");
  924.   test_eq(u32, 0x04030201u);
  925.   test_eq(u16, 99);
  926.   tor_free(cp);
  927.   test_assert(!parse_addr_port(LOG_WARN, "nonexistent.address:4040",
  928.                                &cp, NULL, &u16));
  929.   test_streq(cp, "nonexistent.address");
  930.   test_eq(u16, 4040);
  931.   tor_free(cp);
  932.   test_assert(!parse_addr_port(LOG_WARN, "localhost:9999", &cp, &u32, &u16));
  933.   test_streq(cp, "localhost");
  934.   test_eq(u32, 0x7f000001u);
  935.   test_eq(u16, 9999);
  936.   tor_free(cp);
  937.   u32 = 3;
  938.   test_assert(!parse_addr_port(LOG_WARN, "localhost", NULL, &u32, &u16));
  939.   test_eq(cp, NULL);
  940.   test_eq(u32, 0x7f000001u);
  941.   test_eq(u16, 0);
  942.   tor_free(cp);
  943.   test_eq(0, addr_mask_get_bits(0x0u));
  944.   test_eq(32, addr_mask_get_bits(0xFFFFFFFFu));
  945.   test_eq(16, addr_mask_get_bits(0xFFFF0000u));
  946.   test_eq(31, addr_mask_get_bits(0xFFFFFFFEu));
  947.   test_eq(1, addr_mask_get_bits(0x80000000u));
  948.   /* Test tor_parse_long. */
  949.   test_eq(10L, tor_parse_long("10",10,0,100,NULL,NULL));
  950.   test_eq(0L, tor_parse_long("10",10,50,100,NULL,NULL));
  951.   test_eq(-50L, tor_parse_long("-50",10,-100,100,NULL,NULL));
  952.   /* Test tor_parse_ulong */
  953.   test_eq(10UL, tor_parse_ulong("10",10,0,100,NULL,NULL));
  954.   test_eq(0UL, tor_parse_ulong("10",10,50,100,NULL,NULL));
  955.   /* Test tor_parse_uint64. */
  956.   test_assert(U64_LITERAL(10) == tor_parse_uint64("10 x",10,0,100, &i, &cp));
  957.   test_assert(i == 1);
  958.   test_streq(cp, " x");
  959.   test_assert(U64_LITERAL(12345678901) ==
  960.               tor_parse_uint64("12345678901",10,0,UINT64_MAX, &i, &cp));
  961.   test_assert(i == 1);
  962.   test_streq(cp, "");
  963.   test_assert(U64_LITERAL(0) ==
  964.               tor_parse_uint64("12345678901",10,500,INT32_MAX, &i, &cp));
  965.   test_assert(i == 0);
  966.   /* Test failing snprintf cases */
  967.   test_eq(-1, tor_snprintf(buf, 0, "Foo"));
  968.   test_eq(-1, tor_snprintf(buf, 2, "Foo"));
  969.   /* Test printf with uint64 */
  970.   tor_snprintf(buf, sizeof(buf), "x!"U64_FORMAT"!x",
  971.                U64_PRINTF_ARG(U64_LITERAL(12345678901)));
  972.   test_streq(buf, "x!12345678901!x");
  973.   /* Test parse_config_line_from_str */
  974.   strlcpy(buf, "k vn" " key    value with spaces   n" "keykey valn"
  975.           "k2n"
  976.           "k3 n" "n" "   n" "#commentn"
  977.           "k4#an" "k5#abcn" "k6 val #with commentn"
  978.           "kseven   "a quoted 'string"n"
  979.           "k8 "a \x71uoted\n\"str\\ing\t\001\01\1\""n"
  980.           , sizeof(buf));
  981.   str = buf;
  982.   str = parse_config_line_from_str(str, &k, &v);
  983.   test_streq(k, "k");
  984.   test_streq(v, "v");
  985.   tor_free(k); tor_free(v);
  986.   test_assert(!strcmpstart(str, "key    value with"));
  987.   str = parse_config_line_from_str(str, &k, &v);
  988.   test_streq(k, "key");
  989.   test_streq(v, "value with spaces");
  990.   tor_free(k); tor_free(v);
  991.   test_assert(!strcmpstart(str, "keykey"));
  992.   str = parse_config_line_from_str(str, &k, &v);
  993.   test_streq(k, "keykey");
  994.   test_streq(v, "val");
  995.   tor_free(k); tor_free(v);
  996.   test_assert(!strcmpstart(str, "k2n"));
  997.   str = parse_config_line_from_str(str, &k, &v);
  998.   test_streq(k, "k2");
  999.   test_streq(v, "");
  1000.   tor_free(k); tor_free(v);
  1001.   test_assert(!strcmpstart(str, "k3 n"));
  1002.   str = parse_config_line_from_str(str, &k, &v);
  1003.   test_streq(k, "k3");
  1004.   test_streq(v, "");
  1005.   tor_free(k); tor_free(v);
  1006.   test_assert(!strcmpstart(str, "#comment"));
  1007.   str = parse_config_line_from_str(str, &k, &v);
  1008.   test_streq(k, "k4");
  1009.   test_streq(v, "");
  1010.   tor_free(k); tor_free(v);
  1011.   test_assert(!strcmpstart(str, "k5#abc"));
  1012.   str = parse_config_line_from_str(str, &k, &v);
  1013.   test_streq(k, "k5");
  1014.   test_streq(v, "");
  1015.   tor_free(k); tor_free(v);
  1016.   test_assert(!strcmpstart(str, "k6"));
  1017.   str = parse_config_line_from_str(str, &k, &v);
  1018.   test_streq(k, "k6");
  1019.   test_streq(v, "val");
  1020.   tor_free(k); tor_free(v);
  1021.   test_assert(!strcmpstart(str, "kseven"));
  1022.   str = parse_config_line_from_str(str, &k, &v);
  1023.   test_streq(k, "kseven");
  1024.   test_streq(v, "a quoted 'string");
  1025.   tor_free(k); tor_free(v);
  1026.   test_assert(!strcmpstart(str, "k8 "));
  1027.   str = parse_config_line_from_str(str, &k, &v);
  1028.   test_streq(k, "k8");
  1029.   test_streq(v, "a quotedn"str\ingtx01x01x01"");
  1030.   tor_free(k); tor_free(v);
  1031.   test_streq(str, "");
  1032.   /* Test for strcmpstart and strcmpend. */
  1033.   test_assert(strcmpstart("abcdef", "abcdef")==0);
  1034.   test_assert(strcmpstart("abcdef", "abc")==0);
  1035.   test_assert(strcmpstart("abcdef", "abd")<0);
  1036.   test_assert(strcmpstart("abcdef", "abb")>0);
  1037.   test_assert(strcmpstart("ab", "abb")<0);
  1038.   test_assert(strcmpend("abcdef", "abcdef")==0);
  1039.   test_assert(strcmpend("abcdef", "def")==0);
  1040.   test_assert(strcmpend("abcdef", "deg")<0);
  1041.   test_assert(strcmpend("abcdef", "dee")>0);
  1042.   test_assert(strcmpend("ab", "abb")<0);
  1043.   test_assert(strcasecmpend("AbcDEF", "abcdef")==0);
  1044.   test_assert(strcasecmpend("abcdef", "dEF")==0);
  1045.   test_assert(strcasecmpend("abcDEf", "deg")<0);
  1046.   test_assert(strcasecmpend("abcdef", "DEE")>0);
  1047.   test_assert(strcasecmpend("ab", "abB")<0);
  1048.   /* Test mem_is_zero */
  1049.   memset(buf,0,128);
  1050.   buf[128] = 'x';
  1051.   test_assert(tor_digest_is_zero(buf));
  1052.   test_assert(tor_mem_is_zero(buf, 10));
  1053.   test_assert(tor_mem_is_zero(buf, 20));
  1054.   test_assert(tor_mem_is_zero(buf, 128));
  1055.   test_assert(!tor_mem_is_zero(buf, 129));
  1056.   buf[60] = (char)255;
  1057.   test_assert(!tor_mem_is_zero(buf, 128));
  1058.   buf[0] = (char)1;
  1059.   test_assert(!tor_mem_is_zero(buf, 10));
  1060.   /* Test inet_ntop */
  1061.   {
  1062.     char tmpbuf[TOR_ADDR_BUF_LEN];
  1063.     const char *ip = "176.192.208.224";
  1064.     struct in_addr in;
  1065.     tor_inet_pton(AF_INET, ip, &in);
  1066.     tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf));
  1067.     test_streq(tmpbuf, ip);
  1068.   }
  1069.   /* Test 'escaped' */
  1070.   test_streq("""", escaped(""));
  1071.   test_streq(""abcd"", escaped("abcd"));
  1072.   test_streq(""\\\n\r\t\"\'"", escaped("\nrt"'"));
  1073.   test_streq(""z\001abc\277d"", escaped("z01abc277d"));
  1074.   test_assert(NULL == escaped(NULL));
  1075.   /* Test strndup and memdup */
  1076.   {
  1077.     const char *s = "abcdefghijklmnopqrstuvwxyz";
  1078.     cp = tor_strndup(s, 30);
  1079.     test_streq(cp, s); /* same string, */
  1080.     test_neq(cp, s); /* but different pointers. */
  1081.     tor_free(cp);
  1082.     cp = tor_strndup(s, 5);
  1083.     test_streq(cp, "abcde");
  1084.     tor_free(cp);
  1085.     s = "abcde";
  1086.     cp = tor_memdup(s,10);
  1087.     test_memeq(cp, s, 10); /* same ram, */
  1088.     test_neq(cp, s); /* but different pointers. */
  1089.     tor_free(cp);
  1090.   }
  1091.   /* Test str-foo functions */
  1092.   cp = tor_strdup("abcdef");
  1093.   test_assert(tor_strisnonupper(cp));
  1094.   cp[3] = 'D';
  1095.   test_assert(!tor_strisnonupper(cp));
  1096.   tor_strupper(cp);
  1097.   test_streq(cp, "ABCDEF");
  1098.   test_assert(tor_strisprint(cp));
  1099.   cp[3] = 3;
  1100.   test_assert(!tor_strisprint(cp));
  1101.   tor_free(cp);
  1102.   /* Test eat_whitespace. */
  1103.   {
  1104.     const char *s = "  n a";
  1105.     test_eq_ptr(eat_whitespace(s), s+4);
  1106.     s = "abcd";
  1107.     test_eq_ptr(eat_whitespace(s), s);
  1108.     s = "#xyznab";
  1109.     test_eq_ptr(eat_whitespace(s), s+5);
  1110.   }
  1111.   /* Test memmem and memstr */
  1112.   {
  1113.     const char *haystack = "abcde";
  1114.     tor_assert(!tor_memmem(haystack, 5, "ef", 2));
  1115.     test_eq_ptr(tor_memmem(haystack, 5, "cd", 2), haystack + 2);
  1116.     test_eq_ptr(tor_memmem(haystack, 5, "cde", 3), haystack + 2);
  1117.     haystack = "ababcad";
  1118.     test_eq_ptr(tor_memmem(haystack, 7, "abc", 3), haystack + 2);
  1119.     test_eq_ptr(tor_memstr(haystack, 7, "abc"), haystack + 2);
  1120.     test_assert(!tor_memstr(haystack, 7, "fe"));
  1121.     test_assert(!tor_memstr(haystack, 7, "longerthantheoriginal"));
  1122.   }
  1123.   /* Test wrap_string */
  1124.   {
  1125.     smartlist_t *sl = smartlist_create();
  1126.     wrap_string(sl, "This is a test of string wrapping functionality: woot.",
  1127.                 10, "", "");
  1128.     cp = smartlist_join_strings(sl, "", 0, NULL);
  1129.     test_streq(cp,
  1130.             "This is antest ofnstringnwrappingnfunctionalnity: woot.n");
  1131.     tor_free(cp);
  1132.     SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1133.     smartlist_clear(sl);
  1134.     wrap_string(sl, "This is a test of string wrapping functionality: woot.",
  1135.                 16, "### ", "# ");
  1136.     cp = smartlist_join_strings(sl, "", 0, NULL);
  1137.     test_streq(cp,
  1138.              "### This is an# test of stringn# wrappingn# functionality:n"
  1139.              "# woot.n");
  1140.     tor_free(cp);
  1141.     SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1142.     smartlist_free(sl);
  1143.   }
  1144.   /* now make sure time works. */
  1145.   tor_gettimeofday(&end);
  1146.   /* We might've timewarped a little. */
  1147.   test_assert(tv_udiff(&start, &end) >= -5000);
  1148.   /* Test tor_log2(). */
  1149.   test_eq(tor_log2(64), 6);
  1150.   test_eq(tor_log2(65), 6);
  1151.   test_eq(tor_log2(63), 5);
  1152.   test_eq(tor_log2(1), 0);
  1153.   test_eq(tor_log2(2), 1);
  1154.   test_eq(tor_log2(3), 1);
  1155.   test_eq(tor_log2(4), 2);
  1156.   test_eq(tor_log2(5), 2);
  1157.   test_eq(tor_log2(U64_LITERAL(40000000000000000)), 55);
  1158.   test_eq(tor_log2(UINT64_MAX), 63);
  1159.   /* Test round_to_power_of_2 */
  1160.   test_eq(round_to_power_of_2(120), 128);
  1161.   test_eq(round_to_power_of_2(128), 128);
  1162.   test_eq(round_to_power_of_2(130), 128);
  1163.   test_eq(round_to_power_of_2(U64_LITERAL(40000000000000000)),
  1164.           U64_LITERAL(1)<<55);
  1165.   test_eq(round_to_power_of_2(0), 2);
  1166.  done:
  1167.   ;
  1168. }
  1169. /** Helper: assert that IPv6 addresses <b>a</b> and <b>b</b> are the same.  On
  1170.  * failure, reports an error, describing the addresses as <b>e1</b> and
  1171.  * <b>e2</b>, and reporting the line number as <b>line</b>. */
  1172. static void
  1173. _test_eq_ip6(struct in6_addr *a, struct in6_addr *b, const char *e1,
  1174.              const char *e2, int line)
  1175. {
  1176.   int i;
  1177.   int ok = 1;
  1178.   for (i = 0; i < 16; ++i) {
  1179.     if (a->s6_addr[i] != b->s6_addr[i]) {
  1180.       ok = 0;
  1181.       break;
  1182.     }
  1183.   }
  1184.   if (ok) {
  1185.     printf("."); fflush(stdout);
  1186.   } else {
  1187.     char buf1[128], *cp1;
  1188.     char buf2[128], *cp2;
  1189.     have_failed = 1;
  1190.     cp1 = buf1; cp2 = buf2;
  1191.     for (i=0; i<16; ++i) {
  1192.       tor_snprintf(cp1, sizeof(buf1)-(cp1-buf1), "%02x", a->s6_addr[i]);
  1193.       tor_snprintf(cp2, sizeof(buf2)-(cp2-buf2), "%02x", b->s6_addr[i]);
  1194.       cp1 += 2; cp2 += 2;
  1195.       if ((i%2)==1 && i != 15) {
  1196.         *cp1++ = ':';
  1197.         *cp2++ = ':';
  1198.       }
  1199.     }
  1200.     *cp1 = *cp2 = '';
  1201.     printf("Line %d: assertion failed: (%s == %s)n"
  1202.            "      %s != %sn", line, e1, e2, buf1, buf2);
  1203.     fflush(stdout);
  1204.   }
  1205. }
  1206. /** Helper: Assert that two strings both decode as IPv6 addresses with
  1207.  * tor_inet_pton(), and both decode to the same address. */
  1208. #define test_pton6_same(a,b) STMT_BEGIN                
  1209.      test_eq(tor_inet_pton(AF_INET6, a, &a1), 1);      
  1210.      test_eq(tor_inet_pton(AF_INET6, b, &a2), 1);      
  1211.     _test_eq_ip6(&a1,&a2,#a,#b,__LINE__);              
  1212.   STMT_END
  1213. /** Helper: Assert that <b>a</b> is recognized as a bad IPv6 address by
  1214.  * tor_inet_pton(). */
  1215. #define test_pton6_bad(a)                       
  1216.   test_eq(0, tor_inet_pton(AF_INET6, a, &a1))
  1217. /** Helper: assert that <b>a</b>, when parsed by tor_inet_pton() and displayed
  1218.  * with tor_inet_ntop(), yields <b>b</b>. Also assert that <b>b</b> parses to
  1219.  * the same value as <b>a</b>. */
  1220. #define test_ntop6_reduces(a,b) STMT_BEGIN                              
  1221.     test_eq(tor_inet_pton(AF_INET6, a, &a1), 1);                        
  1222.     test_streq(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), b);      
  1223.     test_eq(tor_inet_pton(AF_INET6, b, &a2), 1);                        
  1224.     _test_eq_ip6(&a1, &a2, a, b, __LINE__);                             
  1225.   STMT_END
  1226. /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
  1227.  * passes tor_addr_is_internal() with <b>for_listening</b>. */
  1228. #define test_internal_ip(a,for_listening) STMT_BEGIN           
  1229.     test_eq(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), 1); 
  1230.     t1.family = AF_INET6;                                      
  1231.     if (!tor_addr_is_internal(&t1, for_listening))             
  1232.       test_fail_msg( a "was not internal.");                   
  1233.   STMT_END
  1234. /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
  1235.  * does not pass tor_addr_is_internal() with <b>for_listening</b>. */
  1236. #define test_external_ip(a,for_listening) STMT_BEGIN           
  1237.     test_eq(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), 1); 
  1238.     t1.family = AF_INET6;                                      
  1239.     if (tor_addr_is_internal(&t1, for_listening))              
  1240.       test_fail_msg(a  "was not external.");                   
  1241.   STMT_END
  1242. /** Helper: Assert that <b>a</b> and <b>b</b>, when parsed by
  1243.  * tor_inet_pton(), give addresses that compare in the order defined by
  1244.  * <b>op</b> with tor_addr_compare(). */
  1245. #define test_addr_compare(a, op, b) STMT_BEGIN                    
  1246.     test_eq(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), 1);    
  1247.     test_eq(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), 1);    
  1248.     t1.family = t2.family = AF_INET6;                             
  1249.     r = tor_addr_compare(&t1,&t2,CMP_SEMANTIC);                   
  1250.     if (!(r op 0))                                                
  1251.       test_fail_msg("failed: tor_addr_compare("a","b") "#op" 0"); 
  1252.   STMT_END
  1253. /** Helper: Assert that <b>a</b> and <b>b</b>, when parsed by
  1254.  * tor_inet_pton(), give addresses that compare in the order defined by
  1255.  * <b>op</b> with tor_addr_compare_masked() with <b>m</b> masked. */
  1256. #define test_addr_compare_masked(a, op, b, m) STMT_BEGIN          
  1257.     test_eq(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), 1);    
  1258.     test_eq(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), 1);    
  1259.     t1.family = t2.family = AF_INET6;                             
  1260.     r = tor_addr_compare_masked(&t1,&t2,m,CMP_SEMANTIC);          
  1261.     if (!(r op 0))                                                
  1262.       test_fail_msg("failed: tor_addr_compare_masked("a","b","#m") "#op" 0"); 
  1263.   STMT_END
  1264. /** Helper: assert that <b>xx</b> is parseable as a masked IPv6 address with
  1265.  * ports by tor_parse_mask_addr_ports(), with family <b>f</b>, IP address
  1266.  * as 4 32-bit words <b>ip1...ip4</b>, mask bits as <b>mm</b>, and port range
  1267.  * as <b>pt1..pt2</b>. */
  1268. #define test_addr_mask_ports_parse(xx, f, ip1, ip2, ip3, ip4, mm, pt1, pt2) 
  1269.   STMT_BEGIN                                                                
  1270.     test_eq(tor_addr_parse_mask_ports(xx, &t1, &mask, &port1, &port2), f);  
  1271.     p1=tor_inet_ntop(AF_INET6, &t1.addr.in6_addr, bug, sizeof(bug));        
  1272.     test_eq(htonl(ip1), tor_addr_to_in6_addr32(&t1)[0]);            
  1273.     test_eq(htonl(ip2), tor_addr_to_in6_addr32(&t1)[1]);            
  1274.     test_eq(htonl(ip3), tor_addr_to_in6_addr32(&t1)[2]);            
  1275.     test_eq(htonl(ip4), tor_addr_to_in6_addr32(&t1)[3]);            
  1276.     test_eq(mask, mm);                                     
  1277.     test_eq(port1, pt1);                                   
  1278.     test_eq(port2, pt2);                                   
  1279.   STMT_END
  1280. /** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
  1281. static void
  1282. test_util_ip6_helpers(void)
  1283. {
  1284.   char buf[TOR_ADDR_BUF_LEN], bug[TOR_ADDR_BUF_LEN];
  1285.   struct in6_addr a1, a2;
  1286.   tor_addr_t t1, t2;
  1287.   int r, i;
  1288.   uint16_t port1, port2;
  1289.   maskbits_t mask;
  1290.   const char *p1;
  1291.   struct sockaddr_storage sa_storage;
  1292.   struct sockaddr_in *sin;
  1293.   struct sockaddr_in6 *sin6;
  1294.   //  struct in_addr b1, b2;
  1295.   /* Test tor_inet_ntop and tor_inet_pton: IPv6 */
  1296.   /* ==== Converting to and from sockaddr_t. */
  1297.   sin = (struct sockaddr_in *)&sa_storage;
  1298.   sin->sin_family = AF_INET;
  1299.   sin->sin_port = 9090;
  1300.   sin->sin_addr.s_addr = htonl(0x7f7f0102); /*127.127.1.2*/
  1301.   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, NULL);
  1302.   test_eq(tor_addr_family(&t1), AF_INET);
  1303.   test_eq(tor_addr_to_ipv4h(&t1), 0x7f7f0102);
  1304.   memset(&sa_storage, 0, sizeof(sa_storage));
  1305.   test_eq(sizeof(struct sockaddr_in),
  1306.           tor_addr_to_sockaddr(&t1, 1234, (struct sockaddr *)&sa_storage,
  1307.                                sizeof(sa_storage)));
  1308.   test_eq(1234, ntohs(sin->sin_port));
  1309.   test_eq(0x7f7f0102, ntohl(sin->sin_addr.s_addr));
  1310.   memset(&sa_storage, 0, sizeof(sa_storage));
  1311.   sin6 = (struct sockaddr_in6 *)&sa_storage;
  1312.   sin6->sin6_family = AF_INET6;
  1313.   sin6->sin6_port = htons(7070);
  1314.   sin6->sin6_addr.s6_addr[0] = 128;
  1315.   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, NULL);
  1316.   test_eq(tor_addr_family(&t1), AF_INET6);
  1317.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
  1318.   test_streq(p1, "8000::");
  1319.   memset(&sa_storage, 0, sizeof(sa_storage));
  1320.   test_eq(sizeof(struct sockaddr_in6),
  1321.           tor_addr_to_sockaddr(&t1, 9999, (struct sockaddr *)&sa_storage,
  1322.                                sizeof(sa_storage)));
  1323.   test_eq(AF_INET6, sin6->sin6_family);
  1324.   test_eq(9999, ntohs(sin6->sin6_port));
  1325.   test_eq(0x80000000, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));
  1326.   /* ==== tor_addr_lookup: static cases.  (Can't test dns without knowing we
  1327.    * have a good resolver. */
  1328.   test_eq(0, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1));
  1329.   test_eq(AF_INET, tor_addr_family(&t1));
  1330.   test_eq(tor_addr_to_ipv4h(&t1), 0x7f808182);
  1331.   test_eq(0, tor_addr_lookup("9000::5", AF_UNSPEC, &t1));
  1332.   test_eq(AF_INET6, tor_addr_family(&t1));
  1333.   test_eq(0x90, tor_addr_to_in6_addr8(&t1)[0]);
  1334.   test_assert(tor_mem_is_zero((char*)tor_addr_to_in6_addr8(&t1)+1, 14));
  1335.   test_eq(0x05, tor_addr_to_in6_addr8(&t1)[15]);
  1336.   /* === Test pton: valid af_inet6 */
  1337.   /* Simple, valid parsing. */
  1338.   r = tor_inet_pton(AF_INET6,
  1339.                     "0102:0304:0506:0708:090A:0B0C:0D0E:0F10", &a1);
  1340.   test_assert(r==1);
  1341.   for (i=0;i<16;++i) { test_eq(i+1, (int)a1.s6_addr[i]); }
  1342.   /* ipv4 ending. */
  1343.   test_pton6_same("0102:0304:0506:0708:090A:0B0C:0D0E:0F10",
  1344.                   "0102:0304:0506:0708:090A:0B0C:13.14.15.16");
  1345.   /* shortened words. */
  1346.   test_pton6_same("0001:0099:BEEF:0000:0123:FFFF:0001:0001",
  1347.                   "1:99:BEEF:0:0123:FFFF:1:1");
  1348.   /* zeros at the beginning */
  1349.   test_pton6_same("0000:0000:0000:0000:0009:C0A8:0001:0001",
  1350.                   "::9:c0a8:1:1");
  1351.   test_pton6_same("0000:0000:0000:0000:0009:C0A8:0001:0001",
  1352.                   "::9:c0a8:0.1.0.1");
  1353.   /* zeros in the middle. */
  1354.   test_pton6_same("fe80:0000:0000:0000:0202:1111:0001:0001",
  1355.                   "fe80::202:1111:1:1");
  1356.   /* zeros at the end. */
  1357.   test_pton6_same("1000:0001:0000:0007:0000:0000:0000:0000",
  1358.                   "1000:1:0:7::");
  1359.   /* === Test ntop: af_inet6 */
  1360.   test_ntop6_reduces("0:0:0:0:0:0:0:0", "::");
  1361.   test_ntop6_reduces("0001:0099:BEEF:0006:0123:FFFF:0001:0001",
  1362.                      "1:99:beef:6:123:ffff:1:1");
  1363.   //test_ntop6_reduces("0:0:0:0:0:0:c0a8:0101", "::192.168.1.1");
  1364.   test_ntop6_reduces("0:0:0:0:0:ffff:c0a8:0101", "::ffff:192.168.1.1");
  1365.   test_ntop6_reduces("002:0:0000:0:3::4", "2::3:0:0:4");
  1366.   test_ntop6_reduces("0:0::1:0:3", "::1:0:3");
  1367.   test_ntop6_reduces("008:0::0", "8::");
  1368.   test_ntop6_reduces("0:0:0:0:0:ffff::1", "::ffff:0.0.0.1");
  1369.   test_ntop6_reduces("abcd:0:0:0:0:0:7f00::", "abcd::7f00:0");
  1370.   test_ntop6_reduces("0000:0000:0000:0000:0009:C0A8:0001:0001",
  1371.                      "::9:c0a8:1:1");
  1372.   test_ntop6_reduces("fe80:0000:0000:0000:0202:1111:0001:0001",
  1373.                      "fe80::202:1111:1:1");
  1374.   test_ntop6_reduces("1000:0001:0000:0007:0000:0000:0000:0000",
  1375.                      "1000:1:0:7::");
  1376.   /* === Test pton: invalid in6. */
  1377.   test_pton6_bad("foobar.");
  1378.   test_pton6_bad("55555::");
  1379.   test_pton6_bad("9:-60::");
  1380.   test_pton6_bad("1:2:33333:4:0002:3::");
  1381.   //test_pton6_bad("1:2:3333:4:00002:3::");// BAD, but glibc doesn't say so.
  1382.   test_pton6_bad("1:2:3333:4:fish:3::");
  1383.   test_pton6_bad("1:2:3:4:5:6:7:8:9");
  1384.   test_pton6_bad("1:2:3:4:5:6:7");
  1385.   test_pton6_bad("1:2:3:4:5:6:1.2.3.4.5");
  1386.   test_pton6_bad("1:2:3:4:5:6:1.2.3");
  1387.   test_pton6_bad("::1.2.3");
  1388.   test_pton6_bad("::1.2.3.4.5");
  1389.   test_pton6_bad("99");
  1390.   test_pton6_bad("");
  1391.   test_pton6_bad("1::2::3:4");
  1392.   test_pton6_bad("a:::b:c");
  1393.   test_pton6_bad(":::a:b:c");
  1394.   test_pton6_bad("a:b:c:::");
  1395.   /* test internal checking */
  1396.   test_external_ip("fbff:ffff::2:7", 0);
  1397.   test_internal_ip("fc01::2:7", 0);
  1398.   test_internal_ip("fdff:ffff::f:f", 0);
  1399.   test_external_ip("fe00::3:f", 0);
  1400.   test_external_ip("fe7f:ffff::2:7", 0);
  1401.   test_internal_ip("fe80::2:7", 0);
  1402.   test_internal_ip("febf:ffff::f:f", 0);
  1403.   test_internal_ip("fec0::2:7:7", 0);
  1404.   test_internal_ip("feff:ffff::e:7:7", 0);
  1405.   test_external_ip("ff00::e:7:7", 0);
  1406.   test_internal_ip("::", 0);
  1407.   test_internal_ip("::1", 0);
  1408.   test_internal_ip("::1", 1);
  1409.   test_internal_ip("::", 0);
  1410.   test_external_ip("::", 1);
  1411.   test_external_ip("::2", 0);
  1412.   test_external_ip("2001::", 0);
  1413.   test_external_ip("ffff::", 0);
  1414.   test_external_ip("::ffff:0.0.0.0", 1);
  1415.   test_internal_ip("::ffff:0.0.0.0", 0);
  1416.   test_internal_ip("::ffff:0.255.255.255", 0);
  1417.   test_external_ip("::ffff:1.0.0.0", 0);
  1418.   test_external_ip("::ffff:9.255.255.255", 0);
  1419.   test_internal_ip("::ffff:10.0.0.0", 0);
  1420.   test_internal_ip("::ffff:10.255.255.255", 0);
  1421.   test_external_ip("::ffff:11.0.0.0", 0);
  1422.   test_external_ip("::ffff:126.255.255.255", 0);
  1423.   test_internal_ip("::ffff:127.0.0.0", 0);
  1424.   test_internal_ip("::ffff:127.255.255.255", 0);
  1425.   test_external_ip("::ffff:128.0.0.0", 0);
  1426.   test_external_ip("::ffff:172.15.255.255", 0);
  1427.   test_internal_ip("::ffff:172.16.0.0", 0);
  1428.   test_internal_ip("::ffff:172.31.255.255", 0);
  1429.   test_external_ip("::ffff:172.32.0.0", 0);
  1430.   test_external_ip("::ffff:192.167.255.255", 0);
  1431.   test_internal_ip("::ffff:192.168.0.0", 0);
  1432.   test_internal_ip("::ffff:192.168.255.255", 0);
  1433.   test_external_ip("::ffff:192.169.0.0", 0);
  1434.   test_external_ip("::ffff:169.253.255.255", 0);
  1435.   test_internal_ip("::ffff:169.254.0.0", 0);
  1436.   test_internal_ip("::ffff:169.254.255.255", 0);
  1437.   test_external_ip("::ffff:169.255.0.0", 0);
  1438.   test_assert(is_internal_IP(0x7f000001, 0));
  1439.   /* tor_addr_compare(tor_addr_t x2) */
  1440.   test_addr_compare("ffff::", ==, "ffff::0");
  1441.   test_addr_compare("0::3:2:1", <, "0::ffff:0.3.2.1");
  1442.   test_addr_compare("0::2:2:1", <, "0::ffff:0.3.2.1");
  1443.   test_addr_compare("0::ffff:0.3.2.1", >, "0::0:0:0");
  1444.   test_addr_compare("0::ffff:5.2.2.1", <, "::ffff:6.0.0.0"); /* XXXX wrong. */
  1445.   tor_addr_parse_mask_ports("[::ffff:2.3.4.5]", &t1, NULL, NULL, NULL);
  1446.   tor_addr_parse_mask_ports("2.3.4.5", &t2, NULL, NULL, NULL);
  1447.   test_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) == 0);
  1448.   tor_addr_parse_mask_ports("[::ffff:2.3.4.4]", &t1, NULL, NULL, NULL);
  1449.   tor_addr_parse_mask_ports("2.3.4.5", &t2, NULL, NULL, NULL);
  1450.   test_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) < 0);
  1451.   /* test compare_masked */
  1452.   test_addr_compare_masked("ffff::", ==, "ffff::0", 128);
  1453.   test_addr_compare_masked("ffff::", ==, "ffff::0", 64);
  1454.   test_addr_compare_masked("0::2:2:1", <, "0::8000:2:1", 81);
  1455.   test_addr_compare_masked("0::2:2:1", ==, "0::8000:2:1", 80);
  1456.   /* Test decorated addr_to_string. */
  1457.   test_eq(AF_INET6, tor_addr_from_str(&t1, "[123:45:6789::5005:11]"));
  1458.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
  1459.   test_streq(p1, "[123:45:6789::5005:11]");
  1460.   test_eq(AF_INET, tor_addr_from_str(&t1, "18.0.0.1"));
  1461.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
  1462.   test_streq(p1, "18.0.0.1");
  1463.   /* Test tor_addr_parse_reverse_lookup_name */
  1464.   i = tor_addr_parse_reverse_lookup_name(&t1, "Foobar.baz", AF_UNSPEC, 0);
  1465.   test_eq(0, i);
  1466.   i = tor_addr_parse_reverse_lookup_name(&t1, "Foobar.baz", AF_UNSPEC, 1);
  1467.   test_eq(0, i);
  1468.   i = tor_addr_parse_reverse_lookup_name(&t1, "1.0.168.192.in-addr.arpa",
  1469.                                          AF_UNSPEC, 1);
  1470.   test_eq(1, i);
  1471.   test_eq(tor_addr_family(&t1), AF_INET);
  1472.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
  1473.   test_streq(p1, "192.168.0.1");
  1474.   i = tor_addr_parse_reverse_lookup_name(&t1, "192.168.0.99", AF_UNSPEC, 0);
  1475.   test_eq(0, i);
  1476.   i = tor_addr_parse_reverse_lookup_name(&t1, "192.168.0.99", AF_UNSPEC, 1);
  1477.   test_eq(1, i);
  1478.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
  1479.   test_streq(p1, "192.168.0.99");
  1480.   memset(&t1, 0, sizeof(t1));
  1481.   i = tor_addr_parse_reverse_lookup_name(&t1,
  1482.                                          "0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f."
  1483.                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
  1484.                                          "ip6.ARPA",
  1485.                                          AF_UNSPEC, 0);
  1486.   test_eq(1, i);
  1487.   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
  1488.   test_streq(p1, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]");
  1489.   /* Failing cases. */
  1490.   i = tor_addr_parse_reverse_lookup_name(&t1,
  1491.                                          "6.7.8.9.a.b.c.d.e.f."
  1492.                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
  1493.                                          "ip6.ARPA",
  1494.                                          AF_UNSPEC, 0);
  1495.   test_eq(i, -1);
  1496.   i = tor_addr_parse_reverse_lookup_name(&t1,
  1497.                                          "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.f.0."
  1498.                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
  1499.                                          "ip6.ARPA",
  1500.                                          AF_UNSPEC, 0);
  1501.   test_eq(i, -1);
  1502.   i = tor_addr_parse_reverse_lookup_name(&t1,
  1503.                                          "6.7.8.9.a.b.c.d.e.f.X.0.0.0.0.9."
  1504.                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
  1505.                                          "ip6.ARPA",
  1506.                                          AF_UNSPEC, 0);
  1507.   test_eq(i, -1);
  1508.   i = tor_addr_parse_reverse_lookup_name(&t1, "32.1.1.in-addr.arpa",
  1509.                                          AF_UNSPEC, 0);
  1510.   test_eq(i, -1);
  1511.   i = tor_addr_parse_reverse_lookup_name(&t1, ".in-addr.arpa",
  1512.                                          AF_UNSPEC, 0);
  1513.   test_eq(i, -1);
  1514.   i = tor_addr_parse_reverse_lookup_name(&t1, "1.2.3.4.5.in-addr.arpa",
  1515.                                          AF_UNSPEC, 0);
  1516.   test_eq(i, -1);
  1517.   i = tor_addr_parse_reverse_lookup_name(&t1, "1.2.3.4.5.in-addr.arpa",
  1518.                                          AF_INET6, 0);
  1519.   test_eq(i, -1);
  1520.   i = tor_addr_parse_reverse_lookup_name(&t1,
  1521.                                          "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.0."
  1522.                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
  1523.                                          "ip6.ARPA",
  1524.                                          AF_INET, 0);
  1525.   test_eq(i, -1);
  1526.   /* test tor_addr_parse_mask_ports */
  1527.   test_addr_mask_ports_parse("[::f]/17:47-95", AF_INET6,
  1528.                              0, 0, 0, 0x0000000f, 17, 47, 95);
  1529.   //test_addr_parse("[::fefe:4.1.1.7/120]:999-1000");
  1530.   //test_addr_parse_check("::fefe:401:107", 120, 999, 1000);
  1531.   test_addr_mask_ports_parse("[::ffff:4.1.1.7]/120:443", AF_INET6,
  1532.                              0, 0, 0x0000ffff, 0x04010107, 120, 443, 443);
  1533.   test_addr_mask_ports_parse("[abcd:2::44a:0]:2-65000", AF_INET6,
  1534.                              0xabcd0002, 0, 0, 0x044a0000, 128, 2, 65000);
  1535.   r=tor_addr_parse_mask_ports("[fefef::]/112", &t1, NULL, NULL, NULL);
  1536.   test_assert(r == -1);
  1537.   r=tor_addr_parse_mask_ports("efef::/112", &t1, NULL, NULL, NULL);
  1538.   test_assert(r == -1);
  1539.   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f::]", &t1, NULL, NULL, NULL);
  1540.   test_assert(r == -1);
  1541.   r=tor_addr_parse_mask_ports("[::f:f:f:f:f:f:f:f]", &t1, NULL, NULL, NULL);
  1542.   test_assert(r == -1);
  1543.   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f:f]", &t1, NULL, NULL, NULL);
  1544.   test_assert(r == -1);
  1545.   /* Test for V4-mapped address with mask < 96.  (arguably not valid) */
  1546.   r=tor_addr_parse_mask_ports("[::ffff:1.1.2.2/33]", &t1, &mask, NULL, NULL);
  1547.   test_assert(r == -1);
  1548.   r=tor_addr_parse_mask_ports("1.1.2.2/33", &t1, &mask, NULL, NULL);
  1549.   test_assert(r == -1);
  1550.   r=tor_addr_parse_mask_ports("1.1.2.2/31", &t1, &mask, NULL, NULL);
  1551.   test_assert(r == AF_INET);
  1552.   r=tor_addr_parse_mask_ports("[efef::]/112", &t1, &mask, &port1, &port2);
  1553.   test_assert(r == AF_INET6);
  1554.   test_assert(port1 == 1);
  1555.   test_assert(port2 == 65535);
  1556.   /* make sure inet address lengths >= max */
  1557.   test_assert(INET_NTOA_BUF_LEN >= sizeof("255.255.255.255"));
  1558.   test_assert(TOR_ADDR_BUF_LEN >=
  1559.               sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"));
  1560.   test_assert(sizeof(tor_addr_t) >= sizeof(struct in6_addr));
  1561.   /* get interface addresses */
  1562.   r = get_interface_address6(LOG_DEBUG, AF_INET, &t1);
  1563.   i = get_interface_address6(LOG_DEBUG, AF_INET6, &t2);
  1564. #if 0
  1565.   tor_inet_ntop(AF_INET, &t1.sa.sin_addr, buf, sizeof(buf));
  1566.   printf("nv4 address: %s  (family=%i)", buf, IN_FAMILY(&t1));
  1567.   tor_inet_ntop(AF_INET6, &t2.sa6.sin6_addr, buf, sizeof(buf));
  1568.   printf("nv6 address: %s  (family=%i)", buf, IN_FAMILY(&t2));
  1569. #endif
  1570.  done:
  1571.   ;
  1572. }
  1573. /** Run unit tests for basic dynamic-sized array functionality. */
  1574. static void
  1575. test_util_smartlist_basic(void)
  1576. {
  1577.   smartlist_t *sl;
  1578.   /* XXXX test sort_digests, uniq_strings, uniq_digests */
  1579.   /* Test smartlist add, del_keeporder, insert, get. */
  1580.   sl = smartlist_create();
  1581.   smartlist_add(sl, (void*)1);
  1582.   smartlist_add(sl, (void*)2);
  1583.   smartlist_add(sl, (void*)3);
  1584.   smartlist_add(sl, (void*)4);
  1585.   smartlist_del_keeporder(sl, 1);
  1586.   smartlist_insert(sl, 1, (void*)22);
  1587.   smartlist_insert(sl, 0, (void*)0);
  1588.   smartlist_insert(sl, 5, (void*)555);
  1589.   test_eq_ptr((void*)0,   smartlist_get(sl,0));
  1590.   test_eq_ptr((void*)1,   smartlist_get(sl,1));
  1591.   test_eq_ptr((void*)22,  smartlist_get(sl,2));
  1592.   test_eq_ptr((void*)3,   smartlist_get(sl,3));
  1593.   test_eq_ptr((void*)4,   smartlist_get(sl,4));
  1594.   test_eq_ptr((void*)555, smartlist_get(sl,5));
  1595.   /* Try deleting in the middle. */
  1596.   smartlist_del(sl, 1);
  1597.   test_eq_ptr((void*)555, smartlist_get(sl, 1));
  1598.   /* Try deleting at the end. */
  1599.   smartlist_del(sl, 4);
  1600.   test_eq(4, smartlist_len(sl));
  1601.   /* test isin. */
  1602.   test_assert(smartlist_isin(sl, (void*)3));
  1603.   test_assert(!smartlist_isin(sl, (void*)99));
  1604.  done:
  1605.   smartlist_free(sl);
  1606. }
  1607. /** Run unit tests for smartlist-of-strings functionality. */
  1608. static void
  1609. test_util_smartlist_strings(void)
  1610. {
  1611.   smartlist_t *sl = smartlist_create();
  1612.   char *cp=NULL, *cp_alloc=NULL;
  1613.   size_t sz;
  1614.   /* Test split and join */
  1615.   test_eq(0, smartlist_len(sl));
  1616.   smartlist_split_string(sl, "abc", ":", 0, 0);
  1617.   test_eq(1, smartlist_len(sl));
  1618.   test_streq("abc", smartlist_get(sl, 0));
  1619.   smartlist_split_string(sl, "a::bc::", "::", 0, 0);
  1620.   test_eq(4, smartlist_len(sl));
  1621.   test_streq("a", smartlist_get(sl, 1));
  1622.   test_streq("bc", smartlist_get(sl, 2));
  1623.   test_streq("", smartlist_get(sl, 3));
  1624.   cp_alloc = smartlist_join_strings(sl, "", 0, NULL);
  1625.   test_streq(cp_alloc, "abcabc");
  1626.   tor_free(cp_alloc);
  1627.   cp_alloc = smartlist_join_strings(sl, "!", 0, NULL);
  1628.   test_streq(cp_alloc, "abc!a!bc!");
  1629.   tor_free(cp_alloc);
  1630.   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
  1631.   test_streq(cp_alloc, "abcXYaXYbcXY");
  1632.   tor_free(cp_alloc);
  1633.   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
  1634.   test_streq(cp_alloc, "abcXYaXYbcXYXY");
  1635.   tor_free(cp_alloc);
  1636.   cp_alloc = smartlist_join_strings(sl, "", 1, NULL);
  1637.   test_streq(cp_alloc, "abcabc");
  1638.   tor_free(cp_alloc);
  1639.   smartlist_split_string(sl, "/def/  /ghijk", "/", 0, 0);
  1640.   test_eq(8, smartlist_len(sl));
  1641.   test_streq("", smartlist_get(sl, 4));
  1642.   test_streq("def", smartlist_get(sl, 5));
  1643.   test_streq("  ", smartlist_get(sl, 6));
  1644.   test_streq("ghijk", smartlist_get(sl, 7));
  1645.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1646.   smartlist_clear(sl);
  1647.   smartlist_split_string(sl, "a,bbd,cdef", ",", SPLIT_SKIP_SPACE, 0);
  1648.   test_eq(3, smartlist_len(sl));
  1649.   test_streq("a", smartlist_get(sl,0));
  1650.   test_streq("bbd", smartlist_get(sl,1));
  1651.   test_streq("cdef", smartlist_get(sl,2));
  1652.   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
  1653.                          SPLIT_SKIP_SPACE, 0);
  1654.   test_eq(8, smartlist_len(sl));
  1655.   test_streq("z", smartlist_get(sl,3));
  1656.   test_streq("zhasd", smartlist_get(sl,4));
  1657.   test_streq("", smartlist_get(sl,5));
  1658.   test_streq("bnud", smartlist_get(sl,6));
  1659.   test_streq("", smartlist_get(sl,7));
  1660.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1661.   smartlist_clear(sl);
  1662.   smartlist_split_string(sl, " abtc td ef  ", NULL,
  1663.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1664.   test_eq(4, smartlist_len(sl));
  1665.   test_streq("ab", smartlist_get(sl,0));
  1666.   test_streq("c", smartlist_get(sl,1));
  1667.   test_streq("d", smartlist_get(sl,2));
  1668.   test_streq("ef", smartlist_get(sl,3));
  1669.   smartlist_split_string(sl, "ghitj", NULL,
  1670.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1671.   test_eq(6, smartlist_len(sl));
  1672.   test_streq("ghi", smartlist_get(sl,4));
  1673.   test_streq("j", smartlist_get(sl,5));
  1674.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1675.   smartlist_clear(sl);
  1676.   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
  1677.   test_streq(cp_alloc, "");
  1678.   tor_free(cp_alloc);
  1679.   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
  1680.   test_streq(cp_alloc, "XY");
  1681.   tor_free(cp_alloc);
  1682.   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
  1683.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1684.   test_eq(3, smartlist_len(sl));
  1685.   test_streq("z", smartlist_get(sl, 0));
  1686.   test_streq("zhasd", smartlist_get(sl, 1));
  1687.   test_streq("bnud", smartlist_get(sl, 2));
  1688.   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
  1689.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
  1690.   test_eq(5, smartlist_len(sl));
  1691.   test_streq("z", smartlist_get(sl, 3));
  1692.   test_streq("zhasd <>  <> bnud<>", smartlist_get(sl, 4));
  1693.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1694.   smartlist_clear(sl);
  1695.   smartlist_split_string(sl, "abcdn", "n",
  1696.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1697.   test_eq(1, smartlist_len(sl));
  1698.   test_streq("abcd", smartlist_get(sl, 0));
  1699.   smartlist_split_string(sl, "efgh", "n",
  1700.                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1701.   test_eq(2, smartlist_len(sl));
  1702.   test_streq("efgh", smartlist_get(sl, 1));
  1703.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1704.   smartlist_clear(sl);
  1705.   /* Test swapping, shuffling, and sorting. */
  1706.   smartlist_split_string(sl, "the,onion,router,by,arma,and,nickm", ",", 0, 0);
  1707.   test_eq(7, smartlist_len(sl));
  1708.   smartlist_sort(sl, _compare_strs);
  1709.   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
  1710.   test_streq(cp_alloc,"and,arma,by,nickm,onion,router,the");
  1711.   tor_free(cp_alloc);
  1712.   smartlist_swap(sl, 1, 5);
  1713.   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
  1714.   test_streq(cp_alloc,"and,router,by,nickm,onion,arma,the");
  1715.   tor_free(cp_alloc);
  1716.   smartlist_shuffle(sl);
  1717.   test_eq(7, smartlist_len(sl));
  1718.   test_assert(smartlist_string_isin(sl, "and"));
  1719.   test_assert(smartlist_string_isin(sl, "router"));
  1720.   test_assert(smartlist_string_isin(sl, "by"));
  1721.   test_assert(smartlist_string_isin(sl, "nickm"));
  1722.   test_assert(smartlist_string_isin(sl, "onion"));
  1723.   test_assert(smartlist_string_isin(sl, "arma"));
  1724.   test_assert(smartlist_string_isin(sl, "the"));
  1725.   /* Test bsearch. */
  1726.   smartlist_sort(sl, _compare_strs);
  1727.   test_streq("nickm", smartlist_bsearch(sl, "zNicKM",
  1728.                                         _compare_without_first_ch));
  1729.   test_streq("and", smartlist_bsearch(sl, " AND", _compare_without_first_ch));
  1730.   test_eq_ptr(NULL, smartlist_bsearch(sl, " ANz", _compare_without_first_ch));
  1731.   /* Test bsearch_idx */
  1732.   {
  1733.     int f;
  1734.     test_eq(0, smartlist_bsearch_idx(sl," aaa",_compare_without_first_ch,&f));
  1735.     test_eq(f, 0);
  1736.     test_eq(0, smartlist_bsearch_idx(sl," and",_compare_without_first_ch,&f));
  1737.     test_eq(f, 1);
  1738.     test_eq(1, smartlist_bsearch_idx(sl," arm",_compare_without_first_ch,&f));
  1739.     test_eq(f, 0);
  1740.     test_eq(1, smartlist_bsearch_idx(sl," arma",_compare_without_first_ch,&f));
  1741.     test_eq(f, 1);
  1742.     test_eq(2, smartlist_bsearch_idx(sl," armb",_compare_without_first_ch,&f));
  1743.     test_eq(f, 0);
  1744.     test_eq(7, smartlist_bsearch_idx(sl," zzzz",_compare_without_first_ch,&f));
  1745.     test_eq(f, 0);
  1746.   }
  1747.   /* Test reverse() and pop_last() */
  1748.   smartlist_reverse(sl);
  1749.   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
  1750.   test_streq(cp_alloc,"the,router,onion,nickm,by,arma,and");
  1751.   tor_free(cp_alloc);
  1752.   cp_alloc = smartlist_pop_last(sl);
  1753.   test_streq(cp_alloc, "and");
  1754.   tor_free(cp_alloc);
  1755.   test_eq(smartlist_len(sl), 6);
  1756.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1757.   smartlist_clear(sl);
  1758.   cp_alloc = smartlist_pop_last(sl);
  1759.   test_eq(cp_alloc, NULL);
  1760.   /* Test uniq() */
  1761.   smartlist_split_string(sl,
  1762.                      "50,noon,radar,a,man,a,plan,a,canal,panama,radar,noon,50",
  1763.                      ",", 0, 0);
  1764.   smartlist_sort(sl, _compare_strs);
  1765.   smartlist_uniq(sl, _compare_strs, _tor_free);
  1766.   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
  1767.   test_streq(cp_alloc, "50,a,canal,man,noon,panama,plan,radar");
  1768.   tor_free(cp_alloc);
  1769.   /* Test string_isin and isin_case and num_isin */
  1770.   test_assert(smartlist_string_isin(sl, "noon"));
  1771.   test_assert(!smartlist_string_isin(sl, "noonoon"));
  1772.   test_assert(smartlist_string_isin_case(sl, "nOOn"));
  1773.   test_assert(!smartlist_string_isin_case(sl, "nooNooN"));
  1774.   test_assert(smartlist_string_num_isin(sl, 50));
  1775.   test_assert(!smartlist_string_num_isin(sl, 60));
  1776.   /* Test smartlist_choose */
  1777.   {
  1778.     int i;
  1779.     int allsame = 1;
  1780.     int allin = 1;
  1781.     void *first = smartlist_choose(sl);
  1782.     test_assert(smartlist_isin(sl, first));
  1783.     for (i = 0; i < 100; ++i) {
  1784.       void *second = smartlist_choose(sl);
  1785.       if (second != first)
  1786.         allsame = 0;
  1787.       if (!smartlist_isin(sl, second))
  1788.         allin = 0;
  1789.     }
  1790.     test_assert(!allsame);
  1791.     test_assert(allin);
  1792.   }
  1793.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1794.   smartlist_clear(sl);
  1795.   /* Test string_remove and remove and join_strings2 */
  1796.   smartlist_split_string(sl,
  1797.                     "Some say the Earth will end in ice and some in fire",
  1798.                     " ", 0, 0);
  1799.   cp = smartlist_get(sl, 4);
  1800.   test_streq(cp, "will");
  1801.   smartlist_add(sl, cp);
  1802.   smartlist_remove(sl, cp);
  1803.   tor_free(cp);
  1804.   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
  1805.   test_streq(cp_alloc, "Some,say,the,Earth,fire,end,in,ice,and,some,in");
  1806.   tor_free(cp_alloc);
  1807.   smartlist_string_remove(sl, "in");
  1808.   cp_alloc = smartlist_join_strings2(sl, "+XX", 1, 0, &sz);
  1809.   test_streq(cp_alloc, "Some+say+the+Earth+fire+end+some+ice+and");
  1810.   test_eq((int)sz, 40);
  1811.  done:
  1812.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1813.   smartlist_free(sl);
  1814.   tor_free(cp_alloc);
  1815. }
  1816. /** Run unit tests for smartlist set manipulation functions. */
  1817. static void
  1818. test_util_smartlist_overlap(void)
  1819. {
  1820.   smartlist_t *sl = smartlist_create();
  1821.   smartlist_t *ints = smartlist_create();
  1822.   smartlist_t *odds = smartlist_create();
  1823.   smartlist_t *evens = smartlist_create();
  1824.   smartlist_t *primes = smartlist_create();
  1825.   int i;
  1826.   for (i=1; i < 10; i += 2)
  1827.     smartlist_add(odds, (void*)(uintptr_t)i);
  1828.   for (i=0; i < 10; i += 2)
  1829.     smartlist_add(evens, (void*)(uintptr_t)i);
  1830.   /* add_all */
  1831.   smartlist_add_all(ints, odds);
  1832.   smartlist_add_all(ints, evens);
  1833.   test_eq(smartlist_len(ints), 10);
  1834.   smartlist_add(primes, (void*)2);
  1835.   smartlist_add(primes, (void*)3);
  1836.   smartlist_add(primes, (void*)5);
  1837.   smartlist_add(primes, (void*)7);
  1838.   /* overlap */
  1839.   test_assert(smartlist_overlap(ints, odds));
  1840.   test_assert(smartlist_overlap(odds, primes));
  1841.   test_assert(smartlist_overlap(evens, primes));
  1842.   test_assert(!smartlist_overlap(odds, evens));
  1843.   /* intersect */
  1844.   smartlist_add_all(sl, odds);
  1845.   smartlist_intersect(sl, primes);
  1846.   test_eq(smartlist_len(sl), 3);
  1847.   test_assert(smartlist_isin(sl, (void*)3));
  1848.   test_assert(smartlist_isin(sl, (void*)5));
  1849.   test_assert(smartlist_isin(sl, (void*)7));
  1850.   /* subtract */
  1851.   smartlist_add_all(sl, primes);
  1852.   smartlist_subtract(sl, odds);
  1853.   test_eq(smartlist_len(sl), 1);
  1854.   test_assert(smartlist_isin(sl, (void*)2));
  1855.  done:
  1856.   smartlist_free(odds);
  1857.   smartlist_free(evens);
  1858.   smartlist_free(ints);
  1859.   smartlist_free(primes);
  1860.   smartlist_free(sl);
  1861. }
  1862. /** Run unit tests for smartlist-of-digests functions. */
  1863. static void
  1864. test_util_smartlist_digests(void)
  1865. {
  1866.   smartlist_t *sl = smartlist_create();
  1867.   /* digest_isin. */
  1868.   smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN));
  1869.   smartlist_add(sl, tor_memdup("0090AAB2AAAAaasdAAAAA", DIGEST_LEN));
  1870.   smartlist_add(sl, tor_memdup("0090AAB2AAAAaasdAAAAA", DIGEST_LEN));
  1871.   test_eq(0, smartlist_digest_isin(NULL, "AAAAAAAAAAAAAAAAAAAA"));
  1872.   test_assert(smartlist_digest_isin(sl, "AAAAAAAAAAAAAAAAAAAA"));
  1873.   test_assert(smartlist_digest_isin(sl, "0090AAB2AAAAaasdAAAAA"));
  1874.   test_eq(0, smartlist_digest_isin(sl, "0090AAB2AAABaasdAAAAA"));
  1875.   /* sort digests */
  1876.   smartlist_sort_digests(sl);
  1877.   test_memeq(smartlist_get(sl, 0), "0090AAB2AAAAaasdAAAAA", DIGEST_LEN);
  1878.   test_memeq(smartlist_get(sl, 1), "0090AAB2AAAAaasdAAAAA", DIGEST_LEN);
  1879.   test_memeq(smartlist_get(sl, 2), "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
  1880.   test_eq(3, smartlist_len(sl));
  1881.   /* uniq_digests */
  1882.   smartlist_uniq_digests(sl);
  1883.   test_eq(2, smartlist_len(sl));
  1884.   test_memeq(smartlist_get(sl, 0), "0090AAB2AAAAaasdAAAAA", DIGEST_LEN);
  1885.   test_memeq(smartlist_get(sl, 1), "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
  1886.  done:
  1887.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1888.   smartlist_free(sl);
  1889. }
  1890. /** Run unit tests for concatenate-a-smartlist-of-strings functions. */
  1891. static void
  1892. test_util_smartlist_join(void)
  1893. {
  1894.   smartlist_t *sl = smartlist_create();
  1895.   smartlist_t *sl2 = smartlist_create(), *sl3 = smartlist_create(),
  1896.     *sl4 = smartlist_create();
  1897.   char *joined=NULL;
  1898.   /* unique, sorted. */
  1899.   smartlist_split_string(sl,
  1900.                          "Abashments Ambush Anchorman Bacon Banks Borscht "
  1901.                          "Bunks Inhumane Insurance Knish Know Manners "
  1902.                          "Maraschinos Stamina Sunbonnets Unicorns Wombats",
  1903.                          " ", 0, 0);
  1904.   /* non-unique, sorted. */
  1905.   smartlist_split_string(sl2,
  1906.                          "Ambush Anchorman Anchorman Anemias Anemias Bacon "
  1907.                          "Crossbowmen Inhumane Insurance Knish Know Manners "
  1908.                          "Manners Maraschinos Wombats Wombats Work",
  1909.                          " ", 0, 0);
  1910.   SMARTLIST_FOREACH_JOIN(sl, char *, cp1,
  1911.                          sl2, char *, cp2,
  1912.                          strcmp(cp1,cp2),
  1913.                          smartlist_add(sl3, cp2)) {
  1914.     test_streq(cp1, cp2);
  1915.     smartlist_add(sl4, cp1);
  1916.   } SMARTLIST_FOREACH_JOIN_END(cp1, cp2);
  1917.   SMARTLIST_FOREACH(sl3, const char *, cp,
  1918.                     test_assert(smartlist_isin(sl2, cp) &&
  1919.                                 !smartlist_string_isin(sl, cp)));
  1920.   SMARTLIST_FOREACH(sl4, const char *, cp,
  1921.                     test_assert(smartlist_isin(sl, cp) &&
  1922.                                 smartlist_string_isin(sl2, cp)));
  1923.   joined = smartlist_join_strings(sl3, ",", 0, NULL);
  1924.   test_streq(joined, "Anemias,Anemias,Crossbowmen,Work");
  1925.   tor_free(joined);
  1926.   joined = smartlist_join_strings(sl4, ",", 0, NULL);
  1927.   test_streq(joined, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance,"
  1928.              "Knish,Know,Manners,Manners,Maraschinos,Wombats,Wombats");
  1929.   tor_free(joined);
  1930.  done:
  1931.   smartlist_free(sl4);
  1932.   smartlist_free(sl3);
  1933.   SMARTLIST_FOREACH(sl2, char *, cp, tor_free(cp));
  1934.   smartlist_free(sl2);
  1935.   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  1936.   smartlist_free(sl);
  1937.   tor_free(joined);
  1938. }
  1939. /** Run unit tests for bitarray code */
  1940. static void
  1941. test_util_bitarray(void)
  1942. {
  1943.   bitarray_t *ba = NULL;
  1944.   int i, j, ok=1;
  1945.   ba = bitarray_init_zero(1);
  1946.   test_assert(ba);
  1947.   test_assert(! bitarray_is_set(ba, 0));
  1948.   bitarray_set(ba, 0);
  1949.   test_assert(bitarray_is_set(ba, 0));
  1950.   bitarray_clear(ba, 0);
  1951.   test_assert(! bitarray_is_set(ba, 0));
  1952.   bitarray_free(ba);
  1953.   ba = bitarray_init_zero(1023);
  1954.   for (i = 1; i < 64; ) {
  1955.     for (j = 0; j < 1023; ++j) {
  1956.       if (j % i)
  1957.         bitarray_set(ba, j);
  1958.       else
  1959.         bitarray_clear(ba, j);
  1960.     }
  1961.     for (j = 0; j < 1023; ++j) {
  1962.       if (!bool_eq(bitarray_is_set(ba, j), j%i))
  1963.         ok = 0;
  1964.     }
  1965.     test_assert(ok);
  1966.     if (i < 7)
  1967.       ++i;
  1968.     else if (i == 28)
  1969.       i = 32;
  1970.     else
  1971.       i += 7;
  1972.   }
  1973.  done:
  1974.   if (ba)
  1975.     bitarray_free(ba);
  1976. }
  1977. /** Run unit tests for digest set code (implemented as a hashtable or as a
  1978.  * bloom filter) */
  1979. static void
  1980. test_util_digestset(void)
  1981. {
  1982.   smartlist_t *included = smartlist_create();
  1983.   char d[DIGEST_LEN];
  1984.   int i;
  1985.   int ok = 1;
  1986.   int false_positives = 0;
  1987.   digestset_t *set = NULL;
  1988.   for (i = 0; i < 1000; ++i) {
  1989.     crypto_rand(d, DIGEST_LEN);
  1990.     smartlist_add(included, tor_memdup(d, DIGEST_LEN));
  1991.   }
  1992.   set = digestset_new(1000);
  1993.   SMARTLIST_FOREACH(included, const char *, cp,
  1994.                     if (digestset_isin(set, cp))
  1995.                       ok = 0);
  1996.   test_assert(ok);
  1997.   SMARTLIST_FOREACH(included, const char *, cp,
  1998.                     digestset_add(set, cp));
  1999.   SMARTLIST_FOREACH(included, const char *, cp,
  2000.                     if (!digestset_isin(set, cp))
  2001.                       ok = 0);
  2002.   test_assert(ok);
  2003.   for (i = 0; i < 1000; ++i) {
  2004.     crypto_rand(d, DIGEST_LEN);
  2005.     if (digestset_isin(set, d))
  2006.       ++false_positives;
  2007.   }
  2008.   test_assert(false_positives < 50); /* Should be far lower. */
  2009.  done:
  2010.   if (set)
  2011.     digestset_free(set);
  2012.   SMARTLIST_FOREACH(included, char *, cp, tor_free(cp));
  2013.   smartlist_free(included);
  2014. }
  2015. /** mutex for thread test to stop the threads hitting data at the same time. */
  2016. static tor_mutex_t *_thread_test_mutex = NULL;
  2017. /** mutexes for the thread test to make sure that the threads have to
  2018.  * interleave somewhat. */
  2019. static tor_mutex_t *_thread_test_start1 = NULL,
  2020.                    *_thread_test_start2 = NULL;
  2021. /** Shared strmap for the thread test. */
  2022. static strmap_t *_thread_test_strmap = NULL;
  2023. /** The name of thread1 for the thread test */
  2024. static char *_thread1_name = NULL;
  2025. /** The name of thread2 for the thread test */
  2026. static char *_thread2_name = NULL;
  2027. static void _thread_test_func(void* _s) ATTR_NORETURN;
  2028. /** How many iterations have the threads in the unit test run? */
  2029. static int t1_count = 0, t2_count = 0;
  2030. /** Helper function for threading unit tests: This function runs in a
  2031.  * subthread. It grabs its own mutex (start1 or start2) to make sure that it
  2032.  * should start, then it repeatedly alters _test_thread_strmap protected by
  2033.  * _thread_test_mutex. */
  2034. static void
  2035. _thread_test_func(void* _s)
  2036. {
  2037.   char *s = _s;
  2038.   int i, *count;
  2039.   tor_mutex_t *m;
  2040.   char buf[64];
  2041.   char **cp;
  2042.   if (!strcmp(s, "thread 1")) {
  2043.     m = _thread_test_start1;
  2044.     cp = &_thread1_name;
  2045.     count = &t1_count;
  2046.   } else {
  2047.     m = _thread_test_start2;
  2048.     cp = &_thread2_name;
  2049.     count = &t2_count;
  2050.   }
  2051.   tor_mutex_acquire(m);
  2052.   tor_snprintf(buf, sizeof(buf), "%lu", tor_get_thread_id());
  2053.   *cp = tor_strdup(buf);
  2054.   for (i=0; i<10000; ++i) {
  2055.     tor_mutex_acquire(_thread_test_mutex);
  2056.     strmap_set(_thread_test_strmap, "last to run", *cp);
  2057.     ++*count;
  2058.     tor_mutex_release(_thread_test_mutex);
  2059.   }
  2060.   tor_mutex_acquire(_thread_test_mutex);
  2061.   strmap_set(_thread_test_strmap, s, *cp);
  2062.   tor_mutex_release(_thread_test_mutex);
  2063.   tor_mutex_release(m);
  2064.   spawn_exit();
  2065. }
  2066. /** Run unit tests for threading logic. */
  2067. static void
  2068. test_util_threads(void)
  2069. {
  2070.   char *s1 = NULL, *s2 = NULL;
  2071.   int done = 0, timedout = 0;
  2072.   time_t started;
  2073. #ifndef TOR_IS_MULTITHREADED
  2074.   /* Skip this test if we aren't threading. We should be threading most
  2075.    * everywhere by now. */
  2076.   if (1)
  2077.     return;
  2078. #endif
  2079.   _thread_test_mutex = tor_mutex_new();
  2080.   _thread_test_start1 = tor_mutex_new();
  2081.   _thread_test_start2 = tor_mutex_new();
  2082.   _thread_test_strmap = strmap_new();
  2083.   s1 = tor_strdup("thread 1");
  2084.   s2 = tor_strdup("thread 2");
  2085.   tor_mutex_acquire(_thread_test_start1);
  2086.   tor_mutex_acquire(_thread_test_start2);
  2087.   spawn_func(_thread_test_func, s1);
  2088.   spawn_func(_thread_test_func, s2);
  2089.   tor_mutex_release(_thread_test_start2);
  2090.   tor_mutex_release(_thread_test_start1);
  2091.   started = time(NULL);
  2092.   while (!done) {
  2093.     tor_mutex_acquire(_thread_test_mutex);
  2094.     strmap_assert_ok(_thread_test_strmap);
  2095.     if (strmap_get(_thread_test_strmap, "thread 1") &&
  2096.         strmap_get(_thread_test_strmap, "thread 2")) {
  2097.       done = 1;
  2098.     } else if (time(NULL) > started + 25) {
  2099.       timedout = done = 1;
  2100.     }
  2101.     tor_mutex_release(_thread_test_mutex);
  2102.   }
  2103.   tor_mutex_free(_thread_test_mutex);
  2104.   tor_mutex_acquire(_thread_test_start1);
  2105.   tor_mutex_release(_thread_test_start1);
  2106.   tor_mutex_acquire(_thread_test_start2);
  2107.   tor_mutex_release(_thread_test_start2);
  2108.   if (timedout) {
  2109.     printf("nTimed out: %d %d", t1_count, t2_count);
  2110.     test_assert(strmap_get(_thread_test_strmap, "thread 1"));
  2111.     test_assert(strmap_get(_thread_test_strmap, "thread 2"));
  2112.     test_assert(!timedout);
  2113.   }
  2114.   /* different thread IDs. */
  2115.   test_assert(strcmp(strmap_get(_thread_test_strmap, "thread 1"),
  2116.                      strmap_get(_thread_test_strmap, "thread 2")));
  2117.   test_assert(!strcmp(strmap_get(_thread_test_strmap, "thread 1"),
  2118.                       strmap_get(_thread_test_strmap, "last to run")) ||
  2119.               !strcmp(strmap_get(_thread_test_strmap, "thread 2"),
  2120.                       strmap_get(_thread_test_strmap, "last to run")));
  2121.  done:
  2122.   tor_free(s1);
  2123.   tor_free(s2);
  2124.   tor_free(_thread1_name);
  2125.   tor_free(_thread2_name);
  2126.   if (_thread_test_strmap)
  2127.     strmap_free(_thread_test_strmap, NULL);
  2128.   if (_thread_test_start1)
  2129.     tor_mutex_free(_thread_test_start1);
  2130.   if (_thread_test_start2)
  2131.     tor_mutex_free(_thread_test_start2);
  2132. }
  2133. /** Helper: return a tristate based on comparing two strings. */
  2134. static int
  2135. _compare_strings_for_pqueue(const void *s1, const void *s2)
  2136. {
  2137.   return strcmp((const char*)s1, (const char*)s2);
  2138. }
  2139. /** Run unit tests for heap-based priority queue functions. */
  2140. static void
  2141. test_util_pqueue(void)
  2142. {
  2143.   smartlist_t *sl = smartlist_create();
  2144.   int (*cmp)(const void *, const void*);
  2145. #define OK() smartlist_pqueue_assert_ok(sl, cmp)
  2146.   cmp = _compare_strings_for_pqueue;
  2147.   smartlist_pqueue_add(sl, cmp, (char*)"cows");
  2148.   smartlist_pqueue_add(sl, cmp, (char*)"zebras");
  2149.   smartlist_pqueue_add(sl, cmp, (char*)"fish");
  2150.   smartlist_pqueue_add(sl, cmp, (char*)"frogs");
  2151.   smartlist_pqueue_add(sl, cmp, (char*)"apples");
  2152.   smartlist_pqueue_add(sl, cmp, (char*)"squid");
  2153.   smartlist_pqueue_add(sl, cmp, (char*)"daschunds");
  2154.   smartlist_pqueue_add(sl, cmp, (char*)"eggplants");
  2155.   smartlist_pqueue_add(sl, cmp, (char*)"weissbier");
  2156.   smartlist_pqueue_add(sl, cmp, (char*)"lobsters");
  2157.   smartlist_pqueue_add(sl, cmp, (char*)"roquefort");
  2158.   OK();
  2159.   test_eq(smartlist_len(sl), 11);
  2160.   test_streq(smartlist_get(sl, 0), "apples");
  2161.   test_streq(smartlist_pqueue_pop(sl, cmp), "apples");
  2162.   test_eq(smartlist_len(sl), 10);
  2163.   OK();
  2164.   test_streq(smartlist_pqueue_pop(sl, cmp), "cows");
  2165.   test_streq(smartlist_pqueue_pop(sl, cmp), "daschunds");
  2166.   smartlist_pqueue_add(sl, cmp, (char*)"chinchillas");
  2167.   OK();
  2168.   smartlist_pqueue_add(sl, cmp, (char*)"fireflies");
  2169.   OK();
  2170.   test_streq(smartlist_pqueue_pop(sl, cmp), "chinchillas");
  2171.   test_streq(smartlist_pqueue_pop(sl, cmp), "eggplants");
  2172.   test_streq(smartlist_pqueue_pop(sl, cmp), "fireflies");
  2173.   OK();
  2174.   test_streq(smartlist_pqueue_pop(sl, cmp), "fish");
  2175.   test_streq(smartlist_pqueue_pop(sl, cmp), "frogs");
  2176.   test_streq(smartlist_pqueue_pop(sl, cmp), "lobsters");
  2177.   test_streq(smartlist_pqueue_pop(sl, cmp), "roquefort");
  2178.   OK();
  2179.   test_eq(smartlist_len(sl), 3);
  2180.   test_streq(smartlist_pqueue_pop(sl, cmp), "squid");
  2181.   test_streq(smartlist_pqueue_pop(sl, cmp), "weissbier");
  2182.   test_streq(smartlist_pqueue_pop(sl, cmp), "zebras");
  2183.   test_eq(smartlist_len(sl), 0);
  2184.   OK();
  2185. #undef OK