static void warts_dealias_radargun_write(const void *data,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_dealias_data_t *state)
{
const scamper_dealias_radargun_t *rg = data;
warts_param_writer_t handlers[] = {
{&rg->probedefc, (wpw_t)insert_uint32, NULL},
{&rg->attempts, (wpw_t)insert_uint16, NULL},
{&rg->wait_probe, (wpw_t)insert_uint16, NULL},
{&rg->wait_round, (wpw_t)insert_uint32, NULL},
{&rg->wait_timeout, (wpw_t)insert_byte, NULL},
{&rg->flags, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint32_t i;
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
for(i=0; i<rg->probedefc; i++)
{
warts_dealias_probedef_write(&rg->probedefs[i], &state->probedefs[i],
sf, table, buf, off, len);
}
return;
}
static void warts_dealias_ally_write(const void *data,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_dealias_data_t *state)
{
const scamper_dealias_ally_t *ally = data;
warts_param_writer_t handlers[] = {
{&ally->wait_probe, (wpw_t)insert_uint16, NULL},
{&ally->wait_timeout, (wpw_t)insert_byte, NULL},
{&ally->attempts, (wpw_t)insert_byte, NULL},
{&ally->fudge, (wpw_t)insert_uint16, NULL},
{&ally->flags, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
warts_dealias_probedef_write(&ally->probedefs[0], &state->probedefs[0],
sf, table, buf, off, len);
warts_dealias_probedef_write(&ally->probedefs[1], &state->probedefs[1],
sf, table, buf, off, len);
return;
}
static void warts_ping_reply_write(const warts_ping_reply_t *state,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off, uint32_t len)
{
scamper_ping_reply_t *reply = state->reply;
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{&reply->flags, (wpw_t)insert_byte, NULL},
{&reply->reply_ttl, (wpw_t)insert_byte, NULL},
{&reply->reply_size, (wpw_t)insert_uint16, NULL},
{reply, (wpw_t)insert_ping_reply_icmptc, NULL},
{&reply->rtt, (wpw_t)insert_rtt, NULL},
{&reply->probe_id, (wpw_t)insert_uint16, NULL},
{&reply->reply_ipid, (wpw_t)insert_uint16, NULL},
{&reply->probe_ipid, (wpw_t)insert_uint16, NULL},
{&reply->reply_proto, (wpw_t)insert_byte, NULL},
{&reply->tcp_flags, (wpw_t)insert_byte, NULL},
{reply->addr, (wpw_t)insert_addr, table},
{reply->v4rr, (wpw_t)insert_ping_reply_v4rr, table},
{reply->v4ts, (wpw_t)insert_ping_reply_v4ts, table},
{&reply->reply_ipid32, (wpw_t)insert_uint32, NULL},
{&reply->tx, (wpw_t)insert_timeval, NULL},
{reply->tsreply, (wpw_t)insert_ping_reply_tsreply, NULL},
};
const int handler_cnt = sizeof(handlers) / sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static int warts_dealias_reply_write(const scamper_dealias_reply_t *r,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_dealias_reply_t *state)
{
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{&r->rx, (wpw_t)insert_timeval, NULL},
{&r->ipid, (wpw_t)insert_uint16, NULL},
{&r->ttl, (wpw_t)insert_byte, NULL},
{r, (wpw_t)insert_dealias_reply_icmptc, NULL},
{&r->icmp_q_ip_ttl, (wpw_t)insert_byte, NULL},
{r, (wpw_t)insert_dealias_reply_icmpext, NULL},
{&r->proto, (wpw_t)insert_byte, NULL},
{&r->tcp_flags, (wpw_t)insert_byte, NULL},
{r->src, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
return 0;
}
static void warts_dealias_probe_write(const scamper_dealias_probe_t *probe,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_dealias_probe_t *state)
{
int i;
warts_param_writer_t handlers[] = {
{&probe->probedef->id, (wpw_t)insert_uint32, NULL},
{&probe->tx, (wpw_t)insert_timeval, NULL},
{&probe->replyc, (wpw_t)insert_uint16, NULL},
{&probe->ipid, (wpw_t)insert_uint16, NULL},
{&probe->seq, (wpw_t)insert_uint32, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
for(i=0; i<probe->replyc; i++)
{
warts_dealias_reply_write(probe->replies[i], sf, table, buf, off, len,
&state->replies[i]);
}
return;
}
static void warts_tracelb_probe_write(const scamper_tracelb_probe_t *probe,
const warts_tracelb_probe_t *state,
warts_addrtable_t *table,
uint8_t *buf,uint32_t *off,uint32_t len)
{
warts_param_writer_t handlers[] = {
{&probe->tx, (wpw_t)insert_timeval, NULL},
{&probe->flowid, (wpw_t)insert_uint16, NULL},
{&probe->ttl, (wpw_t)insert_byte, NULL},
{&probe->attempt, (wpw_t)insert_byte, NULL},
{&probe->rxc, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint16_t i;
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
for(i=0; i<probe->rxc; i++)
{
warts_tracelb_reply_write(probe->rxs[i], &state->replies[i], table,
buf, off, len);
}
return;
}
static void warts_trace_pmtud_write(const scamper_trace_t *trace,
uint8_t *buf, uint32_t *off, uint32_t len,
warts_trace_pmtud_t *state,
warts_addrtable_t *table)
{
warts_param_writer_t handlers[] = {
{&trace->pmtud->ifmtu, (wpw_t)insert_uint16, NULL},
{&trace->pmtud->pmtu, (wpw_t)insert_uint16, NULL},
{&trace->pmtud->outmtu, (wpw_t)insert_uint16, NULL},
{&trace->pmtud->ver, (wpw_t)insert_byte, NULL},
{&trace->pmtud->notec, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint16_t u16;
uint8_t u8;
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
/* write the number of hop records */
insert_uint16(buf, off, len, &state->hopc, NULL);
/* write the hop records */
for(u16=0; u16<state->hopc; u16++)
warts_trace_hop_write(&state->hops[u16], table, buf, off, len);
/* write the notes */
for(u8=0; u8<trace->pmtud->notec; u8++)
warts_trace_pmtud_n_write(trace->pmtud->notes[u8], buf, off, len,
&state->notes[u8]);
return;
}
static int warts_neighbourdisc_probe_write(const scamper_neighbourdisc_probe_t *probe,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_neighbourdisc_probe_t *state)
{
uint16_t i;
warts_param_writer_t handlers[] = {
{&probe->tx, (wpw_t)insert_timeval, NULL},
{&probe->rxc, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
for(i=0; i<probe->rxc; i++)
{
warts_neighbourdisc_reply_write(probe->rxs[i], sf, table, buf, off, len,
&state->rxs[i]);
}
return 0;
}
static void warts_trace_hop_write(const warts_trace_hop_t *state,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off, uint32_t len)
{
scamper_trace_hop_t *hop = state->hop;
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{&hop->hop_probe_ttl, (wpw_t)insert_byte, NULL},
{&hop->hop_reply_ttl, (wpw_t)insert_byte, NULL},
{&hop->hop_flags, (wpw_t)insert_byte, NULL},
{&hop->hop_probe_id, (wpw_t)warts_trace_hop_write_probe_id, NULL},
{&hop->hop_rtt, (wpw_t)insert_rtt, NULL},
{hop, (wpw_t)warts_trace_hop_write_icmp_tc, NULL},
{&hop->hop_probe_size, (wpw_t)insert_uint16, NULL},
{&hop->hop_reply_size, (wpw_t)insert_uint16, NULL},
{&hop->hop_reply_ipid, (wpw_t)insert_uint16, NULL},
{&hop->hop_reply_tos, (wpw_t)insert_byte, NULL},
{&hop->hop_icmp_nhmtu, (wpw_t)insert_uint16, NULL},
{&hop->hop_icmp_q_ipl, (wpw_t)insert_uint16, NULL},
{&hop->hop_icmp_q_ttl, (wpw_t)insert_byte, NULL},
{&hop->hop_tcp_flags, (wpw_t)insert_byte, NULL},
{&hop->hop_icmp_q_tos, (wpw_t)insert_byte, NULL},
{hop, (wpw_t)warts_trace_hop_write_icmpext, NULL},
{hop->hop_addr, (wpw_t)insert_addr, table},
{&hop->hop_tx, (wpw_t)insert_timeval, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static int warts_dealias_params_write(const scamper_dealias_t *dealias,
const scamper_file_t *sf,
uint8_t *buf, uint32_t *off,
const uint32_t len,
const uint8_t *flags,
const uint16_t flags_len,
const uint16_t params_len)
{
uint32_t list_id, cycle_id;
warts_param_writer_t handlers[] = {
{&list_id, (wpw_t)insert_uint32, NULL},
{&cycle_id, (wpw_t)insert_uint32, NULL},
{&dealias->start, (wpw_t)insert_timeval, NULL},
{&dealias->method, (wpw_t)insert_byte, NULL},
{&dealias->result, (wpw_t)insert_byte, NULL},
{&dealias->probec, (wpw_t)insert_uint32, NULL},
{&dealias->userid, (wpw_t)insert_uint32, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(warts_list_getid(sf, dealias->list, &list_id) == -1) return -1;
if(warts_cycle_getid(sf, dealias->cycle, &cycle_id) == -1) return -1;
warts_params_write(buf, off, len, flags, flags_len, params_len, handlers,
handler_cnt);
return 0;
}
static void warts_dealias_probedef_write(const scamper_dealias_probedef_t *p,
warts_dealias_probedef_t *state,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len)
{
uint8_t bytes[4]; uint16_t bytes_len = 4;
uint8_t tcp_flags;
uint16_t icmpid;
uint16_t u16;
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{NULL, NULL, NULL},
{&p->id, (wpw_t)insert_uint32, NULL},
{&p->method, (wpw_t)insert_byte, NULL},
{&p->ttl, (wpw_t)insert_byte, NULL},
{&p->tos, (wpw_t)insert_byte, NULL},
{bytes, (wpw_t)insert_bytes_uint16, &bytes_len},
{&tcp_flags, (wpw_t)insert_byte, NULL},
{&icmpid, (wpw_t)insert_uint16, NULL},
{p->dst, (wpw_t)insert_addr, table},
{p->src, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(SCAMPER_DEALIAS_PROBEDEF_PROTO_IS_ICMP(p))
{
bytes[0] = p->un.icmp.type;
bytes[1] = p->un.icmp.code;
u16 = htons(p->un.icmp.csum);
memcpy(bytes+2, &u16, 2);
icmpid = p->un.icmp.id;
}
else if(SCAMPER_DEALIAS_PROBEDEF_PROTO_IS_UDP(p))
{
u16 = htons(p->un.udp.sport);
memcpy(bytes+0, &u16, 2);
u16 = htons(p->un.udp.dport);
memcpy(bytes+2, &u16, 2);
}
else if(SCAMPER_DEALIAS_PROBEDEF_PROTO_IS_TCP(p))
{
u16 = htons(p->un.tcp.sport);
memcpy(bytes+0, &u16, 2);
u16 = htons(p->un.tcp.dport);
memcpy(bytes+2, &u16, 2);
tcp_flags = p->un.tcp.flags;
}
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
return;
}
static int warts_ping_params_write(const scamper_ping_t *ping,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
const uint8_t *flags,
const uint16_t flags_len,
const uint16_t params_len)
{
uint32_t list_id, cycle_id;
uint16_t pad_len = ping->probe_datalen;
warts_param_writer_t handlers[] = {
{&list_id, (wpw_t)insert_uint32, NULL},
{&cycle_id, (wpw_t)insert_uint32, NULL},
{NULL, NULL, NULL},
{NULL, NULL, NULL},
{&ping->start, (wpw_t)insert_timeval, NULL},
{&ping->stop_reason, (wpw_t)insert_byte, NULL},
{&ping->stop_data, (wpw_t)insert_byte, NULL},
{&ping->probe_datalen, (wpw_t)insert_uint16, NULL},
{ping->probe_data, (wpw_t)insert_bytes_uint16, &pad_len},
{&ping->probe_count, (wpw_t)insert_uint16, NULL},
{&ping->probe_size, (wpw_t)insert_uint16, NULL},
{&ping->probe_wait, (wpw_t)insert_byte, NULL},
{&ping->probe_ttl, (wpw_t)insert_byte, NULL},
{&ping->reply_count, (wpw_t)insert_uint16, NULL},
{&ping->ping_sent, (wpw_t)insert_uint16, NULL},
{&ping->probe_method, (wpw_t)insert_byte, NULL},
{&ping->probe_sport, (wpw_t)insert_uint16, NULL},
{&ping->probe_dport, (wpw_t)insert_uint16, NULL},
{&ping->userid, (wpw_t)insert_uint32, NULL},
{ping->src, (wpw_t)insert_addr, table},
{ping->dst, (wpw_t)insert_addr, table},
{&ping->flags, (wpw_t)insert_byte, NULL},
{&ping->probe_tos, (wpw_t)insert_byte, NULL},
{ping->probe_tsps, (wpw_t)insert_ping_probe_tsps, table},
{&ping->probe_icmpsum, (wpw_t)insert_uint16, NULL},
{&ping->reply_pmtu, (wpw_t)insert_uint16, NULL},
{&ping->probe_timeout, (wpw_t)insert_byte, NULL},
{&ping->probe_wait_us, (wpw_t)insert_uint32, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(warts_list_getid(sf, ping->list, &list_id) == -1) return -1;
if(warts_cycle_getid(sf, ping->cycle, &cycle_id) == -1) return -1;
warts_params_write(buf, off, len, flags, flags_len, params_len, handlers,
handler_cnt);
return 0;
}
static int warts_trace_params_write(const scamper_trace_t *trace,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
const uint8_t *flags,
const uint16_t flags_len,
const uint16_t params_len)
{
uint32_t list_id, cycle_id;
warts_param_writer_t handlers[] = {
{&list_id, (wpw_t)insert_uint32, NULL},
{&cycle_id, (wpw_t)insert_uint32, NULL},
{NULL, NULL, NULL},
{NULL, NULL, NULL},
{&trace->start, (wpw_t)insert_timeval, NULL},
{&trace->stop_reason, (wpw_t)insert_byte, NULL},
{&trace->stop_data, (wpw_t)insert_byte, NULL},
{&trace->flags, (wpw_t)insert_byte, NULL},
{&trace->attempts, (wpw_t)insert_byte, NULL},
{&trace->hoplimit, (wpw_t)insert_byte, NULL},
{&trace->type, (wpw_t)insert_byte, NULL},
{&trace->probe_size, (wpw_t)insert_uint16, NULL},
{&trace->sport, (wpw_t)insert_uint16, NULL},
{&trace->dport, (wpw_t)insert_uint16, NULL},
{&trace->firsthop, (wpw_t)insert_byte, NULL},
{&trace->tos, (wpw_t)insert_byte, NULL},
{&trace->wait, (wpw_t)insert_byte, NULL},
{&trace->loops, (wpw_t)insert_byte, NULL},
{&trace->hop_count, (wpw_t)insert_uint16, NULL},
{&trace->gaplimit, (wpw_t)insert_byte, NULL},
{&trace->gapaction, (wpw_t)insert_byte, NULL},
{&trace->loopaction, (wpw_t)insert_byte, NULL},
{&trace->probec, (wpw_t)insert_uint16, NULL},
{&trace->wait_probe, (wpw_t)insert_byte, NULL},
{&trace->confidence, (wpw_t)insert_byte, NULL},
{trace->src, (wpw_t)insert_addr, table},
{trace->dst, (wpw_t)insert_addr, table},
{&trace->userid, (wpw_t)insert_uint32, NULL},
{&trace->offset, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(warts_list_getid(sf, trace->list, &list_id) == -1) return -1;
if(warts_cycle_getid(sf, trace->cycle, &cycle_id) == -1) return -1;
warts_params_write(buf, off, len, flags, flags_len, params_len, handlers,
handler_cnt);
return 0;
}
static void warts_trace_pmtud_n_write(const scamper_trace_pmtud_n_t *note,
uint8_t *buf, uint32_t *off, uint32_t len,
warts_trace_pmtud_n_t *state)
{
warts_param_writer_t handlers[] = {
{¬e->type, (wpw_t)insert_byte, NULL},
{¬e->nhmtu, (wpw_t)insert_uint16, NULL},
{&state->hop, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static void warts_tbit_app_http_write(const scamper_tbit_t *tbit, uint8_t *buf,
uint32_t *off, uint32_t len,
warts_tbit_app_http_t *state)
{
scamper_tbit_app_http_t *http = tbit->app_data;
warts_param_writer_t handlers[] = {
{http->host, (wpw_t)insert_string, NULL},
{http->file, (wpw_t)insert_string, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static void warts_tbit_null_write(const scamper_tbit_t *tbit, uint8_t *buf,
uint32_t *off, uint32_t len,
warts_tbit_null_t *state)
{
scamper_tbit_null_t *null = tbit->data;
warts_param_writer_t handlers[] = {
{&null->options, (wpw_t)insert_uint16, NULL},
{&null->results, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static int warts_tbit_pkt_write(const scamper_tbit_pkt_t *pkt,
const scamper_file_t *sf,
uint8_t *buf,uint32_t *off,const uint32_t len,
warts_tbit_pkt_t *state)
{
uint16_t dl = pkt->len;
warts_param_writer_t handlers[] = {
{&pkt->dir, (wpw_t)insert_byte, NULL},
{&pkt->tv, (wpw_t)insert_timeval, NULL},
{&pkt->len, (wpw_t)insert_uint16, NULL},
{pkt->data, (wpw_t)insert_bytes_uint16, &dl},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return 0;
}
static void warts_tbit_pmtud_write(const scamper_tbit_t *tbit, uint8_t *buf,
uint32_t *off, uint32_t len,
warts_addrtable_t *table,
warts_tbit_pmtud_t *state)
{
scamper_tbit_pmtud_t *pmtud = tbit->data;
warts_param_writer_t handlers[] = {
{&pmtud->mtu, (wpw_t)insert_uint16, NULL},
{&pmtud->ptb_retx, (wpw_t)insert_byte, NULL},
{&pmtud->options, (wpw_t)insert_byte, NULL},
{pmtud->ptbsrc, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static void warts_tracelb_node_write(const scamper_tracelb_node_t *node,
const warts_tracelb_node_t *state,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off, uint32_t len)
{
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{&node->flags, (wpw_t)insert_byte, NULL},
{&node->linkc, (wpw_t)insert_uint16, NULL},
{&node->q_ttl, (wpw_t)insert_byte, NULL},
{node->addr, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static int warts_neighbourdisc_reply_write(const scamper_neighbourdisc_reply_t *reply,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_neighbourdisc_reply_t *state)
{
warts_param_writer_t handlers[] = {
{&reply->rx, (wpw_t)insert_timeval, NULL},
{reply->mac, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
return 0;
}
static void warts_trace_dtree_write(const scamper_trace_t *trace,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off, uint32_t len,
warts_trace_dtree_t *state)
{
warts_param_writer_t handlers[] = {
{NULL, NULL, NULL},
{NULL, NULL, NULL},
{&trace->dtree->firsthop, (wpw_t)insert_byte, NULL},
{trace->dtree->lss_stop, (wpw_t)insert_addr, table},
{trace->dtree->gss_stop, (wpw_t)insert_addr, table},
{trace->dtree->lss, (wpw_t)insert_string, NULL},
{&trace->dtree->flags, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
return;
}
static int warts_tbit_params_write(const scamper_tbit_t *tbit,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len, const uint8_t *flags,
const uint16_t flags_len,
const uint16_t params_len)
{
uint32_t list_id, cycle_id;
/* Specifies how to write each variable to the warts file. */
warts_param_writer_t handlers[] = {
{&list_id, (wpw_t)insert_uint32, NULL},
{&cycle_id, (wpw_t)insert_uint32, NULL},
{&tbit->userid, (wpw_t)insert_uint32, NULL},
{tbit->src, (wpw_t)insert_addr, table},
{tbit->dst, (wpw_t)insert_addr, table},
{&tbit->sport, (wpw_t)insert_uint16, NULL},
{&tbit->dport, (wpw_t)insert_uint16, NULL},
{&tbit->start, (wpw_t)insert_timeval, NULL},
{&tbit->result, (wpw_t)insert_uint16, NULL},
{&tbit->type, (wpw_t)insert_byte, NULL},
{&tbit->app_proto, (wpw_t)insert_byte, NULL},
{&tbit->client_mss, (wpw_t)insert_uint16, NULL},
{&tbit->server_mss, (wpw_t)insert_uint16, NULL},
{&tbit->syn_retx, (wpw_t)insert_byte, NULL},
{&tbit->dat_retx, (wpw_t)insert_byte, NULL},
{NULL, NULL, NULL}, /* PKTC16 */
{&tbit->pktc, (wpw_t)insert_uint32, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(warts_list_getid(sf, tbit->list, &list_id) == -1) return -1;
if(warts_cycle_getid(sf, tbit->cycle, &cycle_id) == -1) return -1;
warts_params_write(buf, off, len, flags, flags_len, params_len,
handlers, handler_cnt);
return 0;
}
static void warts_dealias_prefixscan_write(const void *data,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
warts_dealias_data_t *state)
{
const scamper_dealias_prefixscan_t *prefixscan = data;
warts_param_writer_t handlers[] = {
{prefixscan->a, (wpw_t)insert_addr, table},
{prefixscan->b, (wpw_t)insert_addr, table},
{prefixscan->ab, (wpw_t)insert_addr, table},
{prefixscan, (wpw_t)insert_dealias_prefixscan_xs, table},
{&prefixscan->prefix, (wpw_t)insert_byte, NULL},
{&prefixscan->attempts, (wpw_t)insert_byte, NULL},
{&prefixscan->fudge, (wpw_t)insert_uint16, NULL},
{&prefixscan->wait_probe, (wpw_t)insert_uint16, NULL},
{&prefixscan->wait_timeout, (wpw_t)insert_byte, NULL},
{&prefixscan->probedefc, (wpw_t)insert_uint16, NULL},
{&prefixscan->flags, (wpw_t)insert_byte, NULL},
{&prefixscan->replyc, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint32_t i;
warts_params_write(buf, off, len,
state->flags, state->flags_len, state->params_len,
handlers, handler_cnt);
for(i=0; i<prefixscan->probedefc; i++)
{
warts_dealias_probedef_write(&prefixscan->probedefs[i],
&state->probedefs[i],
sf, table, buf, off, len);
}
return;
}
static void warts_tracelb_reply_write(const scamper_tracelb_reply_t *reply,
const warts_tracelb_reply_t *state,
warts_addrtable_t *table,
uint8_t *buf,uint32_t *off,uint32_t len)
{
warts_param_writer_t handlers[] = {
{&reply->reply_rx, (wpw_t)insert_timeval, NULL},
{&reply->reply_ipid, (wpw_t)insert_uint16, NULL},
{&reply->reply_ttl, (wpw_t)insert_byte, NULL},
{&reply->reply_flags, (wpw_t)insert_byte, NULL},
{reply, (wpw_t)insert_tracelb_reply_icmp_tc, NULL},
{&reply->reply_tcp_flags, (wpw_t)insert_byte, NULL},
{reply, (wpw_t)insert_tracelb_reply_icmp_ext, NULL},
{&reply->reply_icmp_q_ttl, (wpw_t)insert_byte, NULL},
{&reply->reply_icmp_q_tos, (wpw_t)insert_byte, NULL},
{NULL, NULL, NULL},
{reply->reply_from, (wpw_t)insert_addr, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
return;
}
static void warts_tracelb_probeset_write(const scamper_tracelb_probeset_t *set,
const warts_tracelb_probeset_t *state,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
uint32_t len)
{
warts_param_writer_t handlers[] = {
{&set->probec, (wpw_t)insert_uint16, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint16_t i;
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
for(i=0; i<set->probec; i++)
{
warts_tracelb_probe_write(set->probes[i], &state->probes[i], table,
buf, off, len);
}
return;
}
static int warts_neighbourdisc_params_write(const scamper_neighbourdisc_t *nd,
const scamper_file_t *sf,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off,
const uint32_t len,
const uint8_t *flags,
const uint16_t flags_len,
const uint16_t params_len)
{
uint32_t list_id, cycle_id;
warts_param_writer_t handlers[] = {
{&list_id, (wpw_t)insert_uint32, NULL},
{&cycle_id, (wpw_t)insert_uint32, NULL},
{&nd->userid, (wpw_t)insert_uint32, NULL},
{nd->ifname, (wpw_t)insert_string, NULL},
{&nd->start, (wpw_t)insert_timeval, NULL},
{&nd->method, (wpw_t)insert_byte, NULL},
{&nd->wait, (wpw_t)insert_uint16, NULL},
{&nd->flags, (wpw_t)insert_byte, NULL},
{&nd->attempts, (wpw_t)insert_uint16, NULL},
{&nd->replyc, (wpw_t)insert_uint16, NULL},
{nd->src_ip, (wpw_t)insert_addr, table},
{nd->src_mac, (wpw_t)insert_addr, table},
{nd->dst_ip, (wpw_t)insert_addr, table},
{nd->dst_mac, (wpw_t)insert_addr, table},
{&nd->probec, (wpw_t)insert_uint16, table},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
if(warts_list_getid(sf, nd->list, &list_id) == -1) return -1;
if(warts_cycle_getid(sf, nd->cycle, &cycle_id) == -1) return -1;
warts_params_write(buf, off, len, flags, flags_len, params_len,
handlers, handler_cnt);
return 0;
}
static void warts_tracelb_link_write(const scamper_tracelb_link_t *link,
const warts_tracelb_link_t *state,
warts_addrtable_t *table,
uint8_t *buf, uint32_t *off, uint32_t len)
{
warts_param_writer_t handlers[] = {
{&state->from, (wpw_t)insert_uint16, NULL},
{&state->to, (wpw_t)insert_uint16, NULL},
{&link->hopc, (wpw_t)insert_byte, NULL},
};
const int handler_cnt = sizeof(handlers)/sizeof(warts_param_writer_t);
uint32_t i;
warts_params_write(buf, off, len, state->flags, state->flags_len,
state->params_len, handlers, handler_cnt);
for(i=0; i<link->hopc; i++)
{
warts_tracelb_probeset_write(link->sets[i], &state->sets[i], table,
buf, off, len);
}
return;
}
