static void
test_rend_cache_validate_intro_point_failure(void *data)
{
(void)data;
rend_service_descriptor_t *desc = NULL;
char *service_id = NULL;
rend_intro_point_t *intro = NULL;
const char *identity = NULL;
rend_cache_failure_t *failure;
rend_cache_failure_intro_t *ip;
rend_cache_init();
create_descriptor(&desc, &service_id, 3);
desc->timestamp = time(NULL) + RECENT_TIME;
intro = (rend_intro_point_t *)smartlist_get(desc->intro_nodes, 0);
identity = intro->extend_info->identity_digest;
failure = rend_cache_failure_entry_new();
ip = rend_cache_failure_intro_entry_new(INTRO_POINT_FAILURE_TIMEOUT);
digestmap_set(failure->intro_failures, identity, ip);
strmap_set_lc(rend_cache_failure, service_id, failure);
// Test when we have an intro point in our cache
validate_intro_point_failure(desc, service_id);
tt_int_op(smartlist_len(desc->intro_nodes), OP_EQ, 2);
done:
rend_cache_free_all();
rend_service_descriptor_free(desc);
tor_free(service_id);
}
size_t list_allocate_string(struct list_table* table)
{
if(!table) return 0;
struct list_descriptor* desc = create_descriptor(unique_desc_id(), STRING);
insert_descriptor(table, desc);
return desc->list_id;
}
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);
}
size_t list_allocate_float(struct list_table* table)
{
if(!table) return 0;
struct list_descriptor* desc = create_descriptor(unique_desc_id(), FLOAT);
insert_descriptor(table, desc);
return desc->list_id;
}
void
surf64_compute_descriptors(const struct csx_features *fs, const struct csx_intimg *ii,
struct csx_surf64_descriptors *ds)
{
if (ds->capacity < fs->n)
surf64_descriptors_realloc(ds, fs->n);
for (unsigned i = 0; i < fs->n; i++)
create_descriptor(&fs->f[i], ii, &ds->d[i]);
}
g_fd g_file_descriptors::map(g_pid pid, g_fs_virt_id node_id, g_fd fd, int32_t open_flags) {
g_file_descriptor_table* process_table = get_process_table(pid);
g_file_descriptor_content* desc = create_descriptor(process_table, fd);
desc->node_id = node_id;
desc->open_flags = open_flags;
return desc->id;
}
int gdt_init() {
const uint32_t COARSE_LIMIT = 0x000FFFFF;
// set up gdtr
gdtr.m_limit = sizeof(uint64_t) * MAX_DESCRIPTORS-1;
gdtr.m_base = (uint32_t)&gdt[0];
// Flat 4GB adress space
gdt[0] = create_descriptor(0, 0, 0); // set null descriptor
gdt[1] = create_descriptor(0, COARSE_LIMIT, (GDT_CODE_PL0));
gdt[2] = create_descriptor(0, COARSE_LIMIT, (GDT_DATA_PL0));
gdt[3] = create_descriptor(0, COARSE_LIMIT, (GDT_CODE_PL3));
gdt[4] = create_descriptor(0, COARSE_LIMIT, (GDT_DATA_PL3));
//TODO: Push this line into gdt_flush
__asm__( "lgdt (%0)" :: "m" (gdtr) );
gdt_flush();
return 0;
}
/*
void client::command_manager::parse_query(const std::string &prefix, const std::string &default_command, const std::string &cmd, client::configuration &config, const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response &response, const Plugin::QueryRequestMessage &request_message) {
boost::program_options::variables_map vm;
std::string real_command;
try {
command_type::const_iterator cit = commands.find(cmd);
boost::program_options::variables_map vm;
if (cit == commands.end()) {
real_command = parse_command(cmd, prefix);
if (real_command == "forward") {
for (int i=0;i<request_message.header().metadata_size();i++) {
if (request_message.header().metadata(i).key() == "command")
config.data->command = request_message.header().metadata(i).value();
}
for (int i=0;i<request.arguments_size();i++) {
config.data->arguments.push_back(request.arguments(i));
}
} else {
po::options_description desc = create_descriptor(real_command, default_command, config);
if (!nscapi::program_options::process_arguments_from_request(vm, desc, request, response))
return;
}
} else {
std::vector<std::string> args;
real_command = parse_command(cit->second.command, prefix);
po::options_description desc = create_descriptor(real_command, default_command, config);
BOOST_FOREACH(std::string argument, cit->second.arguments) {
for (int i=0;i<request.arguments_size();i++) {
strEx::replace(argument, "$ARG" + strEx::s::xtos(i+1) + "$", request.arguments(i));
}
args.push_back(argument);
}
if (!nscapi::program_options::process_arguments_from_vector(vm, desc, request.command(), args, response))
return;
}
} catch (const std::exception &e) {
return nscapi::protobuf::functions::set_response_bad(response, "Exception processing command line: " + utf8::utf8_from_native(e.what()));
}
if (!config.data->target_id.empty()) {
if (!config.targets.has_object(config.data->target_id))
return nscapi::protobuf::functions::set_response_bad(response, "Target not found: " + config.data->target_id);
//TODO: config.data->recipient.import(config.target_lookup->lookup_target(config.data->target_id));
}
if (real_command == "query" || (real_command.empty() && default_command == "query")) {
do_query(config, request_message.header(), response);
} else if (real_command == "exec" || (real_command.empty() && default_command == "exec")) {
return nscapi::protobuf::functions::set_response_bad(response, "Paradigm shift currently not supported");
} else if (real_command == "submit" || (real_command.empty() && default_command == "submit")) {
return nscapi::protobuf::functions::set_response_bad(response, "Paradigm shift currently not supported");
} else {
return nscapi::protobuf::functions::set_response_bad(response, "Invalid command: " +real_command);
}
}
*/
void client::configuration::parse_query(const Plugin::QueryRequestMessage &request, Plugin::QueryResponseMessage &response) {
std::string command = "";
for (int i = 0; i<request.header().metadata_size(); i++) {
if (request.header().metadata(i).key() == "command")
command = request.header().metadata(i).value();
}
for (int i = 0; i < request.payload_size(); i++) {
::Plugin::QueryRequestMessage::Request *reqp = request.mutable_payload(0);
if (!command.empty()) {
command = reqp->command();
}
// Check pre populated commands
if (reqp->arguments_size() > 0) {
boost::program_options::variables_map vm;
std::string real_command = "query";
try {
po::options_description desc = create_descriptor(real_command, real_command, config);
if (!nscapi::program_options::process_arguments_from_vector(vm, desc, real_command, args, response))
return;
}
catch (const std::exception &e) {
return nscapi::protobuf::functions::set_response_bad(response, "Exception processing command line: " + utf8::utf8_from_native(e.what()));
}
if (real_command == "query") {
const ::Plugin::Common::Header header;
do_query(config, header, response);
}
else {
return nscapi::protobuf::functions::set_response_bad(response, "Invalid command: " + real_command);
}
}
}
}
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
test_rend_cache_store_v2_desc_as_client_with_different_time(void *data)
{
int ret;
rend_data_t *mock_rend_query;
char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
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;
t = time(NULL);
rend_cache_init();
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);
(void)data;
// Test when a descriptor is already in the cache and it is newer than the
// one we submit
mock_rend_query = mock_rend_data(service_id);
base32_encode(desc_id_base32, sizeof(desc_id_base32),
desc_holder_newer->desc_id, DIGEST_LEN);
rend_cache_store_v2_desc_as_client(desc_holder_newer->desc_str,
desc_id_base32, mock_rend_query, NULL);
ret = rend_cache_store_v2_desc_as_client(desc_holder_older->desc_str,
desc_id_base32, mock_rend_query,
NULL);
tt_int_op(ret, OP_EQ, 0);
rend_cache_free_all();
// Test when an old descriptor is in the cache and we submit a newer one
rend_cache_init();
rend_cache_store_v2_desc_as_client(desc_holder_older->desc_str,
desc_id_base32, mock_rend_query, NULL);
ret = rend_cache_store_v2_desc_as_client(desc_holder_newer->desc_str,
desc_id_base32, mock_rend_query,
NULL);
tt_int_op(ret, OP_EQ, 0);
done:
rend_encoded_v2_service_descriptor_free(desc_holder_newer);
rend_encoded_v2_service_descriptor_free(desc_holder_older);
SMARTLIST_FOREACH(descs, rend_encoded_v2_service_descriptor_t *, d,
rend_encoded_v2_service_descriptor_free(d));
smartlist_free(descs);
rend_service_descriptor_free(generated);
tor_free(service_id);
rend_cache_free_all();
rend_data_free(mock_rend_query);
}
