int main(int argc, char **argv)
{
//Check whether user has entered enough arguments
if(argc < 2)
{
printf("Usage: ./firewall mode [input pcap file] [output pcap file]\n",
" Mode: 1/2\n");
}
char errbuf[100];
int mode = atoi(argv[1]);
//If mode = 1 then use the interfaces to capture packets
if(mode == 1)
{
pid_t childPID;
//Open the interface handlers
in_handle = pcap_open_live(INT_IN,65536,1,0,errbuf);
out_handle = pcap_open_live(INT_OUT,65536,1,0,errbuf);
//Create two processes for two interfaces
childPID = fork();
if(childPID >= 0)
{
//Associate the handlers with the interfaces
if(childPID == 0)
{
capture_loop(in_handle, -1, (pcap_handler)parse_packet, NULL);
}
else
{
capture_loop(out_handle, -1, (pcap_handler)parse_packet_p, NULL);
}
}
else
{
printf("\n Fork failed, quitting!!!!!!\n");
return 1;
}
}
//Else open the input pcap file for the processing and write to output pcap file
else
{
//Check for the valid arguments
if(argc < 4)
{
printf("Usage: ./firewall mode [input pcap file] [output pcap file]\n",
" Mode: 1/2\n");
}
in_handle = pcap_open_offline(argv[2],errbuf);
//802.3 = 1 - link type
//open new pcap handler
out_handle = pcap_open_dead(1,65536);
//open the file with the handler
dumper = pcap_dump_open(out_handle, argv[3]);
//Process all the packets from the file
capture_loop(in_handle, -1, (pcap_handler)parse_packet_file, (u_char*)dumper);
}
return 0;
}
void* dag_legacy_capture(void* ptr){
struct CI* CI = (struct CI*)ptr;
struct dag_context cap;
capture_init(CI, &cap.base);
logmsg(verbose, CAPTURE, "CI[%d] initializing capture on %s using DAGv1 (memory at %p).\n", CI->id, cap.base.iface, &datamem[CI->id]);
if ( !setup_device(CI) ){
/* error already show */
return NULL;
}
cap.fd = CI->sd;
cap.buffer = dag_mmap(CI->sd);
cap.top = 0;
cap.bottom = 0;
/* setup callbacks */
cap.base.init = (init_callback)dagcapture_init;
cap.base.destroy = (destroy_callback)dagcapture_destroy;
cap.base.read_packet = (read_packet_callback)legacy_read_packet;
/* start capture */
capture_loop(CI, (struct capture_context*)&cap);
return NULL;
}
void* dag_capture(void* ptr){
struct CI* CI = (struct CI*)ptr;
struct dag_context cap;
capture_init(CI, &cap.base);
logmsg(verbose, CAPTURE, "CI[%d] initializing capture on %s using DAGv2 (memory at %p).\n", CI->id, cap.base.iface, CI->buffer);
if ( !setup_device(CI) ){
/* error already show */
return NULL;
}
cap.fd = CI->sd;
cap.buffer = NULL; /* not used by this driver */
cap.top = NULL;
cap.bottom = NULL;
/* setup callbacks */
if ( dag_mode == 0 ){
cap.base.init = (init_callback)dagcapture_init_rxtx;
cap.base.destroy = (destroy_callback)dagcapture_destroy_rxtx;
cap.base.read_packet = (read_packet_callback)read_packet_rxtx;
} else if ( dag_mode == 1 ){
cap.base.init = (init_callback)dagcapture_init_wiretap;
cap.base.destroy = (destroy_callback)dagcapture_destroy_wiretap;
cap.base.read_packet = (read_packet_callback)read_packet_wiretap;
} else {
logmsg(stderr, CAPTURE, "Unsupported mode: %d\n", dag_mode);
abort();
}
/* start capture */
capture_loop(CI, (struct capture_context*)&cap);
return NULL;
}
static void twin_capture(const char *basename, float framerate, int cam, bool eight_bit_mode, bool testonly)
{
struct chameleon_camera *c1=NULL, *c2=NULL;
do {
if (c1) chameleon_camera_free(c1);
if (c2) chameleon_camera_free(c2);
if (cam == -1 || cam == 0) {
c1 = open_camera(true, eight_bit_mode);
}
if (cam == -1 || cam == 1) {
c2 = open_camera(false, eight_bit_mode);
}
printf("Got camera c1=%p c2=%p\n", c1, c2);
if (!c1 || !c2) sleep(1);
} while (c1 == NULL && c2 == NULL);
signal(SIGCHLD, SIG_IGN);
capture_loop(c1, c2, framerate, basename, testonly, eight_bit_mode);
if (c1) {
chameleon_camera_free(c1);
}
if (c2) {
chameleon_camera_free(c2);
}
}
static DWORD WINAPI main_capture_thread(HANDLE thread_handle)
{
if (!init_hook(thread_handle)) {
DbgOut("Failed to init hook\n");
free_hook();
return 0;
}
capture_loop();
return 0;
}
int main(int argc, char const *argv[])
{
char interface[256] = "", bpfstr[256] = "";
int packets = 0, c, i;
// Get the command line options, if any
while ((c = getopt (argc, argv, "hi:n:")) != -1)
{
switch (c)
{
case 'h':
printf("usage: %s [-h] [-i ] [-n ] []\n", argv[0]);
exit(0);
break;
case 'i':
strcpy(interface, optarg);
break;
case 'n':
packets = atoi(optarg);
break;
}
}
// Get the packet capture filter expression, if any.
for (i = optind; i < argc; i++)
{
strcat(bpfstr, argv[i]);
strcat(bpfstr, " ");
}
// Open libpcap, set the program termination signals then start
// processing packets.
if ((pd = open_pcap_socket(interface, bpfstr)))
{
signal(SIGINT, bailout);
signal(SIGTERM, bailout);
signal(SIGQUIT, bailout);
capture_loop(pd, packets, (pcap_handler)parse_packet);
bailout(0);
}
// pcap_loop(descr,-1,another_callback,NULL);
return 0;
}
static int run_capture(const char *basename, float delay, bool testonly)
{
dc1394camera_t *camera;
printf("Waiting for camera\n");
while ((camera = open_camera()) == NULL) {
printf(".");
fflush(stdout);
sleep(1);
}
dc1394_camera_reset(camera);
capture_loop(camera, basename, delay, testonly);
close_camera(camera);
return 0;
}
int internal_main( output_callback_func_ptr callback_ptr )
{
output = OUTPUT_CALLBACK;
output_callback_ptr = callback_ptr;
device_open();
init_device();
start_capturing();
capture_loop();
stop_capturing();
uninit_device();
device_close();
return 0;
}
static void start_capture(char *ifname)
{
char errbuf[PCAP_ERRBUF_SIZE];
// char filter_exp[FLITER_STR_MAX_SIZE];
// struct bpf_program filter;
// bpf_u_int32 mask;
// bpf_u_int32 net;
if ((pd = pcap_open_live(ifname, SNAPLEN, IS_PROMISC,
WAITMS, errbuf)) == NULL) {
fprintf(stderr, "pcap_open err %s, %s\n", ifname, errbuf);
exit(1);
}
capture_loop();
if (pd != NULL) {
pcap_close(pd);
pd = NULL;
}
}
int main(int argc,char **argv)
{
mac_array = malloc(sizeof(struct MACarray));
ip_array = malloc(sizeof(struct IParray));
initIParray(ip_array,10);
initMACarray(mac_array,10);
char interface[256] = "", bpfstr[256] = "";
int packets = 0, c, i;
while ((c = getopt (argc, argv, "hi:n:")) != -1)
{
switch (c)
{
case 'h':
printf("Usage: %s [-h] [-i ] []\n", argv[0]);
exit(0);
break;
case 'i':
strcpy(interface, optarg);
break;
}
}
for (i = optind; i < argc; i++)
{
strcat(bpfstr, argv[i]);
strcat(bpfstr, " ");
}
if ((handle = open_pcap_socket(interface, bpfstr)))
{
signal(SIGINT, program_terminate);
signal(SIGTERM, program_terminate);
signal(SIGQUIT, program_terminate);
capture_loop(handle, packets, (pcap_handler)handle_packet);
}
return 0;
}
int main(int argc, char **argv)
{
//Check whether user has entered enough arguments
if(argc < 2)
{
printf("Usage: ./firewall mode rules_file [input pcap file] [output pcap file] 1/0\n",
" Mode: 1/2\n"
" Debugging: On/Off\n");
}
char errbuf[100];
int mode = atoi(argv[1]);
//Convert rules from File to linkedlist
createList(argv[2]);
//Print the rules for Debugging
//iterList();
//Initialize the hashtables
state_tbl = NULL;
arp_tbl = NULL;
//Intitialze the locks
if (pthread_rwlock_init(&arp_lock,NULL) != 0)
{
printf("ARP lock init failed.\n");
}
if (pthread_rwlock_init(&state_lock,NULL) != 0)
{
printf("State lock init failed.\n");
}
//If mode = 1 then use the interfaces to capture packets
if(mode == 1)
{
debugging = atoi(argv[3]);
pthread_t threads[4];
//Open the interface handlers
in_handle = pcap_open_live(INT_IN,65536,1,0,errbuf);
out_handle = pcap_open_live(INT_OUT,65536,1,0,errbuf);
//Create four threads
pthread_create(threads + 0, NULL, func1, (void *) 0);
pthread_create(threads + 1, NULL, func2, (void *) 1);
pthread_create(threads + 2, NULL, func3, (void *) 2);
pthread_create(threads + 3, NULL, func4, (void *) 3);
//Wait for the four threads
pthread_join(threads[0], NULL);
pthread_join(threads[1], NULL);
pthread_join(threads[2], NULL);
pthread_join(threads[3], NULL);
pthread_exit(NULL);
}
//Else open the input pcap file for the processing and write to output pcap file
else
{
//Check for the valid arguments
if(argc < 5)
{
printf("Usage: ./firewall mode rule_file [input pcap file] [output pcap file] 0/1\n",
" Mode: 1/2\n"
" Debug:On/Off\n");
}
debugging = atoi(argv[5]);
in_handle = pcap_open_offline(argv[3],errbuf);
//802.3 = 1 - link type
//open new pcap handler
out_handle = pcap_open_dead(1,65536);
//open the file with the handler
dumper = pcap_dump_open(out_handle, argv[4]);
capture_loop(in_handle, -1, (pcap_handler)parse_packet_file, (u_char*)dumper);
}
//Memory cleanup
cleanList();
return 0;
}
//Thread 2 - which processes packets from another interface
void func2()
{
printf("Thread-2 Started.\n");
capture_loop(out_handle, -1, (pcap_handler)parse_packet_p, NULL);
pthread_exit(NULL);
}
//Thread 1 - which processes packets from one interface
void func1()
{
printf("Thread-1 Started.\n");
capture_loop(in_handle, -1, (pcap_handler)parse_packet, NULL);
pthread_exit(NULL);
}
static int capture(char *dev_name, int x_res, int y_res, int n_frames,
char *out_dir, int block, int threads, int sleep_ms)
{
struct v4l2_format fmt;
struct v4l2_buffer buf;
struct v4l2_requestbuffers req;
enum v4l2_buf_type type;
int fd = -1;
unsigned int i, n_buffers;
struct buffer *buffers;
if (block)
fd = v4l2_open(dev_name, O_RDWR, 0);
else
fd = v4l2_open(dev_name, O_RDWR | O_NONBLOCK, 0);
if (fd < 0) {
perror("Cannot open device");
exit(EXIT_FAILURE);
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = x_res;
fmt.fmt.pix.height = y_res;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
xioctl(fd, VIDIOC_S_FMT, &fmt);
if (fmt.fmt.pix.pixelformat != V4L2_PIX_FMT_RGB24) {
printf("Libv4l didn't accept RGB24 format. Can't proceed.\n");
exit(EXIT_FAILURE);
}
if ((fmt.fmt.pix.width != x_res) || (fmt.fmt.pix.height != y_res))
printf("Warning: driver is sending image at %dx%d\n",
fmt.fmt.pix.width, fmt.fmt.pix.height);
CLEAR(req);
req.count = 2;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
xioctl(fd, VIDIOC_REQBUFS, &req);
buffers = calloc(req.count, sizeof(*buffers));
for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = n_buffers;
xioctl(fd, VIDIOC_QUERYBUF, &buf);
buffers[n_buffers].length = buf.length;
buffers[n_buffers].start = v4l2_mmap(NULL, buf.length,
PROT_READ | PROT_WRITE, MAP_SHARED,
fd, buf.m.offset);
if (MAP_FAILED == buffers[n_buffers].start) {
perror("mmap");
exit(EXIT_FAILURE);
}
}
for (i = 0; i < n_buffers; ++i) {
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
xioctl(fd, VIDIOC_QBUF, &buf);
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
xioctl(fd, VIDIOC_STREAMON, &type);
if (threads)
capture_threads(fd, buffers, 2, fmt, n_frames, out_dir,
sleep_ms);
else
capture_loop(fd, buffers, fmt, n_frames, out_dir);
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
xioctl(fd, VIDIOC_STREAMOFF, &type);
for (i = 0; i < n_buffers; ++i)
v4l2_munmap(buffers[i].start, buffers[i].length);
v4l2_close(fd);
return 0;
}
int main(int argc, char **argv)
{
init_defaults();
while (1) {
int index, c = 0;
c = getopt_long(argc, argv, short_options, long_options, &index);
if (c == -1)
break;
switch (c) {
case 0:
break;
case 'd':
free(device_name);
device_name = optarg;
break;
case 'W':
v_width = atoi(optarg);
break;
case 'H':
v_height = atoi(optarg);
break;
case 'c':
num_frames = atoi(optarg);
break;
case 'f':
framerate = atoi(optarg);
break;
case 'j':
use_jpeg_header_boundry = true;
break;
case 'o':
output = OUTPUT_STDOUT;
break;
default:
usage(stderr, argc, argv);
exit(EXIT_FAILURE);
}
}
if ( io == IO_METHOD_USERPTR ) {
fprintf(stderr, "IO_METHOD_USERPTR not supported yet, using MMAP instead");
io = IO_METHOD_MMAP;
}
device_open();
init_device();
start_capturing();
capture_loop();
stop_capturing();
uninit_device();
device_close();
return 0;
}
