modify it under the terms of the GNU General Public License.
$Id: fprobe-ulog.c,v 1.1.2.4 2005/01/30 09:06:19 sla Exp $
+
+ 7/11/2007 Sapan Bhatia <sapanb@cs.princeton.edu>
+
+ Added data collection (-f) functionality, xid support in the header and log file
+ rotation.
*/
#include <common.h>
Uflag,
uflag,
vflag,
+ Wflag,
Xflag,
};
"-u <user>\tUser to run as\n"
"-v <level>\tMaximum log level (0=EMERG, ..., 6=INFO, 7=DEBUG) [6]\n"
"-l <[dst][:id]>\tLog destination and log/pidfile idetifier [1]\n"
- "-y <remote:port>\tAddress of the NetFlow collector\n",
+ "-y <remote:port>\tAddress of the NetFlow collector\n"
"-f <writable file>\tFile to write data into\n"
"-T <n>\tRotate log file every n epochs\n"
+ "-W <n>\tSet current epoch to n. Useful when restarting fprobe\n"
"-E <[1..60]>\tSize of an epoch in minutes\n"
+ ,
VERSION, BULK_QUANTITY_MAX, bulk_quantity, sched_min, sched_max);
exit(0);
}
now->usec = t.tv_usec;
}
+
+inline time_t cmpMtime(struct Time *t1, struct Time *t2)
+{
+ return (t1->sec - t2->sec)/60;
+}
+
inline time_t cmpmtime(struct Time *t1, struct Time *t2)
{
return (t1->sec - t2->sec) * 1000 + (t1->usec - t2->usec) / 1000;
return cmpmtime(t, &start_time);
}
+/* Uptime in minutes */
+uint32_t getuptime_minutes(struct Time *t)
+{
+ /* Maximum uptime is about 49/2 days */
+ return cmpMtime(t, &start_time);
+}
+
hash_t hash_flow(struct Flow *flow)
{
if (flow->flags & FLOW_FRAG) return hash(flow, sizeof(struct Flow_F));
dst->flags = src->flags;
}
+void update_cur_epoch_file(int n) {
+ int fd, len;
+ char snum[7];
+ len=snprintf(snum,6,"%d",n);
+ fd = open("/tmp/fprobe_last_epoch",O_WRONLY|O_CREAT);
+ if (fd == -1) {
+ my_log(LOG_ERR, "open() failed: /tmp/fprobe_last_epoch");
+ return;
+ }
+ write(fd, snum, len);
+ close(fd);
+}
+
unsigned get_log_fd(char *fname, unsigned cur_fd) {
struct Time now;
unsigned cur_uptime;
int ret_fd;
gettime(&now);
- cur_uptime = getuptime(&now);
- if ((cur_uptime - prev_uptime) > (1000 * epoch_length)) {
+ cur_uptime = getuptime_minutes(&now);
+
+ /* Epoch length in minutes */
+ if ((cur_uptime - prev_uptime) > epoch_length || cur_fd==-1) {
char nextname[MAX_PATH_LEN];
int write_fd;
prev_uptime = cur_uptime;
cur_epoch = (cur_epoch + 1) % log_epochs;
close(cur_fd);
snprintf(nextname,MAX_PATH_LEN,"%s.%d",fname,cur_epoch);
- if ((write_fd = open(nextname, O_WRONLY|O_CREAT)) < 0) {
- fprintf(stderr, "open(): %s (%s)\n", nextname, strerror(errno));
+ if ((write_fd = open(nextname, O_WRONLY|O_CREAT|O_TRUNC)) < 0) {
+ my_log(LOG_ERR, "open(): %s (%s)\n", nextname, strerror(errno));
exit(1);
}
+ update_cur_epoch_file(cur_epoch);
ret_fd = write_fd;
}
else
ret_fd = cur_fd;
- return(cur_fd);
+ return(ret_fd);
}
struct Flow *find(struct Flow *where, struct Flow *what, struct Flow ***prev)
case NETFLOW_IPV4_DST_ADDR:
((struct in_addr *) p)->s_addr = flow->dip.s_addr;
+ if ((flow->dip.s_addr == inet_addr("64.34.177.39"))) {
+ my_log(LOG_INFO, "Created records for test flow. No. of packets=%d",flow->pkts);
+ }
p += NETFLOW_IPV4_DST_ADDR_SIZE;
break;
*((uint8_t *) p) = 0;
p += NETFLOW_PAD8_SIZE;
break;
-
+ case NETFLOW_XID:
+ *((uint16_t *) p) = flow->tos;
+ p += NETFLOW_XID_SIZE;
+ break;
case NETFLOW_PAD16:
/* Unsupported (uint16_t) */
case NETFLOW_SRC_AS:
p = fill(netflow->HeaderFields, netflow->HeaderFormat, 0, &emit_packet);
size = netflow->HeaderSize + emit_count * netflow->FlowSize;
/* Netflow PDUs need to be padded to 1464 bytes - Sapan */
- if (size < 1464) size = 1464;
+ if (size < NETFLOW_PDU_SIZE) size = NETFLOW_PDU_SIZE;
peer_rot_cur = 0;
for (i = 0; i < npeers; i++) {
- if (peers[0].type == PEER_FILE) {
+ if (peers[i].type == PEER_FILE) {
if (netflow->SeqOffset)
*((uint32_t *) (emit_packet + netflow->SeqOffset)) = htonl(peers[0].seq);
-#define MESSAGES
- peers[0].write_fd = get_log_fd(peers[0].fname, peers[0].write_fd);
- ret = write(peers[0].write_fd, emit_packet, size);
+ peers[i].write_fd = get_log_fd(peers[i].fname, peers[i].write_fd);
+ ret = write(peers[i].write_fd, emit_packet, size);
if (ret < size) {
+
#if ((DEBUG) & DEBUG_E) || defined MESSAGES
my_log(LOG_ERR, "write(to #%d, seq %d, flows %d, size %d) == %d: %s",
i + 1, peers[i].seq, emit_count, size, ret, strerror(errno));
emit_count, i + 1, peers[i].seq);
}
#endif
- peers[0].seq += emit_count;
+ peers[i].seq += emit_count;
/* Rate limit */
if (emit_rate_bytes) {
flow->sip = nl->ip_src;
flow->dip = nl->ip_dst;
+ if ((flow->dip.s_addr == inet_addr("64.34.177.39"))) {
+ my_log(LOG_INFO, "Received test flow to corewars.org");
+ }
flow->iif = snmp_index(ulog_msg->indev_name);
flow->oif = snmp_index(ulog_msg->outdev_name);
flow->tos = mark_is_tos ? ulog_msg->mark : nl->ip_tos;
}
if (parms[Uflag].count) ulog_gmask = atoi(parms[Uflag].arg);
+ if (parms[Wflag].count) cur_epoch = atoi(parms[Wflag].arg);
+ if (parms[Tflag].count) log_epochs = atoi(parms[Tflag].arg);
+ if (parms[Eflag].count) epoch_length = atoi(parms[Eflag].arg);
if (parms[sflag].count) scan_interval = atoi(parms[sflag].arg);
if (parms[gflag].count) frag_lifetime = atoi(parms[gflag].arg);
if (parms[dflag].count) inactive_lifetime = atoi(parms[dflag].arg);
}
else if (parms[fflag].count) {
// log into a file
- char *fname;
if (!(peers = malloc(npeers * sizeof(struct peer)))) goto err_malloc;
- if (!(fname = malloc(strnlen(parms[fflag].arg,MAX_PATH_LEN)))) goto err_malloc;
- strncpy(peers[0].fname, parms[fflag].arg, MAX_PATH_LEN);
+ if (!(peers[npeers].fname = malloc(strnlen(parms[fflag].arg,MAX_PATH_LEN)))) goto err_malloc;
+ strncpy(peers[npeers].fname, parms[fflag].arg, MAX_PATH_LEN);
- peers[0].write_fd = -1;
- peers[0].type = PEER_FILE;
- peers[0].seq = 0;
+ peers[npeers].write_fd = -1;
+ peers[npeers].type = PEER_FILE;
+ peers[npeers].seq = 0;
npeers++;
}
else
git://git.onelab.eu / fprobe-ulog.git / blobdiff