static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); (void)arg; NS_MOCK(geoip_is_loaded); NS_MOCK(geoip_get_n_countries); NS_MOCK(geoip_get_country); smartlist_add(set->country_names, tor_strndup("foo", 3)); routerset_refresh_countries(set); tt_ptr_op(set->countries, !=, NULL); tt_int_op(set->n_countries, ==, 2); tt_int_op(CALLED(geoip_is_loaded), ==, 1); tt_int_op(CALLED(geoip_get_n_countries), ==, 1); tt_int_op(CALLED(geoip_get_country), ==, 1); tt_int_op((unsigned int)(*set->countries), ==, 0); done: NS_UNMOCK(geoip_is_loaded); NS_UNMOCK(geoip_get_n_countries); NS_UNMOCK(geoip_get_country); routerset_free(set); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); (void)arg; NS_MOCK(geoip_is_loaded); NS_MOCK(geoip_get_n_countries); NS_MOCK(geoip_get_country); routerset_refresh_countries(set); tt_ptr_op(set->countries, OP_NE, NULL); tt_int_op(set->n_countries, OP_EQ, 1); tt_int_op((unsigned int)(*set->countries), OP_EQ, 0); tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1); tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1); tt_int_op(CALLED(geoip_get_country), OP_EQ, 0); done: NS_UNMOCK(geoip_is_loaded); NS_UNMOCK(geoip_get_n_countries); NS_UNMOCK(geoip_get_country); routerset_free(set); }
static void test_rend_cache_store_v2_desc_as_dir_with_different_content(void *data) { (void)data; rend_cache_store_status_t ret; rend_service_descriptor_t *generated = NULL; smartlist_t *descs = smartlist_new(); time_t t; char *service_id = NULL; rend_encoded_v2_service_descriptor_t *desc_holder_one = NULL; rend_encoded_v2_service_descriptor_t *desc_holder_two = NULL; NS_MOCK(router_get_my_routerinfo); NS_MOCK(hid_serv_responsible_for_desc_id); rend_cache_init(); t = time(NULL); create_descriptor(&generated, &service_id, 3); generated->timestamp = t + RECENT_TIME; rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0, REND_NO_AUTH, NULL, NULL); desc_holder_one = ((rend_encoded_v2_service_descriptor_t *) smartlist_get(descs, 0)); smartlist_set(descs, 0, NULL); SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d, rend_encoded_v2_service_descriptor_free(d)); smartlist_free(descs); descs = smartlist_new(); generated->timestamp = t + RECENT_TIME; generated->protocols = 41; rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0, REND_NO_AUTH, NULL, NULL); desc_holder_two = ((rend_encoded_v2_service_descriptor_t *) smartlist_get(descs, 0)); smartlist_set(descs, 0, NULL); // Test when we have another descriptor stored, with a different descriptor mock_routerinfo = tor_malloc(sizeof(routerinfo_t)); hid_serv_responsible_for_desc_id_response = 1; rend_cache_store_v2_desc_as_dir(desc_holder_one->desc_str); ret = rend_cache_store_v2_desc_as_dir(desc_holder_two->desc_str); tt_int_op(ret, OP_EQ, RCS_OKAY); done: NS_UNMOCK(router_get_my_routerinfo); NS_UNMOCK(hid_serv_responsible_for_desc_id); rend_cache_free_all(); rend_service_descriptor_free(generated); tor_free(service_id); SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d, rend_encoded_v2_service_descriptor_free(d)); smartlist_free(descs); rend_encoded_v2_service_descriptor_free(desc_holder_one); rend_encoded_v2_service_descriptor_free(desc_holder_two); }
static void NS(test_main)(void *arg) { int expected, actual; (void)arg; NS_MOCK(tls_get_write_overhead_ratio); NS_MOCK(we_are_hibernating); NS_MOCK(public_server_mode); NS_MOCK(get_uptime); NS_MOCK(get_bytes_read); NS_MOCK(get_bytes_written); NS_MOCK(logv); NS_MOCK(server_mode); NS_MOCK(accounting_is_enabled); stats_n_data_cells_packaged = 0; log_global_min_severity_ = LOG_DEBUG; expected = 0; actual = log_heartbeat(0); tt_int_op(actual, OP_EQ, expected); tt_int_op(CALLED(logv), OP_EQ, 2); done: NS_UNMOCK(tls_get_write_overhead_ratio); NS_UNMOCK(we_are_hibernating); NS_UNMOCK(public_server_mode); NS_UNMOCK(get_uptime); NS_UNMOCK(get_bytes_read); NS_UNMOCK(get_bytes_written); NS_UNMOCK(logv); NS_UNMOCK(server_mode); NS_UNMOCK(accounting_is_enabled); }
static void NS(test_main)(void *arg) { int retval; int made_pending = 0; pending_connection_t *pending_conn = NULL; edge_connection_t *exitconn = create_valid_exitconn(); or_circuit_t *on_circ = tor_malloc_zero(sizeof(or_circuit_t)); cached_resolve_t *cache_entry = NULL; cached_resolve_t query; (void)arg; TO_CONN(exitconn)->address = tor_strdup("torproject.org"); strlcpy(query.address, TO_CONN(exitconn)->address, sizeof(query.address)); NS_MOCK(router_my_exit_policy_is_reject_star); NS_MOCK(launch_resolve); dns_init(); retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending, NULL); tt_int_op(retval,OP_EQ,0); tt_int_op(made_pending,OP_EQ,1); cache_entry = dns_get_cache_entry(&query); tt_assert(cache_entry); pending_conn = cache_entry->pending_connections; tt_assert(pending_conn != NULL); tt_assert(pending_conn->conn == exitconn); tt_assert(last_launched_resolve == cache_entry); tt_str_op(cache_entry->address,OP_EQ,TO_CONN(exitconn)->address); done: NS_UNMOCK(router_my_exit_policy_is_reject_star); NS_UNMOCK(launch_resolve); tor_free(on_circ); tor_free(TO_CONN(exitconn)->address); if (cache_entry) tor_free(cache_entry->pending_connections); tor_free(cache_entry); tor_free(exitconn); return; }
static void NS(test_main)(void *arg) { int retval; int made_pending = 0; edge_connection_t *exitconn = create_valid_exitconn(); or_circuit_t *on_circ = tor_malloc_zero(sizeof(or_circuit_t)); cached_resolve_t *resolve_out = NULL; cached_resolve_t *cache_entry = tor_malloc_zero(sizeof(cached_resolve_t)); cache_entry->magic = CACHED_RESOLVE_MAGIC; cache_entry->state = CACHE_STATE_CACHED; cache_entry->minheap_idx = -1; cache_entry->expire = time(NULL) + 60 * 60; (void)arg; TO_CONN(exitconn)->address = tor_strdup("torproject.org"); strlcpy(cache_entry->address, TO_CONN(exitconn)->address, sizeof(cache_entry->address)); NS_MOCK(router_my_exit_policy_is_reject_star); NS_MOCK(set_exitconn_info_from_resolve); dns_init(); dns_insert_cache_entry(cache_entry); retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending, &resolve_out); tt_int_op(retval,OP_EQ,0); tt_int_op(made_pending,OP_EQ,0); tt_assert(resolve_out == cache_entry); tt_assert(last_exitconn == exitconn); tt_assert(last_resolve == cache_entry); done: NS_UNMOCK(router_my_exit_policy_is_reject_star); NS_UNMOCK(set_exitconn_info_from_resolve); tor_free(on_circ); tor_free(TO_CONN(exitconn)->address); tor_free(cache_entry->pending_connections); tor_free(cache_entry); return; }
static void NS(test_main)(void *arg) { int expected, actual; (void)arg; NS_MOCK(tls_get_write_overhead_ratio); NS_MOCK(we_are_hibernating); NS_MOCK(public_server_mode); NS_MOCK(get_uptime); NS_MOCK(get_bytes_read); NS_MOCK(get_bytes_written); NS_MOCK(logv); NS_MOCK(server_mode); log_global_min_severity_ = LOG_DEBUG; expected = 0; actual = log_heartbeat(0); tt_int_op(actual, OP_EQ, expected); tt_int_op(NS(n_msgs), OP_EQ, 1); done: NS_UNMOCK(tls_get_write_overhead_ratio); NS_UNMOCK(we_are_hibernating); NS_UNMOCK(public_server_mode); NS_UNMOCK(get_uptime); NS_UNMOCK(get_bytes_read); NS_UNMOCK(get_bytes_written); NS_UNMOCK(logv); NS_UNMOCK(server_mode); }
static void NS(test_main)(void *arg) { routerset_t *set, *bad_set; (void)arg; set = routerset_new(); bad_set = routerset_new(); smartlist_free(bad_set->list); bad_set->list = NULL; NS_MOCK(smartlist_new); routerset_union(set, NULL); tt_int_op(CALLED(smartlist_new), ==, 0); routerset_union(set, bad_set); tt_int_op(CALLED(smartlist_new), ==, 0); done: NS_UNMOCK(smartlist_new); routerset_free(set); /* Just recreate list, so we can simply use routerset_free. */ bad_set->list = smartlist_new(); routerset_free(bad_set); }
static void NS(test_main)(void *arg) { /* Choose origin_circuit_t wlog. */ origin_circuit_t *mock_circuit1, *mock_circuit2; int expected_circuits = 2, actual_circuits; (void)arg; mock_circuit1 = tor_malloc_zero(sizeof(origin_circuit_t)); mock_circuit2 = tor_malloc_zero(sizeof(origin_circuit_t)); mock_global_circuitlist = smartlist_new(); smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit1)); smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit2)); NS_MOCK(circuit_get_global_list); actual_circuits = count_circuits(); tt_assert(expected_circuits == actual_circuits); done: tor_free(mock_circuit1); tor_free(mock_circuit2); smartlist_free(mock_global_circuitlist); mock_global_circuitlist = NULL; NS_UNMOCK(circuit_get_global_list); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); smartlist_t *out = smartlist_new(); int r; (void)arg; NS_MOCK(nodelist_get_list); smartlist_add(set->country_names, tor_strdup("{xx}")); NS(mock_smartlist) = smartlist_new(); NS(mock_node).is_running = 0; smartlist_add(NS(mock_smartlist), (void *)&NS(mock_node)); routerset_get_all_nodes(out, set, NULL, 1); r = smartlist_len(out); routerset_free(set); smartlist_free(out); smartlist_free(NS(mock_smartlist)); tt_int_op(r, ==, 0); tt_int_op(CALLED(nodelist_get_list), ==, 1); done: ; }
static void NS(test_main)(void *arg) { smartlist_t *out = smartlist_new(); routerset_t *set = routerset_new(); int out_len; node_t *ent; (void)arg; NS_MOCK(node_get_by_nickname); NS(mock_nickname) = tor_strdup("foo"); smartlist_add(set->list, NS(mock_nickname)); routerset_get_all_nodes(out, set, NULL, 0); out_len = smartlist_len(out); ent = (node_t *)smartlist_get(out, 0); smartlist_free(out); routerset_free(set); tt_int_op(out_len, ==, 1); tt_ptr_op(ent, ==, &NS(mock_node)); tt_int_op(CALLED(node_get_by_nickname), ==, 1); done: ; }
static void NS(test_main)(void *arg) { smartlist_t *out = smartlist_new(); routerset_t *set = routerset_new(); int out_len; (void)arg; NS_MOCK(node_get_by_nickname); NS(mock_node).is_running = 0; NS(mock_nickname) = "foo"; smartlist_add(set->list, tor_strdup(NS(mock_nickname))); routerset_get_all_nodes(out, set, NULL, 1); out_len = smartlist_len(out); smartlist_free(out); routerset_free(set); tt_int_op(out_len, ==, 0); tt_int_op(CALLED(node_get_by_nickname), ==, 1); done: ; }
static void NS(test_main)(void *arg) { int retval; int made_pending; edge_connection_t *exitconn = create_valid_exitconn(); or_circuit_t *on_circ = tor_malloc_zero(sizeof(or_circuit_t)); (void)arg; NS_MOCK(router_my_exit_policy_is_reject_star); TO_CONN(exitconn)->address = tor_strdup("invalid#@!.org"); retval = dns_resolve_impl(exitconn, 1, on_circ, NULL, &made_pending, NULL); tt_int_op(retval,OP_EQ,-1); done: NS_UNMOCK(router_my_exit_policy_is_reject_star); tor_free(TO_CONN(exitconn)->address); tor_free(exitconn); tor_free(on_circ); return; }
static void NS(test_main)(void *arg) { routerset_t *routerset = routerset_new(); (void)arg; NS_MOCK(smartlist_free); NS_MOCK(strmap_free); NS_MOCK(digestmap_free); routerset_free(routerset); tt_int_op(CALLED(smartlist_free), !=, 0); tt_int_op(CALLED(strmap_free), !=, 0); tt_int_op(CALLED(digestmap_free), !=, 0); done: ; }
static void test_rend_cache_lookup_v2_desc_as_dir(void *data) { int ret; char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1]; rend_encoded_v2_service_descriptor_t *desc_holder = NULL; char *service_id = NULL; const char *ret_desc = NULL; (void)data; NS_MOCK(router_get_my_routerinfo); NS_MOCK(hid_serv_responsible_for_desc_id); rend_cache_init(); // Test invalid base32 ret = rend_cache_lookup_v2_desc_as_dir("!bababababababab", NULL); tt_int_op(ret, OP_EQ, -1); // Test non-existent descriptor but well formed ret = rend_cache_lookup_v2_desc_as_dir("3xqunszqnaolrrfmtzgaki7mxelgvkje", NULL); tt_int_op(ret, OP_EQ, 0); // Test existing descriptor hid_serv_responsible_for_desc_id_response = 1; generate_desc(RECENT_TIME, &desc_holder, &service_id, 3); rend_cache_store_v2_desc_as_dir(desc_holder->desc_str); base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_holder->desc_id, DIGEST_LEN); ret = rend_cache_lookup_v2_desc_as_dir(desc_id_base32, &ret_desc); tt_int_op(ret, OP_EQ, 1); tt_assert(ret_desc); done: NS_UNMOCK(router_get_my_routerinfo); NS_UNMOCK(hid_serv_responsible_for_desc_id); tor_free(mock_routerinfo); rend_cache_free_all(); rend_encoded_v2_service_descriptor_free(desc_holder); tor_free(service_id); }
static void test_rend_cache_store_v2_desc_as_dir(void *data) { (void)data; int ret; rend_encoded_v2_service_descriptor_t *desc_holder = NULL; char *service_id = NULL; NS_MOCK(router_get_my_routerinfo); rend_cache_init(); // Test when we can't parse the descriptor mock_routerinfo = tor_malloc(sizeof(routerinfo_t)); ret = rend_cache_store_v2_desc_as_dir("unparseable"); tt_int_op(ret, OP_EQ, -1); // Test when we have an old descriptor generate_desc(TIME_IN_THE_PAST, &desc_holder, &service_id, 3); ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str); tt_int_op(ret, OP_EQ, 0); rend_encoded_v2_service_descriptor_free(desc_holder); tor_free(service_id); // Test when we have a descriptor in the future generate_desc(TIME_IN_THE_FUTURE, &desc_holder, &service_id, 3); ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str); tt_int_op(ret, OP_EQ, 0); rend_encoded_v2_service_descriptor_free(desc_holder); tor_free(service_id); // Test when two descriptors generate_desc(TIME_IN_THE_FUTURE, &desc_holder, &service_id, 3); ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str); tt_int_op(ret, OP_EQ, 0); rend_encoded_v2_service_descriptor_free(desc_holder); tor_free(service_id); // Test when asking for hidden service statistics HiddenServiceStatistics rend_cache_purge(); generate_desc(RECENT_TIME, &desc_holder, &service_id, 3); get_options_mutable()->HiddenServiceStatistics = 1; ret = rend_cache_store_v2_desc_as_dir(desc_holder->desc_str); tt_int_op(ret, OP_EQ, 0); done: NS_UNMOCK(router_get_my_routerinfo); rend_encoded_v2_service_descriptor_free(desc_holder); tor_free(service_id); rend_cache_free_all(); tor_free(mock_routerinfo); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); routerset_t **setp = &set; int r; (void)arg; NS_MOCK(geoip_get_country); NS_MOCK(geoip_is_loaded); r = routerset_add_unknown_ccs(setp, 0); tt_int_op(r, ==, 1); tt_int_op(smartlist_contains_string(set->country_names, "a1"), ==, 1); tt_int_op(smartlist_contains_string(set->list, "{a1}"), ==, 1); done: if (set != NULL) routerset_free(set); }
static void NS(test_main)(void *arg) { int expected, actual; (void)arg; NS_MOCK(tls_get_write_overhead_ratio); NS_MOCK(we_are_hibernating); NS_MOCK(public_server_mode); NS_MOCK(router_get_my_routerinfo); expected = -1; actual = log_heartbeat(0); tt_int_op(actual, OP_EQ, expected); done: NS_UNMOCK(tls_get_write_overhead_ratio); NS_UNMOCK(we_are_hibernating); NS_UNMOCK(public_server_mode); NS_UNMOCK(router_get_my_routerinfo); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); int contains = 1; (void)arg; NS_MOCK(compare_tor_addr_to_addr_policy); NS_MOCK(geoip_get_country_by_addr); set->countries = bitarray_init_zero(1); bitarray_set(set->countries, 1); contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1); routerset_free(set); tt_int_op(contains, ==, 0); tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); tt_int_op(CALLED(geoip_get_country_by_addr), ==, 1); done: ; }
static void NS(test_main)(void *arg) { (void)arg; NS_MOCK(smartlist_free); routerset_free(NULL); tt_int_op(CALLED(smartlist_free), ==, 0); done: ; }
/* If no distribution option was set, then check_bridge_distribution_setting() * should have set it to "any". */ static void test_router_dump_router_to_string_no_bridge_distribution_method(void *arg) { const char* needle = "bridge-distribution-request any"; or_options_t* options = get_options_mutable(); routerinfo_t* router = NULL; curve25519_keypair_t ntor_keypair; ed25519_keypair_t signing_keypair; char* desc = NULL; char* found = NULL; (void)arg; NS_MOCK(router_get_my_routerinfo); options->ORPort_set = 1; options->BridgeRelay = 1; /* Generate keys which router_dump_router_to_string() expects to exist. */ tt_int_op(0, ==, curve25519_keypair_generate(&ntor_keypair, 0)); tt_int_op(0, ==, ed25519_keypair_generate(&signing_keypair, 0)); /* Set up part of our routerinfo_t so that we don't trigger any other * assertions in router_dump_router_to_string(). */ router = (routerinfo_t*)router_get_my_routerinfo(); tt_ptr_op(router, !=, NULL); /* The real router_get_my_routerinfo() looks up onion_curve25519_pkey using * get_current_curve25519_keypair(), but we don't initialise static data in * this test. */ router->onion_curve25519_pkey = &ntor_keypair.pubkey; /* Generate our server descriptor and ensure that the substring * "bridge-distribution-request any" occurs somewhere within it. */ crypto_pk_t *onion_pkey = router_get_rsa_onion_pkey(router->onion_pkey, router->onion_pkey_len); desc = router_dump_router_to_string(router, router->identity_pkey, onion_pkey, &ntor_keypair, &signing_keypair); crypto_pk_free(onion_pkey); tt_ptr_op(desc, !=, NULL); found = strstr(desc, needle); tt_ptr_op(found, !=, NULL); done: NS_UNMOCK(router_get_my_routerinfo); tor_free(desc); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); int contains; (void)arg; NS_MOCK(compare_tor_addr_to_addr_policy); contains = routerset_contains(set, NULL, 0, NULL, NULL, 0); routerset_free(set); tt_int_op(contains, ==, 0); done: ; }
static void NS(test_main)(void *arg) { routerset_t *set = NULL; routerset_t **setp = &set; int r; (void)arg; NS_MOCK(geoip_get_country); r = routerset_add_unknown_ccs(setp, 0); tt_ptr_op(*setp, !=, NULL); tt_int_op(r, ==, 0); done: if (set != NULL) routerset_free(set); }
static void test_accounting_limits(void *arg) { or_options_t *options = get_options_mutable(); time_t fake_time = time(NULL); (void) arg; NS_MOCK(get_or_state); or_state = or_state_new(); options->AccountingMax = 100; options->AccountingRule = ACCT_MAX; tor_assert(accounting_is_enabled(options)); configure_accounting(fake_time); accounting_add_bytes(10, 0, 1); fake_time += 1; consider_hibernation(fake_time); tor_assert(we_are_hibernating() == 0); accounting_add_bytes(90, 0, 1); fake_time += 1; consider_hibernation(fake_time); tor_assert(we_are_hibernating() == 1); options->AccountingMax = 200; options->AccountingRule = ACCT_SUM; accounting_add_bytes(0, 10, 1); fake_time += 1; consider_hibernation(fake_time); tor_assert(we_are_hibernating() == 0); accounting_add_bytes(0, 90, 1); fake_time += 1; consider_hibernation(fake_time); tor_assert(we_are_hibernating() == 1); goto done; done: NS_UNMOCK(get_or_state); or_state_free(or_state); }
static void NS(test_main)(void *arg) { routerset_t *set = routerset_new(); tor_addr_t *addr = MOCK_TOR_ADDR_PTR; int contains; (void)arg; NS_MOCK(compare_tor_addr_to_addr_policy); contains = routerset_contains(set, addr, 0, NULL, NULL, 0); routerset_free(set); tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); tt_int_op(contains, ==, 0); done: ; }
static void NS(test_main)(void *arg) { routerset_t *set; const char *s; int r; (void)arg; NS_MOCK(router_parse_addr_policy_item_from_string); NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t)); set = routerset_new(); s = "*"; r = routerset_parse(set, s, ""); tt_int_op(r, ==, 0); tt_int_op(smartlist_len(set->policies), !=, 0); tt_int_op(CALLED(router_parse_addr_policy_item_from_string), ==, 1); done: routerset_free(set); }
static void NS(test_main)(void *arg) { int expected, actual; (void)arg; NS_MOCK(tls_get_write_overhead_ratio); NS_MOCK(we_are_hibernating); NS_MOCK(public_server_mode); NS_MOCK(router_get_my_routerinfo); NS_MOCK(node_get_by_id); NS_MOCK(logv); NS_MOCK(server_mode); log_global_min_severity_ = LOG_DEBUG; onion_handshakes_requested[ONION_HANDSHAKE_TYPE_TAP] = 1; onion_handshakes_assigned[ONION_HANDSHAKE_TYPE_TAP] = 1; onion_handshakes_requested[ONION_HANDSHAKE_TYPE_NTOR] = 1; onion_handshakes_assigned[ONION_HANDSHAKE_TYPE_NTOR] = 1; expected = 0; actual = log_heartbeat(0); tt_int_op(actual, OP_EQ, expected); tt_int_op(CALLED(logv), OP_EQ, 4); done: NS_UNMOCK(tls_get_write_overhead_ratio); NS_UNMOCK(we_are_hibernating); NS_UNMOCK(public_server_mode); NS_UNMOCK(router_get_my_routerinfo); NS_UNMOCK(node_get_by_id); NS_UNMOCK(logv); NS_UNMOCK(server_mode); tor_free(mock_routerinfo); }
static void test_rend_cache_store_v2_desc_as_dir_with_different_time(void *data) { (void)data; int ret; rend_service_descriptor_t *generated = NULL; smartlist_t *descs = smartlist_new(); time_t t; char *service_id = NULL; rend_encoded_v2_service_descriptor_t *desc_holder_newer; rend_encoded_v2_service_descriptor_t *desc_holder_older; NS_MOCK(router_get_my_routerinfo); rend_cache_init(); t = time(NULL); create_descriptor(&generated, &service_id, 3); generated->timestamp = t + RECENT_TIME; rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0, REND_NO_AUTH, NULL, NULL); desc_holder_newer = ((rend_encoded_v2_service_descriptor_t *) smartlist_get(descs, 0)); smartlist_set(descs, 0, NULL); SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d, rend_encoded_v2_service_descriptor_free(d)); smartlist_free(descs); descs = smartlist_new(); generated->timestamp = (t + RECENT_TIME) - 20; rend_encode_v2_descriptors(descs, generated, t + RECENT_TIME, 0, REND_NO_AUTH, NULL, NULL); desc_holder_older = ((rend_encoded_v2_service_descriptor_t *) smartlist_get(descs, 0)); smartlist_set(descs, 0, NULL); // Test when we have a newer descriptor stored mock_routerinfo = tor_malloc(sizeof(routerinfo_t)); rend_cache_store_v2_desc_as_dir(desc_holder_newer->desc_str); ret = rend_cache_store_v2_desc_as_dir(desc_holder_older->desc_str); tt_int_op(ret, OP_EQ, 0); // Test when we have an old descriptor stored rend_cache_purge(); rend_cache_store_v2_desc_as_dir(desc_holder_older->desc_str); ret = rend_cache_store_v2_desc_as_dir(desc_holder_newer->desc_str); tt_int_op(ret, OP_EQ, 0); done: NS_UNMOCK(router_get_my_routerinfo); rend_cache_free_all(); rend_service_descriptor_free(generated); tor_free(service_id); SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d, rend_encoded_v2_service_descriptor_free(d)); smartlist_free(descs); rend_encoded_v2_service_descriptor_free(desc_holder_newer); rend_encoded_v2_service_descriptor_free(desc_holder_older); tor_free(mock_routerinfo); }
static void NS(test_main)(void *arg) { (void) arg; int retval; int prev_n_send_resolved_hostname_cell_replacement; int prev_n_send_resolved_cell_replacement; int prev_n_connection_free; cached_resolve_t *fake_resolved = tor_malloc(sizeof(cached_resolve_t)); edge_connection_t *exitconn = tor_malloc(sizeof(edge_connection_t)); edge_connection_t *nextconn = tor_malloc(sizeof(edge_connection_t)); or_circuit_t *on_circuit = tor_malloc(sizeof(or_circuit_t)); memset(on_circuit,0,sizeof(or_circuit_t)); on_circuit->base_.magic = OR_CIRCUIT_MAGIC; memset(fake_resolved,0,sizeof(cached_resolve_t)); memset(exitconn,0,sizeof(edge_connection_t)); memset(nextconn,0,sizeof(edge_connection_t)); NS_MOCK(dns_resolve_impl); NS_MOCK(send_resolved_cell); NS_MOCK(send_resolved_hostname_cell); /* * CASE 1: dns_resolve_impl returns 1 and sets a hostname. purpose is * EXIT_PURPOSE_RESOLVE. * * We want dns_resolve() to call send_resolved_hostname_cell() for a * given exit connection (represented by edge_connection_t object) * with a hostname it received from _impl. */ prev_n_send_resolved_hostname_cell_replacement = n_send_resolved_hostname_cell_replacement; exitconn->base_.purpose = EXIT_PURPOSE_RESOLVE; exitconn->on_circuit = &(on_circuit->base_); resolve_retval = 1; resolved_name = tor_strdup("www.torproject.org"); retval = dns_resolve(exitconn); tt_int_op(retval,OP_EQ,1); tt_str_op(resolved_name,OP_EQ,last_resolved_hostname); tt_assert(conn_for_resolved_cell == exitconn); tt_int_op(n_send_resolved_hostname_cell_replacement,OP_EQ, prev_n_send_resolved_hostname_cell_replacement + 1); tt_assert(exitconn->on_circuit == NULL); tor_free(last_resolved_hostname); // implies last_resolved_hostname = NULL; /* CASE 2: dns_resolve_impl returns 1, but does not set hostname. * Instead, it yields cached_resolve_t object. * * We want dns_resolve to call send_resolved_cell on exitconn with * RESOLVED_TYPE_AUTO and the cached_resolve_t object from _impl. */ tor_free(resolved_name); resolved_name = NULL; exitconn->on_circuit = &(on_circuit->base_); cache_entry_mock = fake_resolved; prev_n_send_resolved_cell_replacement = n_send_resolved_cell_replacement; retval = dns_resolve(exitconn); tt_int_op(retval,OP_EQ,1); tt_assert(conn_for_resolved_cell == exitconn); tt_int_op(n_send_resolved_cell_replacement,OP_EQ, prev_n_send_resolved_cell_replacement + 1); tt_assert(last_resolved == fake_resolved); tt_int_op(last_answer_type,OP_EQ,0xff); tt_assert(exitconn->on_circuit == NULL); /* CASE 3: The purpose of exit connection is not EXIT_PURPOSE_RESOLVE * and _impl returns 1. * * We want dns_resolve to prepend exitconn to n_streams linked list. * We don't want it to send any cells about hostname being resolved. */ exitconn->base_.purpose = EXIT_PURPOSE_CONNECT; exitconn->on_circuit = &(on_circuit->base_); on_circuit->n_streams = nextconn; prev_n_send_resolved_cell_replacement = n_send_resolved_cell_replacement; prev_n_send_resolved_hostname_cell_replacement = n_send_resolved_hostname_cell_replacement; retval = dns_resolve(exitconn); tt_int_op(retval,OP_EQ,1); tt_assert(on_circuit->n_streams == exitconn); tt_assert(exitconn->next_stream == nextconn); tt_int_op(prev_n_send_resolved_cell_replacement,OP_EQ, n_send_resolved_cell_replacement); tt_int_op(prev_n_send_resolved_hostname_cell_replacement,OP_EQ, n_send_resolved_hostname_cell_replacement); /* CASE 4: _impl returns 0. * * We want dns_resolve() to set exitconn state to * EXIT_CONN_STATE_RESOLVING and prepend exitconn to resolving_streams * linked list. */ exitconn->on_circuit = &(on_circuit->base_); resolve_retval = 0; exitconn->next_stream = NULL; on_circuit->resolving_streams = nextconn; retval = dns_resolve(exitconn); tt_int_op(retval,OP_EQ,0); tt_int_op(exitconn->base_.state,OP_EQ,EXIT_CONN_STATE_RESOLVING); tt_assert(on_circuit->resolving_streams == exitconn); tt_assert(exitconn->next_stream == nextconn); /* CASE 5: _impl returns -1 when purpose of exitconn is * EXIT_PURPOSE_RESOLVE. We want dns_resolve to call send_resolved_cell * on exitconn with type being RESOLVED_TYPE_ERROR. */ NS_MOCK(dns_cancel_pending_resolve); NS_MOCK(connection_free_); exitconn->on_circuit = &(on_circuit->base_); exitconn->base_.purpose = EXIT_PURPOSE_RESOLVE; resolve_retval = -1; prev_n_send_resolved_cell_replacement = n_send_resolved_cell_replacement; prev_n_connection_free = n_connection_free; retval = dns_resolve(exitconn); tt_int_op(retval,OP_EQ,-1); tt_int_op(n_send_resolved_cell_replacement,OP_EQ, prev_n_send_resolved_cell_replacement + 1); tt_int_op(last_answer_type,OP_EQ,RESOLVED_TYPE_ERROR); tt_int_op(n_dns_cancel_pending_resolve_replacement,OP_EQ,1); tt_int_op(n_connection_free,OP_EQ,prev_n_connection_free + 1); tt_assert(last_freed_conn == TO_CONN(exitconn)); done: NS_UNMOCK(dns_resolve_impl); NS_UNMOCK(send_resolved_cell); NS_UNMOCK(send_resolved_hostname_cell); NS_UNMOCK(dns_cancel_pending_resolve); NS_UNMOCK(connection_free_); tor_free(on_circuit); tor_free(exitconn); tor_free(nextconn); tor_free(resolved_name); tor_free(fake_resolved); tor_free(last_resolved_hostname); return; }
static void test_rend_cache_clean_v2_descs_as_dir(void *data) { rend_cache_entry_t *e; time_t now; rend_service_descriptor_t *desc; now = time(NULL); const char key[DIGEST_LEN] = "abcde"; (void)data; NS_MOCK(hid_serv_responsible_for_desc_id); rend_cache_init(); // Test running with an empty cache rend_cache_clean_v2_descs_as_dir(now, 0); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0); // Test with only one new entry e = tor_malloc_zero(sizeof(rend_cache_entry_t)); e->last_served = now; desc = tor_malloc_zero(sizeof(rend_service_descriptor_t)); desc->timestamp = now; desc->pk = pk_generate(0); e->parsed = desc; digestmap_set(rend_cache_v2_dir, key, e); hid_serv_responsible_for_desc_id_response = 1; rend_cache_clean_v2_descs_as_dir(now, 0); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 1); // Test with one old entry desc->timestamp = now - (REND_CACHE_MAX_AGE + REND_CACHE_MAX_SKEW + 1000); rend_cache_clean_v2_descs_as_dir(now, 0); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0); // Test with one entry that is not under the responsibility of this // hidden service e = tor_malloc_zero(sizeof(rend_cache_entry_t)); e->last_served = now; desc = tor_malloc_zero(sizeof(rend_service_descriptor_t)); desc->timestamp = now; desc->pk = pk_generate(0); e->parsed = desc; digestmap_set(rend_cache_v2_dir, key, e); hid_serv_responsible_for_desc_id_response = 0; rend_cache_clean_v2_descs_as_dir(now, 0); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0); // Test with one entry that has an old last served e = tor_malloc_zero(sizeof(rend_cache_entry_t)); e->last_served = now - (REND_CACHE_MAX_AGE + REND_CACHE_MAX_SKEW + 1000); desc = tor_malloc_zero(sizeof(rend_service_descriptor_t)); desc->timestamp = now; desc->pk = pk_generate(0); e->parsed = desc; digestmap_set(rend_cache_v2_dir, key, e); hid_serv_responsible_for_desc_id_response = 1; rend_cache_clean_v2_descs_as_dir(now, 0); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 0); // Test a run through asking for a large force_remove e = tor_malloc_zero(sizeof(rend_cache_entry_t)); e->last_served = now; desc = tor_malloc_zero(sizeof(rend_service_descriptor_t)); desc->timestamp = now; desc->pk = pk_generate(0); e->parsed = desc; digestmap_set(rend_cache_v2_dir, key, e); hid_serv_responsible_for_desc_id_response = 1; rend_cache_clean_v2_descs_as_dir(now, 20000); tt_int_op(digestmap_size(rend_cache_v2_dir), OP_EQ, 1); done: NS_UNMOCK(hid_serv_responsible_for_desc_id); rend_cache_free_all(); }