static int
fixedread(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
register Fixedstate_t* state = (Fixedstate_t*)file->data;
register Bgproute_t* rp;
if (!(rp = (Bgproute_t*)sfreserve(file->io, sizeof(*rp), 0)))
{
if (sfvalue(file->io))
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, 2, "%s: last record incomplete", file->format->name);
return -1;
}
return 0;
}
if (state->swap)
{
swapmem(state->swap, rp, rp, (char*)&rp->path - (char*)rp);
if (rp->cluster.size)
swapmem(state->swap, rp->data + rp->cluster.offset, rp->data + rp->cluster.offset, rp->cluster.size * sizeof(Bgpnum_t));
if (state->swap & 1)
{
swapmem(state->swap & 1, (char*)&rp->path, (char*)&rp->path, (char*)&rp->bits - (char*)&rp->path);
if (rp->path.size)
swapmem(state->swap & 1, rp->data + rp->path.offset, rp->data + rp->path.offset, rp->path.size * sizeof(Bgpasn_t));
if (rp->community.size)
swapmem(state->swap & 1, rp->data + rp->community.offset, rp->data + rp->community.offset, rp->community.size * sizeof(Bgpasn_t));
}
}
record->data = rp;
record->size = rp->size;
return 1;
}
static int
ast4_data(Sum_t* p, Sumdata_t* data)
{
data->size = sizeof(((Ast4_t*)p)->cur);
data->num = 0;
#if _ast_intswap
swapmem(_ast_intswap, data->buf = ((Ast4_t*)p)->buf, &((Ast4_t*)p)->cur, sizeof(((Ast4_t*)p)->cur));
#else
data->buf = &((Ast4_t*)p)->cur;
#endif
return 0;
}
void*
swapput(int op, void* b, int n, intmax_t v)
{
register char* p = (char*)b + n;
while (p > (char*)b)
{
*--p = v;
v >>= CHAR_BIT;
}
if (op)
swapmem(op, p, p, n);
return b;
}
intmax_t
swapget(int op, const void* b, int n)
{
register unsigned char* p;
register unsigned char* d;
intmax_t v;
unsigned char tmp[sizeof(intmax_t)];
if (n > sizeof(intmax_t))
n = sizeof(intmax_t);
if (op) swapmem(op, b, d = tmp, n);
else d = (unsigned char*)b;
p = d + n;
v = 0;
while (d < p)
{
v <<= CHAR_BIT;
v |= *d++;
}
return v;
}
int
swapop(const void* internal, const void* external, int size)
{
register int op;
register int z;
char tmp[sizeof(intmax_t)];
if ((z = size) < 0)
z = -z;
if (z <= 1)
return 0;
if (z <= sizeof(intmax_t))
for (op = 0; op < z; op++)
if (!memcmp(internal, swapmem(op, external, tmp, z), z))
{
if (size < 0 && z == 4 && op == 3)
op = 7;
return op;
}
return -1;
}
static int
dumpfclose(Dssfile_t* file, Dssdisc_t* disc)
{
register State_t* state = (State_t*)file->data;
if (!state)
return -1;
if ((file->flags & DSS_FILE_WRITE) && state->count)
{
((Hdr_1_t*)state->data)->count = state->count;
if (state->swap)
swapmem(1, &((Hdr_1_t*)state->data)->count, &((Hdr_1_t*)state->data)->count, 2);
memset(state->next, 0, NETFLOW_PACKET - (state->next - state->data));
if (sfwrite(file->io, state->data, NETFLOW_PACKET) != NETFLOW_PACKET)
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: last packet write error", file->format->name);
return -1;
}
}
vmfree(file->dss->vm, state);
return 0;
}
static int
ftfread(register Dssfile_t* file, register Dssrecord_t* record, Dssdisc_t* disc)
{
register State_t* state = (State_t*)file->data;
register Netflow_t* rp = &state->record;
register char* fp;
size_t n;
Nftime_t boot;
while (!state->count--)
{
if (state->data = (char*)sfreserve(file->io, state->chunk * state->size, 0))
{
state->count = state->chunk;
break;
}
if (!(n = sfvalue(file->io)))
return 0;
if (!(state->chunk = n / state->size))
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, 2, "%slast packet incomplete", cxlocation(file->dss->cx, record));
return -1;
}
state->count = 0;
}
memset(rp, 0, sizeof(*rp));
rp->set = NETFLOW_SET_src_addrv4|NETFLOW_SET_dst_addrv4|NETFLOW_SET_hopv4;
fp = state->data;
state->data += state->size;
switch (state->version)
{
case 1:
if (n = state->swap & 3)
{
swapmem(n, &R1(fp)->unix_secs, &R1(fp)->unix_secs, (char*)&R1(fp)->input - (char*)&R1(fp)->unix_secs);
swapmem(n, &R1(fp)->dPkts, &R1(fp)->dPkts, (char*)&R1(fp)->srcport - (char*)&R1(fp)->dPkts);
if (n &= 1)
{
swapmem(n, &R1(fp)->input, &R1(fp)->input, (char*)&R1(fp)->dPkts - (char*)&R1(fp)->input);
swapmem(n, &R1(fp)->srcport, &R1(fp)->srcport, (char*)&R1(fp)->prot - (char*)&R1(fp)->srcport);
}
}
rp->src_addrv4 = R1(fp)->srcaddr;
rp->dst_addrv4 = R1(fp)->dstaddr;
rp->hopv4 = R1(fp)->nexthop;
rp->input = R1(fp)->input;
rp->output = R1(fp)->output;
rp->packets = R1(fp)->dPkts;
rp->bytes = R1(fp)->dOctets;
rp->first = R1(fp)->First;
rp->last = R1(fp)->Last;
rp->src_port = R1(fp)->srcport;
rp->dst_port = R1(fp)->dstport;
rp->flags = 0;
rp->tcp_flags = R1(fp)->tcp_flags;
rp->protocol = R1(fp)->prot;
rp->src_tos = R1(fp)->tos;
rp->time = R1(fp)->unix_secs;
rp->nsec = R1(fp)->unix_nsecs;
rp->uptime = R1(fp)->sysUpTime;
break;
case 5:
if (n = state->swap & 3)
{
swapmem(n, &R5(fp)->unix_secs, &R5(fp)->unix_secs, (char*)&R5(fp)->input - (char*)&R5(fp)->unix_secs);
swapmem(n, &R5(fp)->dPkts, &R5(fp)->dPkts, (char*)&R5(fp)->srcport - (char*)&R5(fp)->dPkts);
if (n &= 1)
{
swapmem(n, &R5(fp)->input, &R5(fp)->input, (char*)&R5(fp)->dPkts - (char*)&R5(fp)->input);
swapmem(n, &R5(fp)->srcport, &R5(fp)->srcport, (char*)&R5(fp)->prot - (char*)&R5(fp)->srcport);
swapmem(n, &R5(fp)->src_as, &R5(fp)->src_as, (char*)(R5(fp)+1) - (char*)&R5(fp)->src_as);
}
}
rp->src_addrv4 = R5(fp)->srcaddr;
rp->dst_addrv4 = R5(fp)->dstaddr;
rp->hopv4 = R5(fp)->nexthop;
rp->input = R5(fp)->input;
rp->output = R5(fp)->output;
rp->packets = R5(fp)->dPkts;
rp->bytes = R5(fp)->dOctets;
rp->first = R5(fp)->First;
rp->last = R5(fp)->Last;
rp->src_port = R5(fp)->srcport;
rp->dst_port = R5(fp)->dstport;
rp->flags = 0;
rp->tcp_flags = R5(fp)->tcp_flags;
rp->protocol = R5(fp)->prot;
rp->src_tos = R5(fp)->tos;
rp->engine_type = R5(fp)->engine_type;
rp->engine_id = R5(fp)->engine_id;
rp->src_as16 = R5(fp)->src_as;
rp->dst_as16 = R5(fp)->dst_as;
rp->src_maskv4 = R5(fp)->src_mask;
rp->dst_maskv4 = R5(fp)->dst_mask;
rp->time = R5(fp)->unix_secs;
rp->nsec = R5(fp)->unix_nsecs;
rp->uptime = R5(fp)->sysUpTime;
break;
case 6:
if (n = state->swap & 3)
{
swapmem(n, &R6(fp)->unix_secs, &R6(fp)->unix_secs, (char*)&R6(fp)->input - (char*)&R6(fp)->unix_secs);
swapmem(n, &R6(fp)->dPkts, &R6(fp)->dPkts, (char*)&R6(fp)->srcport - (char*)&R6(fp)->dPkts);
if (n &= 1)
{
swapmem(n, &R6(fp)->input, &R6(fp)->input, (char*)&R6(fp)->dPkts - (char*)&R6(fp)->input);
swapmem(n, &R6(fp)->srcport, &R6(fp)->srcport, (char*)&R6(fp)->prot - (char*)&R6(fp)->srcport);
swapmem(n, &R6(fp)->src_as, &R6(fp)->src_as, (char*)(R6(fp)+1) - (char*)&R6(fp)->src_as);
}
}
rp->src_addrv4 = R6(fp)->srcaddr;
rp->dst_addrv4 = R6(fp)->dstaddr;
rp->hopv4 = R6(fp)->nexthop;
rp->input = R6(fp)->input;
rp->output = R6(fp)->output;
rp->packets = R6(fp)->dPkts;
rp->bytes = R6(fp)->dOctets;
rp->first = R6(fp)->First;
rp->last = R6(fp)->Last;
rp->src_port = R6(fp)->srcport;
rp->dst_port = R6(fp)->dstport;
rp->flags = 0;
rp->tcp_flags = R6(fp)->tcp_flags;
rp->protocol = R6(fp)->prot;
rp->src_tos = R6(fp)->tos;
rp->engine_type = R6(fp)->engine_type;
rp->engine_id = R6(fp)->engine_id;
rp->src_as16 = R6(fp)->src_as;
rp->dst_as16 = R6(fp)->dst_as;
rp->src_maskv4 = R6(fp)->src_mask;
rp->dst_maskv4 = R6(fp)->dst_mask;
rp->time = R6(fp)->unix_secs;
rp->nsec = R6(fp)->unix_nsecs;
rp->uptime = R6(fp)->sysUpTime;
break;
case 7:
if (n = state->swap & 3)
{
swapmem(n, &R7(fp)->unix_secs, &R7(fp)->unix_secs, (char*)&R7(fp)->input - (char*)&R7(fp)->unix_secs);
swapmem(n, &R7(fp)->dPkts, &R7(fp)->dPkts, (char*)&R7(fp)->srcport - (char*)&R7(fp)->dPkts);
if (n &= 1)
{
swapmem(n, &R7(fp)->input, &R7(fp)->input, (char*)&R7(fp)->dPkts - (char*)&R7(fp)->input);
swapmem(n, &R7(fp)->srcport, &R7(fp)->srcport, (char*)&R7(fp)->prot - (char*)&R7(fp)->srcport);
swapmem(n, &R7(fp)->src_as, &R7(fp)->src_as, (char*)(R7(fp)+1) - (char*)&R7(fp)->src_as);
}
}
rp->src_addrv4 = R7(fp)->srcaddr;
rp->dst_addrv4 = R7(fp)->dstaddr;
rp->hopv4 = R7(fp)->nexthop;
rp->input = R7(fp)->input;
rp->output = R7(fp)->output;
rp->packets = R7(fp)->dPkts;
rp->bytes = R7(fp)->dOctets;
rp->first = R7(fp)->First;
rp->last = R7(fp)->Last;
rp->src_port = R7(fp)->srcport;
rp->dst_port = R7(fp)->dstport;
rp->flags = 0;
rp->tcp_flags = R7(fp)->tcp_flags;
rp->protocol = R7(fp)->prot;
rp->src_tos = R7(fp)->tos;
rp->engine_type = R7(fp)->engine_type;
rp->engine_id = R7(fp)->engine_id;
rp->src_as16 = R7(fp)->src_as;
rp->dst_as16 = R7(fp)->dst_as;
rp->src_maskv4 = R7(fp)->src_mask;
rp->dst_maskv4 = R7(fp)->dst_mask;
rp->time = R7(fp)->unix_secs;
rp->nsec = R7(fp)->unix_nsecs;
rp->uptime = R7(fp)->sysUpTime;
break;
}
boot = ((Nftime_t)rp->time * MS - (Nftime_t)rp->uptime) * US + (Nftime_t)rp->nsec;
rp->start = boot + (Nftime_t)rp->first * US;
rp->end = boot + (Nftime_t)rp->last * US;
record->size = sizeof(*rp);
record->data = rp;
return 1;
}
static int
dumpfwrite(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
register State_t* state = (State_t*)file->data;
register Netflow_t* rp = (Netflow_t*)record->data;
register size_t n;
if (!state->count++)
{
state->swap = _ast_intswap;
switch (rp->version)
{
case 1:
state->flush = 24;
n = 16;
if (state->swap)
{
swapmem(1, &rp->version, state->data, 4);
swapmem(3, &rp->uptime, state->data + 4, 12);
}
else
memcpy(state->data, &rp->version, n);
break;
case 5:
state->flush = 30;
n = 24;
if (state->swap)
{
swapmem(1, &rp->version, state->data, 4);
swapmem(3, &rp->uptime, state->data + 4, 16);
memcpy(state->data + 20, &rp->engine_type, 2);
swapmem(1, &rp->sampler_interval, state->data + 22, 2);
*(state->data + 23) |= rp->sampler_mode << 6;
}
else
{
memcpy(state->data, &rp->version, n);
*(state->data + 22) |= rp->sampler_mode << 6;
}
break;
case 7:
state->flush = 27;
n = 24;
if (state->swap)
{
swapmem(1, &rp->version, state->data, 4);
swapmem(3, &rp->uptime, state->data + 4, 16);
}
else
memcpy(state->data, &rp->version, n);
break;
}
state->next = state->data + n;
state->version = rp->version;
}
if (rp->version != state->version)
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, 2, "%s%d: record version does not match header version %d", cxlocation(file->dss->cx, record), rp->version, state->version);
return -1;
}
switch (rp->version)
{
case 1:
n = sizeof(Rec_1_t);
if (state->swap)
{
swapmem(3, &rp->src_addrv4, state->next, 12);
swapmem(1, &rp->input, state->next + 12, 4);
swapmem(3, &rp->packets, state->next + 16, 16);
swapmem(1, &rp->src_port, state->next + 32, 4);
memcpy(state->next + 36, &rp->flags, 4);
}
else
memcpy(state->next, rp, n);
#if 0
memcpy(&rp->pad1, state->next + 40, 4);
#endif
*(state->next + 44) = rp->flags;
break;
case 5:
n = sizeof(Rec_5_t);
if (state->swap)
{
swapmem(3, &rp->src_addrv4, state->next, 12);
swapmem(1, &rp->input, state->next + 12, 4);
swapmem(3, &rp->packets, state->next + 16, 16);
swapmem(1, &rp->src_port, state->next + 32, 4);
memcpy(state->next + 36, &rp->flags, 4);
swapmem(1, &rp->src_as16, state->next + 40, 4);
memcpy(state->next + 44, &rp->src_maskv4, 2);
}
else
memcpy(state->next, rp, n);
*(state->next + 36) = 0;
*(state->next + 46) = 0;
*(state->next + 47) = 0;
break;
case 7:
n = sizeof(Rec_7_t);
if (state->swap)
{
swapmem(3, &rp->src_addrv4, state->next, 12);
swapmem(1, &rp->input, state->next + 12, 4);
swapmem(3, &rp->packets, state->next + 16, 16);
swapmem(1, &rp->src_port, state->next + 32, 4);
memcpy(state->next + 36, &rp->flags, 4);
swapmem(1, &rp->src_as16, state->next + 40, 4);
memcpy(state->next + 44, &rp->src_maskv4, 2);
swapmem(1, &rp->router_scv4, state->next + 48, 4);
}
else
memcpy(state->next, rp, n);
break;
}
state->next += n;
if (state->count >= state->flush)
{
((Hdr_1_t*)state->data)->count = state->count;
if (state->swap)
swapmem(1, &((Hdr_1_t*)state->data)->count, &((Hdr_1_t*)state->data)->count, 2);
state->count = 0;
if (sfwrite(file->io, state->data, NETFLOW_PACKET) != NETFLOW_PACKET)
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: packet write error", file->format->name);
return -1;
}
}
return 0;
}
static int
dumpfread(register Dssfile_t* file, register Dssrecord_t* record, Dssdisc_t* disc)
{
register State_t* state = (State_t*)file->data;
register Netflow_t* rp = &state->record;
Rec_1_t* r1;
int n;
while (!rp->count--)
{
if (!(state->data = (char*)sfreserve(file->io, NETFLOW_PACKET, 0)))
{
if (sfvalue(file->io))
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, 2, "%slast packet incomplete", cxlocation(file->dss->cx, record));
return -1;
}
return 0;
}
state->swap = 0;
n = ((Hdr_1_t*)state->data)->version;
for (;;)
{
switch (n)
{
case 1:
n = 16;
if (state->swap)
{
swapmem(1, state->data, &rp->version, 4);
swapmem(3, state->data + 4, &rp->uptime, 12);
}
else
memcpy(&rp->version, state->data, n);
break;
case 5:
n = 24;
if (state->swap)
{
swapmem(1, state->data, &rp->version, 4);
swapmem(3, state->data + 4, &rp->uptime, 16);
memcpy(&rp->engine_type, state->data + 20, 2);
swapmem(1, state->data + 22, &rp->sampler_interval, 2);
}
else
memcpy(&rp->version, state->data, n);
rp->sampler_mode = (rp->sampler_interval >> 14) & ((1<<2)-1);
rp->sampler_interval &= ((1<<14)-1);
break;
case 7:
n = 24;
if (state->swap)
{
swapmem(1, state->data, &rp->version, 4);
swapmem(3, state->data + 4, &rp->uptime, 16);
}
else
memcpy(&rp->version, state->data, n);
break;
default:
if (state->swap)
{
if (disc->errorf)
(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%sheader corrupted", cxlocation(file->dss->cx, record));
return -1;
}
state->swap = 7;
n = swapget(2, state->data, 2);
continue;
}
state->boot = ((Nftime_t)rp->time * MS - (Nftime_t)rp->uptime) * US + (Nftime_t)rp->nsec;
break;
}
state->data += n;
}
switch (rp->version)
{
case 1:
r1 = (Rec_1_t*)state->data;
if (state->swap)
{
swapmem(3, state->data, &rp->src_addrv4, 12);
swapmem(1, state->data + 12, &rp->input, 4);
swapmem(3, state->data + 16, &rp->packets, 16);
swapmem(1, state->data + 32, &rp->src_port, 4);
memcpy(&rp->flags, state->data + 36, 4);
}
else
memcpy(rp, r1, sizeof(Rec_1_t));
state->data += sizeof(Rec_1_t);
rp->flags = r1->flags;
memset(&rp->src_as16, 0, 12);
break;
case 5:
if (state->swap)
{
swapmem(3, state->data, &rp->src_addrv4, 12);
swapmem(1, state->data + 12, &rp->input, 4);
swapmem(3, state->data + 16, &rp->packets, 16);
swapmem(1, state->data + 32, &rp->src_port, 4);
memcpy(&rp->flags, state->data + 36, 4);
swapmem(1, state->data + 40, &rp->src_as16, 4);
memcpy(&rp->src_maskv4, state->data + 44, 2);
}
else
memcpy(rp, state->data, sizeof(Rec_5_t));
state->data += sizeof(Rec_5_t);
rp->flags = 0;
break;
case 7:
if (state->swap)
{
swapmem(3, state->data, &rp->src_addrv4, 12);
swapmem(1, state->data + 12, &rp->input, 4);
swapmem(3, state->data + 16, &rp->packets, 16);
swapmem(1, state->data + 32, &rp->src_port, 4);
memcpy(&rp->flags, state->data + 36, 4);
swapmem(1, state->data + 40, &rp->src_as16, 4);
memcpy(&rp->src_maskv4, state->data + 44, 2);
swapmem(1, state->data + 48, &rp->router_scv4, 4);
}
else
memcpy(rp, state->data, sizeof(Rec_7_t));
state->data += sizeof(Rec_7_t);
break;
}
rp->start = state->boot + (Nftime_t)rp->first * US;
rp->end = state->boot + (Nftime_t)rp->last * US;
record->size = sizeof(*rp);
record->data = rp;
return 1;
}
