static int warts_trace_dtree_params(const scamper_file_t *sf,
const scamper_trace_t *trace,
warts_addrtable_t *table,
warts_trace_dtree_t *state)
{
scamper_trace_dtree_t *dtree = trace->dtree;
const warts_var_t *var;
int i, max_id = 0;
/* unset all the flags possible */
memset(state->flags, 0, trace_dtree_vars_mfb);
state->params_len = 0;
for(i=0; i<sizeof(trace_dtree_vars)/sizeof(warts_var_t); i++)
{
var = &trace_dtree_vars[i];
/* not used any more */
if(var->id == WARTS_TRACE_DTREE_LSS_STOP_GID ||
var->id == WARTS_TRACE_DTREE_GSS_STOP_GID)
continue;
if((var->id == WARTS_TRACE_DTREE_LSS_STOP && dtree->lss_stop == NULL) ||
(var->id == WARTS_TRACE_DTREE_LSS_NAME && dtree->lss == NULL) ||
(var->id == WARTS_TRACE_DTREE_GSS_STOP && dtree->gss_stop == NULL) ||
(var->id == WARTS_TRACE_DTREE_FLAGS && dtree->flags == 0))
continue;
flag_set(state->flags, var->id, &max_id);
/* variables that don't have a fixed size */
if(var->id == WARTS_TRACE_DTREE_LSS_STOP)
{
state->params_len += warts_addr_size(table, dtree->lss_stop);
continue;
}
else if(var->id == WARTS_TRACE_DTREE_LSS_NAME)
{
state->params_len += warts_str_size(dtree->lss);
continue;
}
else if(var->id == WARTS_TRACE_DTREE_GSS_STOP)
{
state->params_len += warts_addr_size(table, dtree->gss_stop);
continue;
}
assert(var->size != -1);
state->params_len += var->size;
}
state->flags_len = fold_flags(state->flags, max_id);
state->len = state->flags_len + state->params_len;
if(state->params_len != 0)
state->len += 2 ;
return 0;
}
static void warts_neighbourdisc_params(const scamper_neighbourdisc_t *nd,
warts_addrtable_t *table,
uint8_t *flags, uint16_t *flags_len,
uint16_t *params_len)
{
int i, max_id = 0;
const warts_var_t *var;
memset(flags, 0, neighbourdisc_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(neighbourdisc_vars)/sizeof(warts_var_t); i++)
{
var = &neighbourdisc_vars[i];
if(var->id == WARTS_NEIGHBOURDISC_LIST && nd->list == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_CYCLE && nd->cycle == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_USERID && nd->userid == 0)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_IFNAME && nd->ifname == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_SRC_IP && nd->src_ip == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_SRC_MAC && nd->src_mac == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_DST_IP && nd->dst_ip == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_DST_MAC && nd->dst_mac == NULL)
continue;
else if(var->id == WARTS_NEIGHBOURDISC_PROBEC && nd->probec == 0)
continue;
flag_set(flags, var->id, &max_id);
if(var->size < 0)
{
if(var->id == WARTS_NEIGHBOURDISC_SRC_IP)
*params_len += warts_addr_size(table, nd->src_ip);
else if(var->id == WARTS_NEIGHBOURDISC_SRC_MAC)
*params_len += warts_addr_size(table, nd->src_mac);
else if(var->id == WARTS_NEIGHBOURDISC_DST_IP)
*params_len += warts_addr_size(table, nd->dst_ip);
else if(var->id == WARTS_NEIGHBOURDISC_DST_MAC)
*params_len += warts_addr_size(table, nd->dst_mac);
else if(var->id == WARTS_NEIGHBOURDISC_IFNAME)
*params_len += warts_str_size(nd->ifname);
continue;
}
assert(var->size >= 0);
*params_len += var->size;
}
*flags_len = fold_flags(flags, max_id);
return;
}
static void warts_trace_params(const scamper_trace_t *trace,
warts_addrtable_t *table, uint8_t *flags,
uint16_t *flags_len, uint16_t *params_len)
{
int max_id = 0;
const warts_var_t *var;
size_t i;
/* unset all the flags possible */
memset(flags, 0, trace_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(trace_vars)/sizeof(warts_var_t); i++)
{
var = &trace_vars[i];
if(var->id == WARTS_TRACE_ADDR_SRC_GID ||
var->id == WARTS_TRACE_ADDR_DST_GID)
{
continue;
}
if(var->id == WARTS_TRACE_USERID)
{
if(trace->userid == 0)
continue;
}
if(var->id == WARTS_TRACE_OFFSET)
{
if(trace->offset == 0)
continue;
}
flag_set(flags, var->id, &max_id);
if(var->id == WARTS_TRACE_ADDR_SRC)
{
*params_len += warts_addr_size(table, trace->src);
continue;
}
else if(var->id == WARTS_TRACE_ADDR_DST)
{
*params_len += warts_addr_size(table, trace->dst);
continue;
}
assert(var->size >= 0);
*params_len += var->size;
}
*flags_len = fold_flags(flags, max_id);
return;
}
static void warts_tbit_params(const scamper_tbit_t *tbit,
warts_addrtable_t *table, uint8_t *flags,
uint16_t *flags_len, uint16_t *params_len)
{
const warts_var_t *var;
int i, max_id = 0;
/* Unset all flags */
memset(flags, 0, tbit_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(tbit_vars)/sizeof(warts_var_t); i++)
{
var = &tbit_vars[i];
/* Skip the variables for which we have no data */
if(var->id == WARTS_TBIT_PKTC16)
continue;
else if(var->id == WARTS_TBIT_LIST && tbit->list == NULL)
continue;
else if(var->id == WARTS_TBIT_CYCLE && tbit->cycle == NULL)
continue;
else if(var->id == WARTS_TBIT_USERID && tbit->userid == 0)
continue;
else if(var->id == WARTS_TBIT_SRC && tbit->src == NULL)
continue;
else if(var->id == WARTS_TBIT_DST && tbit->dst == NULL)
continue;
/* Set the flag for the rest of the variables */
flag_set(flags, var->id, &max_id);
/* Variables that don't have a fixed size */
if(var->id == WARTS_TBIT_SRC)
{
*params_len += warts_addr_size(table, tbit->src);
continue;
}
else if(var->id == WARTS_TBIT_DST)
{
*params_len += warts_addr_size(table, tbit->dst);
continue;
}
/* The rest of the variables have a fixed size */
*params_len += var->size;
}
*flags_len = fold_flags(flags, max_id);
return;
}
static int warts_dealias_probedef_params(const scamper_file_t *sf,
const scamper_dealias_probedef_t *p,
warts_dealias_probedef_t *state,
warts_addrtable_t *table,
uint32_t *len)
{
int max_id = 0;
memset(state->flags, 0, dealias_probedef_vars_mfb);
state->params_len = 0;
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_DST, &max_id);
state->params_len += warts_addr_size(table, p->dst);
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_SRC, &max_id);
state->params_len += warts_addr_size(table, p->src);
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_ID, &max_id);
state->params_len += 4;
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_METHOD, &max_id);
state->params_len += 1;
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_TTL, &max_id);
state->params_len += 1;
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_TOS, &max_id);
state->params_len += 1;
/* always include the first 4 bytes of the IP payload */
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_4BYTES, &max_id);
state->params_len += 4;
/* sometimes include icmp id/sequence number */
if(SCAMPER_DEALIAS_PROBEDEF_PROTO_IS_ICMP(p))
{
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_ICMP_ID, &max_id);
state->params_len += 2;
}
/* sometimes include tcp flags */
if(SCAMPER_DEALIAS_PROBEDEF_PROTO_IS_TCP(p))
{
flag_set(state->flags, WARTS_DEALIAS_PROBEDEF_TCP_FLAGS, &max_id);
state->params_len += 1;
}
state->flags_len = fold_flags(state->flags, max_id);
/* increase length for the probedef record */
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static int warts_tracelb_node_state(const scamper_file_t *sf,
const scamper_tracelb_node_t *node,
warts_addrtable_t *table,
warts_tracelb_node_t *state, uint32_t *len)
{
const warts_var_t *var;
int i, max_id = 0;
/* unset all the flags possible */
memset(state->flags, 0, tracelb_node_vars_mfb);
state->params_len = 0;
/* for now, we include the base data items */
for(i=0; i<sizeof(tracelb_node_vars)/sizeof(warts_var_t); i++)
{
var = &tracelb_node_vars[i];
if(var->id == WARTS_TRACELB_NODE_ADDR_GID)
{
continue;
}
else if(var->id == WARTS_TRACELB_NODE_QTTL)
{
/* don't include the qttl field if it isn't used */
if(SCAMPER_TRACELB_NODE_QTTL(node) == 0)
continue;
}
if(var->id == WARTS_TRACELB_NODE_ADDR)
{
if(node->addr != NULL)
{
flag_set(state->flags, var->id, &max_id);
state->params_len += warts_addr_size(table, node->addr);
}
continue;
}
assert(var->size >= 0);
flag_set(state->flags, var->id, &max_id);
state->params_len += var->size;
}
state->flags_len = fold_flags(state->flags, max_id);
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static void warts_tbit_pmtud_params(const scamper_tbit_t *tbit,
warts_addrtable_t *table,
warts_tbit_pmtud_t *state)
{
scamper_tbit_pmtud_t *pmtud = tbit->data;
const warts_var_t *var;
int i, max_id = 0;
/* unset all the flags possible */
memset(state->flags, 0, tbit_pmtud_vars_mfb);
state->params_len = 0;
for(i=0; i<sizeof(tbit_pmtud_vars)/sizeof(warts_var_t); i++)
{
var = &tbit_pmtud_vars[i];
if(var->id == WARTS_TBIT_PMTUD_MTU && pmtud->mtu == 0)
continue;
if(var->id == WARTS_TBIT_PMTUD_PTBRETX && pmtud->ptb_retx == 0)
continue;
if(var->id == WARTS_TBIT_PMTUD_OPTIONS && pmtud->options == 0)
continue;
if(var->id == WARTS_TBIT_PMTUD_PTBSRC && pmtud->ptbsrc == NULL)
continue;
flag_set(state->flags, var->id, &max_id);
if(var->id == WARTS_TBIT_PMTUD_PTBSRC)
{
state->params_len += warts_addr_size(table, pmtud->ptbsrc);
continue;
}
assert(var->size >= 0);
state->params_len += var->size;
}
state->flags_len = fold_flags(state->flags, max_id);
state->len = state->flags_len + state->params_len;
if(state->params_len != 0)
state->len += 2;
return;
}
static int warts_neighbourdisc_reply_state(scamper_neighbourdisc_reply_t *reply,
warts_neighbourdisc_reply_t *state,
warts_addrtable_t *table,
uint32_t *len)
{
int i = 0;
memset(state->flags, 0, neighbourdisc_reply_vars_mfb);
state->params_len = 0;
flag_set(state->flags, WARTS_NEIGHBOURDISC_REPLY_RX, &i);
state->params_len += 8;
flag_set(state->flags, WARTS_NEIGHBOURDISC_REPLY_MAC, &i);
state->params_len += warts_addr_size(table, reply->mac);
state->flags_len = fold_flags(state->flags, i);
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static void warts_ping_params(const scamper_ping_t *ping,
warts_addrtable_t *table, uint8_t *flags,
uint16_t *flags_len, uint16_t *params_len)
{
const warts_var_t *var;
int i, j, max_id = 0;
/* unset all the flags possible */
memset(flags, 0, ping_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(ping_vars)/sizeof(warts_var_t); i++)
{
var = &ping_vars[i];
if(var->id == WARTS_PING_ADDR_SRC_GID ||
var->id == WARTS_PING_ADDR_DST_GID ||
(var->id == WARTS_PING_ADDR_SRC && ping->src == NULL) ||
(var->id == WARTS_PING_ADDR_DST && ping->dst == NULL) ||
(var->id == WARTS_PING_LIST_ID && ping->list == NULL) ||
(var->id == WARTS_PING_CYCLE_ID && ping->cycle == NULL) ||
(var->id == WARTS_PING_USERID && ping->userid == 0) ||
(var->id == WARTS_PING_DATA_LEN && ping->probe_datalen == 0) ||
(var->id == WARTS_PING_PROBE_METHOD && ping->probe_method == 0) ||
(var->id == WARTS_PING_PROBE_TOS && ping->probe_tos == 0) ||
(var->id == WARTS_PING_PROBE_SPORT && ping->probe_sport == 0) ||
(var->id == WARTS_PING_PROBE_DPORT && ping->probe_dport == 0) ||
(var->id == WARTS_PING_FLAGS && ping->flags == 0) ||
(var->id == WARTS_PING_REPLY_PMTU && ping->reply_pmtu == 0) ||
(var->id == WARTS_PING_PROBE_TIMEOUT && ping->probe_timeout == ping->probe_wait))
{
continue;
}
if(var->id == WARTS_PING_PROBE_ICMPSUM)
{
if(ping->probe_icmpsum == 0 ||
(ping->flags & SCAMPER_PING_FLAG_ICMPSUM) == 0)
continue;
}
if(var->id == WARTS_PING_DATA_BYTES)
{
if(ping->probe_datalen != 0)
{
flag_set(flags, WARTS_PING_DATA_BYTES, &max_id);
*params_len += ping->probe_datalen;
}
continue;
}
if(var->id == WARTS_PING_PROBE_TSPS)
{
if(ping->probe_tsps != NULL)
{
flag_set(flags, WARTS_PING_PROBE_TSPS, &max_id);
*params_len += 1;
for(j=0; j<ping->probe_tsps->ipc; j++)
*params_len += warts_addr_size(table,ping->probe_tsps->ips[j]);
}
continue;
}
flag_set(flags, var->id, &max_id);
if(var->id == WARTS_PING_ADDR_SRC)
{
*params_len += warts_addr_size(table, ping->src);
continue;
}
else if(var->id == WARTS_PING_ADDR_DST)
{
*params_len += warts_addr_size(table, ping->dst);
continue;
}
assert(var->size >= 0);
*params_len += var->size;
}
*flags_len = fold_flags(flags, max_id);
return;
}
static void warts_ping_reply_params(const scamper_ping_t *ping,
const scamper_ping_reply_t *reply,
warts_addrtable_t *table,
uint8_t *flags, uint16_t *flags_len,
uint16_t *params_len)
{
const warts_var_t *var;
int i, j, max_id = 0;
/* unset all the flags possible */
memset(flags, 0, ping_reply_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(ping_reply_vars)/sizeof(warts_var_t); i++)
{
var = &ping_reply_vars[i];
if(var->id == WARTS_PING_REPLY_ADDR_GID ||
(var->id == WARTS_PING_REPLY_ADDR && reply->addr == NULL) ||
(var->id == WARTS_PING_REPLY_FLAGS && reply->flags == 0) ||
(var->id == WARTS_PING_REPLY_REPLY_PROTO &&
SCAMPER_PING_METHOD_IS_ICMP(ping)) ||
(var->id == WARTS_PING_REPLY_REPLY_TTL &&
(reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_TTL) == 0) ||
(var->id == WARTS_PING_REPLY_REPLY_IPID &&
SCAMPER_ADDR_TYPE_IS_IPV4(ping->dst) &&
(reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_IPID) == 0) ||
(var->id == WARTS_PING_REPLY_REPLY_IPID32 &&
SCAMPER_ADDR_TYPE_IS_IPV6(ping->dst) &&
(reply->flags & SCAMPER_PING_REPLY_FLAG_REPLY_IPID) == 0) ||
(var->id == WARTS_PING_REPLY_PROBE_IPID &&
SCAMPER_ADDR_TYPE_IS_IPV4(ping->dst) &&
(reply->flags & SCAMPER_PING_REPLY_FLAG_PROBE_IPID) == 0) ||
(var->id == WARTS_PING_REPLY_ICMP_TC &&
SCAMPER_PING_REPLY_IS_ICMP(reply) == 0) ||
(var->id == WARTS_PING_REPLY_TCP_FLAGS &&
SCAMPER_PING_REPLY_IS_TCP(reply) == 0) ||
(var->id == WARTS_PING_REPLY_V4RR && reply->v4rr == NULL) ||
(var->id == WARTS_PING_REPLY_V4TS && reply->v4ts == NULL) ||
(var->id == WARTS_PING_REPLY_TX && reply->tx.tv_sec == 0) ||
(var->id == WARTS_PING_REPLY_TSREPLY && reply->tsreply == NULL))
{
continue;
}
flag_set(flags, var->id, &max_id);
if(var->id == WARTS_PING_REPLY_ADDR)
{
*params_len += warts_addr_size(table, reply->addr);
}
else if(var->id == WARTS_PING_REPLY_V4RR)
{
*params_len += 1;
for(j=0; j<reply->v4rr->rrc; j++)
*params_len += warts_addr_size(table, reply->v4rr->rr[j]);
}
else if(var->id == WARTS_PING_REPLY_V4TS)
{
assert(reply->v4ts != NULL);
*params_len += 2; /* one byte tsc, one byte count of v4ts->ips */
*params_len += (reply->v4ts->tsc * 4);
if(reply->v4ts->ips != NULL)
for(j=0; j<reply->v4ts->tsc; j++)
*params_len += warts_addr_size(table, reply->v4ts->ips[j]);
}
else
{
assert(var->size >= 0);
*params_len += var->size;
}
}
*flags_len = fold_flags(flags, max_id);
return;
}
static int warts_dealias_prefixscan_state(const scamper_file_t *sf,
const void *data,
warts_dealias_data_t *state,
warts_addrtable_t *table,
uint32_t *len)
{
const scamper_dealias_prefixscan_t *p = data;
const warts_var_t *var;
int max_id = 0;
uint16_t i, j;
size_t size;
if(p->probedefc > 0)
{
size = p->probedefc * sizeof(warts_dealias_probedef_t);
if((state->probedefs = malloc_zero(size)) == NULL)
return -1;
}
memset(state->flags, 0, dealias_prefixscan_vars_mfb);
state->params_len = 0;
for(i=0; i<sizeof(dealias_prefixscan_vars)/sizeof(warts_var_t); i++)
{
var = &dealias_prefixscan_vars[i];
if(var->id == WARTS_DEALIAS_PREFIXSCAN_A)
{
if(p->a != NULL)
{
flag_set(state->flags, var->id, &max_id);
state->params_len += warts_addr_size(table, p->a);
}
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_B)
{
if(p->b != NULL)
{
flag_set(state->flags, var->id, &max_id);
state->params_len += warts_addr_size(table, p->b);
}
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_AB)
{
if(p->ab != NULL)
{
flag_set(state->flags, var->id, &max_id);
state->params_len += warts_addr_size(table, p->ab);
}
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_XS)
{
if(p->xc > 0)
{
flag_set(state->flags, var->id, &max_id);
state->params_len += 2;
for(j=0; j<p->xc; j++)
state->params_len += warts_addr_size(table, p->xs[j]);
}
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_PROBEDEFC)
{
if(p->probedefc == 0)
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_FLAGS)
{
if(p->flags == 0)
continue;
}
else if(var->id == WARTS_DEALIAS_PREFIXSCAN_REPLYC)
{
if(p->replyc == 5)
continue;
}
flag_set(state->flags, var->id, &max_id);
assert(var->size >= 0);
state->params_len += var->size;
}
state->flags_len = fold_flags(state->flags, max_id);
for(i=0; i<p->probedefc; i++)
{
if(warts_dealias_probedef_params(sf, &p->probedefs[i],
&state->probedefs[i], table, len) != 0)
{
return -1;
}
}
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static int warts_dealias_reply_state(const scamper_dealias_reply_t *reply,
warts_dealias_reply_t *state,
const scamper_file_t *sf,
warts_addrtable_t *table, uint32_t *len)
{
const warts_var_t *var;
scamper_icmpext_t *ie;
int i, max_id = 0;
memset(state->flags, 0, dealias_reply_vars_mfb);
state->params_len = 0;
/* encode any icmp extensions included */
if(SCAMPER_DEALIAS_REPLY_IS_ICMP(reply) && reply->icmp_ext != NULL)
{
flag_set(state->flags, WARTS_DEALIAS_REPLY_ICMP_EXT, &max_id);
state->params_len += 2;
for(ie = reply->icmp_ext; ie != NULL; ie = ie->ie_next)
{
state->params_len += (2 + 1 + 1 + ie->ie_dl);
}
}
for(i=0; i<sizeof(dealias_reply_vars)/sizeof(warts_var_t); i++)
{
var = &dealias_reply_vars[i];
if(var->id == WARTS_DEALIAS_REPLY_SRC_GID)
{
continue;
}
else if(var->id == WARTS_DEALIAS_REPLY_ICMP_TC)
{
if(SCAMPER_DEALIAS_REPLY_IS_ICMP(reply) == 0)
continue;
}
else if(var->id == WARTS_DEALIAS_REPLY_ICMP_Q_TTL)
{
if(SCAMPER_DEALIAS_REPLY_IS_ICMP(reply) == 0)
continue;
}
else if(var->id == WARTS_DEALIAS_REPLY_ICMP_EXT)
{
continue;
}
else if(var->id == WARTS_DEALIAS_REPLY_PROTO)
{
if(SCAMPER_DEALIAS_REPLY_IS_ICMP(reply))
continue;
}
else if(var->id == WARTS_DEALIAS_REPLY_TCP_FLAGS)
{
if(SCAMPER_DEALIAS_REPLY_IS_TCP(reply) == 0)
continue;
}
flag_set(state->flags, var->id, &max_id);
if(var->id == WARTS_DEALIAS_REPLY_SRC)
{
state->params_len += warts_addr_size(table, reply->src);
continue;
}
assert(var->size >= 0);
state->params_len += var->size;
}
state->flags_len = fold_flags(state->flags, max_id);
/* increase length required for the dealias reply record */
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static int warts_tracelb_reply_state(const scamper_file_t *sf,
const scamper_tracelb_reply_t *reply,
warts_tracelb_reply_t *state,
warts_addrtable_t *table, uint32_t *len)
{
const warts_var_t *var;
scamper_icmpext_t *ie;
int i, max_id = 0;
/* unset all the flags possible */
memset(state->flags, 0, tracelb_reply_vars_mfb);
state->params_len = 0;
/* figure out what to include */
for(i=0; i<sizeof(tracelb_reply_vars)/sizeof(warts_var_t); i++)
{
var = &tracelb_reply_vars[i];
if(var->id == WARTS_TRACELB_REPLY_FROM_GID)
{
continue;
}
else if(var->id == WARTS_TRACELB_REPLY_TTL)
{
if((reply->reply_flags & SCAMPER_TRACELB_REPLY_FLAG_REPLY_TTL) == 0)
continue;
}
else if(var->id == WARTS_TRACELB_REPLY_ICMP_TC ||
var->id == WARTS_TRACELB_REPLY_ICMP_Q_TTL ||
var->id == WARTS_TRACELB_REPLY_ICMP_Q_TOS)
{
if((reply->reply_flags & SCAMPER_TRACELB_REPLY_FLAG_TCP) != 0)
continue;
}
else if(var->id == WARTS_TRACELB_REPLY_TCP_FLAGS)
{
if((reply->reply_flags & SCAMPER_TRACELB_REPLY_FLAG_TCP) == 0)
continue;
}
else if(var->id == WARTS_TRACELB_REPLY_ICMP_EXT)
{
if((reply->reply_flags & SCAMPER_TRACELB_REPLY_FLAG_TCP) != 0 ||
reply->reply_icmp_ext == NULL)
continue;
state->params_len += 2;
for(ie = reply->reply_icmp_ext; ie != NULL; ie = ie->ie_next)
{
state->params_len += (2 + 1 + 1 + ie->ie_dl);
}
}
else if(var->id == WARTS_TRACELB_REPLY_FROM)
{
state->params_len += warts_addr_size(table, reply->reply_from);
}
flag_set(state->flags, var->id, &max_id);
if(var->size > 0)
{
state->params_len += var->size;
}
}
state->flags_len = fold_flags(state->flags, max_id);
*len += state->flags_len + state->params_len;
if(state->params_len != 0) *len += 2;
return 0;
}
static void warts_trace_hop_params(const scamper_trace_t *trace,
const scamper_trace_hop_t *hop,
warts_addrtable_t *table, uint8_t *flags,
uint16_t *flags_len, uint16_t *params_len)
{
scamper_icmpext_t *ie;
const warts_var_t *var;
int i, max_id = 0;
/* unset all the flags possible */
memset(flags, 0, hop_vars_mfb);
*params_len = 0;
for(i=0; i<sizeof(hop_vars)/sizeof(warts_var_t); i++)
{
var = &hop_vars[i];
/* not used any more */
if(var->id == WARTS_TRACE_HOP_ADDR_GID)
continue;
if(var->id == WARTS_TRACE_HOP_ADDR)
{
if(hop->hop_addr == NULL)
continue;
}
else if(var->id == WARTS_TRACE_HOP_TCP_FLAGS)
{
if(SCAMPER_TRACE_HOP_IS_TCP(hop) == 0)
continue;
}
else if(var->id == WARTS_TRACE_HOP_ICMP_TC)
{
if(SCAMPER_TRACE_HOP_IS_ICMP(hop) == 0)
continue;
}
else if(var->id == WARTS_TRACE_HOP_Q_IPLEN)
{
if(SCAMPER_TRACE_HOP_IS_ICMP_Q(hop) == 0)
continue;
if(hop->hop_icmp_q_ipl == trace->probe_size)
continue;
}
else if(var->id == WARTS_TRACE_HOP_Q_IPTTL)
{
if(SCAMPER_TRACE_HOP_IS_ICMP_Q(hop) == 0)
continue;
if(hop->hop_icmp_q_ttl == 1)
continue;
}
else if(var->id == WARTS_TRACE_HOP_Q_IPTOS)
{
if(SCAMPER_TRACE_HOP_IS_ICMP_Q(hop) == 0)
continue;
if(hop->hop_addr->type != SCAMPER_ADDR_TYPE_IPV4)
continue;
}
else if(var->id == WARTS_TRACE_HOP_NHMTU)
{
if(SCAMPER_TRACE_HOP_IS_ICMP_PTB(hop) == 0)
continue;
}
else if(var->id == WARTS_TRACE_HOP_ICMPEXT)
{
if(hop->hop_icmpext == NULL)
continue;
}
else if(var->id == WARTS_TRACE_HOP_REPLY_IPID)
{
if(hop->hop_reply_ipid == 0)
continue;
}
else if(var->id == WARTS_TRACE_HOP_TX)
{
if(hop->hop_tx.tv_sec == 0)
continue;
}
flag_set(flags, var->id, &max_id);
if(var->id == WARTS_TRACE_HOP_ADDR)
{
*params_len += warts_addr_size(table, hop->hop_addr);
}
else if(var->id == WARTS_TRACE_HOP_ICMPEXT)
{
*params_len += 2;
for(ie = hop->hop_icmpext; ie != NULL; ie = ie->ie_next)
*params_len += (2 + 1 + 1 + ie->ie_dl);
}
else
{
assert(var->size >= 0);
*params_len += var->size;
}
}
*flags_len = fold_flags(flags, max_id);
return;
}
