void iterate_network(network_t *network)
{
unsigned int each_node;
for (each_node = 0; each_node < NODES; each_node++) {
iterate_node(network->nodes[each_node]);
}
}
void iterate_groups(Ctx &ctx) {
std::cout << "Iterating groups:" << std::endl;
std::set<int> groups_set(ctx.groups.begin(), ctx.groups.end());
std::set<dnet_addr, less> addr_set;
for (auto it = ctx.routes.begin(), end = ctx.routes.end(); it != end; ++it) {
if (groups_set.find(it->group_id) != groups_set.end()) {
addr_set.insert(it->addr);
}
}
for (auto it = addr_set.begin(), end = addr_set.end(); it != end; ++it) {
iterate_node(ctx, *it);
}
}
int main(int argc, char *argv[]) {
Ctx ctx;
std::string log_file;
dnet_log_level log_level;
std::vector<std::string> remotes;
boost::program_options::options_description desc("Usage");
bool iter_groups = false;
bool iter_node = false;
desc.add_options()
("group,g", boost::program_options::value<std::vector<int>>()->multitoken(), "group IDs to connect")
("log-file,l", boost::program_options::value<std::string>()->default_value("/dev/stderr"), "log file")
("log-level,L", boost::program_options::value<int>()->default_value(1), "log level")
("remote,r", boost::program_options::value<std::vector<std::string>>()->multitoken(), "adds a route to the given node")
("data,d", "requests object's data with other info")
("key-begin,k", boost::program_options::value<std::string>(), "Begin key of range for iterating")
("key-end,K", boost::program_options::value<std::string>(), "End key of range for iterating")
("time-begin,t", boost::program_options::value<std::string>(), "Begin timestamp of time range for iterating")
("time-end,T", boost::program_options::value<std::string>(), "End timestamp of time range for iterating")
("nodes,n", "Iterate nodes")
("groups,G", "Iterate nodes in groups")
("help,h", "this help");
boost::program_options::variables_map vm;
try {
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
if (vm.count("help"))
{
std::cout << desc << std::endl;
return 0;
}
if (vm.count("group"))
ctx.groups = vm["group"].as<std::vector<int>>();
log_file = vm["log-file"].as<std::string>();
log_level = ioremap::elliptics::file_logger::parse_level(vm["log-level"].as<std::string>());
if (vm.count("remote"))
remotes = vm["remote"].as<std::vector<std::string>>();
if (vm.count("data"))
ctx.iflags |= DNET_IFLAGS_DATA;
if (vm.count("key-begin")) {
ctx.key_range.key_begin = parse_hex_id(vm["key-begin"].as<std::string>());
ctx.iflags |= DNET_IFLAGS_KEY_RANGE;
}
if (vm.count("key-end")) {
ctx.key_range.key_end = parse_hex_id(vm["key-end"].as<std::string>());
ctx.iflags |= DNET_IFLAGS_KEY_RANGE;
}
if (vm.count("time-begin")) {
ctx.time_begin = parse_time(vm["time-begin"].as<std::string>());
ctx.iflags |= DNET_IFLAGS_TS_RANGE;
}
if (vm.count("time-end")) {
ctx.time_end = parse_time(vm["time-end"].as<std::string>());
ctx.iflags |= DNET_IFLAGS_TS_RANGE;
}
if (vm.count("groups"))
iter_groups = true;
if (vm.count("nodes"))
iter_node = true;
boost::program_options::notify(vm);
} catch(boost::program_options::error& e) {
std::cerr << "ERROR: " << e.what() << "\n" << desc << std::endl;
exit(1);
}
ioremap::elliptics::file_logger logger(log_file.c_str(), log_level);
ioremap::elliptics::node node(ioremap::elliptics::logger(logger, blackhole::attribute::set_t()));
for (auto it = remotes.begin(), end = remotes.end(); it != end; ++it) {
try {
node.add_remote(it->c_str());
} catch(...) {}
}
ctx.session.reset(new ioremap::elliptics::session(node));
ctx.routes = ctx.session->get_routes();
if (iter_groups)
iterate_groups(ctx);
else if (iter_node) {
for (auto it = remotes.begin(), end = remotes.end(); it != end; ++it) {
iterate_node(ctx, parse_addr(*it));
}
} else {
std::cerr << "You should specify one of iteration mode: --nodes or --groups\n" << desc << std::endl;
exit(1);
}
return 0;
}
static void
lookup_done(isc_task_t *task, isc_event_t *event) {
ns_lwdclient_t *client;
ns_lwdclientmgr_t *cm;
dns_lookupevent_t *levent;
lwres_buffer_t lwb;
dns_name_t *name;
dns_rdataset_t *rdataset;
dns_rdataset_t *sigrdataset;
isc_result_t result;
lwres_result_t lwresult;
isc_region_t r;
isc_buffer_t b;
lwres_grbnresponse_t *grbn;
int i;
REQUIRE(event != NULL);
UNUSED(task);
lwb.base = NULL;
client = event->ev_arg;
cm = client->clientmgr;
INSIST(client->lookup == (dns_lookup_t *)event->ev_sender);
levent = (dns_lookupevent_t *)event;
grbn = &client->grbn;
ns_lwdclient_log(50, "lookup event result = %s",
isc_result_totext(levent->result));
result = levent->result;
if (result != ISC_R_SUCCESS) {
dns_lookup_destroy(&client->lookup);
isc_event_free(&event);
levent = NULL;
switch (result) {
case DNS_R_NXDOMAIN:
case DNS_R_NCACHENXDOMAIN:
result = ns_lwsearchctx_next(&client->searchctx);
if (result != ISC_R_SUCCESS)
lwresult = LWRES_R_NOTFOUND;
else {
start_lookup(client);
return;
}
break;
case DNS_R_NXRRSET:
case DNS_R_NCACHENXRRSET:
lwresult = LWRES_R_TYPENOTFOUND;
break;
default:
lwresult = LWRES_R_FAILURE;
}
ns_lwdclient_errorpktsend(client, lwresult);
return;
}
name = levent->name;
b = client->recv_buffer;
grbn->flags = 0;
grbn->nrdatas = 0;
grbn->rdatas = NULL;
grbn->rdatalen = NULL;
grbn->nsigs = 0;
grbn->sigs = NULL;
grbn->siglen = NULL;
result = dns_name_totext(name, ISC_TRUE, &client->recv_buffer);
if (result != ISC_R_SUCCESS)
goto out;
grbn->realname = (char *)isc_buffer_used(&b);
grbn->realnamelen = isc_buffer_usedlength(&client->recv_buffer) -
isc_buffer_usedlength(&b);
ns_lwdclient_log(50, "found name '%.*s'", grbn->realnamelen,
grbn->realname);
grbn->rdclass = cm->view->rdclass;
grbn->rdtype = client->rdtype;
rdataset = levent->rdataset;
if (rdataset != NULL) {
/* The normal case */
grbn->nrdatas = dns_rdataset_count(rdataset);
grbn->rdatas = isc_mem_get(cm->mctx, grbn->nrdatas *
sizeof(unsigned char *));
if (grbn->rdatas == NULL)
goto out;
grbn->rdatalen = isc_mem_get(cm->mctx, grbn->nrdatas *
sizeof(lwres_uint16_t));
if (grbn->rdatalen == NULL)
goto out;
i = 0;
result = fill_array(&i, rdataset, grbn->nrdatas, grbn->rdatas,
grbn->rdatalen);
if (result != ISC_R_SUCCESS)
goto out;
INSIST(i == grbn->nrdatas);
grbn->ttl = rdataset->ttl;
if (rdataset->trust == dns_trust_secure)
grbn->flags |= LWRDATA_VALIDATED;
} else {
/* The SIG query case */
result = iterate_node(grbn, levent->db, levent->node,
cm->mctx);
if (result != ISC_R_SUCCESS)
goto out;
}
ns_lwdclient_log(50, "filled in %d rdata%s", grbn->nrdatas,
(grbn->nrdatas == 1) ? "" : "s");
sigrdataset = levent->sigrdataset;
if (sigrdataset != NULL) {
grbn->nsigs = dns_rdataset_count(sigrdataset);
grbn->sigs = isc_mem_get(cm->mctx, grbn->nsigs *
sizeof(unsigned char *));
if (grbn->sigs == NULL)
goto out;
grbn->siglen = isc_mem_get(cm->mctx, grbn->nsigs *
sizeof(lwres_uint16_t));
if (grbn->siglen == NULL)
goto out;
i = 0;
result = fill_array(&i, sigrdataset, grbn->nsigs, grbn->sigs,
grbn->siglen);
if (result != ISC_R_SUCCESS)
goto out;
INSIST(i == grbn->nsigs);
ns_lwdclient_log(50, "filled in %d signature%s", grbn->nsigs,
(grbn->nsigs == 1) ? "" : "s");
}
/*
* Render the packet.
*/
client->pkt.recvlength = LWRES_RECVLENGTH;
client->pkt.authtype = 0; /* XXXMLG */
client->pkt.authlength = 0;
client->pkt.result = LWRES_R_SUCCESS;
lwresult = lwres_grbnresponse_render(cm->lwctx,
grbn, &client->pkt, &lwb);
if (lwresult != LWRES_R_SUCCESS)
goto out;
isc_mem_put(cm->mctx, grbn->rdatas,
grbn->nrdatas * sizeof(unsigned char *));
isc_mem_put(cm->mctx, grbn->rdatalen,
grbn->nrdatas * sizeof(lwres_uint16_t));
if (grbn->sigs != NULL)
isc_mem_put(cm->mctx, grbn->sigs,
grbn->nsigs * sizeof(unsigned char *));
if (grbn->siglen != NULL)
isc_mem_put(cm->mctx, grbn->siglen,
grbn->nsigs * sizeof(lwres_uint16_t));
r.base = lwb.base;
r.length = lwb.used;
client->sendbuf = r.base;
client->sendlength = r.length;
result = ns_lwdclient_sendreply(client, &r);
if (result != ISC_R_SUCCESS)
goto out2;
NS_LWDCLIENT_SETSEND(client);
dns_lookup_destroy(&client->lookup);
isc_event_free(&event);
return;
out:
if (grbn->rdatas != NULL)
isc_mem_put(cm->mctx, grbn->rdatas,
grbn->nrdatas * sizeof(unsigned char *));
if (grbn->rdatalen != NULL)
isc_mem_put(cm->mctx, grbn->rdatalen,
grbn->nrdatas * sizeof(lwres_uint16_t));
if (grbn->sigs != NULL)
isc_mem_put(cm->mctx, grbn->sigs,
grbn->nsigs * sizeof(unsigned char *));
if (grbn->siglen != NULL)
isc_mem_put(cm->mctx, grbn->siglen,
grbn->nsigs * sizeof(lwres_uint16_t));
out2:
if (client->lookup != NULL)
dns_lookup_destroy(&client->lookup);
if (lwb.base != NULL)
lwres_context_freemem(cm->lwctx, lwb.base, lwb.length);
isc_event_free(&event);
ns_lwdclient_log(50, "error constructing getrrsetbyname response");
ns_lwdclient_errorpktsend(client, LWRES_R_FAILURE);
}
