rdpPcap* pcap_open(char* name, BOOL write)
{
rdpPcap* pcap;
FILE* pcap_fp = fopen(name, write ? "w+b" : "rb");
if (pcap_fp == NULL)
{
WLog_ERR(TAG, "opening pcap dump");
return NULL;
}
pcap = (rdpPcap*) calloc(1, sizeof(rdpPcap));
if (!pcap)
goto fail_close;
pcap->name = name;
pcap->write = write;
pcap->record_count = 0;
pcap->fp = pcap_fp;
if (write)
{
pcap->header.magic_number = 0xA1B2C3D4;
pcap->header.version_major = 2;
pcap->header.version_minor = 4;
pcap->header.thiszone = 0;
pcap->header.sigfigs = 0;
pcap->header.snaplen = 0xFFFFFFFF;
pcap->header.network = 0;
if (!pcap_write_header(pcap, &pcap->header))
goto fail;
}
else
{
fseek(pcap->fp, 0, SEEK_END);
pcap->file_size = (int) ftell(pcap->fp);
fseek(pcap->fp, 0, SEEK_SET);
if (!pcap_read_header(pcap, &pcap->header))
goto fail;
}
return pcap;
fail:
free(pcap);
fail_close:
fclose(pcap_fp);
return NULL;
}
rdpPcap* pcap_open(char* name, BOOL write)
{
rdpPcap* pcap;
FILE* pcap_fp = fopen(name, write ? "w+" : "r");
if (pcap_fp == NULL)
{
perror("opening pcap dump");
return NULL;
}
pcap = (rdpPcap*) malloc(sizeof(rdpPcap));
if (pcap != NULL)
{
ZeroMemory(pcap, sizeof(rdpPcap));
pcap->name = name;
pcap->write = write;
pcap->record_count = 0;
pcap->fp = pcap_fp;
if (write)
{
pcap->header.magic_number = 0xA1B2C3D4;
pcap->header.version_major = 2;
pcap->header.version_minor = 4;
pcap->header.thiszone = 0;
pcap->header.sigfigs = 0;
pcap->header.snaplen = 0xFFFFFFFF;
pcap->header.network = 0;
pcap_write_header(pcap, &pcap->header);
}
else
{
fseek(pcap->fp, 0, SEEK_END);
pcap->file_size = (int) ftell(pcap->fp);
fseek(pcap->fp, 0, SEEK_SET);
pcap_read_header(pcap, &pcap->header);
}
}
return pcap;
}
rdpPcap* pcap_open(char* name, boolean write)
{
rdpPcap* pcap;
pcap = (rdpPcap*) xzalloc(sizeof(rdpPcap));
if (pcap != NULL)
{
pcap->name = name;
pcap->write = write;
pcap->record_count = 0;
if (write)
{
pcap->fp = fopen(name, "w+");
pcap->header.magic_number = 0xA1B2C3D4;
pcap->header.version_major = 2;
pcap->header.version_minor = 4;
pcap->header.thiszone = 0;
pcap->header.sigfigs = 0;
pcap->header.snaplen = 0xFFFFFFFF;
pcap->header.network = 0;
pcap_write_header(pcap, &pcap->header);
}
else
{
pcap->fp = fopen(name, "r");
fseek(pcap->fp, 0, SEEK_END);
pcap->file_size = (int) ftell(pcap->fp);
fseek(pcap->fp, 0, SEEK_SET);
pcap_read_header(pcap, &pcap->header);
}
}
return pcap;
}
int main(int argc, char *argv[])
{
int opt = 0;
/*
signal(SIGABRT, sighandler);
signal(SIGHUP, sighandler);
signal(SIGINT, sighandler);
signal(SIGKILL, sighandler);
signal(SIGQUIT, sighandler);
signal(SIGSEGV, sighandler);
signal(SIGTERM, sighandler);
*/
/* parse command line arguments */
while ((opt = getopt(argc, argv, "i:")) != -1) {
switch (opt) {
case 'i':
dev = optarg;
break;
default:
fprintf(stderr, "Missing option: %c", opt);
break;
}
}
fprintf(stdout, "Device: %s\n", dev);
#if 0
pcap_object.savefile =
open("v300-new.pcap", O_WRONLY | O_TRUNC | O_CREAT, 0600);
if (pcap_object.savefile < 0) {
fprintf(stderr, "Error opening output file\n");
goto lzEXIT;
}
linktype = pcap_datalink(pcap_object.handler);
file_snaplen = pcap_snapshot(pcap_object.handler);
/* write capture file header */
pcap_write_header(pcap_object.savefile, linktype, file_snaplen);
#endif
pcap_object.exitflag = 0;
pcap_object.packets_captured = 0;
int inpkts = 0, inpkts_to_sync = 0;
time_t upd_time, cur_time;
int pkt_num = 0;
pthread_t threads[2];
int rc = 0;
int skfd = 0;
struct ifreq ifr;
CAPTURE_IOCTL capture_ioctl;
#if 1
/*
upd_time = time(NULL);
time_t end_time, begin_time;
begin_time = time(NULL);
*/
bzero(&capture_ioctl, sizeof(capture_ioctl));
bzero(&ifr, sizeof(ifr));
strncpy(ifr.ifr_name, "eth5", sizeof(ifr.ifr_name) - 1);
ifr.ifr_data = (char *)&capture_ioctl;
if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) == 0) {
fprintf(stderr, "create socket error!\n");
goto lzEXIT;
}
/* tell 10GE port start capture */
capture_ioctl.cmd = CAPTURE_CMD_START;
if (ioctl(skfd, SIOCETHTOOL, &ifr) == -1) {
fprintf(stderr, "ioctl: CAPTURE_CMD_START error!\n");
goto lzEXIT;
}
fprintf(stderr, "send CAPTURE_CMD_START to driver, start capture!\n");
#endif
pBuffer = (char *)calloc(1, ringsize + 1);
if (!pBuffer) {
fprintf(stderr, "Malloc failed, exiting\n");
goto lzEXIT;
}
pReadPtr = pBuffer;
pWritePtr = pBuffer;
fprintf(stderr, "Ring buffer size: %d\n", ringsize);
fp = fopen("/tmp/pcap000.pcap", "w");
if (fp == NULL) {
fprintf(stderr, "fopen error\n");
goto lzEXIT;
}
FILE *procf = NULL;
int rmem_def = 0;
procf = fopen(RMEM_DEF, "r");
if (procf) {
fscanf(procf, "%d", &rmem_def);
fclose(procf);
}
if (rmem_def != RECV_BUFF_SIZE) {
char cmd[64] = "";
sprintf(cmd, "echo \"%d\" > %s", RECV_BUFF_SIZE, RMEM_DEF);
system(cmd);
sprintf(cmd, "echo \"%d\" > %s", RECV_BUFF_SIZE, RMEM_MAX);
system(cmd);
}
fprintf(stderr, "%s: %d\n%s: %d\n", RMEM_DEF, RECV_BUFF_SIZE, RMEM_MAX,
RECV_BUFF_SIZE);
// Create the corresponding measurement thread
struct sched_param schParam;
pthread_attr_t ptaAttr;
schParam.sched_priority = THREAD_DEFAULT_PRIORITY + 10;
pthread_attr_init(&ptaAttr);
pthread_attr_setdetachstate(&ptaAttr, PTHREAD_CREATE_DETACHED);
pthread_attr_setschedpolicy(&ptaAttr, SCHED_FIFO);
pthread_attr_setschedparam(&ptaAttr, &schParam);
//pthread_attr_setstacksize(&ptaAttr, THREAD_DEFAULT_STACKSIZE*3);
if (0 != pthread_create(&threads[0], &ptaAttr, (void *(*)(void *))Reader, NULL))
{
fprintf(stderr, "pthread_create error\n");
goto lzEXIT;
}
schParam.sched_priority = THREAD_DEFAULT_PRIORITY;
pthread_attr_init(&ptaAttr);
pthread_attr_setdetachstate(&ptaAttr, PTHREAD_CREATE_DETACHED);
pthread_attr_setschedpolicy(&ptaAttr, SCHED_FIFO);
pthread_attr_setschedparam(&ptaAttr, &schParam);
//pthread_attr_setstacksize(&ptaAttr, THREAD_DEFAULT_STACKSIZE*3);
rc = pthread_create(&threads[1], &ptaAttr, (void *(*)(void *))Writer, NULL);
if (rc) {
fprintf(stderr, "pthread_create error\n");
goto lzEXIT;
}
while (!pcap_object.exitflag) {
usleep(500000);
fprintf(stderr, "Got %ld\n", pcap_object.packets_captured);
}
/*
if( 0 == (rc = pthread_cancel(threads[0])) )
{
pthread_join(threads[0], NULL);
}
if( 0 == (rc = pthread_cancel(threads[1])) )
{
pthread_join(threads[1], NULL);
}
*/
fprintf(stderr, "\n%ld packets captured\n",
pcap_object.packets_captured);
fprintf(stderr, "ring buffer use: %.1lf%% of %d MB\n",
100.0 * (float)pcap_object.packets_captured / (float)(ringsize),
ringsize / 1024 / 1024);
lzEXIT:
if (skfd != 0)
close(skfd);
skfd = 0;
if (pBuffer != NULL) {
free(pBuffer);
pBuffer = NULL;
}
if (fp != NULL)
fclose(fp);
fp = NULL;
if (pcap_object.savefile > 0) {
fsync(pcap_object.savefile);
close(pcap_object.savefile);
}
printf("Packet capture done.\n");
exit(0);
}
