src/test/test_rendcache.c

   1 /* Copyright (c) 2010-2016, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 #include "orconfig.h"
   5 #include "or.h"
   6
   7 #include "test.h"
   8 #define RENDCACHE_PRIVATE
   9 #include "rendcache.h"
  10 #include "router.h"
  11 #include "routerlist.h"
  12 #include "config.h"
  13 #include <openssl/rsa.h>
  14 #include "rend_test_helpers.h"
  15
  16 #define NS_MODULE rend_cache
  17
  18 static const int RECENT_TIME = -10;
  19 static const int TIME_IN_THE_PAST = -(REND_CACHE_MAX_AGE + \
  20                                       REND_CACHE_MAX_SKEW + 60);
  21 static const int TIME_IN_THE_FUTURE = REND_CACHE_MAX_SKEW + 60;
  22
  23 static rend_data_t *
  24 mock_rend_data(const char *onion_address)
  25 {
  26   rend_data_t *rend_query = tor_malloc_zero(sizeof(rend_data_t));
  27
  28   strlcpy(rend_query->onion_address, onion_address,
  29           sizeof(rend_query->onion_address));
  30   rend_query->auth_type = REND_NO_AUTH;
  31   rend_query->hsdirs_fp = smartlist_new();
  32   smartlist_add(rend_query->hsdirs_fp, tor_memdup("aaaaaaaaaaaaaaaaaaaaaaaa",
  33                                                  DIGEST_LEN));
  34
  35   return rend_query;
  36 }
  37
  38 static void
  39 test_rend_cache_lookup_entry(void *data)
  40 {
  41   int ret;
  42   rend_data_t *mock_rend_query = NULL;
  43   char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  44   rend_cache_entry_t *entry = NULL;
  45   rend_encoded_v2_service_descriptor_t *desc_holder = NULL;
  46   char *service_id = NULL;
  47   (void)data;
  48
  49   rend_cache_init();
  50
  51   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
  52
  53   ret = rend_cache_lookup_entry("abababababababab", 0, NULL);
  54   tt_int_op(ret, OP_EQ, -ENOENT);
  55
  56   ret = rend_cache_lookup_entry("invalid query", 2, NULL);
  57   tt_int_op(ret, OP_EQ, -EINVAL);
  58
  59   ret = rend_cache_lookup_entry("abababababababab", 2, NULL);
  60   tt_int_op(ret, OP_EQ, -ENOENT);
  61
  62   ret = rend_cache_lookup_entry("abababababababab", 4224, NULL);
  63   tt_int_op(ret, OP_EQ, -ENOENT);
  64
  65   mock_rend_query = mock_rend_data(service_id);
  66   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
  67                 DIGEST_LEN);
  68   rend_cache_store_v2_desc_as_client(desc_holder->desc_str, desc_id_base32,
  69                                      mock_rend_query, NULL);
  70
  71   ret = rend_cache_lookup_entry(service_id, 2, NULL);
  72   tt_int_op(ret, OP_EQ, 0);
  73
  74   ret = rend_cache_lookup_entry(service_id, 2, &entry);
  75   tt_assert(entry);
  76   tt_int_op(entry->len, OP_EQ, strlen(desc_holder->desc_str));
  77   tt_str_op(entry->desc, OP_EQ, desc_holder->desc_str);
  78
  79  done:
  80   rend_encoded_v2_service_descriptor_free(desc_holder);
  81   tor_free(service_id);
  82   rend_cache_free_all();
  83   rend_data_free(mock_rend_query);
  84 }
  85
  86 static void
  87 test_rend_cache_store_v2_desc_as_client(void *data)
  88 {
  89   int ret;
  90   rend_data_t *mock_rend_query;
  91   char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  92   rend_cache_entry_t *entry = NULL;
  93   rend_encoded_v2_service_descriptor_t *desc_holder = NULL;
  94   char *service_id = NULL;
  95   char client_cookie[REND_DESC_COOKIE_LEN];
  96   (void)data;
  97
  98   rend_cache_init();
  99
 100   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 101
 102   // Test success
 103   mock_rend_query = mock_rend_data(service_id);
 104   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 105                 DIGEST_LEN);
 106   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 107                                            desc_id_base32, mock_rend_query,
 108                                            &entry);
 109
 110   tt_int_op(ret, OP_EQ, 0);
 111   tt_assert(entry);
 112   tt_int_op(entry->len, OP_EQ, strlen(desc_holder->desc_str));
 113   tt_str_op(entry->desc, OP_EQ, desc_holder->desc_str);
 114
 115   // Test various failure modes
 116
 117   // TODO: a too long desc_id_base32 argument crashes the function
 118    /* ret = rend_cache_store_v2_desc_as_client( */
 119    /*                   desc_holder->desc_str, */
 120    /*                   "3TOOLONG3TOOLONG3TOOLONG3TOOLONG3TOOLONG3TOOLONG", */
 121    /*                   &mock_rend_query, NULL); */
 122   /* tt_int_op(ret, OP_EQ, -1); */
 123
 124   // Test bad base32 failure
 125   // This causes an assertion failure if we're running with assertions.
 126   // But when building without asserts, we can test it.
 127 #ifdef DISABLE_ASSERTS_IN_UNIT_TESTS
 128   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 129                    "!xqunszqnaolrrfmtzgaki7mxelgvkj", mock_rend_query, NULL);
 130   tt_int_op(ret, OP_EQ, -1);
 131 #endif
 132
 133   // Test invalid descriptor
 134   ret = rend_cache_store_v2_desc_as_client("invalid descriptor",
 135              "3xqunszqnaolrrfmtzgaki7mxelgvkje", mock_rend_query, NULL);
 136   tt_int_op(ret, OP_EQ, -1);
 137
 138   // TODO: it doesn't seem to be possible to test invalid service ID condition.
 139   // that means it is likely not possible to have that condition without
 140   // earlier conditions failing first (such as signature checking of the desc)
 141
 142   rend_cache_free_all();
 143
 144   // Test mismatch between service ID and onion address
 145   rend_cache_init();
 146   strncpy(mock_rend_query->onion_address, "abc", REND_SERVICE_ID_LEN_BASE32+1);
 147   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 148                                            desc_id_base32,
 149                                            mock_rend_query, NULL);
 150   tt_int_op(ret, OP_EQ, -1);
 151   rend_cache_free_all();
 152   rend_data_free(mock_rend_query);
 153
 154   // Test incorrect descriptor ID
 155   rend_cache_init();
 156   mock_rend_query = mock_rend_data(service_id);
 157   desc_id_base32[0]++;
 158   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 159                                            desc_id_base32, mock_rend_query,
 160                                            NULL);
 161   tt_int_op(ret, OP_EQ, -1);
 162   desc_id_base32[0]--;
 163   rend_cache_free_all();
 164
 165   // Test too old descriptor
 166   rend_cache_init();
 167   rend_encoded_v2_service_descriptor_free(desc_holder);
 168   tor_free(service_id);
 169   rend_data_free(mock_rend_query);
 170
 171   generate_desc(TIME_IN_THE_PAST, &desc_holder, &service_id, 3);
 172   mock_rend_query = mock_rend_data(service_id);
 173   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 174                 DIGEST_LEN);
 175
 176   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 177                                            desc_id_base32,
 178                                            mock_rend_query, NULL);
 179   tt_int_op(ret, OP_EQ, -1);
 180   rend_cache_free_all();
 181
 182   // Test too new descriptor (in the future)
 183   rend_cache_init();
 184   rend_encoded_v2_service_descriptor_free(desc_holder);
 185   tor_free(service_id);
 186   rend_data_free(mock_rend_query);
 187
 188   generate_desc(TIME_IN_THE_FUTURE, &desc_holder, &service_id, 3);
 189   mock_rend_query = mock_rend_data(service_id);
 190   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 191                 DIGEST_LEN);
 192
 193   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 194                                            desc_id_base32, mock_rend_query,
 195                                            NULL);
 196   tt_int_op(ret, OP_EQ, -1);
 197   rend_cache_free_all();
 198
 199   // Test when a descriptor is already in the cache
 200   rend_cache_init();
 201   rend_encoded_v2_service_descriptor_free(desc_holder);
 202   tor_free(service_id);
 203   rend_data_free(mock_rend_query);
 204
 205   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 206   mock_rend_query = mock_rend_data(service_id);
 207   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 208                 DIGEST_LEN);
 209
 210   rend_cache_store_v2_desc_as_client(desc_holder->desc_str, desc_id_base32,
 211                                      mock_rend_query, NULL);
 212   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 213                                            desc_id_base32, mock_rend_query,
 214                                            NULL);
 215   tt_int_op(ret, OP_EQ, 0);
 216
 217   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 218                                            desc_id_base32, mock_rend_query,
 219                                            &entry);
 220   tt_int_op(ret, OP_EQ, 0);
 221   tt_assert(entry);
 222   rend_cache_free_all();
 223
 224   // Test unsuccessful decrypting of introduction points
 225   rend_cache_init();
 226   rend_encoded_v2_service_descriptor_free(desc_holder);
 227   tor_free(service_id);
 228   rend_data_free(mock_rend_query);
 229
 230   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 231   mock_rend_query = mock_rend_data(service_id);
 232   mock_rend_query->auth_type = REND_BASIC_AUTH;
 233   client_cookie[0] = 'A';
 234   memcpy(mock_rend_query->descriptor_cookie, client_cookie,
 235          REND_DESC_COOKIE_LEN);
 236   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 237                 DIGEST_LEN);
 238   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 239                                            desc_id_base32, mock_rend_query,
 240                                            NULL);
 241   tt_int_op(ret, OP_EQ, 0);
 242   rend_cache_free_all();
 243
 244   // Test successful run when we have REND_BASIC_AUTH but not cookie
 245   rend_cache_init();
 246   rend_encoded_v2_service_descriptor_free(desc_holder);
 247   tor_free(service_id);
 248   rend_data_free(mock_rend_query);
 249
 250   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 251   mock_rend_query = mock_rend_data(service_id);
 252   mock_rend_query->auth_type = REND_BASIC_AUTH;
 253   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 254                 DIGEST_LEN);
 255   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 256                                            desc_id_base32, mock_rend_query,
 257                                            NULL);
 258   tt_int_op(ret, OP_EQ, 0);
 259
 260   rend_cache_free_all();
 261
 262   // Test when we have no introduction points
 263   rend_cache_init();
 264   rend_encoded_v2_service_descriptor_free(desc_holder);
 265   tor_free(service_id);
 266   rend_data_free(mock_rend_query);
 267
 268   generate_desc(RECENT_TIME, &desc_holder, &service_id, 0);
 269   mock_rend_query = mock_rend_data(service_id);
 270   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 271                 DIGEST_LEN);
 272   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 273                                            desc_id_base32, mock_rend_query,
 274                                            NULL);
 275   tt_int_op(ret, OP_EQ, -1);
 276   rend_cache_free_all();
 277
 278   // Test when we have too many intro points
 279   rend_cache_init();
 280   rend_encoded_v2_service_descriptor_free(desc_holder);
 281   tor_free(service_id);
 282   rend_data_free(mock_rend_query);
 283
 284   generate_desc(RECENT_TIME, &desc_holder, &service_id, MAX_INTRO_POINTS+1);
 285   mock_rend_query = mock_rend_data(service_id);
 286   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 287                 DIGEST_LEN);
 288   ret = rend_cache_store_v2_desc_as_client(desc_holder->desc_str,
 289                                            desc_id_base32, mock_rend_query,
 290                                            NULL);
 291   tt_int_op(ret, OP_EQ, -1);
 292
 293  done:
 294   rend_encoded_v2_service_descriptor_free(desc_holder);
 295   tor_free(service_id);
 296   rend_cache_free_all();
 297   rend_data_free(mock_rend_query);
 298 }
 299
 300 static void
 301 test_rend_cache_store_v2_desc_as_client_with_different_time(void *data)
 302 {
 303   int ret;
 304   rend_data_t *mock_rend_query;
 305   char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
 306   rend_service_descriptor_t *generated = NULL;
 307   smartlist_t *descs = smartlist_new();
 308   time_t t;
 309   char *service_id = NULL;
 310   rend_encoded_v2_service_descriptor_t *desc_holder_newer;
 311   rend_encoded_v2_service_descriptor_t *desc_holder_older;
 312
 313   t = time(NULL);
 314   rend_cache_init();
 315
 316   create_descriptor(&generated, &service_id, 3);
 317
 318   generated->timestamp = t + RECENT_TIME;
 319   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 320                              REND_NO_AUTH, NULL, NULL);
 321   desc_holder_newer = ((rend_encoded_v2_service_descriptor_t *)
 322                        smartlist_get(descs, 0));
 323   smartlist_set(descs, 0, NULL);
 324
 325   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 326                     rend_encoded_v2_service_descriptor_free(d));
 327   smartlist_free(descs);
 328   descs = smartlist_new();
 329
 330   generated->timestamp = (t + RECENT_TIME) - 20;
 331   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 332                              REND_NO_AUTH, NULL, NULL);
 333   desc_holder_older = ((rend_encoded_v2_service_descriptor_t *)
 334                        smartlist_get(descs, 0));
 335   smartlist_set(descs, 0, NULL);
 336   (void)data;
 337
 338   // Test when a descriptor is already in the cache and it is newer than the
 339   // one we submit
 340   mock_rend_query = mock_rend_data(service_id);
 341   base32_encode(desc_id_base32, sizeof(desc_id_base32),
 342                 desc_holder_newer->desc_id, DIGEST_LEN);
 343   rend_cache_store_v2_desc_as_client(desc_holder_newer->desc_str,
 344                                      desc_id_base32, mock_rend_query, NULL);
 345   ret = rend_cache_store_v2_desc_as_client(desc_holder_older->desc_str,
 346                                            desc_id_base32, mock_rend_query,
 347                                            NULL);
 348   tt_int_op(ret, OP_EQ, 0);
 349
 350   rend_cache_free_all();
 351
 352   // Test when an old descriptor is in the cache and we submit a newer one
 353   rend_cache_init();
 354   rend_cache_store_v2_desc_as_client(desc_holder_older->desc_str,
 355                                      desc_id_base32, mock_rend_query, NULL);
 356   ret = rend_cache_store_v2_desc_as_client(desc_holder_newer->desc_str,
 357                                            desc_id_base32, mock_rend_query,
 358                                            NULL);
 359   tt_int_op(ret, OP_EQ, 0);
 360
 361  done:
 362   rend_encoded_v2_service_descriptor_free(desc_holder_newer);
 363   rend_encoded_v2_service_descriptor_free(desc_holder_older);
 364   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 365                     rend_encoded_v2_service_descriptor_free(d));
 366   smartlist_free(descs);
 367   rend_service_descriptor_free(generated);
 368   tor_free(service_id);
 369   rend_cache_free_all();
 370   rend_data_free(mock_rend_query);
 371 }
 372
 373 #define NS_SUBMODULE lookup_v2_desc_as_dir
 374 NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
 375
 376 static routerinfo_t *mock_routerinfo;
 377
 378 static const routerinfo_t *
 379 NS(router_get_my_routerinfo)(void)
 380 {
 381   if (!mock_routerinfo) {
 382     mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
 383   }
 384
 385   return mock_routerinfo;
 386 }
 387
 388 static void
 389 test_rend_cache_lookup_v2_desc_as_dir(void *data)
 390 {
 391   int ret;
 392   char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
 393   rend_encoded_v2_service_descriptor_t *desc_holder = NULL;
 394   char *service_id = NULL;
 395   const char *ret_desc = NULL;
 396
 397   (void)data;
 398
 399   NS_MOCK(router_get_my_routerinfo);
 400
 401   rend_cache_init();
 402
 403   // Test invalid base32
 404   ret = rend_cache_lookup_v2_desc_as_dir("!bababababababab", NULL);
 405   tt_int_op(ret, OP_EQ, -1);
 406
 407   // Test non-existent descriptor but well formed
 408   ret = rend_cache_lookup_v2_desc_as_dir("3xqunszqnaolrrfmtzgaki7mxelgvkje",
 409                                          NULL);
 410   tt_int_op(ret, OP_EQ, 0);
 411
 412   // Test existing descriptor
 413   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 414   rend_cache_store_v2_desc_as_dir(desc_holder->desc_str);
 415   base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id,
 416                 DIGEST_LEN);
 417   ret = rend_cache_lookup_v2_desc_as_dir(desc_id_base32, &ret_desc);
 418   tt_int_op(ret, OP_EQ, 1);
 419   tt_assert(ret_desc);
 420
 421  done:
 422   NS_UNMOCK(router_get_my_routerinfo);
 423   tor_free(mock_routerinfo);
 424   rend_cache_free_all();
 425   rend_encoded_v2_service_descriptor_free(desc_holder);
 426   tor_free(service_id);
 427 }
 428
 429 #undef NS_SUBMODULE
 430
 431 #define NS_SUBMODULE store_v2_desc_as_dir
 432 NS_DECL(const routerinfo_t *, router_get_my_routerinfo, (void));
 433
 434 static const routerinfo_t *
 435 NS(router_get_my_routerinfo)(void)
 436 {
 437   return mock_routerinfo;
 438 }
 439
 440 static void
 441 test_rend_cache_store_v2_desc_as_dir(void *data)
 442 {
 443   (void)data;
 444   int ret;
 445   rend_encoded_v2_service_descriptor_t *desc_holder = NULL;
 446   char *service_id = NULL;
 447
 448   NS_MOCK(router_get_my_routerinfo);
 449
 450   rend_cache_init();
 451
 452   // Test when we can't parse the descriptor
 453   mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
 454   ret = rend_cache_store_v2_desc_as_dir("unparseable");
 455   tt_int_op(ret, OP_EQ, -1);
 456
 457   // Test when we have an old descriptor
 458   generate_desc(TIME_IN_THE_PAST, &desc_holder, &service_id, 3);
 459   ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str);
 460   tt_int_op(ret, OP_EQ, 0);
 461
 462   rend_encoded_v2_service_descriptor_free(desc_holder);
 463   tor_free(service_id);
 464
 465   // Test when we have a descriptor in the future
 466   generate_desc(TIME_IN_THE_FUTURE, &desc_holder, &service_id, 3);
 467   ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str);
 468   tt_int_op(ret, OP_EQ, 0);
 469
 470   rend_encoded_v2_service_descriptor_free(desc_holder);
 471   tor_free(service_id);
 472
 473   // Test when two descriptors
 474   generate_desc(TIME_IN_THE_FUTURE, &desc_holder, &service_id, 3);
 475   ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str);
 476   tt_int_op(ret, OP_EQ, 0);
 477
 478   rend_encoded_v2_service_descriptor_free(desc_holder);
 479   tor_free(service_id);
 480
 481   // Test when asking for hidden service statistics  HiddenServiceStatistics
 482   rend_cache_purge();
 483   generate_desc(RECENT_TIME, &desc_holder, &service_id, 3);
 484   get_options_mutable()->HiddenServiceStatistics = 1;
 485   ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str);
 486   tt_int_op(ret, OP_EQ, 0);
 487
 488  done:
 489   NS_UNMOCK(router_get_my_routerinfo);
 490   rend_encoded_v2_service_descriptor_free(desc_holder);
 491   tor_free(service_id);
 492   rend_cache_free_all();
 493   tor_free(mock_routerinfo);
 494 }
 495
 496 static void
 497 test_rend_cache_store_v2_desc_as_dir_with_different_time(void *data)
 498 {
 499   (void)data;
 500
 501   int ret;
 502   rend_service_descriptor_t *generated = NULL;
 503   smartlist_t *descs = smartlist_new();
 504   time_t t;
 505   char *service_id = NULL;
 506   rend_encoded_v2_service_descriptor_t *desc_holder_newer;
 507   rend_encoded_v2_service_descriptor_t *desc_holder_older;
 508
 509   NS_MOCK(router_get_my_routerinfo);
 510
 511   rend_cache_init();
 512
 513   t = time(NULL);
 514
 515   create_descriptor(&generated, &service_id, 3);
 516   generated->timestamp = t + RECENT_TIME;
 517   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 518                              REND_NO_AUTH, NULL, NULL);
 519   desc_holder_newer = ((rend_encoded_v2_service_descriptor_t *)
 520                        smartlist_get(descs, 0));
 521   smartlist_set(descs, 0, NULL);
 522   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 523                     rend_encoded_v2_service_descriptor_free(d));
 524   smartlist_free(descs);
 525   descs = smartlist_new();
 526
 527   generated->timestamp = (t + RECENT_TIME) - 20;
 528   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 529                              REND_NO_AUTH, NULL, NULL);
 530   desc_holder_older = ((rend_encoded_v2_service_descriptor_t *)
 531                        smartlist_get(descs, 0));
 532   smartlist_set(descs, 0, NULL);
 533
 534   // Test when we have a newer descriptor stored
 535   mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
 536   rend_cache_store_v2_desc_as_dir(desc_holder_newer->desc_str);
 537   ret = rend_cache_store_v2_desc_as_dir(desc_holder_older->desc_str);
 538   tt_int_op(ret, OP_EQ, 0);
 539
 540   // Test when we have an old descriptor stored
 541   rend_cache_purge();
 542   rend_cache_store_v2_desc_as_dir(desc_holder_older->desc_str);
 543   ret = rend_cache_store_v2_desc_as_dir(desc_holder_newer->desc_str);
 544   tt_int_op(ret, OP_EQ, 0);
 545
 546  done:
 547   NS_UNMOCK(router_get_my_routerinfo);
 548   rend_cache_free_all();
 549   rend_service_descriptor_free(generated);
 550   tor_free(service_id);
 551   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 552                     rend_encoded_v2_service_descriptor_free(d));
 553   smartlist_free(descs);
 554   rend_encoded_v2_service_descriptor_free(desc_holder_newer);
 555   rend_encoded_v2_service_descriptor_free(desc_holder_older);
 556   tor_free(mock_routerinfo);
 557 }
 558
 559 static void
 560 test_rend_cache_store_v2_desc_as_dir_with_different_content(void *data)
 561 {
 562   (void)data;
 563
 564   int ret;
 565   rend_service_descriptor_t *generated = NULL;
 566   smartlist_t *descs = smartlist_new();
 567   time_t t;
 568   char *service_id = NULL;
 569   rend_encoded_v2_service_descriptor_t *desc_holder_one = NULL;
 570   rend_encoded_v2_service_descriptor_t *desc_holder_two = NULL;
 571
 572   NS_MOCK(router_get_my_routerinfo);
 573
 574   rend_cache_init();
 575
 576   t = time(NULL);
 577
 578   create_descriptor(&generated, &service_id, 3);
 579   generated->timestamp = t + RECENT_TIME;
 580   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 581                              REND_NO_AUTH, NULL, NULL);
 582   desc_holder_one = ((rend_encoded_v2_service_descriptor_t *)
 583                      smartlist_get(descs, 0));
 584   smartlist_set(descs, 0, NULL);
 585
 586   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 587                     rend_encoded_v2_service_descriptor_free(d));
 588   smartlist_free(descs);
 589   descs = smartlist_new();
 590
 591   generated->timestamp = t + RECENT_TIME;
 592   generated->protocols = 41;
 593   rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0,
 594                              REND_NO_AUTH, NULL, NULL);
 595   desc_holder_two = ((rend_encoded_v2_service_descriptor_t *)
 596                      smartlist_get(descs, 0));
 597   smartlist_set(descs, 0, NULL);
 598
 599   // Test when we have another descriptor stored, with a different descriptor
 600   mock_routerinfo = tor_malloc(sizeof(routerinfo_t));
 601   rend_cache_store_v2_desc_as_dir(desc_holder_one->desc_str);
 602   ret = rend_cache_store_v2_desc_as_dir(desc_holder_two->desc_str);
 603   tt_int_op(ret, OP_EQ, 0);
 604
 605  done:
 606   NS_UNMOCK(router_get_my_routerinfo);
 607   rend_cache_free_all();
 608   rend_service_descriptor_free(generated);
 609   tor_free(service_id);
 610   SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
 611                     rend_encoded_v2_service_descriptor_free(d));
 612   smartlist_free(descs);
 613   rend_encoded_v2_service_descriptor_free(desc_holder_one);
 614   rend_encoded_v2_service_descriptor_free(desc_holder_two);
 615 }
 616
 617 #undef NS_SUBMODULE
 618
 619 static void
 620 test_rend_cache_init(void *data)
 621 {
 622   (void)data;
 623
 624   tt_assert_msg(!rend_cache, "rend_cache should be NULL when starting");
 625   tt_assert_msg(!rend_cache_v2_dir, "rend_cache_v2_dir should be NULL "
 626                 "when starting");
 627   tt_assert_msg(!rend_cache_failure, "rend_cache_failure should be NULL when "
 628                 "starting");
 629
 630   rend_cache_init();
 631
 632   tt_assert_msg(rend_cache, "rend_cache should not be NULL after initing");
 633   tt_assert_msg(rend_cache_v2_dir, "rend_cache_v2_dir should not be NULL "
 634                 "after initing");
 635   tt_assert_msg(rend_cache_failure, "rend_cache_failure should not be NULL "
 636                 "after initing");
 637
 638   tt_int_op(strmap_size(rend_cache), OP_EQ, 0);
 639   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0);
 640   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 0);
 641
 642  done:
 643   rend_cache_free_all();
 644 }
 645
 646 static void
 647 test_rend_cache_decrement_allocation(void *data)
 648 {
 649   (void)data;
 650
 651   // Test when the cache has enough allocations
 652   rend_cache_total_allocation = 10;
 653   rend_cache_decrement_allocation(3);
 654   tt_int_op(rend_cache_total_allocation, OP_EQ, 7);
 655
 656   // Test when there are not enough allocations
 657   rend_cache_total_allocation = 1;
 658   rend_cache_decrement_allocation(2);
 659   tt_int_op(rend_cache_total_allocation, OP_EQ, 0);
 660
 661   // And again
 662   rend_cache_decrement_allocation(2);
 663   tt_int_op(rend_cache_total_allocation, OP_EQ, 0);
 664
 665  done:
 666   (void)0;
 667 }
 668
 669 static void
 670 test_rend_cache_increment_allocation(void *data)
 671 {
 672   (void)data;
 673
 674   // Test when the cache is not overflowing
 675   rend_cache_total_allocation = 5;
 676   rend_cache_increment_allocation(3);
 677   tt_int_op(rend_cache_total_allocation, OP_EQ, 8);
 678
 679   // Test when there are too many allocations
 680   rend_cache_total_allocation = SIZE_MAX-1;
 681   rend_cache_increment_allocation(2);
 682   tt_u64_op(rend_cache_total_allocation, OP_EQ, SIZE_MAX);
 683
 684   // And again
 685   rend_cache_increment_allocation(2);
 686   tt_u64_op(rend_cache_total_allocation, OP_EQ, SIZE_MAX);
 687
 688  done:
 689   (void)0;
 690 }
 691
 692 static void
 693 test_rend_cache_failure_intro_entry_new(void *data)
 694 {
 695   time_t now;
 696   rend_cache_failure_intro_t *entry;
 697   rend_intro_point_failure_t failure;
 698
 699   (void)data;
 700
 701   failure = INTRO_POINT_FAILURE_TIMEOUT;
 702   now = time(NULL);
 703   entry = rend_cache_failure_intro_entry_new(failure);
 704
 705   tt_int_op(entry->failure_type, OP_EQ, INTRO_POINT_FAILURE_TIMEOUT);
 706   tt_int_op(entry->created_ts, OP_GE, now-5);
 707   tt_int_op(entry->created_ts, OP_LE, now+5);
 708
 709  done:
 710   tor_free(entry);
 711 }
 712
 713 static void
 714 test_rend_cache_failure_intro_lookup(void *data)
 715 {
 716   (void)data;
 717   int ret;
 718   rend_cache_failure_t *failure;
 719   rend_cache_failure_intro_t *ip;
 720   rend_cache_failure_intro_t *entry;
 721   const char key_ip_one[DIGEST_LEN] = "ip1";
 722   const char key_ip_two[DIGEST_LEN] = "ip2";
 723   const char key_foo[DIGEST_LEN] = "foo1";
 724
 725   rend_cache_init();
 726
 727   failure = rend_cache_failure_entry_new();
 728   ip = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
 729   digestmap_set(failure->intro_failures, key_ip_one, ip);
 730   strmap_set_lc(rend_cache_failure, "foo1", failure);
 731
 732   // Test not found
 733   ret = cache_failure_intro_lookup((const uint8_t *) key_foo, "foo2", NULL);
 734   tt_int_op(ret, OP_EQ, 0);
 735
 736   // Test found with no intro failures in it
 737   ret = cache_failure_intro_lookup((const uint8_t *) key_ip_two, "foo1", NULL);
 738   tt_int_op(ret, OP_EQ, 0);
 739
 740   // Test found
 741   ret = cache_failure_intro_lookup((const uint8_t *) key_ip_one, "foo1", NULL);
 742   tt_int_op(ret, OP_EQ, 1);
 743
 744   // Test found and asking for entry
 745   cache_failure_intro_lookup((const uint8_t *) key_ip_one, "foo1", &entry);
 746   tt_assert(entry);
 747   tt_assert(entry == ip);
 748
 749  done:
 750   rend_cache_free_all();
 751 }
 752
 753 static void
 754 test_rend_cache_clean(void *data)
 755 {
 756   rend_cache_entry_t *one, *two;
 757   rend_service_descriptor_t *desc_one, *desc_two;
 758   strmap_iter_t *iter = NULL;
 759   const char *key;
 760   void *val;
 761
 762   (void)data;
 763
 764   rend_cache_init();
 765
 766   // Test with empty rendcache
 767   rend_cache_clean(time(NULL), REND_CACHE_TYPE_CLIENT);
 768   tt_int_op(strmap_size(rend_cache), OP_EQ, 0);
 769
 770   // Test with two old entries
 771   one = tor_malloc_zero(sizeof(rend_cache_entry_t));
 772   two = tor_malloc_zero(sizeof(rend_cache_entry_t));
 773   desc_one = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 774   desc_two = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 775   one->parsed = desc_one;
 776   two->parsed = desc_two;
 777
 778   desc_one->timestamp = time(NULL) + TIME_IN_THE_PAST;
 779   desc_two->timestamp = (time(NULL) + TIME_IN_THE_PAST) - 10;
 780   desc_one->pk = pk_generate(0);
 781   desc_two->pk = pk_generate(1);
 782
 783   strmap_set_lc(rend_cache, "foo1", one);
 784   strmap_set_lc(rend_cache, "foo2", two);
 785
 786   rend_cache_clean(time(NULL), REND_CACHE_TYPE_CLIENT);
 787   tt_int_op(strmap_size(rend_cache), OP_EQ, 0);
 788
 789   // Test with one old entry and one newer entry
 790   one = tor_malloc_zero(sizeof(rend_cache_entry_t));
 791   two = tor_malloc_zero(sizeof(rend_cache_entry_t));
 792   desc_one = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 793   desc_two = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 794   one->parsed = desc_one;
 795   two->parsed = desc_two;
 796
 797   desc_one->timestamp = (time(NULL) + TIME_IN_THE_PAST) - 10;
 798   desc_two->timestamp = time(NULL) - 100;
 799   desc_one->pk = pk_generate(0);
 800   desc_two->pk = pk_generate(1);
 801
 802   strmap_set_lc(rend_cache, "foo1", one);
 803   strmap_set_lc(rend_cache, "foo2", two);
 804
 805   rend_cache_clean(time(NULL), REND_CACHE_TYPE_CLIENT);
 806   tt_int_op(strmap_size(rend_cache), OP_EQ, 1);
 807
 808   iter = strmap_iter_init(rend_cache);
 809   strmap_iter_get(iter, &key, &val);
 810   tt_str_op(key, OP_EQ, "foo2");
 811
 812  done:
 813   rend_cache_free_all();
 814 }
 815
 816 static void
 817 test_rend_cache_failure_entry_new(void *data)
 818 {
 819   rend_cache_failure_t *failure;
 820
 821   (void)data;
 822
 823   failure = rend_cache_failure_entry_new();
 824   tt_assert(failure);
 825   tt_int_op(digestmap_size(failure->intro_failures), OP_EQ, 0);
 826
 827  done:
 828   rend_cache_failure_entry_free(failure);
 829 }
 830
 831 static void
 832 test_rend_cache_failure_entry_free(void *data)
 833 {
 834   (void)data;
 835
 836   // Test that it can deal with a NULL argument
 837   rend_cache_failure_entry_free(NULL);
 838
 839  /* done: */
 840  /*  (void)0; */
 841 }
 842
 843 static void
 844 test_rend_cache_failure_clean(void *data)
 845 {
 846   rend_cache_failure_t *failure;
 847   rend_cache_failure_intro_t *ip_one, *ip_two;
 848
 849   const char key_one[DIGEST_LEN] = "ip1";
 850   const char key_two[DIGEST_LEN] = "ip2";
 851
 852   (void)data;
 853
 854   rend_cache_init();
 855
 856   // Test with empty failure cache
 857   rend_cache_failure_clean(time(NULL));
 858   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 0);
 859
 860   // Test with one empty failure entry
 861   failure = rend_cache_failure_entry_new();
 862   strmap_set_lc(rend_cache_failure, "foo1", failure);
 863   rend_cache_failure_clean(time(NULL));
 864   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 0);
 865
 866   // Test with one new intro point
 867   failure = rend_cache_failure_entry_new();
 868   ip_one = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
 869   digestmap_set(failure->intro_failures, key_one, ip_one);
 870   strmap_set_lc(rend_cache_failure, "foo1", failure);
 871   rend_cache_failure_clean(time(NULL));
 872   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 1);
 873
 874   // Test with one old intro point
 875   rend_cache_failure_purge();
 876   failure = rend_cache_failure_entry_new();
 877   ip_one = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
 878   ip_one->created_ts = time(NULL) - 7*60;
 879   digestmap_set(failure->intro_failures, key_one, ip_one);
 880   strmap_set_lc(rend_cache_failure, "foo1", failure);
 881   rend_cache_failure_clean(time(NULL));
 882   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 0);
 883
 884   // Test with one old intro point and one new one
 885   rend_cache_failure_purge();
 886   failure = rend_cache_failure_entry_new();
 887   ip_one = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
 888   ip_one->created_ts = time(NULL) - 7*60;
 889   digestmap_set(failure->intro_failures, key_one, ip_one);
 890   ip_two = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
 891   ip_two->created_ts = time(NULL) - 2*60;
 892   digestmap_set(failure->intro_failures, key_two, ip_two);
 893   strmap_set_lc(rend_cache_failure, "foo1", failure);
 894   rend_cache_failure_clean(time(NULL));
 895   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 1);
 896   tt_int_op(digestmap_size(failure->intro_failures), OP_EQ, 1);
 897
 898  done:
 899   rend_cache_free_all();
 900 }
 901
 902 static void
 903 test_rend_cache_failure_remove(void *data)
 904 {
 905   rend_service_descriptor_t *desc;
 906   (void)data;
 907
 908   rend_cache_init();
 909
 910   // Test that it deals well with a NULL desc
 911   rend_cache_failure_remove(NULL);
 912
 913   // Test a descriptor that isn't in the cache
 914   desc = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 915   desc->pk = pk_generate(0);
 916   rend_cache_failure_remove(desc);
 917
 918   // There seems to not exist any way of getting rend_cache_failure_remove()
 919   // to fail because of a problem with rend_get_service_id from here
 920   rend_cache_free_all();
 921
 922   rend_service_descriptor_free(desc);
 923  /* done: */
 924  /*  (void)0; */
 925 }
 926
 927 static void
 928 test_rend_cache_free_all(void *data)
 929 {
 930   rend_cache_failure_t *failure;
 931   rend_cache_entry_t *one;
 932   rend_service_descriptor_t *desc_one;
 933
 934   (void)data;
 935
 936   rend_cache_init();
 937
 938   failure = rend_cache_failure_entry_new();
 939   strmap_set_lc(rend_cache_failure, "foo1", failure);
 940
 941   one = tor_malloc_zero(sizeof(rend_cache_entry_t));
 942   desc_one = tor_malloc_zero(sizeof(rend_service_descriptor_t));
 943   one->parsed = desc_one;
 944   desc_one->timestamp = time(NULL) + TIME_IN_THE_PAST;
 945   desc_one->pk = pk_generate(0);
 946   strmap_set_lc(rend_cache, "foo1", one);
 947
 948   rend_cache_free_all();
 949
 950   tt_assert(!rend_cache);
 951   tt_assert(!rend_cache_v2_dir);
 952   tt_assert(!rend_cache_failure);
 953   tt_assert(!rend_cache_total_allocation);
 954
 955  done:
 956   rend_cache_free_all();
 957 }
 958
 959 static void
 960 test_rend_cache_entry_free(void *data)
 961 {
 962   (void)data;
 963   rend_cache_entry_t *e;
 964
 965   // Handles NULL correctly
 966   rend_cache_entry_free(NULL);
 967
 968   // Handles NULL descriptor correctly
 969   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
 970   rend_cache_entry_free(e);
 971
 972   // Handles non-NULL descriptor correctly
 973   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
 974   e->desc = tor_malloc(10);
 975   rend_cache_entry_free(e);
 976
 977  /* done: */
 978  /*  (void)0; */
 979 }
 980
 981 static void
 982 test_rend_cache_purge(void *data)
 983 {
 984   (void)data;
 985
 986   // Deals with a NULL rend_cache
 987   rend_cache_purge();
 988   tt_assert(rend_cache);
 989   tt_assert(strmap_size(rend_cache) == 0);
 990
 991   // Deals with existing rend_cache
 992   rend_cache_free_all();
 993   rend_cache_init();
 994   tt_assert(rend_cache);
 995   tt_assert(strmap_size(rend_cache) == 0);
 996
 997   rend_cache_purge();
 998   tt_assert(rend_cache);
 999   tt_assert(strmap_size(rend_cache) == 0);
1000
1001  done:
1002   rend_cache_free_all();
1003 }
1004
1005 static void
1006 test_rend_cache_failure_intro_add(void *data)
1007 {
1008   (void)data;
1009   rend_cache_failure_t *fail_entry;
1010   rend_cache_failure_intro_t *entry;
1011   const char identity[DIGEST_LEN] = "foo1";
1012
1013   rend_cache_init();
1014
1015   // Adds non-existing entry
1016   cache_failure_intro_add((const uint8_t *) identity, "foo2",
1017                           INTRO_POINT_FAILURE_TIMEOUT);
1018   fail_entry = strmap_get_lc(rend_cache_failure, "foo2");
1019   tt_assert(fail_entry);
1020   tt_int_op(digestmap_size(fail_entry->intro_failures), OP_EQ, 1);
1021   entry = digestmap_get(fail_entry->intro_failures, identity);
1022   tt_assert(entry);
1023
1024   // Adds existing entry
1025   cache_failure_intro_add((const uint8_t *) identity, "foo2",
1026                           INTRO_POINT_FAILURE_TIMEOUT);
1027   fail_entry = strmap_get_lc(rend_cache_failure, "foo2");
1028   tt_assert(fail_entry);
1029   tt_int_op(digestmap_size(fail_entry->intro_failures), OP_EQ, 1);
1030   entry = digestmap_get(fail_entry->intro_failures, identity);
1031   tt_assert(entry);
1032
1033  done:
1034   rend_cache_free_all();
1035 }
1036
1037 static void
1038 test_rend_cache_intro_failure_note(void *data)
1039 {
1040   (void)data;
1041   rend_cache_failure_t *fail_entry;
1042   rend_cache_failure_intro_t *entry;
1043   const char key[DIGEST_LEN] = "foo1";
1044
1045   rend_cache_init();
1046
1047   // Test not found
1048   rend_cache_intro_failure_note(INTRO_POINT_FAILURE_TIMEOUT,
1049                                 (const uint8_t *) key, "foo2");
1050   fail_entry = strmap_get_lc(rend_cache_failure, "foo2");
1051   tt_assert(fail_entry);
1052   tt_int_op(digestmap_size(fail_entry->intro_failures), OP_EQ, 1);
1053   entry = digestmap_get(fail_entry->intro_failures, key);
1054   tt_assert(entry);
1055   tt_int_op(entry->failure_type, OP_EQ, INTRO_POINT_FAILURE_TIMEOUT);
1056
1057   // Test found
1058   rend_cache_intro_failure_note(INTRO_POINT_FAILURE_UNREACHABLE,
1059                                 (const uint8_t *) key, "foo2");
1060   tt_int_op(entry->failure_type, OP_EQ, INTRO_POINT_FAILURE_UNREACHABLE);
1061
1062  done:
1063   rend_cache_free_all();
1064 }
1065
1066 #define NS_SUBMODULE clean_v2_descs_as_dir
1067
1068 static void
1069 test_rend_cache_clean_v2_descs_as_dir(void *data)
1070 {
1071   rend_cache_entry_t *e;
1072   time_t now;
1073   rend_service_descriptor_t *desc;
1074   now = time(NULL);
1075   const char key[DIGEST_LEN] = "abcde";
1076
1077   (void)data;
1078
1079   rend_cache_init();
1080
1081   // Test running with an empty cache
1082   rend_cache_clean_v2_descs_as_dir(now, 0);
1083   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0);
1084
1085   // Test with only one new entry
1086   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
1087   e->last_served = now;
1088   desc = tor_malloc_zero(sizeof(rend_service_descriptor_t));
1089   desc->timestamp = now;
1090   desc->pk = pk_generate(0);
1091   e->parsed = desc;
1092   digestmap_set(rend_cache_v2_dir, key, e);
1093
1094   rend_cache_clean_v2_descs_as_dir(now, 0);
1095   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 1);
1096
1097   // Test with one old entry
1098   desc->timestamp = now - (REND_CACHE_MAX_AGE + REND_CACHE_MAX_SKEW + 1000);
1099   rend_cache_clean_v2_descs_as_dir(now, 0);
1100   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0);
1101
1102   // Test with one entry that has an old last served
1103   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
1104   e->last_served = now - (REND_CACHE_MAX_AGE + REND_CACHE_MAX_SKEW + 1000);
1105   desc = tor_malloc_zero(sizeof(rend_service_descriptor_t));
1106   desc->timestamp = now;
1107   desc->pk = pk_generate(0);
1108   e->parsed = desc;
1109   digestmap_set(rend_cache_v2_dir, key, e);
1110
1111   rend_cache_clean_v2_descs_as_dir(now, 0);
1112   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0);
1113
1114   // Test a run through asking for a large force_remove
1115   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
1116   e->last_served = now;
1117   desc = tor_malloc_zero(sizeof(rend_service_descriptor_t));
1118   desc->timestamp = now;
1119   desc->pk = pk_generate(0);
1120   e->parsed = desc;
1121   digestmap_set(rend_cache_v2_dir, key, e);
1122
1123   rend_cache_clean_v2_descs_as_dir(now, 20000);
1124   tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 1);
1125
1126  done:
1127   rend_cache_free_all();
1128 }
1129
1130 #undef NS_SUBMODULE
1131
1132 static void
1133 test_rend_cache_entry_allocation(void *data)
1134 {
1135   (void)data;
1136
1137   size_t ret;
1138   rend_cache_entry_t *e = NULL;
1139
1140   // Handles a null argument
1141   ret = rend_cache_entry_allocation(NULL);
1142   tt_int_op(ret, OP_EQ, 0);
1143
1144   // Handles a non-null argument
1145   e = tor_malloc_zero(sizeof(rend_cache_entry_t));
1146   ret = rend_cache_entry_allocation(e);
1147   tt_int_op(ret, OP_GT, sizeof(rend_cache_entry_t));
1148
1149  done:
1150   tor_free(e);
1151 }
1152
1153 static void
1154 test_rend_cache_failure_intro_entry_free(void *data)
1155 {
1156   (void)data;
1157   rend_cache_failure_intro_t *entry;
1158
1159   // Handles a null argument
1160   rend_cache_failure_intro_entry_free(NULL);
1161
1162   // Handles a non-null argument
1163   entry = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
1164   rend_cache_failure_intro_entry_free(entry);
1165 }
1166
1167 static void
1168 test_rend_cache_failure_purge(void *data)
1169 {
1170   (void)data;
1171
1172   // Handles a null failure cache
1173   strmap_free(rend_cache_failure, rend_cache_failure_entry_free_);
1174   rend_cache_failure = NULL;
1175
1176   rend_cache_failure_purge();
1177
1178   tt_ptr_op(rend_cache_failure, OP_NE, NULL);
1179   tt_int_op(strmap_size(rend_cache_failure), OP_EQ, 0);
1180
1181  done:
1182   rend_cache_free_all();
1183 }
1184
1185 static void
1186 test_rend_cache_validate_intro_point_failure(void *data)
1187 {
1188   (void)data;
1189   rend_service_descriptor_t *desc = NULL;
1190   char *service_id = NULL;
1191   rend_intro_point_t *intro = NULL;
1192   const char *identity = NULL;
1193   rend_cache_failure_t *failure;
1194   rend_cache_failure_intro_t *ip;
1195
1196   rend_cache_init();
1197
1198   create_descriptor(&desc, &service_id, 3);
1199   desc->timestamp = time(NULL) + RECENT_TIME;
1200
1201   intro = (rend_intro_point_t *)smartlist_get(desc->intro_nodes, 0);
1202   identity = intro->extend_info->identity_digest;
1203
1204   failure = rend_cache_failure_entry_new();
1205   ip = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
1206   digestmap_set(failure->intro_failures, identity, ip);
1207   strmap_set_lc(rend_cache_failure, service_id, failure);
1208
1209   // Test when we have an intro point in our cache
1210   validate_intro_point_failure(desc, service_id);
1211   tt_int_op(smartlist_len(desc->intro_nodes), OP_EQ, 2);
1212
1213  done:
1214   rend_cache_free_all();
1215   rend_service_descriptor_free(desc);
1216   tor_free(service_id);
1217 }
1218
1219 struct testcase_t rend_cache_tests[] = {
1220   { "init", test_rend_cache_init, 0, NULL, NULL },
1221   { "decrement_allocation", test_rend_cache_decrement_allocation, 0,
1222     NULL, NULL },
1223   { "increment_allocation", test_rend_cache_increment_allocation, 0,
1224     NULL, NULL },
1225   { "clean", test_rend_cache_clean, TT_FORK, NULL, NULL },
1226   { "clean_v2_descs_as_dir", test_rend_cache_clean_v2_descs_as_dir, 0,
1227     NULL, NULL },
1228   { "entry_allocation", test_rend_cache_entry_allocation, 0, NULL, NULL },
1229   { "entry_free", test_rend_cache_entry_free, 0, NULL, NULL },
1230   { "failure_intro_entry_free", test_rend_cache_failure_intro_entry_free, 0,
1231     NULL, NULL },
1232   { "free_all", test_rend_cache_free_all, 0, NULL, NULL },
1233   { "purge", test_rend_cache_purge, 0, NULL, NULL },
1234   { "failure_clean", test_rend_cache_failure_clean, 0, NULL, NULL },
1235   { "failure_entry_new", test_rend_cache_failure_entry_new, 0, NULL, NULL },
1236   { "failure_entry_free", test_rend_cache_failure_entry_free, 0, NULL, NULL },
1237   { "failure_intro_add", test_rend_cache_failure_intro_add, 0, NULL, NULL },
1238   { "failure_intro_entry_new", test_rend_cache_failure_intro_entry_new, 0,
1239     NULL, NULL },
1240   { "failure_intro_lookup", test_rend_cache_failure_intro_lookup, 0,
1241     NULL, NULL },
1242   { "failure_purge", test_rend_cache_failure_purge, 0, NULL, NULL },
1243   { "failure_remove", test_rend_cache_failure_remove, 0, NULL, NULL },
1244   { "intro_failure_note", test_rend_cache_intro_failure_note, 0, NULL, NULL },
1245   { "lookup", test_rend_cache_lookup_entry, 0, NULL, NULL },
1246   { "lookup_v2_desc_as_dir", test_rend_cache_lookup_v2_desc_as_dir, 0,
1247     NULL, NULL },
1248   { "store_v2_desc_as_client", test_rend_cache_store_v2_desc_as_client, 0,
1249     NULL, NULL },
1250   { "store_v2_desc_as_client_with_different_time",
1251     test_rend_cache_store_v2_desc_as_client_with_different_time, 0,
1252     NULL, NULL },
1253   { "store_v2_desc_as_dir", test_rend_cache_store_v2_desc_as_dir, 0,
1254     NULL, NULL },
1255   { "store_v2_desc_as_dir_with_different_time",
1256     test_rend_cache_store_v2_desc_as_dir_with_different_time, 0, NULL, NULL },
1257   { "store_v2_desc_as_dir_with_different_content",
1258     test_rend_cache_store_v2_desc_as_dir_with_different_content, 0,
1259     NULL, NULL },
1260   { "validate_intro_point_failure",
1261     test_rend_cache_validate_intro_point_failure, 0, NULL, NULL },
1262   END_OF_TESTCASES
1263 };
1264