static int node_recovery(int argc, char **argv)
{
int i, ret;
if (!raw_output) {
printf("Nodes In Recovery:\n");
printf(" Id Host:Port V-Nodes Zone\n");
}
for (i = 0; i < sd_nodes_nr; i++) {
char host[128];
struct sd_node_req req;
addr_to_str(host, sizeof(host), sd_nodes[i].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_STAT_RECOVERY);
ret = send_light_req_get_response((struct sd_req *)&req, host,
sd_nodes[i].nid.port);
if (ret == SD_RES_NODE_IN_RECOVERY) {
addr_to_str(host, sizeof(host),
sd_nodes[i].nid.addr, sd_nodes[i].nid.port);
printf(raw_output ? "%d %s %d %d\n" : "%4d %-20s%5d%11d\n",
i, host, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone);
}
}
return EXIT_SUCCESS;
}
struct xio_session *sd_xio_gw_create_session(struct xio_context *ctx,
const struct node_id *nid,
void *user_ctx)
{
struct xio_session *session;
char url[256];
struct xio_session_params params;
if (nid->io_transport_type == IO_TRANSPORT_TYPE_RDMA)
snprintf(url, 256, "rdma://%s",
addr_to_str(nid->io_addr, nid->io_port));
else
snprintf(url, 256, "tcp://%s",
addr_to_str(nid->io_addr, nid->io_port));
memset(¶ms, 0, sizeof(params));
params.type = XIO_SESSION_CLIENT;
params.ses_ops = &gw_client_ses_ops;
params.uri = url;
params.user_context = user_ctx;
session = xio_session_create(¶ms);
return session;
}
void print_data(struct db_cache *cache_elem, u_int32_t wtc, int num)
{
struct pkt_primitives *data = &cache_elem->primitives;
struct tm *lt;
char src_mac[18], dst_mac[18], src_host[INET6_ADDRSTRLEN], dst_host[INET6_ADDRSTRLEN];
int j;
printf("%-8d ", num);
printf("%-5d ", data->id);
#if defined (HAVE_L2)
etheraddr_string(data->eth_shost, src_mac);
printf("%-17s ", src_mac);
etheraddr_string(data->eth_dhost, dst_mac);
printf("%-17s ", dst_mac);
printf("%-5d ", data->vlan_id);
#endif
printf("%-5d ", data->src_as);
printf("%-5d ", data->dst_as);
#if defined ENABLE_IPV6
addr_to_str(src_host, &data->src_ip);
printf("%-45s ", src_host);
addr_to_str(dst_host, &data->dst_ip);
printf("%-45s ", dst_host);
#else
addr_to_str(src_host, &data->src_ip);
printf("%-15s ", src_host);
addr_to_str(dst_host, &data->dst_ip);
printf("%-15s ", dst_host);
#endif
printf("%-5d ", data->src_port);
printf("%-5d ", data->dst_port);
printf("%-10s ", _protocols[data->proto].name);
printf("%-3d ", data->tos);
#if defined HAVE_64BIT_COUNTERS
printf("%-20llu ", cache_elem->packet_counter);
printf("%-20llu ", cache_elem->flows_counter);
printf("%-20llu ", cache_elem->bytes_counter);
#else
printf("%-10lu ", cache_elem->packet_counter);
printf("%-10lu ", cache_elem->flows_counter);
printf("%-10lu ", cache_elem->bytes_counter);
#endif
if (lh.sql_history) {
if (!sql_history_since_epoch) {
lt = localtime(&cache_elem->basetime);
strftime(timebuf, SRVBUFLEN, "%Y-%m-%d %H:%M:%S" , lt);
printf("%s\n", timebuf);
}
else printf("%u\n", cache_elem->basetime);
}
else printf("0\n");
}
static void do_print_nodes_diff(const struct epoch_log *log1,
const struct epoch_log *log2, uint16_t flags,
char act)
{
int i, j, nr_disk1 = 0, nr_disk2 = 0;
const struct sd_node *entry1, *entry2;
bool first = true;
for (i = 0; i < log1->nr_nodes; i++) {
entry1 = log1->nodes + i;
if (flags & SD_CLUSTER_FLAG_DISKMODE) {
for (nr_disk1 = 0; nr_disk1 < DISK_MAX; nr_disk1++) {
if (entry1->disks[nr_disk1].disk_id == 0)
break;
}
}
for (j = 0; j < log2->nr_nodes; j++) {
entry2 = log2->nodes + j;
if (flags & SD_CLUSTER_FLAG_DISKMODE) {
for (nr_disk2 = 0; nr_disk2 < DISK_MAX;
nr_disk2++) {
if (entry2->disks[nr_disk2].disk_id
== 0)
break;
}
}
if (node_cmp(entry1, entry2) == 0
&& nr_disk1 == nr_disk2)
break;
}
if (j == log2->nr_nodes) {
if (flags & SD_CLUSTER_FLAG_DISKMODE)
printf("%s%c%s(%d)", first ? "" : ", ",
act,
addr_to_str(entry1->nid.addr,
entry1->nid.port),
nr_disk1);
else
printf("%s%c%s",
first ? "" : ", ",
act,
addr_to_str(entry1->nid.addr,
entry1->nid.port));
first = false;
}
}
}
void bmp_process_msg_route(char **bmp_packet, u_int32_t *len, struct bgp_peer *peer)
{
struct bmp_data bdata;
struct bmp_peer_hdr *bph;
char tstamp_str[SRVBUFLEN], peer_ip[INET6_ADDRSTRLEN];
if (!(bph = (struct bmp_peer_hdr *) bmp_get_and_check_length(bmp_packet, len, sizeof(struct bmp_peer_hdr)))) {
Log(LOG_INFO, "INFO ( %s/core/BMP ): [Id: %s] [route] packet discarded: failed bmp_get_and_check_length() BMP peer hdr\n",
config.name, peer->addr_str);
return;
}
bmp_peer_hdr_get_family(bph, &bdata.family);
bmp_peer_hdr_get_peer_ip(bph, &bdata.peer_ip, bdata.family);
bmp_peer_hdr_get_bgp_id(bph, &bdata.bgp_id);
bmp_peer_hdr_get_tstamp(bph, &bdata.tstamp);
bmp_peer_hdr_get_peer_asn(bph, &bdata.peer_asn);
bmp_peer_hdr_get_peer_type(bph, &bdata.peer_type);
/* If no timestamp in BMP then let's generate one */
if (!bdata.tstamp.tv_sec) gettimeofday(&bdata.tstamp, NULL);
compose_timestamp(tstamp_str, SRVBUFLEN, &bdata.tstamp, TRUE, config.sql_history_since_epoch);
addr_to_str(peer_ip, &bdata.peer_ip);
// XXX: parse BGP UPDATE(s)
}
static int node_list(int argc, char **argv)
{
int i;
if (!raw_output)
printf("M Id Host:Port V-Nodes Zone\n");
for (i = 0; i < sd_nodes_nr; i++) {
char data[128];
addr_to_str(data, sizeof(data), sd_nodes[i].nid.addr,
sd_nodes[i].nid.port);
if (i == master_idx) {
if (highlight)
printf(TEXT_BOLD);
printf(raw_output ? "* %d %s %d %d\n" : "* %4d %-20s\t%2d%11d\n",
i, data, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone);
if (highlight)
printf(TEXT_NORMAL);
} else
printf(raw_output ? "- %d %s %d %d\n" : "- %4d %-20s\t%2d%11d\n",
i, data, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone);
}
return EXIT_SUCCESS;
}
void compose_json_tunnel_dst_host(json_t *obj, struct chained_cache *cc)
{
char ip_address[INET6_ADDRSTRLEN];
addr_to_str(ip_address, &cc->ptun->tunnel_dst_ip);
json_object_set_new_nocheck(obj, "tunnel_ip_dst", json_string(ip_address));
}
void Tee_init_socks()
{
struct tee_receiver *target = NULL;
struct sockaddr *sa;
int pool_idx, recv_idx, err;
char dest_addr[256], dest_serv[256];
for (pool_idx = 0; pool_idx < receivers.num; pool_idx++) {
for (recv_idx = 0; recv_idx < receivers.pools[pool_idx].num; recv_idx++) {
target = &receivers.pools[pool_idx].receivers[recv_idx];
sa = (struct sockaddr *) &target->dest;
if (sa->sa_family != 0) {
if ((err = getnameinfo(sa, target->dest_len, dest_addr, sizeof(dest_addr),
dest_serv, sizeof(dest_serv), NI_NUMERICHOST)) == -1) {
Log(LOG_ERR, "ERROR ( %s/%s ): getnameinfo: %d\n", config.name, config.type, err);
exit_plugin(1);
}
}
target->fd = Tee_prepare_sock((struct sockaddr *) &target->dest, target->dest_len);
if (config.debug) {
struct host_addr recv_addr;
u_char recv_addr_str[INET6_ADDRSTRLEN];
u_int16_t recv_port;
sa_to_addr(&target->dest, &recv_addr, &recv_port);
addr_to_str(recv_addr_str, &recv_addr);
Log(LOG_DEBUG, "DEBUG ( %s/%s ): pool ID: %u :: receiver: %s :: fd: %d.\n",
config.name, config.type, receivers.pools[pool_idx].id, recv_addr_str, target->fd);
}
}
}
}
void compose_json_peer_dst_ip(json_t *obj, struct chained_cache *cc)
{
char ip_address[INET6_ADDRSTRLEN];
addr_to_str(ip_address, &cc->pbgp->peer_dst_ip);
json_object_set_new_nocheck(obj, "peer_ip_dst", json_string(ip_address));
}
/** printout a delegation point info */
static int
ssl_print_name_dp(SSL* ssl, char* str, uint8_t* nm, uint16_t dclass,
struct delegpt* dp)
{
char buf[257];
struct delegpt_ns* ns;
struct delegpt_addr* a;
int f = 0;
if(str) { /* print header for forward, stub */
char* c = ldns_rr_class2str(dclass);
dname_str(nm, buf);
if(!ssl_printf(ssl, "%s %s %s: ", buf, c, str)) {
free(c);
return 0;
}
free(c);
}
for(ns = dp->nslist; ns; ns = ns->next) {
dname_str(ns->name, buf);
if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf))
return 0;
f = 1;
}
for(a = dp->target_list; a; a = a->next_target) {
addr_to_str(&a->addr, a->addrlen, buf, sizeof(buf));
if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf))
return 0;
f = 1;
}
return ssl_printf(ssl, "\n");
}
/*
* \fn build_http_post_header()
*
* \param buff buffer for storing the new header
* \param content_len value to use for the Content-length field
* \param addr value to use in the Host field
*
* \return Returns the length of the newly created HTTP string.
*
* \brief Builds an HTTP POST string in the specified buffer.
*/
int build_http_post_header(char *buff, int content_len, struct sockaddr *addr)
{
unsigned short port = 0;
char addrstr[INET6_ADDRSTRLEN];
addr_to_str(addr, (__u8*)addrstr, INET6_ADDRSTRLEN);
if (AF_INET == addr->sa_family)
{
port = ntohs(((struct sockaddr_in*)addr)->sin_port);
}
else if (AF_INET6 == addr->sa_family)
{
port = ntohs(((struct sockaddr_in6*)addr)->sin6_port);
}
sprintf(
buff,
"POST /RPC2 HTTP/1.0\r\nUser-Agent: %s %s\r\nHost: %s:%d\r\nContent-Type: text/xml\r\nContent-length: %d\r\n\r\n",
HIP_NAME,
HIP_VERSION,
addrstr,
port,
content_len);
return(strlen(buff));
}
static int node_kill(int argc, char **argv)
{
char host[128];
int node_id, ret;
struct sd_node_req req;
const char *p = argv[optind++];
if (!is_numeric(p)) {
fprintf(stderr, "Invalid node id '%s', "
"please specify a numeric value\n", p);
exit(EXIT_USAGE);
}
node_id = strtol(p, NULL, 10);
if (node_id < 0 || node_id >= sd_nodes_nr) {
fprintf(stderr, "Invalid node id '%d'\n", node_id);
exit(EXIT_USAGE);
}
addr_to_str(host, sizeof(host), sd_nodes[node_id].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_KILL_NODE);
ret = send_light_req((struct sd_req *)&req, host,
sd_nodes[node_id].nid.port);
if (ret) {
fprintf(stderr, "Failed to execute request\n");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
void compose_json_post_nat_src_host(json_t *obj, struct chained_cache *cc)
{
char ip_address[INET6_ADDRSTRLEN];
addr_to_str(ip_address, &cc->pnat->post_nat_src_ip);
json_object_set_new_nocheck(obj, "post_nat_ip_src", json_string(ip_address));
}
void compose_json_dst_net(json_t *obj, struct chained_cache *cc)
{
char ip_address[INET6_ADDRSTRLEN];
addr_to_str(ip_address, &cc->primitives.dst_net);
json_object_set_new_nocheck(obj, "net_dst", json_string(ip_address));
}
static void list_interfaces(void) {
char pcap_err[PCAP_ERRBUF_SIZE];
pcap_if_t *dev;
u8 i = 0;
/* There is a bug in several years' worth of libpcap releases that causes it
to SEGV here if /sys/class/net is not readable. See http://goo.gl/nEnGx */
if (access("/sys/class/net", R_OK | X_OK) && errno != ENOENT)
printf("\n FATAL: This operation requires access to /sys/class/net/, sorry.");
if (pcap_findalldevs(&dev, pcap_err) == -1)
printf("\n FATAL: pcap_findalldevs: %s\n", pcap_err);
if (!dev) printf("\n FATAL: Can't find any interfaces. Maybe you need to be root?");
SAYF("\n-- Available interfaces --\n");
do {
pcap_addr_t *a = dev->addresses;
SAYF("\n%3d: Name : %s\n", i++, dev->name);
SAYF(" Description : %s\n", dev->description ? dev->description : "-");
/* Let's try to find something we can actually display. */
while (a && a->addr->sa_family != PF_INET && a->addr->sa_family != PF_INET6)
a = a->next;
if (a) {
if (a->addr->sa_family == PF_INET)
SAYF(" IP address : %s\n", addr_to_str(((u8*)a->addr) + 4, IP_VER4));
else
SAYF(" IP address : %s\n", addr_to_str(((u8*)a->addr) + 8, IP_VER6));
} else SAYF(" IP address : (none)\n");
} while ((dev = dev->next));
SAYF("\n");
pcap_freealldevs(dev);
}
static int node_info(int argc, char **argv)
{
int i, ret, success = 0;
uint64_t total_size = 0, total_avail = 0, total_vdi_size = 0;
char total_str[UINT64_DECIMAL_SIZE], avail_str[UINT64_DECIMAL_SIZE], vdi_size_str[UINT64_DECIMAL_SIZE];
if (!raw_output)
printf("Id\tSize\tUsed\tUse%%\n");
for (i = 0; i < sd_nodes_nr; i++) {
char host[128];
struct sd_node_req req;
struct sd_node_rsp *rsp = (struct sd_node_rsp *)&req;
char store_str[UINT64_DECIMAL_SIZE], free_str[UINT64_DECIMAL_SIZE];
addr_to_str(host, sizeof(host), sd_nodes[i].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_STAT_SHEEP);
req.epoch = sd_epoch;
ret = send_light_req((struct sd_req *)&req, host,
sd_nodes[i].nid.port);
size_to_str(rsp->store_size, store_str, sizeof(store_str));
size_to_str(rsp->store_size - rsp->store_free, free_str,
sizeof(free_str));
if (!ret) {
printf(raw_output ? "%d %s %s %d%%\n" : "%2d\t%s\t%s\t%3d%%\n",
i, store_str, free_str,
rsp->store_size == 0 ? 0 :
(int)(((double)(rsp->store_size - rsp->store_free) / rsp->store_size) * 100));
success++;
}
total_size += rsp->store_size;
total_avail += rsp->store_free;
}
if (success == 0) {
fprintf(stderr, "Cannot get information from any nodes\n");
return EXIT_SYSFAIL;
}
if (parse_vdi(cal_total_vdi_size, SD_INODE_HEADER_SIZE,
&total_vdi_size) < 0)
return EXIT_SYSFAIL;
size_to_str(total_size, total_str, sizeof(total_str));
size_to_str(total_size - total_avail, avail_str, sizeof(avail_str));
size_to_str(total_vdi_size, vdi_size_str, sizeof(vdi_size_str));
printf(raw_output ? "Total %s %s %d%% %s\n"
: "Total\t%s\t%s\t%3d%%\n\nTotal virtual image size\t%s\n",
total_str, avail_str,
(int)(((double)(total_size - total_avail) / total_size) * 100),
vdi_size_str);
return EXIT_SUCCESS;
}
static int node_recovery(int argc, char **argv)
{
int i, ret;
if (!raw_output) {
printf("Nodes In Recovery:\n");
printf(" Id Host:Port V-Nodes Zone\n");
}
for (i = 0; i < nr_nodes; i++) {
char host[128];
int fd;
unsigned wlen, rlen;
struct sd_node_req req;
struct sd_node_rsp *rsp = (struct sd_node_rsp *)&req;
addr_to_str(host, sizeof(host), node_list_entries[i].addr, 0);
fd = connect_to(host, node_list_entries[i].port);
if (fd < 0)
return EXIT_FAILURE;
memset(&req, 0, sizeof(req));
req.opcode = SD_OP_STAT_RECOVERY;
wlen = 0;
rlen = 0;
ret = exec_req(fd, (struct sd_req *)&req, NULL, &wlen, &rlen);
close(fd);
if (!ret && rsp->result == SD_RES_SUCCESS) {
addr_to_str(host, sizeof(host),
node_list_entries[i].addr, node_list_entries[i].port);
printf(raw_output ? "%d %s %d %d\n" : "%4d %-20s%5d%11d\n",
i, host, node_list_entries[i].nr_vnodes,
node_list_entries[i].zone);
}
}
return EXIT_SUCCESS;
}
void
respip_inform_print(struct respip_addr_info* respip_addr, uint8_t* qname,
uint16_t qtype, uint16_t qclass, struct local_rrset* local_alias,
struct comm_reply* repinfo)
{
char srcip[128], respip[128], txt[512];
unsigned port;
if(local_alias)
qname = local_alias->rrset->rk.dname;
port = (unsigned)((repinfo->addr.ss_family == AF_INET) ?
ntohs(((struct sockaddr_in*)&repinfo->addr)->sin_port) :
ntohs(((struct sockaddr_in6*)&repinfo->addr)->sin6_port));
addr_to_str(&repinfo->addr, repinfo->addrlen, srcip, sizeof(srcip));
addr_to_str(&respip_addr->addr, respip_addr->addrlen,
respip, sizeof(respip));
snprintf(txt, sizeof(txt), "%s/%d inform %s@%u", respip,
respip_addr->net, srcip, port);
log_nametypeclass(0, txt, qname, qtype, qclass);
}
void bmp_process_msg_route_monitor(char **bmp_packet, u_int32_t *len, struct bmp_peer *bmpp)
{
struct bgp_misc_structs *bms;
struct bgp_peer *peer, *bmpp_bgp_peer;
struct bmp_data bdata;
struct bmp_peer_hdr *bph;
char tstamp_str[SRVBUFLEN], peer_ip[INET6_ADDRSTRLEN];
int bgp_update_len;
void *ret;
if (!bmpp) return;
peer = &bmpp->self;
bms = bgp_select_misc_db(peer->type);
if (!bms) return;
if (!(bph = (struct bmp_peer_hdr *) bmp_get_and_check_length(bmp_packet, len, sizeof(struct bmp_peer_hdr)))) {
Log(LOG_INFO, "INFO ( %s/core/BMP ): [%s] [route] packet discarded: failed bmp_get_and_check_length() BMP peer hdr\n",
config.name, peer->addr_str);
return;
}
bmp_peer_hdr_get_family(bph, &bdata.family);
bmp_peer_hdr_get_peer_ip(bph, &bdata.peer_ip, bdata.family);
bmp_peer_hdr_get_bgp_id(bph, &bdata.bgp_id);
bmp_peer_hdr_get_tstamp(bph, &bdata.tstamp);
bmp_peer_hdr_get_peer_asn(bph, &bdata.peer_asn);
bmp_peer_hdr_get_peer_type(bph, &bdata.peer_type);
if (bdata.family) {
/* If no timestamp in BMP then let's generate one */
if (!bdata.tstamp.tv_sec) gettimeofday(&bdata.tstamp, NULL);
compose_timestamp(tstamp_str, SRVBUFLEN, &bdata.tstamp, TRUE, config.timestamps_since_epoch);
addr_to_str(peer_ip, &bdata.peer_ip);
ret = pm_tfind(&bdata.peer_ip, &bmpp->bgp_peers, bmp_bmpp_bgp_peer_host_addr_cmp);
if (ret) {
char peer_str[] = "peer_ip", *saved_peer_str = bms->peer_str;
bmpp_bgp_peer = (*(struct bgp_peer **) ret);
bms->peer_str = peer_str;
bgp_update_len = bgp_parse_update_msg(bmpp_bgp_peer, (*bmp_packet));
bms->peer_str = saved_peer_str;
bmp_get_and_check_length(bmp_packet, len, bgp_update_len);
}
}
}
static void print_nodes(const struct epoch_log *logs, uint16_t flags)
{
int i, nr_disk;
const struct sd_node *entry;
for (i = 0; i < logs->nr_nodes; i++) {
entry = logs->nodes + i;
if (flags & SD_CLUSTER_FLAG_DISKMODE) {
for (nr_disk = 0; nr_disk < DISK_MAX; nr_disk++) {
if (entry->disks[nr_disk].disk_id == 0)
break;
}
printf("%s%s(%d)",
(i == 0) ? "" : ", ",
addr_to_str(entry->nid.addr, entry->nid.port),
nr_disk);
} else
printf("%s%s",
(i == 0) ? "" : ", ",
addr_to_str(entry->nid.addr, entry->nid.port));
}
}
void start_observation(char* keyword, u8 field_cnt, u8 to_srv,
struct packet_flow* f) {
if (obs_fields) printf("\n FATAL: Premature end of observation.");
if (!daemon_mode) {
SAYF(".-[ %s/%u -> ", addr_to_str(f->client->addr, f->client->ip_ver),
f->cli_port);
SAYF("%s/%u (%s) ]-\n|\n", addr_to_str(f->server->addr, f->client->ip_ver),
f->srv_port, keyword);
SAYF("| %-8s = %s/%u\n", to_srv ? "client" : "server",
addr_to_str(to_srv ? f->client->addr :
f->server->addr, f->client->ip_ver),
to_srv ? f->cli_port : f->srv_port);
}
if (log_file) {
u8 tmp[64];
time_t ut = get_unix_time();
struct tm* lt = localtime(&ut);
strftime((char*)tmp, 64, "%Y/%m/%d %H:%M:%S", lt);
LOGF("[%s] mod=%s|cli=%s/%u|",tmp, keyword, addr_to_str(f->client->addr,
f->client->ip_ver), f->cli_port);
LOGF("srv=%s/%u|subj=%s", addr_to_str(f->server->addr, f->server->ip_ver),
f->srv_port, to_srv ? "cli" : "srv");
}
obs_fields = field_cnt;
}
/** print log information for an inform zone query */
static void
lz_inform_print(struct local_zone* z, struct query_info* qinfo,
struct comm_reply* repinfo)
{
char ip[128], txt[512];
char zname[LDNS_MAX_DOMAINLEN+1];
uint16_t port = ntohs(((struct sockaddr_in*)&repinfo->addr)->sin_port);
dname_str(z->name, zname);
addr_to_str(&repinfo->addr, repinfo->addrlen, ip, sizeof(ip));
snprintf(txt, sizeof(txt), "%s inform %s@%u", zname, ip,
(unsigned)port);
log_nametypeclass(0, txt, qinfo->qname, qinfo->qtype, qinfo->qclass);
}
static int node_recovery(int argc, char **argv)
{
int i, ret;
if (node_cmd_data.recovery_progress)
return node_recovery_progress();
if (!raw_output) {
printf("Nodes In Recovery:\n");
printf(" Id Host:Port V-Nodes Zone"
" Progress\n");
}
for (i = 0; i < sd_nodes_nr; i++) {
struct sd_req req;
struct sd_rsp *rsp = (struct sd_rsp *)&req;
struct recovery_state state;
memset(&state, 0, sizeof(state));
sd_init_req(&req, SD_OP_STAT_RECOVERY);
req.data_length = sizeof(state);
ret = dog_exec_req(sd_nodes[i].nid.addr,
sd_nodes[i].nid.port, &req, &state);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
return EXIT_FAILURE;
}
if (state.in_recovery) {
const char *host = addr_to_str(sd_nodes[i].nid.addr,
sd_nodes[i].nid.port);
if (raw_output)
printf("%d %s %d %d %"PRIu64" %"PRIu64"\n", i,
host, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone, state.nr_finished,
state.nr_total);
else
printf("%4d %-20s%5d%11d%11.1f%%\n", i, host,
sd_nodes[i].nr_vnodes, sd_nodes[i].zone,
100 * (float)state.nr_finished
/ state.nr_total);
}
}
return EXIT_SUCCESS;
}
int main(int argc, const char *argv[])
{
int packets_in_buf = 1024;
const char *payload = (const char[32]){0};
int payload_sz = 32;
if (argc == 1) {
FATAL("Usage: %s [target ip:port] [target ...]", argv[0]);
}
struct net_addr *target_addrs = calloc(argc-1, sizeof(struct net_addr));
int thread_num = argc - 1;
int t;
for (t = 0; t < thread_num; t++) {
const char *target_addr_str = argv[t+1];
parse_addr(&target_addrs[t], target_addr_str);
fprintf(stderr, "[*] Sending to %s, send buffer %i packets\n",
addr_to_str(&target_addrs[t]), packets_in_buf);
}
struct state *array_of_states = calloc(thread_num, sizeof(struct state));
for (t = 0; t < thread_num; t++) {
struct state *state = &array_of_states[t];
state->target_addr = &target_addrs[t];
state->packets_in_buf = packets_in_buf;
state->payload = payload;
state->payload_sz = payload_sz;
state->src_port = 11404;
thread_spawn(thread_loop, state);
}
while (1) {
struct timeval timeout =
NSEC_TIMEVAL(MSEC_NSEC(1000UL));
while (1) {
int r = select(0, NULL, NULL, NULL, &timeout);
if (r != 0) {
continue;
}
if (TIMEVAL_NSEC(&timeout) == 0) {
break;
}
}
// pass
}
return 0;
}
void log_template_header(struct template_cache_entry *tpl, struct packet_ptrs *pptrs, u_int16_t tpl_type, u_int32_t sid, u_int8_t version)
{
struct host_addr a;
u_char agent_addr[50];
u_int16_t agent_port, count, size;
sa_to_addr((struct sockaddr *)pptrs->f_agent, &a, &agent_port);
addr_to_str(agent_addr, &a);
Log(LOG_DEBUG, "DEBUG ( default/core ): NfV%u agent : %s:%u\n", version, agent_addr, sid);
Log(LOG_DEBUG, "DEBUG ( default/core ): NfV%u template type : %s\n", version, ( tpl->template_type == 0 || tpl->template_type == 2 ) ? "flow" : "options");
Log(LOG_DEBUG, "DEBUG ( default/core ): NfV%u template ID : %u\n", version, ntohs(tpl->template_id));
Log(LOG_DEBUG, "DEBUG ( default/core ): -----------------------------------------------------\n");
Log(LOG_DEBUG, "DEBUG ( default/core ): | pen | field type | offset | size |\n");
}
/** get status of a mesh state */
static void
get_mesh_status(struct mesh_area* mesh, struct mesh_state* m,
char* buf, size_t len)
{
enum module_ext_state s = m->s.ext_state[m->s.curmod];
const char *modname = mesh->mods.mod[m->s.curmod]->name;
size_t l;
if(strcmp(modname, "iterator") == 0 && s == module_wait_reply &&
m->s.minfo[m->s.curmod]) {
/* break into iterator to find out who its waiting for */
struct iter_qstate* qstate = (struct iter_qstate*)
m->s.minfo[m->s.curmod];
struct outbound_list* ol = &qstate->outlist;
struct outbound_entry* e;
snprintf(buf, len, "%s wait for", modname);
l = strlen(buf);
buf += l; len -= l;
if(ol->first == NULL)
snprintf(buf, len, " (empty_list)");
for(e = ol->first; e; e = e->next) {
snprintf(buf, len, " ");
l = strlen(buf);
buf += l; len -= l;
addr_to_str(&e->qsent->addr, e->qsent->addrlen,
buf, len);
l = strlen(buf);
buf += l; len -= l;
}
} else if(s == module_wait_subquery) {
/* look in subs from mesh state to see what */
char nm[257];
struct mesh_state_ref* sub;
snprintf(buf, len, "%s wants", modname);
l = strlen(buf);
buf += l; len -= l;
if(m->sub_set.count == 0)
snprintf(buf, len, " (empty_list)");
RBTREE_FOR(sub, struct mesh_state_ref*, &m->sub_set) {
char* t = ldns_rr_type2str(sub->s->s.qinfo.qtype);
char* c = ldns_rr_class2str(sub->s->s.qinfo.qclass);
dname_str(sub->s->s.qinfo.qname, nm);
snprintf(buf, len, " %s %s %s", t, c, nm);
l = strlen(buf);
buf += l; len -= l;
free(t);
free(c);
}
} else {
static int node_list(int argc, char **argv)
{
int i;
if (!raw_output)
printf(" Id Host:Port V-Nodes Zone My-Vnodes\n");
for (i = 0; i < sd_nodes_nr; i++) {
const char *host = addr_to_str(sd_nodes[i].nid.addr,
sd_nodes[i].nid.port);
printf(raw_output ? "%d %s %d %u %d\n" : "%4d %-20s\t%2d%11u\t%2d\n",
i, host, sd_nodes[i].nr_vnodes, sd_nodes[i].zone, sd_nodes[i].my_nr_vnodes);
}
return EXIT_SUCCESS;
}
static int get_vdi_bitmap_from(struct sd_node *node)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
static DECLARE_BITMAP(tmp_vdi_inuse, SD_NR_VDIS);
int fd, i, ret = SD_RES_SUCCESS;
unsigned int rlen, wlen;
char host[128];
if (is_myself(node->addr, node->port))
goto out;
addr_to_str(host, sizeof(host), node->addr, 0);
fd = connect_to(host, node->port);
if (fd < 0) {
vprintf(SDOG_ERR, "unable to get the VDI bitmap from %s: %m\n", host);
ret = -SD_RES_EIO;
goto out;
}
vprintf(SDOG_ERR, "%s:%d\n", host, node->port);
memset(&hdr, 0, sizeof(hdr));
hdr.opcode = SD_OP_READ_VDIS;
hdr.epoch = sys->epoch;
hdr.data_length = sizeof(tmp_vdi_inuse);
rlen = hdr.data_length;
wlen = 0;
ret = exec_req(fd, &hdr, (char *)tmp_vdi_inuse,
&wlen, &rlen);
close(fd);
if (ret || rsp->result != SD_RES_SUCCESS) {
vprintf(SDOG_ERR, "unable to get the VDI bitmap (%d, %d)\n", ret,
rsp->result);
goto out;
}
for (i = 0; i < ARRAY_SIZE(sys->vdi_inuse); i++)
sys->vdi_inuse[i] |= tmp_vdi_inuse[i];
out:
return ret;
}
static void parse_objs(uint64_t oid, obj_parser_func_t func, void *data, unsigned size)
{
char name[128];
int i, fd, ret, cb_ret;
char *buf;
buf = zalloc(size);
if (!buf) {
fprintf(stderr, "Failed to allocate memory\n");
return;
}
for (i = 0; i < sd_nodes_nr; i++) {
unsigned wlen = 0, rlen = size;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
addr_to_str(name, sizeof(name), sd_nodes[i].nid.addr, 0);
fd = connect_to(name, sd_nodes[i].nid.port);
if (fd < 0)
break;
sd_init_req(&hdr, SD_OP_READ_PEER);
hdr.data_length = rlen;
hdr.flags = 0;
hdr.epoch = sd_epoch;
hdr.obj.oid = oid;
ret = exec_req(fd, &hdr, buf, &wlen, &rlen);
close(fd);
sprintf(name + strlen(name), ":%d", sd_nodes[i].nid.port);
if (ret)
fprintf(stderr, "Failed to connect to %s\n", name);
else {
cb_ret = func(name, oid, rsp, buf, data);
if (cb_ret)
break;
}
}
free(buf);
}
int sd_read_object(uint64_t oid, void *data, unsigned int datalen,
uint64_t offset)
{
struct sd_obj_req hdr;
struct sd_obj_rsp *rsp = (struct sd_obj_rsp *)&hdr;
char name[128];
int n, fd, ret;
unsigned wlen = 0, rlen = datalen;
n = obj_to_sheep(vnode_list_entries, nr_vnodes, oid, 0);
addr_to_str(name, sizeof(name), vnode_list_entries[n].addr, 0);
fd = connect_to(name, vnode_list_entries[n].port);
if (fd < 0) {
fprintf(stderr, "failed to connect %s:%d\n", name,
vnode_list_entries[n].port);
return SD_RES_EIO;
}
memset(&hdr, 0, sizeof(hdr));
hdr.epoch = node_list_version;
hdr.opcode = SD_OP_READ_OBJ;
hdr.oid = oid;
/* use direct to avoid checking consistency */
hdr.flags = SD_FLAG_CMD_DIRECT;
hdr.data_length = rlen;
hdr.offset = offset;
ret = exec_req(fd, (struct sd_req *)&hdr, data, &wlen, &rlen);
close(fd);
if (ret) {
fprintf(stderr, "failed to read object, %lx\n", oid);
return SD_RES_EIO;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "failed to read object, %lx %s\n", oid,
sd_strerror(rsp->result));
return rsp->result;
}
return SD_RES_SUCCESS;
}
