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; }