test.c 59 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751
  1. /* Copyright (c) 2001-2004, Roger Dingledine.
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2013, 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_git_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 _WIN32
  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 GEOIP_PRIVATE
  26. #define ROUTER_PRIVATE
  27. #define CIRCUITSTATS_PRIVATE
  28. #define CIRCUITLIST_PRIVATE
  29. /*
  30. * Linux doesn't provide lround in math.h by default, but mac os does...
  31. * It's best just to leave math.h out of the picture entirely.
  32. */
  33. //#include <math.h>
  34. long int lround(double x);
  35. double fabs(double x);
  36. #include "or.h"
  37. #include "buffers.h"
  38. #include "circuitlist.h"
  39. #include "circuitstats.h"
  40. #include "config.h"
  41. #include "connection_edge.h"
  42. #include "geoip.h"
  43. #include "rendcommon.h"
  44. #include "test.h"
  45. #include "torgzip.h"
  46. #include "mempool.h"
  47. #include "memarea.h"
  48. #include "onion.h"
  49. #include "onion_ntor.h"
  50. #include "onion_tap.h"
  51. #include "policies.h"
  52. #include "rephist.h"
  53. #include "routerparse.h"
  54. #ifdef CURVE25519_ENABLED
  55. #include "crypto_curve25519.h"
  56. #include "onion_ntor.h"
  57. #endif
  58. #ifdef USE_DMALLOC
  59. #include <dmalloc.h>
  60. #include <openssl/crypto.h>
  61. #include "main.h"
  62. #endif
  63. /** Set to true if any unit test has failed. Mostly, this is set by the macros
  64. * in test.h */
  65. int have_failed = 0;
  66. /** Temporary directory (set up by setup_directory) under which we store all
  67. * our files during testing. */
  68. static char temp_dir[256];
  69. #ifdef _WIN32
  70. #define pid_t int
  71. #endif
  72. static pid_t temp_dir_setup_in_pid = 0;
  73. /** Select and create the temporary directory we'll use to run our unit tests.
  74. * Store it in <b>temp_dir</b>. Exit immediately if we can't create it.
  75. * idempotent. */
  76. static void
  77. setup_directory(void)
  78. {
  79. static int is_setup = 0;
  80. int r;
  81. char rnd[256], rnd32[256];
  82. if (is_setup) return;
  83. /* Due to base32 limitation needs to be a multiple of 5. */
  84. #define RAND_PATH_BYTES 5
  85. crypto_rand(rnd, RAND_PATH_BYTES);
  86. base32_encode(rnd32, sizeof(rnd32), rnd, RAND_PATH_BYTES);
  87. #ifdef _WIN32
  88. {
  89. char buf[MAX_PATH];
  90. const char *tmp = buf;
  91. /* If this fails, we're probably screwed anyway */
  92. if (!GetTempPathA(sizeof(buf),buf))
  93. tmp = "c:\\windows\\temp";
  94. tor_snprintf(temp_dir, sizeof(temp_dir),
  95. "%s\\tor_test_%d_%s", tmp, (int)getpid(), rnd32);
  96. r = mkdir(temp_dir);
  97. }
  98. #else
  99. tor_snprintf(temp_dir, sizeof(temp_dir), "/tmp/tor_test_%d_%s",
  100. (int) getpid(), rnd32);
  101. r = mkdir(temp_dir, 0700);
  102. #endif
  103. if (r) {
  104. fprintf(stderr, "Can't create directory %s:", temp_dir);
  105. perror("");
  106. exit(1);
  107. }
  108. is_setup = 1;
  109. temp_dir_setup_in_pid = getpid();
  110. }
  111. /** Return a filename relative to our testing temporary directory */
  112. const char *
  113. get_fname(const char *name)
  114. {
  115. static char buf[1024];
  116. setup_directory();
  117. if (!name)
  118. return temp_dir;
  119. tor_snprintf(buf,sizeof(buf),"%s/%s",temp_dir,name);
  120. return buf;
  121. }
  122. /* Remove a directory and all of its subdirectories */
  123. static void
  124. rm_rf(const char *dir)
  125. {
  126. struct stat st;
  127. smartlist_t *elements;
  128. elements = tor_listdir(dir);
  129. if (elements) {
  130. SMARTLIST_FOREACH_BEGIN(elements, const char *, cp) {
  131. char *tmp = NULL;
  132. tor_asprintf(&tmp, "%s"PATH_SEPARATOR"%s", dir, cp);
  133. if (0 == stat(tmp,&st) && (st.st_mode & S_IFDIR)) {
  134. rm_rf(tmp);
  135. } else {
  136. if (unlink(tmp)) {
  137. fprintf(stderr, "Error removing %s: %s\n", tmp, strerror(errno));
  138. }
  139. }
  140. tor_free(tmp);
  141. } SMARTLIST_FOREACH_END(cp);
  142. SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));
  143. smartlist_free(elements);
  144. }
  145. if (rmdir(dir))
  146. fprintf(stderr, "Error removing directory %s: %s\n", dir, strerror(errno));
  147. }
  148. /** Remove all files stored under the temporary directory, and the directory
  149. * itself. Called by atexit(). */
  150. static void
  151. remove_directory(void)
  152. {
  153. if (getpid() != temp_dir_setup_in_pid) {
  154. /* Only clean out the tempdir when the main process is exiting. */
  155. return;
  156. }
  157. rm_rf(temp_dir);
  158. }
  159. /** Define this if unit tests spend too much time generating public keys*/
  160. #undef CACHE_GENERATED_KEYS
  161. static crypto_pk_t *pregen_keys[5] = {NULL, NULL, NULL, NULL, NULL};
  162. #define N_PREGEN_KEYS ((int)(sizeof(pregen_keys)/sizeof(pregen_keys[0])))
  163. /** Generate and return a new keypair for use in unit tests. If we're using
  164. * the key cache optimization, we might reuse keys: we only guarantee that
  165. * keys made with distinct values for <b>idx</b> are different. The value of
  166. * <b>idx</b> must be at least 0, and less than N_PREGEN_KEYS. */
  167. crypto_pk_t *
  168. pk_generate(int idx)
  169. {
  170. #ifdef CACHE_GENERATED_KEYS
  171. tor_assert(idx < N_PREGEN_KEYS);
  172. if (! pregen_keys[idx]) {
  173. pregen_keys[idx] = crypto_pk_new();
  174. tor_assert(!crypto_pk_generate_key(pregen_keys[idx]));
  175. }
  176. return crypto_pk_dup_key(pregen_keys[idx]);
  177. #else
  178. crypto_pk_t *result;
  179. (void) idx;
  180. result = crypto_pk_new();
  181. tor_assert(!crypto_pk_generate_key(result));
  182. return result;
  183. #endif
  184. }
  185. /** Free all storage used for the cached key optimization. */
  186. static void
  187. free_pregenerated_keys(void)
  188. {
  189. unsigned idx;
  190. for (idx = 0; idx < N_PREGEN_KEYS; ++idx) {
  191. if (pregen_keys[idx]) {
  192. crypto_pk_free(pregen_keys[idx]);
  193. pregen_keys[idx] = NULL;
  194. }
  195. }
  196. }
  197. /** Run unit tests for the onion handshake code. */
  198. static void
  199. test_onion_handshake(void)
  200. {
  201. /* client-side */
  202. crypto_dh_t *c_dh = NULL;
  203. char c_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  204. char c_keys[40];
  205. /* server-side */
  206. char s_buf[TAP_ONIONSKIN_REPLY_LEN];
  207. char s_keys[40];
  208. int i;
  209. /* shared */
  210. crypto_pk_t *pk = NULL, *pk2 = NULL;
  211. pk = pk_generate(0);
  212. pk2 = pk_generate(1);
  213. /* client handshake 1. */
  214. memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
  215. test_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
  216. for (i = 1; i <= 3; ++i) {
  217. crypto_pk_t *k1, *k2;
  218. if (i==1) {
  219. /* server handshake: only one key known. */
  220. k1 = pk; k2 = NULL;
  221. } else if (i==2) {
  222. /* server handshake: try the right key first. */
  223. k1 = pk; k2 = pk2;
  224. } else {
  225. /* server handshake: try the right key second. */
  226. k1 = pk2; k2 = pk;
  227. }
  228. memset(s_buf, 0, TAP_ONIONSKIN_REPLY_LEN);
  229. memset(s_keys, 0, 40);
  230. test_assert(! onion_skin_TAP_server_handshake(c_buf, k1, k2,
  231. s_buf, s_keys, 40));
  232. /* client handshake 2 */
  233. memset(c_keys, 0, 40);
  234. test_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
  235. test_memeq(c_keys, s_keys, 40);
  236. memset(s_buf, 0, 40);
  237. test_memneq(c_keys, s_buf, 40);
  238. }
  239. done:
  240. crypto_dh_free(c_dh);
  241. crypto_pk_free(pk);
  242. crypto_pk_free(pk2);
  243. }
  244. static void
  245. test_bad_onion_handshake(void *arg)
  246. {
  247. char junk_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  248. char junk_buf2[TAP_ONIONSKIN_CHALLENGE_LEN];
  249. /* client-side */
  250. crypto_dh_t *c_dh = NULL;
  251. char c_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  252. char c_keys[40];
  253. /* server-side */
  254. char s_buf[TAP_ONIONSKIN_REPLY_LEN];
  255. char s_keys[40];
  256. /* shared */
  257. crypto_pk_t *pk = NULL, *pk2 = NULL;
  258. (void)arg;
  259. pk = pk_generate(0);
  260. pk2 = pk_generate(1);
  261. /* Server: Case 1: the encrypted data is degenerate. */
  262. memset(junk_buf, 0, sizeof(junk_buf));
  263. crypto_pk_public_hybrid_encrypt(pk, junk_buf2, TAP_ONIONSKIN_CHALLENGE_LEN,
  264. junk_buf, DH_KEY_LEN, PK_PKCS1_OAEP_PADDING, 1);
  265. tt_int_op(-1, ==,
  266. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  267. s_buf, s_keys, 40));
  268. /* Server: Case 2: the encrypted data is not long enough. */
  269. memset(junk_buf, 0, sizeof(junk_buf));
  270. memset(junk_buf2, 0, sizeof(junk_buf2));
  271. crypto_pk_public_encrypt(pk, junk_buf2, sizeof(junk_buf2),
  272. junk_buf, 48, PK_PKCS1_OAEP_PADDING);
  273. tt_int_op(-1, ==,
  274. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  275. s_buf, s_keys, 40));
  276. /* client handshake 1: do it straight. */
  277. memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
  278. test_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
  279. /* Server: Case 3: we just don't have the right key. */
  280. tt_int_op(-1, ==,
  281. onion_skin_TAP_server_handshake(c_buf, pk2, NULL,
  282. s_buf, s_keys, 40));
  283. /* Server: Case 4: The RSA-encrypted portion is corrupt. */
  284. c_buf[64] ^= 33;
  285. tt_int_op(-1, ==,
  286. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  287. s_buf, s_keys, 40));
  288. c_buf[64] ^= 33;
  289. /* (Let the server procede) */
  290. tt_int_op(0, ==,
  291. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  292. s_buf, s_keys, 40));
  293. /* Client: Case 1: The server sent back junk. */
  294. s_buf[64] ^= 33;
  295. tt_int_op(-1, ==,
  296. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
  297. s_buf[64] ^= 33;
  298. /* Let the client finish; make sure it can. */
  299. tt_int_op(0, ==,
  300. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
  301. test_memeq(s_keys, c_keys, 40);
  302. /* Client: Case 2: The server sent back a degenerate DH. */
  303. memset(s_buf, 0, sizeof(s_buf));
  304. tt_int_op(-1, ==,
  305. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
  306. done:
  307. crypto_dh_free(c_dh);
  308. crypto_pk_free(pk);
  309. crypto_pk_free(pk2);
  310. }
  311. #ifdef CURVE25519_ENABLED
  312. static void
  313. test_ntor_handshake(void *arg)
  314. {
  315. /* client-side */
  316. ntor_handshake_state_t *c_state = NULL;
  317. uint8_t c_buf[NTOR_ONIONSKIN_LEN];
  318. uint8_t c_keys[400];
  319. /* server-side */
  320. di_digest256_map_t *s_keymap=NULL;
  321. curve25519_keypair_t s_keypair;
  322. uint8_t s_buf[NTOR_REPLY_LEN];
  323. uint8_t s_keys[400];
  324. /* shared */
  325. const curve25519_public_key_t *server_pubkey;
  326. uint8_t node_id[20] = "abcdefghijklmnopqrst";
  327. (void) arg;
  328. /* Make the server some keys */
  329. curve25519_secret_key_generate(&s_keypair.seckey, 0);
  330. curve25519_public_key_generate(&s_keypair.pubkey, &s_keypair.seckey);
  331. dimap_add_entry(&s_keymap, s_keypair.pubkey.public_key, &s_keypair);
  332. server_pubkey = &s_keypair.pubkey;
  333. /* client handshake 1. */
  334. memset(c_buf, 0, NTOR_ONIONSKIN_LEN);
  335. tt_int_op(0, ==, onion_skin_ntor_create(node_id, server_pubkey,
  336. &c_state, c_buf));
  337. /* server handshake */
  338. memset(s_buf, 0, NTOR_REPLY_LEN);
  339. memset(s_keys, 0, 40);
  340. tt_int_op(0, ==, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,
  341. node_id,
  342. s_buf, s_keys, 400));
  343. /* client handshake 2 */
  344. memset(c_keys, 0, 40);
  345. tt_int_op(0, ==, onion_skin_ntor_client_handshake(c_state, s_buf,
  346. c_keys, 400));
  347. test_memeq(c_keys, s_keys, 400);
  348. memset(s_buf, 0, 40);
  349. test_memneq(c_keys, s_buf, 40);
  350. done:
  351. ntor_handshake_state_free(c_state);
  352. dimap_free(s_keymap, NULL);
  353. }
  354. #endif
  355. /** Run unit tests for the onion queues. */
  356. static void
  357. test_onion_queues(void)
  358. {
  359. uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0};
  360. uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0};
  361. or_circuit_t *circ1 = or_circuit_new(0, NULL);
  362. or_circuit_t *circ2 = or_circuit_new(0, NULL);
  363. create_cell_t *onionskin = NULL;
  364. create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t));
  365. create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t));
  366. create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
  367. TAP_ONIONSKIN_CHALLENGE_LEN, buf1);
  368. create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR,
  369. NTOR_ONIONSKIN_LEN, buf2);
  370. test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  371. test_eq(0, onion_pending_add(circ1, create1));
  372. create1 = NULL;
  373. test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  374. test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  375. test_eq(0, onion_pending_add(circ2, create2));
  376. create2 = NULL;
  377. test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  378. test_eq_ptr(circ2, onion_next_task(&onionskin));
  379. test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  380. test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  381. clear_pending_onions();
  382. test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  383. test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  384. done:
  385. circuit_free(TO_CIRCUIT(circ1));
  386. circuit_free(TO_CIRCUIT(circ2));
  387. tor_free(create1);
  388. tor_free(create2);
  389. }
  390. static void
  391. test_circuit_timeout(void)
  392. {
  393. /* Plan:
  394. * 1. Generate 1000 samples
  395. * 2. Estimate parameters
  396. * 3. If difference, repeat
  397. * 4. Save state
  398. * 5. load state
  399. * 6. Estimate parameters
  400. * 7. compare differences
  401. */
  402. circuit_build_times_t initial;
  403. circuit_build_times_t estimate;
  404. circuit_build_times_t final;
  405. double timeout1, timeout2;
  406. or_state_t state;
  407. int i, runs;
  408. double close_ms;
  409. circuit_build_times_init(&initial);
  410. circuit_build_times_init(&estimate);
  411. circuit_build_times_init(&final);
  412. memset(&state, 0, sizeof(or_state_t));
  413. circuitbuild_running_unit_tests();
  414. #define timeout0 (build_time_t)(30*1000.0)
  415. initial.Xm = 3000;
  416. circuit_build_times_initial_alpha(&initial,
  417. CBT_DEFAULT_QUANTILE_CUTOFF/100.0,
  418. timeout0);
  419. close_ms = MAX(circuit_build_times_calculate_timeout(&initial,
  420. CBT_DEFAULT_CLOSE_QUANTILE/100.0),
  421. CBT_DEFAULT_TIMEOUT_INITIAL_VALUE);
  422. do {
  423. for (i=0; i < CBT_DEFAULT_MIN_CIRCUITS_TO_OBSERVE; i++) {
  424. build_time_t sample = circuit_build_times_generate_sample(&initial,0,1);
  425. if (sample > close_ms) {
  426. circuit_build_times_add_time(&estimate, CBT_BUILD_ABANDONED);
  427. } else {
  428. circuit_build_times_add_time(&estimate, sample);
  429. }
  430. }
  431. circuit_build_times_update_alpha(&estimate);
  432. timeout1 = circuit_build_times_calculate_timeout(&estimate,
  433. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  434. circuit_build_times_set_timeout(&estimate);
  435. log_notice(LD_CIRC, "Timeout1 is %f, Xm is %d", timeout1, estimate.Xm);
  436. /* 2% error */
  437. } while (fabs(circuit_build_times_cdf(&initial, timeout0) -
  438. circuit_build_times_cdf(&initial, timeout1)) > 0.02);
  439. test_assert(estimate.total_build_times <= CBT_NCIRCUITS_TO_OBSERVE);
  440. circuit_build_times_update_state(&estimate, &state);
  441. test_assert(circuit_build_times_parse_state(&final, &state) == 0);
  442. circuit_build_times_update_alpha(&final);
  443. timeout2 = circuit_build_times_calculate_timeout(&final,
  444. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  445. circuit_build_times_set_timeout(&final);
  446. log_notice(LD_CIRC, "Timeout2 is %f, Xm is %d", timeout2, final.Xm);
  447. /* 5% here because some accuracy is lost due to histogram conversion */
  448. test_assert(fabs(circuit_build_times_cdf(&initial, timeout0) -
  449. circuit_build_times_cdf(&initial, timeout2)) < 0.05);
  450. for (runs = 0; runs < 50; runs++) {
  451. int build_times_idx = 0;
  452. int total_build_times = 0;
  453. final.close_ms = final.timeout_ms = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  454. estimate.close_ms = estimate.timeout_ms
  455. = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  456. for (i = 0; i < CBT_DEFAULT_RECENT_CIRCUITS*2; i++) {
  457. circuit_build_times_network_circ_success(&estimate);
  458. circuit_build_times_add_time(&estimate,
  459. circuit_build_times_generate_sample(&estimate, 0,
  460. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  461. circuit_build_times_network_circ_success(&estimate);
  462. circuit_build_times_add_time(&final,
  463. circuit_build_times_generate_sample(&final, 0,
  464. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  465. }
  466. test_assert(!circuit_build_times_network_check_changed(&estimate));
  467. test_assert(!circuit_build_times_network_check_changed(&final));
  468. /* Reset liveness to be non-live */
  469. final.liveness.network_last_live = 0;
  470. estimate.liveness.network_last_live = 0;
  471. build_times_idx = estimate.build_times_idx;
  472. total_build_times = estimate.total_build_times;
  473. test_assert(circuit_build_times_network_check_live(&estimate));
  474. test_assert(circuit_build_times_network_check_live(&final));
  475. circuit_build_times_count_close(&estimate, 0,
  476. (time_t)(approx_time()-estimate.close_ms/1000.0-1));
  477. circuit_build_times_count_close(&final, 0,
  478. (time_t)(approx_time()-final.close_ms/1000.0-1));
  479. test_assert(!circuit_build_times_network_check_live(&estimate));
  480. test_assert(!circuit_build_times_network_check_live(&final));
  481. log_info(LD_CIRC, "idx: %d %d, tot: %d %d",
  482. build_times_idx, estimate.build_times_idx,
  483. total_build_times, estimate.total_build_times);
  484. /* Check rollback index. Should match top of loop. */
  485. test_assert(build_times_idx == estimate.build_times_idx);
  486. // This can fail if estimate.total_build_times == 1000, because
  487. // in that case, rewind actually causes us to lose timeouts
  488. if (total_build_times != CBT_NCIRCUITS_TO_OBSERVE)
  489. test_assert(total_build_times == estimate.total_build_times);
  490. /* Now simulate that the network has become live and we need
  491. * a change */
  492. circuit_build_times_network_is_live(&estimate);
  493. circuit_build_times_network_is_live(&final);
  494. for (i = 0; i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT; i++) {
  495. circuit_build_times_count_timeout(&estimate, 1);
  496. if (i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1) {
  497. circuit_build_times_count_timeout(&final, 1);
  498. }
  499. }
  500. test_assert(estimate.liveness.after_firsthop_idx == 0);
  501. test_assert(final.liveness.after_firsthop_idx ==
  502. CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1);
  503. test_assert(circuit_build_times_network_check_live(&estimate));
  504. test_assert(circuit_build_times_network_check_live(&final));
  505. circuit_build_times_count_timeout(&final, 1);
  506. }
  507. done:
  508. return;
  509. }
  510. /* Helper: assert that short_policy parses and writes back out as itself,
  511. or as <b>expected</b> if that's provided. */
  512. static void
  513. test_short_policy_parse(const char *input,
  514. const char *expected)
  515. {
  516. short_policy_t *short_policy = NULL;
  517. char *out = NULL;
  518. if (expected == NULL)
  519. expected = input;
  520. short_policy = parse_short_policy(input);
  521. tt_assert(short_policy);
  522. out = write_short_policy(short_policy);
  523. tt_str_op(out, ==, expected);
  524. done:
  525. tor_free(out);
  526. short_policy_free(short_policy);
  527. }
  528. /** Helper: Parse the exit policy string in <b>policy_str</b>, and make sure
  529. * that policies_summarize() produces the string <b>expected_summary</b> from
  530. * it. */
  531. static void
  532. test_policy_summary_helper(const char *policy_str,
  533. const char *expected_summary)
  534. {
  535. config_line_t line;
  536. smartlist_t *policy = smartlist_new();
  537. char *summary = NULL;
  538. char *summary_after = NULL;
  539. int r;
  540. short_policy_t *short_policy = NULL;
  541. line.key = (char*)"foo";
  542. line.value = (char *)policy_str;
  543. line.next = NULL;
  544. r = policies_parse_exit_policy(&line, &policy, 1, 0, 0, 1);
  545. test_eq(r, 0);
  546. summary = policy_summarize(policy, AF_INET);
  547. test_assert(summary != NULL);
  548. test_streq(summary, expected_summary);
  549. short_policy = parse_short_policy(summary);
  550. tt_assert(short_policy);
  551. summary_after = write_short_policy(short_policy);
  552. test_streq(summary, summary_after);
  553. done:
  554. tor_free(summary_after);
  555. tor_free(summary);
  556. if (policy)
  557. addr_policy_list_free(policy);
  558. short_policy_free(short_policy);
  559. }
  560. /** Run unit tests for generating summary lines of exit policies */
  561. static void
  562. test_policies(void)
  563. {
  564. int i;
  565. smartlist_t *policy = NULL, *policy2 = NULL, *policy3 = NULL,
  566. *policy4 = NULL, *policy5 = NULL, *policy6 = NULL,
  567. *policy7 = NULL;
  568. addr_policy_t *p;
  569. tor_addr_t tar;
  570. config_line_t line;
  571. smartlist_t *sm = NULL;
  572. char *policy_str = NULL;
  573. short_policy_t *short_parsed = NULL;
  574. policy = smartlist_new();
  575. p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1);
  576. test_assert(p != NULL);
  577. test_eq(ADDR_POLICY_REJECT, p->policy_type);
  578. tor_addr_from_ipv4h(&tar, 0xc0a80000u);
  579. test_eq(0, tor_addr_compare(&p->addr, &tar, CMP_EXACT));
  580. test_eq(16, p->maskbits);
  581. test_eq(1, p->prt_min);
  582. test_eq(65535, p->prt_max);
  583. smartlist_add(policy, p);
  584. tor_addr_from_ipv4h(&tar, 0x01020304u);
  585. test_assert(ADDR_POLICY_ACCEPTED ==
  586. compare_tor_addr_to_addr_policy(&tar, 2, policy));
  587. tor_addr_make_unspec(&tar);
  588. test_assert(ADDR_POLICY_PROBABLY_ACCEPTED ==
  589. compare_tor_addr_to_addr_policy(&tar, 2, policy));
  590. tor_addr_from_ipv4h(&tar, 0xc0a80102);
  591. test_assert(ADDR_POLICY_REJECTED ==
  592. compare_tor_addr_to_addr_policy(&tar, 2, policy));
  593. test_assert(0 == policies_parse_exit_policy(NULL, &policy2, 1, 1, 0, 1));
  594. test_assert(policy2);
  595. policy3 = smartlist_new();
  596. p = router_parse_addr_policy_item_from_string("reject *:*",-1);
  597. test_assert(p != NULL);
  598. smartlist_add(policy3, p);
  599. p = router_parse_addr_policy_item_from_string("accept *:*",-1);
  600. test_assert(p != NULL);
  601. smartlist_add(policy3, p);
  602. policy4 = smartlist_new();
  603. p = router_parse_addr_policy_item_from_string("accept *:443",-1);
  604. test_assert(p != NULL);
  605. smartlist_add(policy4, p);
  606. p = router_parse_addr_policy_item_from_string("accept *:443",-1);
  607. test_assert(p != NULL);
  608. smartlist_add(policy4, p);
  609. policy5 = smartlist_new();
  610. p = router_parse_addr_policy_item_from_string("reject 0.0.0.0/8:*",-1);
  611. test_assert(p != NULL);
  612. smartlist_add(policy5, p);
  613. p = router_parse_addr_policy_item_from_string("reject 169.254.0.0/16:*",-1);
  614. test_assert(p != NULL);
  615. smartlist_add(policy5, p);
  616. p = router_parse_addr_policy_item_from_string("reject 127.0.0.0/8:*",-1);
  617. test_assert(p != NULL);
  618. smartlist_add(policy5, p);
  619. p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1);
  620. test_assert(p != NULL);
  621. smartlist_add(policy5, p);
  622. p = router_parse_addr_policy_item_from_string("reject 10.0.0.0/8:*",-1);
  623. test_assert(p != NULL);
  624. smartlist_add(policy5, p);
  625. p = router_parse_addr_policy_item_from_string("reject 172.16.0.0/12:*",-1);
  626. test_assert(p != NULL);
  627. smartlist_add(policy5, p);
  628. p = router_parse_addr_policy_item_from_string("reject 80.190.250.90:*",-1);
  629. test_assert(p != NULL);
  630. smartlist_add(policy5, p);
  631. p = router_parse_addr_policy_item_from_string("reject *:1-65534",-1);
  632. test_assert(p != NULL);
  633. smartlist_add(policy5, p);
  634. p = router_parse_addr_policy_item_from_string("reject *:65535",-1);
  635. test_assert(p != NULL);
  636. smartlist_add(policy5, p);
  637. p = router_parse_addr_policy_item_from_string("accept *:1-65535",-1);
  638. test_assert(p != NULL);
  639. smartlist_add(policy5, p);
  640. policy6 = smartlist_new();
  641. p = router_parse_addr_policy_item_from_string("accept 43.3.0.0/9:*",-1);
  642. test_assert(p != NULL);
  643. smartlist_add(policy6, p);
  644. policy7 = smartlist_new();
  645. p = router_parse_addr_policy_item_from_string("accept 0.0.0.0/8:*",-1);
  646. test_assert(p != NULL);
  647. smartlist_add(policy7, p);
  648. test_assert(!exit_policy_is_general_exit(policy));
  649. test_assert(exit_policy_is_general_exit(policy2));
  650. test_assert(!exit_policy_is_general_exit(NULL));
  651. test_assert(!exit_policy_is_general_exit(policy3));
  652. test_assert(!exit_policy_is_general_exit(policy4));
  653. test_assert(!exit_policy_is_general_exit(policy5));
  654. test_assert(!exit_policy_is_general_exit(policy6));
  655. test_assert(!exit_policy_is_general_exit(policy7));
  656. test_assert(cmp_addr_policies(policy, policy2));
  657. test_assert(cmp_addr_policies(policy, NULL));
  658. test_assert(!cmp_addr_policies(policy2, policy2));
  659. test_assert(!cmp_addr_policies(NULL, NULL));
  660. test_assert(!policy_is_reject_star(policy2, AF_INET));
  661. test_assert(policy_is_reject_star(policy, AF_INET));
  662. test_assert(policy_is_reject_star(NULL, AF_INET));
  663. addr_policy_list_free(policy);
  664. policy = NULL;
  665. /* make sure compacting logic works. */
  666. policy = NULL;
  667. line.key = (char*)"foo";
  668. line.value = (char*)"accept *:80,reject private:*,reject *:*";
  669. line.next = NULL;
  670. test_assert(0 == policies_parse_exit_policy(&line, &policy, 1, 0, 0, 1));
  671. test_assert(policy);
  672. //test_streq(policy->string, "accept *:80");
  673. //test_streq(policy->next->string, "reject *:*");
  674. test_eq(smartlist_len(policy), 4);
  675. /* test policy summaries */
  676. /* check if we properly ignore private IP addresses */
  677. test_policy_summary_helper("reject 192.168.0.0/16:*,"
  678. "reject 0.0.0.0/8:*,"
  679. "reject 10.0.0.0/8:*,"
  680. "accept *:10-30,"
  681. "accept *:90,"
  682. "reject *:*",
  683. "accept 10-30,90");
  684. /* check all accept policies, and proper counting of rejects */
  685. test_policy_summary_helper("reject 11.0.0.0/9:80,"
  686. "reject 12.0.0.0/9:80,"
  687. "reject 13.0.0.0/9:80,"
  688. "reject 14.0.0.0/9:80,"
  689. "accept *:*", "accept 1-65535");
  690. test_policy_summary_helper("reject 11.0.0.0/9:80,"
  691. "reject 12.0.0.0/9:80,"
  692. "reject 13.0.0.0/9:80,"
  693. "reject 14.0.0.0/9:80,"
  694. "reject 15.0.0.0:81,"
  695. "accept *:*", "accept 1-65535");
  696. test_policy_summary_helper("reject 11.0.0.0/9:80,"
  697. "reject 12.0.0.0/9:80,"
  698. "reject 13.0.0.0/9:80,"
  699. "reject 14.0.0.0/9:80,"
  700. "reject 15.0.0.0:80,"
  701. "accept *:*",
  702. "reject 80");
  703. /* no exits */
  704. test_policy_summary_helper("accept 11.0.0.0/9:80,"
  705. "reject *:*",
  706. "reject 1-65535");
  707. /* port merging */
  708. test_policy_summary_helper("accept *:80,"
  709. "accept *:81,"
  710. "accept *:100-110,"
  711. "accept *:111,"
  712. "reject *:*",
  713. "accept 80-81,100-111");
  714. /* border ports */
  715. test_policy_summary_helper("accept *:1,"
  716. "accept *:3,"
  717. "accept *:65535,"
  718. "reject *:*",
  719. "accept 1,3,65535");
  720. /* holes */
  721. test_policy_summary_helper("accept *:1,"
  722. "accept *:3,"
  723. "accept *:5,"
  724. "accept *:7,"
  725. "reject *:*",
  726. "accept 1,3,5,7");
  727. test_policy_summary_helper("reject *:1,"
  728. "reject *:3,"
  729. "reject *:5,"
  730. "reject *:7,"
  731. "accept *:*",
  732. "reject 1,3,5,7");
  733. /* Short policies with unrecognized formats should get accepted. */
  734. test_short_policy_parse("accept fred,2,3-5", "accept 2,3-5");
  735. test_short_policy_parse("accept 2,fred,3", "accept 2,3");
  736. test_short_policy_parse("accept 2,fred,3,bob", "accept 2,3");
  737. test_short_policy_parse("accept 2,-3,500-600", "accept 2,500-600");
  738. /* Short policies with nil entries are accepted too. */
  739. test_short_policy_parse("accept 1,,3", "accept 1,3");
  740. test_short_policy_parse("accept 100-200,,", "accept 100-200");
  741. test_short_policy_parse("reject ,1-10,,,,30-40", "reject 1-10,30-40");
  742. /* Try parsing various broken short policies */
  743. #define TT_BAD_SHORT_POLICY(s) \
  744. do { \
  745. tt_ptr_op(NULL, ==, (short_parsed = parse_short_policy((s)))); \
  746. } while (0)
  747. TT_BAD_SHORT_POLICY("accept 200-199");
  748. TT_BAD_SHORT_POLICY("");
  749. TT_BAD_SHORT_POLICY("rejekt 1,2,3");
  750. TT_BAD_SHORT_POLICY("reject ");
  751. TT_BAD_SHORT_POLICY("reject");
  752. TT_BAD_SHORT_POLICY("rej");
  753. TT_BAD_SHORT_POLICY("accept 2,3,100000");
  754. TT_BAD_SHORT_POLICY("accept 2,3x,4");
  755. TT_BAD_SHORT_POLICY("accept 2,3x,4");
  756. TT_BAD_SHORT_POLICY("accept 2-");
  757. TT_BAD_SHORT_POLICY("accept 2-x");
  758. TT_BAD_SHORT_POLICY("accept 1-,3");
  759. TT_BAD_SHORT_POLICY("accept 1-,3");
  760. /* Test a too-long policy. */
  761. {
  762. int i;
  763. char *policy = NULL;
  764. smartlist_t *chunks = smartlist_new();
  765. smartlist_add(chunks, tor_strdup("accept "));
  766. for (i=1; i<10000; ++i)
  767. smartlist_add_asprintf(chunks, "%d,", i);
  768. smartlist_add(chunks, tor_strdup("20000"));
  769. policy = smartlist_join_strings(chunks, "", 0, NULL);
  770. SMARTLIST_FOREACH(chunks, char *, ch, tor_free(ch));
  771. smartlist_free(chunks);
  772. short_parsed = parse_short_policy(policy);/* shouldn't be accepted */
  773. tor_free(policy);
  774. tt_ptr_op(NULL, ==, short_parsed);
  775. }
  776. /* truncation ports */
  777. sm = smartlist_new();
  778. for (i=1; i<2000; i+=2) {
  779. char buf[POLICY_BUF_LEN];
  780. tor_snprintf(buf, sizeof(buf), "reject *:%d", i);
  781. smartlist_add(sm, tor_strdup(buf));
  782. }
  783. smartlist_add(sm, tor_strdup("accept *:*"));
  784. policy_str = smartlist_join_strings(sm, ",", 0, NULL);
  785. test_policy_summary_helper( policy_str,
  786. "accept 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,"
  787. "46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,"
  788. "92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,"
  789. "130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,"
  790. "166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,"
  791. "202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,"
  792. "238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,"
  793. "274,276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,"
  794. "310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,340,342,344,"
  795. "346,348,350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,"
  796. "382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,412,414,416,"
  797. "418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,448,450,452,"
  798. "454,456,458,460,462,464,466,468,470,472,474,476,478,480,482,484,486,488,"
  799. "490,492,494,496,498,500,502,504,506,508,510,512,514,516,518,520,522");
  800. done:
  801. addr_policy_list_free(policy);
  802. addr_policy_list_free(policy2);
  803. addr_policy_list_free(policy3);
  804. addr_policy_list_free(policy4);
  805. addr_policy_list_free(policy5);
  806. addr_policy_list_free(policy6);
  807. addr_policy_list_free(policy7);
  808. tor_free(policy_str);
  809. if (sm) {
  810. SMARTLIST_FOREACH(sm, char *, s, tor_free(s));
  811. smartlist_free(sm);
  812. }
  813. short_policy_free(short_parsed);
  814. }
  815. /** Test encoding and parsing of rendezvous service descriptors. */
  816. static void
  817. test_rend_fns(void)
  818. {
  819. rend_service_descriptor_t *generated = NULL, *parsed = NULL;
  820. char service_id[DIGEST_LEN];
  821. char service_id_base32[REND_SERVICE_ID_LEN_BASE32+1];
  822. const char *next_desc;
  823. smartlist_t *descs = smartlist_new();
  824. char computed_desc_id[DIGEST_LEN];
  825. char parsed_desc_id[DIGEST_LEN];
  826. crypto_pk_t *pk1 = NULL, *pk2 = NULL;
  827. time_t now;
  828. char *intro_points_encrypted = NULL;
  829. size_t intro_points_size;
  830. size_t encoded_size;
  831. int i;
  832. char address1[] = "fooaddress.onion";
  833. char address2[] = "aaaaaaaaaaaaaaaa.onion";
  834. char address3[] = "fooaddress.exit";
  835. char address4[] = "www.torproject.org";
  836. char address5[] = "foo.abcdefghijklmnop.onion";
  837. char address6[] = "foo.bar.abcdefghijklmnop.onion";
  838. char address7[] = ".abcdefghijklmnop.onion";
  839. test_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
  840. test_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
  841. test_streq(address2, "aaaaaaaaaaaaaaaa");
  842. test_assert(EXIT_HOSTNAME == parse_extended_hostname(address3));
  843. test_assert(NORMAL_HOSTNAME == parse_extended_hostname(address4));
  844. test_assert(ONION_HOSTNAME == parse_extended_hostname(address5));
  845. test_streq(address5, "abcdefghijklmnop");
  846. test_assert(ONION_HOSTNAME == parse_extended_hostname(address6));
  847. test_streq(address6, "abcdefghijklmnop");
  848. test_assert(BAD_HOSTNAME == parse_extended_hostname(address7));
  849. pk1 = pk_generate(0);
  850. pk2 = pk_generate(1);
  851. generated = tor_malloc_zero(sizeof(rend_service_descriptor_t));
  852. generated->pk = crypto_pk_dup_key(pk1);
  853. crypto_pk_get_digest(generated->pk, service_id);
  854. base32_encode(service_id_base32, REND_SERVICE_ID_LEN_BASE32+1,
  855. service_id, REND_SERVICE_ID_LEN);
  856. now = time(NULL);
  857. generated->timestamp = now;
  858. generated->version = 2;
  859. generated->protocols = 42;
  860. generated->intro_nodes = smartlist_new();
  861. for (i = 0; i < 3; i++) {
  862. rend_intro_point_t *intro = tor_malloc_zero(sizeof(rend_intro_point_t));
  863. crypto_pk_t *okey = pk_generate(2 + i);
  864. intro->extend_info = tor_malloc_zero(sizeof(extend_info_t));
  865. intro->extend_info->onion_key = okey;
  866. crypto_pk_get_digest(intro->extend_info->onion_key,
  867. intro->extend_info->identity_digest);
  868. //crypto_rand(info->identity_digest, DIGEST_LEN); /* Would this work? */
  869. intro->extend_info->nickname[0] = '$';
  870. base16_encode(intro->extend_info->nickname + 1,
  871. sizeof(intro->extend_info->nickname) - 1,
  872. intro->extend_info->identity_digest, DIGEST_LEN);
  873. /* Does not cover all IP addresses. */
  874. tor_addr_from_ipv4h(&intro->extend_info->addr, crypto_rand_int(65536));
  875. intro->extend_info->port = 1 + crypto_rand_int(65535);
  876. intro->intro_key = crypto_pk_dup_key(pk2);
  877. smartlist_add(generated->intro_nodes, intro);
  878. }
  879. test_assert(rend_encode_v2_descriptors(descs, generated, now, 0,
  880. REND_NO_AUTH, NULL, NULL) > 0);
  881. test_assert(rend_compute_v2_desc_id(computed_desc_id, service_id_base32,
  882. NULL, now, 0) == 0);
  883. test_memeq(((rend_encoded_v2_service_descriptor_t *)
  884. smartlist_get(descs, 0))->desc_id, computed_desc_id, DIGEST_LEN);
  885. test_assert(rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
  886. &intro_points_encrypted,
  887. &intro_points_size,
  888. &encoded_size,
  889. &next_desc,
  890. ((rend_encoded_v2_service_descriptor_t *)
  891. smartlist_get(descs, 0))->desc_str) == 0);
  892. test_assert(parsed);
  893. test_memeq(((rend_encoded_v2_service_descriptor_t *)
  894. smartlist_get(descs, 0))->desc_id, parsed_desc_id, DIGEST_LEN);
  895. test_eq(rend_parse_introduction_points(parsed, intro_points_encrypted,
  896. intro_points_size), 3);
  897. test_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk));
  898. test_eq(parsed->timestamp, now);
  899. test_eq(parsed->version, 2);
  900. test_eq(parsed->protocols, 42);
  901. test_eq(smartlist_len(parsed->intro_nodes), 3);
  902. for (i = 0; i < smartlist_len(parsed->intro_nodes); i++) {
  903. rend_intro_point_t *par_intro = smartlist_get(parsed->intro_nodes, i),
  904. *gen_intro = smartlist_get(generated->intro_nodes, i);
  905. extend_info_t *par_info = par_intro->extend_info;
  906. extend_info_t *gen_info = gen_intro->extend_info;
  907. test_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key));
  908. test_memeq(gen_info->identity_digest, par_info->identity_digest,
  909. DIGEST_LEN);
  910. test_streq(gen_info->nickname, par_info->nickname);
  911. test_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
  912. test_eq(gen_info->port, par_info->port);
  913. }
  914. rend_service_descriptor_free(parsed);
  915. rend_service_descriptor_free(generated);
  916. parsed = generated = NULL;
  917. done:
  918. if (descs) {
  919. for (i = 0; i < smartlist_len(descs); i++)
  920. rend_encoded_v2_service_descriptor_free(smartlist_get(descs, i));
  921. smartlist_free(descs);
  922. }
  923. if (parsed)
  924. rend_service_descriptor_free(parsed);
  925. if (generated)
  926. rend_service_descriptor_free(generated);
  927. if (pk1)
  928. crypto_pk_free(pk1);
  929. if (pk2)
  930. crypto_pk_free(pk2);
  931. tor_free(intro_points_encrypted);
  932. }
  933. /* Record odd numbered fake-IPs using ipv6, even numbered fake-IPs
  934. * using ipv4. Since our fake geoip database is the same between
  935. * ipv4 and ipv6, we should get the same result no matter which
  936. * address family we pick for each IP. */
  937. #define SET_TEST_ADDRESS(i) do { \
  938. if ((i) & 1) { \
  939. SET_TEST_IPV6(i); \
  940. tor_addr_from_in6(&addr, &in6); \
  941. } else { \
  942. tor_addr_from_ipv4h(&addr, (uint32_t) i); \
  943. } \
  944. } while (0)
  945. /* Make sure that country ID actually works. */
  946. #define SET_TEST_IPV6(i) \
  947. do { \
  948. set_uint32(in6.s6_addr + 12, htonl((uint32_t) (i))); \
  949. } while (0)
  950. #define CHECK_COUNTRY(country, val) do { \
  951. /* test ipv4 country lookup */ \
  952. test_streq(country, \
  953. geoip_get_country_name(geoip_get_country_by_ipv4(val))); \
  954. /* test ipv6 country lookup */ \
  955. SET_TEST_IPV6(val); \
  956. test_streq(country, \
  957. geoip_get_country_name(geoip_get_country_by_ipv6(&in6))); \
  958. } while (0)
  959. /** Run unit tests for GeoIP code. */
  960. static void
  961. test_geoip(void)
  962. {
  963. int i, j;
  964. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  965. char *s = NULL, *v = NULL;
  966. const char *bridge_stats_1 =
  967. "bridge-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  968. "bridge-ips zz=24,xy=8\n"
  969. "bridge-ip-versions v4=16,v6=16\n"
  970. "bridge-ip-transports <OR>=24\n",
  971. *dirreq_stats_1 =
  972. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  973. "dirreq-v3-ips ab=8\n"
  974. "dirreq-v3-reqs ab=8\n"
  975. "dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,"
  976. "not-modified=0,busy=0\n"
  977. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  978. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  979. *dirreq_stats_2 =
  980. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  981. "dirreq-v3-ips \n"
  982. "dirreq-v3-reqs \n"
  983. "dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,"
  984. "not-modified=0,busy=0\n"
  985. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  986. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  987. *dirreq_stats_3 =
  988. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  989. "dirreq-v3-ips \n"
  990. "dirreq-v3-reqs \n"
  991. "dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,"
  992. "not-modified=0,busy=0\n"
  993. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  994. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  995. *dirreq_stats_4 =
  996. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  997. "dirreq-v3-ips \n"
  998. "dirreq-v3-reqs \n"
  999. "dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,"
  1000. "not-modified=0,busy=0\n"
  1001. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  1002. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=4\n",
  1003. *entry_stats_1 =
  1004. "entry-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1005. "entry-ips ab=8\n",
  1006. *entry_stats_2 =
  1007. "entry-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1008. "entry-ips \n";
  1009. tor_addr_t addr;
  1010. struct in6_addr in6;
  1011. /* Populate the DB a bit. Add these in order, since we can't do the final
  1012. * 'sort' step. These aren't very good IP addresses, but they're perfectly
  1013. * fine uint32_t values. */
  1014. test_eq(0, geoip_parse_entry("10,50,AB", AF_INET));
  1015. test_eq(0, geoip_parse_entry("52,90,XY", AF_INET));
  1016. test_eq(0, geoip_parse_entry("95,100,AB", AF_INET));
  1017. test_eq(0, geoip_parse_entry("\"105\",\"140\",\"ZZ\"", AF_INET));
  1018. test_eq(0, geoip_parse_entry("\"150\",\"190\",\"XY\"", AF_INET));
  1019. test_eq(0, geoip_parse_entry("\"200\",\"250\",\"AB\"", AF_INET));
  1020. /* Populate the IPv6 DB equivalently with fake IPs in the same range */
  1021. test_eq(0, geoip_parse_entry("::a,::32,AB", AF_INET6));
  1022. test_eq(0, geoip_parse_entry("::34,::5a,XY", AF_INET6));
  1023. test_eq(0, geoip_parse_entry("::5f,::64,AB", AF_INET6));
  1024. test_eq(0, geoip_parse_entry("::69,::8c,ZZ", AF_INET6));
  1025. test_eq(0, geoip_parse_entry("::96,::be,XY", AF_INET6));
  1026. test_eq(0, geoip_parse_entry("::c8,::fa,AB", AF_INET6));
  1027. /* We should have 4 countries: ??, ab, xy, zz. */
  1028. test_eq(4, geoip_get_n_countries());
  1029. memset(&in6, 0, sizeof(in6));
  1030. CHECK_COUNTRY("??", 3);
  1031. CHECK_COUNTRY("ab", 32);
  1032. CHECK_COUNTRY("??", 5);
  1033. CHECK_COUNTRY("??", 51);
  1034. CHECK_COUNTRY("xy", 150);
  1035. CHECK_COUNTRY("xy", 190);
  1036. CHECK_COUNTRY("??", 2000);
  1037. test_eq(0, geoip_get_country_by_ipv4(3));
  1038. SET_TEST_IPV6(3);
  1039. test_eq(0, geoip_get_country_by_ipv6(&in6));
  1040. get_options_mutable()->BridgeRelay = 1;
  1041. get_options_mutable()->BridgeRecordUsageByCountry = 1;
  1042. /* Put 9 observations in AB... */
  1043. for (i=32; i < 40; ++i) {
  1044. SET_TEST_ADDRESS(i);
  1045. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  1046. }
  1047. SET_TEST_ADDRESS(225);
  1048. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  1049. /* and 3 observations in XY, several times. */
  1050. for (j=0; j < 10; ++j)
  1051. for (i=52; i < 55; ++i) {
  1052. SET_TEST_ADDRESS(i);
  1053. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-3600);
  1054. }
  1055. /* and 17 observations in ZZ... */
  1056. for (i=110; i < 127; ++i) {
  1057. SET_TEST_ADDRESS(i);
  1058. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  1059. }
  1060. geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
  1061. test_assert(s);
  1062. test_assert(v);
  1063. test_streq("zz=24,ab=16,xy=8", s);
  1064. test_streq("v4=16,v6=16", v);
  1065. tor_free(s);
  1066. tor_free(v);
  1067. /* Now clear out all the AB observations. */
  1068. geoip_remove_old_clients(now-6000);
  1069. geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
  1070. test_assert(s);
  1071. test_assert(v);
  1072. test_streq("zz=24,xy=8", s);
  1073. test_streq("v4=16,v6=16", v);
  1074. tor_free(s);
  1075. tor_free(v);
  1076. /* Start testing bridge statistics by making sure that we don't output
  1077. * bridge stats without initializing them. */
  1078. s = geoip_format_bridge_stats(now + 86400);
  1079. test_assert(!s);
  1080. /* Initialize stats and generate the bridge-stats history string out of
  1081. * the connecting clients added above. */
  1082. geoip_bridge_stats_init(now);
  1083. s = geoip_format_bridge_stats(now + 86400);
  1084. test_assert(s);
  1085. test_streq(bridge_stats_1, s);
  1086. tor_free(s);
  1087. /* Stop collecting bridge stats and make sure we don't write a history
  1088. * string anymore. */
  1089. geoip_bridge_stats_term();
  1090. s = geoip_format_bridge_stats(now + 86400);
  1091. test_assert(!s);
  1092. /* Stop being a bridge and start being a directory mirror that gathers
  1093. * directory request statistics. */
  1094. geoip_bridge_stats_term();
  1095. get_options_mutable()->BridgeRelay = 0;
  1096. get_options_mutable()->BridgeRecordUsageByCountry = 0;
  1097. get_options_mutable()->DirReqStatistics = 1;
  1098. /* Start testing dirreq statistics by making sure that we don't collect
  1099. * dirreq stats without initializing them. */
  1100. SET_TEST_ADDRESS(100);
  1101. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  1102. s = geoip_format_dirreq_stats(now + 86400);
  1103. test_assert(!s);
  1104. /* Initialize stats, note one connecting client, and generate the
  1105. * dirreq-stats history string. */
  1106. geoip_dirreq_stats_init(now);
  1107. SET_TEST_ADDRESS(100);
  1108. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  1109. s = geoip_format_dirreq_stats(now + 86400);
  1110. test_streq(dirreq_stats_1, s);
  1111. tor_free(s);
  1112. /* Stop collecting stats, add another connecting client, and ensure we
  1113. * don't generate a history string. */
  1114. geoip_dirreq_stats_term();
  1115. SET_TEST_ADDRESS(101);
  1116. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  1117. s = geoip_format_dirreq_stats(now + 86400);
  1118. test_assert(!s);
  1119. /* Re-start stats, add a connecting client, reset stats, and make sure
  1120. * that we get an all empty history string. */
  1121. geoip_dirreq_stats_init(now);
  1122. SET_TEST_ADDRESS(100);
  1123. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  1124. geoip_reset_dirreq_stats(now);
  1125. s = geoip_format_dirreq_stats(now + 86400);
  1126. test_streq(dirreq_stats_2, s);
  1127. tor_free(s);
  1128. /* Note a successful network status response and make sure that it
  1129. * appears in the history string. */
  1130. geoip_note_ns_response(GEOIP_SUCCESS);
  1131. s = geoip_format_dirreq_stats(now + 86400);
  1132. test_streq(dirreq_stats_3, s);
  1133. tor_free(s);
  1134. /* Start a tunneled directory request. */
  1135. geoip_start_dirreq((uint64_t) 1, 1024, DIRREQ_TUNNELED);
  1136. s = geoip_format_dirreq_stats(now + 86400);
  1137. test_streq(dirreq_stats_4, s);
  1138. /* Stop collecting directory request statistics and start gathering
  1139. * entry stats. */
  1140. geoip_dirreq_stats_term();
  1141. get_options_mutable()->DirReqStatistics = 0;
  1142. get_options_mutable()->EntryStatistics = 1;
  1143. /* Start testing entry statistics by making sure that we don't collect
  1144. * anything without initializing entry stats. */
  1145. SET_TEST_ADDRESS(100);
  1146. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  1147. s = geoip_format_entry_stats(now + 86400);
  1148. test_assert(!s);
  1149. /* Initialize stats, note one connecting client, and generate the
  1150. * entry-stats history string. */
  1151. geoip_entry_stats_init(now);
  1152. SET_TEST_ADDRESS(100);
  1153. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  1154. s = geoip_format_entry_stats(now + 86400);
  1155. test_streq(entry_stats_1, s);
  1156. tor_free(s);
  1157. /* Stop collecting stats, add another connecting client, and ensure we
  1158. * don't generate a history string. */
  1159. geoip_entry_stats_term();
  1160. SET_TEST_ADDRESS(101);
  1161. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  1162. s = geoip_format_entry_stats(now + 86400);
  1163. test_assert(!s);
  1164. /* Re-start stats, add a connecting client, reset stats, and make sure
  1165. * that we get an all empty history string. */
  1166. geoip_entry_stats_init(now);
  1167. SET_TEST_ADDRESS(100);
  1168. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  1169. geoip_reset_entry_stats(now);
  1170. s = geoip_format_entry_stats(now + 86400);
  1171. test_streq(entry_stats_2, s);
  1172. tor_free(s);
  1173. /* Stop collecting entry statistics. */
  1174. geoip_entry_stats_term();
  1175. get_options_mutable()->EntryStatistics = 0;
  1176. done:
  1177. tor_free(s);
  1178. tor_free(v);
  1179. }
  1180. static void
  1181. test_geoip_with_pt(void)
  1182. {
  1183. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  1184. char *s = NULL;
  1185. int i;
  1186. tor_addr_t addr;
  1187. struct in6_addr in6;
  1188. get_options_mutable()->BridgeRelay = 1;
  1189. get_options_mutable()->BridgeRecordUsageByCountry = 1;
  1190. /* No clients seen yet. */
  1191. s = geoip_get_transport_history();
  1192. tor_assert(!s);
  1193. /* 4 connections without a pluggable transport */
  1194. for (i=0; i < 4; ++i) {
  1195. SET_TEST_ADDRESS(i);
  1196. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  1197. }
  1198. /* 9 connections with "alpha" */
  1199. for (i=4; i < 13; ++i) {
  1200. SET_TEST_ADDRESS(i);
  1201. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "alpha", now-7200);
  1202. }
  1203. /* one connection with "beta" */
  1204. SET_TEST_ADDRESS(13);
  1205. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "beta", now-7200);
  1206. /* 14 connections with "charlie" */
  1207. for (i=14; i < 28; ++i) {
  1208. SET_TEST_ADDRESS(i);
  1209. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "charlie", now-7200);
  1210. }
  1211. /* 131 connections with "ddr" */
  1212. for (i=28; i < 159; ++i) {
  1213. SET_TEST_ADDRESS(i);
  1214. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "ddr", now-7200);
  1215. }
  1216. /* 8 connections with "entropy" */
  1217. for (i=159; i < 167; ++i) {
  1218. SET_TEST_ADDRESS(i);
  1219. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "entropy", now-7200);
  1220. }
  1221. /* 2 connections from the same IP with two different transports. */
  1222. SET_TEST_ADDRESS(++i);
  1223. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "fire", now-7200);
  1224. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "google", now-7200);
  1225. /* Test the transport history string. */
  1226. s = geoip_get_transport_history();
  1227. tor_assert(s);
  1228. test_streq(s, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
  1229. "entropy=8,fire=8,google=8");
  1230. /* Stop collecting entry statistics. */
  1231. geoip_entry_stats_term();
  1232. get_options_mutable()->EntryStatistics = 0;
  1233. done:
  1234. tor_free(s);
  1235. }
  1236. #undef SET_TEST_ADDRESS
  1237. #undef SET_TEST_IPV6
  1238. #undef CHECK_COUNTRY
  1239. /** Run unit tests for stats code. */
  1240. static void
  1241. test_stats(void)
  1242. {
  1243. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  1244. char *s = NULL;
  1245. int i;
  1246. /* Start with testing exit port statistics; we shouldn't collect exit
  1247. * stats without initializing them. */
  1248. rep_hist_note_exit_stream_opened(80);
  1249. rep_hist_note_exit_bytes(80, 100, 10000);
  1250. s = rep_hist_format_exit_stats(now + 86400);
  1251. test_assert(!s);
  1252. /* Initialize stats, note some streams and bytes, and generate history
  1253. * string. */
  1254. rep_hist_exit_stats_init(now);
  1255. rep_hist_note_exit_stream_opened(80);
  1256. rep_hist_note_exit_bytes(80, 100, 10000);
  1257. rep_hist_note_exit_stream_opened(443);
  1258. rep_hist_note_exit_bytes(443, 100, 10000);
  1259. rep_hist_note_exit_bytes(443, 100, 10000);
  1260. s = rep_hist_format_exit_stats(now + 86400);
  1261. test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1262. "exit-kibibytes-written 80=1,443=1,other=0\n"
  1263. "exit-kibibytes-read 80=10,443=20,other=0\n"
  1264. "exit-streams-opened 80=4,443=4,other=0\n", s);
  1265. tor_free(s);
  1266. /* Add a few bytes on 10 more ports and ensure that only the top 10
  1267. * ports are contained in the history string. */
  1268. for (i = 50; i < 60; i++) {
  1269. rep_hist_note_exit_bytes(i, i, i);
  1270. rep_hist_note_exit_stream_opened(i);
  1271. }
  1272. s = rep_hist_format_exit_stats(now + 86400);
  1273. test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1274. "exit-kibibytes-written 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  1275. "59=1,80=1,443=1,other=1\n"
  1276. "exit-kibibytes-read 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  1277. "59=1,80=10,443=20,other=1\n"
  1278. "exit-streams-opened 52=4,53=4,54=4,55=4,56=4,57=4,58=4,"
  1279. "59=4,80=4,443=4,other=4\n", s);
  1280. tor_free(s);
  1281. /* Stop collecting stats, add some bytes, and ensure we don't generate
  1282. * a history string. */
  1283. rep_hist_exit_stats_term();
  1284. rep_hist_note_exit_bytes(80, 100, 10000);
  1285. s = rep_hist_format_exit_stats(now + 86400);
  1286. test_assert(!s);
  1287. /* Re-start stats, add some bytes, reset stats, and see what history we
  1288. * get when observing no streams or bytes at all. */
  1289. rep_hist_exit_stats_init(now);
  1290. rep_hist_note_exit_stream_opened(80);
  1291. rep_hist_note_exit_bytes(80, 100, 10000);
  1292. rep_hist_reset_exit_stats(now);
  1293. s = rep_hist_format_exit_stats(now + 86400);
  1294. test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1295. "exit-kibibytes-written other=0\n"
  1296. "exit-kibibytes-read other=0\n"
  1297. "exit-streams-opened other=0\n", s);
  1298. tor_free(s);
  1299. /* Continue with testing connection statistics; we shouldn't collect
  1300. * conn stats without initializing them. */
  1301. rep_hist_note_or_conn_bytes(1, 20, 400, now);
  1302. s = rep_hist_format_conn_stats(now + 86400);
  1303. test_assert(!s);
  1304. /* Initialize stats, note bytes, and generate history string. */
  1305. rep_hist_conn_stats_init(now);
  1306. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  1307. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  1308. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  1309. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  1310. s = rep_hist_format_conn_stats(now + 86400);
  1311. test_streq("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n", s);
  1312. tor_free(s);
  1313. /* Stop collecting stats, add some bytes, and ensure we don't generate
  1314. * a history string. */
  1315. rep_hist_conn_stats_term();
  1316. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  1317. s = rep_hist_format_conn_stats(now + 86400);
  1318. test_assert(!s);
  1319. /* Re-start stats, add some bytes, reset stats, and see what history we
  1320. * get when observing no bytes at all. */
  1321. rep_hist_conn_stats_init(now);
  1322. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  1323. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  1324. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  1325. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  1326. rep_hist_reset_conn_stats(now);
  1327. s = rep_hist_format_conn_stats(now + 86400);
  1328. test_streq("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n", s);
  1329. tor_free(s);
  1330. /* Continue with testing buffer statistics; we shouldn't collect buffer
  1331. * stats without initializing them. */
  1332. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  1333. s = rep_hist_format_buffer_stats(now + 86400);
  1334. test_assert(!s);
  1335. /* Initialize stats, add statistics for a single circuit, and generate
  1336. * the history string. */
  1337. rep_hist_buffer_stats_init(now);
  1338. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  1339. s = rep_hist_format_buffer_stats(now + 86400);
  1340. test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1341. "cell-processed-cells 20,0,0,0,0,0,0,0,0,0\n"
  1342. "cell-queued-cells 2.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  1343. "0.00,0.00\n"
  1344. "cell-time-in-queue 2,0,0,0,0,0,0,0,0,0\n"
  1345. "cell-circuits-per-decile 1\n", s);
  1346. tor_free(s);
  1347. /* Add nineteen more circuit statistics to the one that's already in the
  1348. * history to see that the math works correctly. */
  1349. for (i = 21; i < 30; i++)
  1350. rep_hist_add_buffer_stats(2.0, 2.0, i);
  1351. for (i = 20; i < 30; i++)
  1352. rep_hist_add_buffer_stats(3.5, 3.5, i);
  1353. s = rep_hist_format_buffer_stats(now + 86400);
  1354. test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1355. "cell-processed-cells 29,28,27,26,25,24,23,22,21,20\n"
  1356. "cell-queued-cells 2.75,2.75,2.75,2.75,2.75,2.75,2.75,2.75,"
  1357. "2.75,2.75\n"
  1358. "cell-time-in-queue 3,3,3,3,3,3,3,3,3,3\n"
  1359. "cell-circuits-per-decile 2\n", s);
  1360. tor_free(s);
  1361. /* Stop collecting stats, add statistics for one circuit, and ensure we
  1362. * don't generate a history string. */
  1363. rep_hist_buffer_stats_term();
  1364. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  1365. s = rep_hist_format_buffer_stats(now + 86400);
  1366. test_assert(!s);
  1367. /* Re-start stats, add statistics for one circuit, reset stats, and make
  1368. * sure that the history has all zeros. */
  1369. rep_hist_buffer_stats_init(now);
  1370. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  1371. rep_hist_reset_buffer_stats(now);
  1372. s = rep_hist_format_buffer_stats(now + 86400);
  1373. test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  1374. "cell-processed-cells 0,0,0,0,0,0,0,0,0,0\n"
  1375. "cell-queued-cells 0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  1376. "0.00,0.00\n"
  1377. "cell-time-in-queue 0,0,0,0,0,0,0,0,0,0\n"
  1378. "cell-circuits-per-decile 0\n", s);
  1379. done:
  1380. tor_free(s);
  1381. }
  1382. static void *
  1383. legacy_test_setup(const struct testcase_t *testcase)
  1384. {
  1385. return testcase->setup_data;
  1386. }
  1387. void
  1388. legacy_test_helper(void *data)
  1389. {
  1390. void (*fn)(void) = data;
  1391. fn();
  1392. }
  1393. static int
  1394. legacy_test_cleanup(const struct testcase_t *testcase, void *ptr)
  1395. {
  1396. (void)ptr;
  1397. (void)testcase;
  1398. return 1;
  1399. }
  1400. const struct testcase_setup_t legacy_setup = {
  1401. legacy_test_setup, legacy_test_cleanup
  1402. };
  1403. #define ENT(name) \
  1404. { #name, legacy_test_helper, 0, &legacy_setup, test_ ## name }
  1405. #define FORK(name) \
  1406. { #name, legacy_test_helper, TT_FORK, &legacy_setup, test_ ## name }
  1407. static struct testcase_t test_array[] = {
  1408. ENT(onion_handshake),
  1409. { "bad_onion_handshake", test_bad_onion_handshake, 0, NULL, NULL },
  1410. ENT(onion_queues),
  1411. #ifdef CURVE25519_ENABLED
  1412. { "ntor_handshake", test_ntor_handshake, 0, NULL, NULL },
  1413. #endif
  1414. ENT(circuit_timeout),
  1415. ENT(policies),
  1416. ENT(rend_fns),
  1417. ENT(geoip),
  1418. FORK(geoip_with_pt),
  1419. FORK(stats),
  1420. END_OF_TESTCASES
  1421. };
  1422. extern struct testcase_t addr_tests[];
  1423. extern struct testcase_t buffer_tests[];
  1424. extern struct testcase_t crypto_tests[];
  1425. extern struct testcase_t container_tests[];
  1426. extern struct testcase_t util_tests[];
  1427. extern struct testcase_t dir_tests[];
  1428. extern struct testcase_t microdesc_tests[];
  1429. extern struct testcase_t pt_tests[];
  1430. extern struct testcase_t config_tests[];
  1431. extern struct testcase_t introduce_tests[];
  1432. extern struct testcase_t replaycache_tests[];
  1433. extern struct testcase_t cell_format_tests[];
  1434. extern struct testcase_t circuitlist_tests[];
  1435. extern struct testcase_t circuitmux_tests[];
  1436. extern struct testcase_t cell_queue_tests[];
  1437. extern struct testcase_t options_tests[];
  1438. extern struct testcase_t socks_tests[];
  1439. extern struct testcase_t extorport_tests[];
  1440. extern struct testcase_t controller_event_tests[];
  1441. extern struct testcase_t logging_tests[];
  1442. extern struct testcase_t backtrace_tests[];
  1443. extern struct testcase_t hs_tests[];
  1444. extern struct testcase_t nodelist_tests[];
  1445. extern struct testcase_t routerkeys_tests[];
  1446. extern struct testcase_t oom_tests[];
  1447. static struct testgroup_t testgroups[] = {
  1448. { "", test_array },
  1449. { "buffer/", buffer_tests },
  1450. { "socks/", socks_tests },
  1451. { "addr/", addr_tests },
  1452. { "crypto/", crypto_tests },
  1453. { "container/", container_tests },
  1454. { "util/", util_tests },
  1455. { "util/logging/", logging_tests },
  1456. { "cellfmt/", cell_format_tests },
  1457. { "cellqueue/", cell_queue_tests },
  1458. { "dir/", dir_tests },
  1459. { "dir/md/", microdesc_tests },
  1460. { "pt/", pt_tests },
  1461. { "config/", config_tests },
  1462. { "replaycache/", replaycache_tests },
  1463. { "introduce/", introduce_tests },
  1464. { "circuitlist/", circuitlist_tests },
  1465. { "circuitmux/", circuitmux_tests },
  1466. { "options/", options_tests },
  1467. { "extorport/", extorport_tests },
  1468. { "control/", controller_event_tests },
  1469. { "hs/", hs_tests },
  1470. { "nodelist/", nodelist_tests },
  1471. { "routerkeys/", routerkeys_tests },
  1472. { "oom/", oom_tests },
  1473. END_OF_GROUPS
  1474. };
  1475. /** Main entry point for unit test code: parse the command line, and run
  1476. * some unit tests. */
  1477. int
  1478. main(int c, const char **v)
  1479. {
  1480. or_options_t *options;
  1481. char *errmsg = NULL;
  1482. int i, i_out;
  1483. int loglevel = LOG_ERR;
  1484. int accel_crypto = 0;
  1485. #ifdef USE_DMALLOC
  1486. {
  1487. int r = CRYPTO_set_mem_ex_functions(tor_malloc_, tor_realloc_, tor_free_);
  1488. tor_assert(r);
  1489. }
  1490. #endif
  1491. update_approx_time(time(NULL));
  1492. options = options_new();
  1493. tor_threads_init();
  1494. init_logging();
  1495. for (i_out = i = 1; i < c; ++i) {
  1496. if (!strcmp(v[i], "--warn")) {
  1497. loglevel = LOG_WARN;
  1498. } else if (!strcmp(v[i], "--notice")) {
  1499. loglevel = LOG_NOTICE;
  1500. } else if (!strcmp(v[i], "--info")) {
  1501. loglevel = LOG_INFO;
  1502. } else if (!strcmp(v[i], "--debug")) {
  1503. loglevel = LOG_DEBUG;
  1504. } else if (!strcmp(v[i], "--accel")) {
  1505. accel_crypto = 1;
  1506. } else {
  1507. v[i_out++] = v[i];
  1508. }
  1509. }
  1510. c = i_out;
  1511. {
  1512. log_severity_list_t s;
  1513. memset(&s, 0, sizeof(s));
  1514. set_log_severity_config(loglevel, LOG_ERR, &s);
  1515. add_stream_log(&s, "", fileno(stdout));
  1516. }
  1517. options->command = CMD_RUN_UNITTESTS;
  1518. if (crypto_global_init(accel_crypto, NULL, NULL)) {
  1519. printf("Can't initialize crypto subsystem; exiting.\n");
  1520. return 1;
  1521. }
  1522. crypto_set_tls_dh_prime(NULL);
  1523. crypto_seed_rng(1);
  1524. rep_hist_init();
  1525. network_init();
  1526. setup_directory();
  1527. options_init(options);
  1528. options->DataDirectory = tor_strdup(temp_dir);
  1529. options->EntryStatistics = 1;
  1530. if (set_options(options, &errmsg) < 0) {
  1531. printf("Failed to set initial options: %s\n", errmsg);
  1532. tor_free(errmsg);
  1533. return 1;
  1534. }
  1535. atexit(remove_directory);
  1536. have_failed = (tinytest_main(c, v, testgroups) != 0);
  1537. free_pregenerated_keys();
  1538. #ifdef USE_DMALLOC
  1539. tor_free_all(0);
  1540. dmalloc_log_unfreed();
  1541. #endif
  1542. if (have_failed)
  1543. return 1;
  1544. else
  1545. return 0;
  1546. }