static void update_pcap_next_dump(struct ctx *ctx, unsigned long snaplen,
int *fd, int sock, bool is_v3)
{
if (!dump_to_pcap(ctx))
return;
if (ctx->dump_mode == DUMP_INTERVAL_SIZE) {
interval += snaplen;
if (interval > ctx->dump_interval) {
next_dump = true;
interval = 0;
}
}
if (sighup) {
if (ctx->verbose)
printf("SIGHUP received, prematurely rotating pcap\n");
sighup = 0;
next_dump = true;
reset_interval(ctx);
}
if (next_dump) {
*fd = next_multi_pcap_file(ctx, *fd);
next_dump = false;
if (update_rx_stats(ctx, sock, is_v3))
return;
if (ctx->verbose && ctx->print_mode == PRINT_NONE)
printf(".(+%"PRIu64"/-%"PRIu64")",
ctx->pkts_recvd_last - ctx->pkts_drops_last,
ctx->pkts_drops_last);
}
}
static int begin_multi_pcap_file(struct ctx *ctx)
{
int fd, ret;
char fname[256];
bug_on(!__pcap_io);
if (ctx->device_out[strlen(ctx->device_out) - 1] == '/')
ctx->device_out[strlen(ctx->device_out) - 1] = 0;
slprintf(fname, sizeof(fname), "%s/%s%lu.pcap", ctx->device_out,
ctx->prefix ? : "dump-", time(NULL));
fd = open_or_die_m(fname, O_RDWR | O_CREAT | O_TRUNC |
O_LARGEFILE, DEFFILEMODE);
ret = __pcap_io->push_fhdr_pcap(fd, ctx->magic, ctx->link_type);
if (ret)
panic("Error writing pcap header!\n");
if (__pcap_io->prepare_access_pcap) {
ret = __pcap_io->prepare_access_pcap(fd, PCAP_MODE_WR, true);
if (ret)
panic("Error prepare writing pcap!\n");
}
reset_interval(ctx);
return fd;
}
/*---------------------------------------------------------------------------*/
void
trickle_send(struct trickle_conn *c)
{
if(c->q != NULL) {
queuebuf_free(c->q);
}
c->seqno++;
packetbuf_set_attr(PACKETBUF_ATTR_EPACKET_ID, c->seqno);
c->q = queuebuf_new_from_packetbuf();
PRINTF("%d.%d: trickle send seqno %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
c->seqno);
reset_interval(c);
send(c);
}
/*---------------------------------------------------------------------------*/
static void
recv(struct udp_socket *c, void *ptr,
const uip_ipaddr_t *source_addr, uint16_t source_port,
const uip_ipaddr_t *dest_addr, uint16_t dest_port,
const uint8_t *data, uint16_t datalen)
{
struct propple_socket *s = ptr;
struct propple_msg *m = (struct propple_msg *)data;
struct propple_hdr h;
memcpy((uint8_t *)&h, (uint8_t *)&m->h, sizeof(h));
uint16_t seqno = h.seqno;
printf("propple-socket: recv seqno %d our %d data len %d\n",
seqno,
s->seqno,
datalen);
if(seqno == s->seqno) {
/* c->cb->recv(c);*/
++s->duplicates;
} else if(SEQNO_LT(seqno, s->seqno)) {
s->interval_scaling = 0;
send(s);
} else { /* hdr->seqno > c->seqno */
/* Sanity check datalen */
if(h.datalen <= PROPPLE_MAXDATALEN) {
s->seqno = seqno;
/* Remember the incoming data */
memcpy(s->data, m->data, h.datalen);
s->datalen = h.datalen;
s->interval_scaling = 0;
reset_interval(s);
ctimer_set(&s->first_transmission_timer,
random_rand() % s->interval,
send, s);
if(s->callback != NULL) {
s->callback(s, s->ptr, s->seqno,
s->data, s->datalen);
}
/* c->cb->recv(c);*/
}
}
}
/*---------------------------------------------------------------------------*/
int
propple_socket_send(struct propple_socket *s,
const uint8_t *data,
uint16_t datalen)
{
if(datalen > PROPPLE_MAXDATALEN) {
datalen = PROPPLE_MAXDATALEN;
}
memcpy(s->data, data, datalen);
s->datalen = datalen;
s->seqno++;
reset_interval(s);
send(s);
printf("propple_socket_send seqno %d, datalen %d data '%s'\n", s->seqno,
s->datalen, data);
return datalen;
}
/*---------------------------------------------------------------------------*/
static void
recv(struct broadcast_conn *bc, const rimeaddr_t *from)
{
struct trickle_conn *c = (struct trickle_conn *)bc;
uint16_t seqno = packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID);
PRINTF("%d.%d: trickle recv seqno %d from %d.%d our %d data len %d channel %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
seqno,
from->u8[0], from->u8[1],
c->seqno,
packetbuf_datalen(),
packetbuf_attr(PACKETBUF_ATTR_CHANNEL));
if(seqno == c->seqno)
{
/* c->cb->recv(c);*/
++c->duplicates;
}
else if(SEQNO_LT(seqno, c->seqno))
{
c->interval_scaling = 0;
send(c);
}
else /* hdr->seqno > c->seqno */
{
#if CONTIKI_TARGET_NETSIM
/* ether_set_line(from->u8[0], from->u8[1]);*/
#endif /* CONTIKI_TARGET_NETSIM */
c->seqno = seqno;
/* Store the incoming data in the queuebuf */
if(c->q != NULL)
{
queuebuf_free(c->q);
}
c->q = queuebuf_new_from_packetbuf();
c->interval_scaling = 0;
reset_interval(c);
ctimer_set(&c->first_transmission_timer, random_rand() % c->interval,
send, c);
c->cb->recv(c);
}
}
