int resetlog_cgi(HttpState *state) { count = 0; clear_log(); cgi_redirectto(state, REDIRECTTO); return 0; }
void ServerWidget::init_console() { connect(action_clear_log, &QAction::triggered, this, &ServerWidget::clear_log); complete_cvar.setModel(&model_cvar); complete_cvar.setCaseSensitivity(Qt::CaseSensitive); complete_cvar.setModelSorting(QCompleter::CaseSensitivelySortedModel); complete_cvar.setCompletionColumn(CvarModel::Name); complete_cvar.setCompletionRole(Qt::DisplayRole); input_console->setWordCompleterPrefix("$"); input_console->setHistory(settings().get_history(connection.details().name)); clear_log(); }
void LogDialog::on_pushButton_2_clicked() { if (this->text.isEmpty() == false) { QMessageBox mbox; int ret; mbox.setText(QObject::tr("Are you sure you want to clear the log?")); mbox.setStandardButtons(QMessageBox::Cancel | QMessageBox::Ok); mbox.setDefaultButton(QMessageBox::Cancel); mbox.setButtonText(QMessageBox::Ok, tr("Clear")); ret = mbox.exec(); if (ret == QMessageBox::Ok) { emit clear_log(); this->text.clear(); ui->listWidget->clear(); } } }
int main(int argc, char **argv) { int err; int has_set_log_format = 0; int is_clear_log = 0; int getLogSize = 0; int mode = O_RDONLY; int i; // const char *forceFilters = NULL; struct log_device_t* devices = NULL; struct log_device_t* dev; g_logformat = (log_format *)log_format_new(); if (argc == 2 && 0 == strcmp(argv[1], "--test")) { logprint_run_tests(); exit(0); } if (argc == 2 && 0 == strcmp(argv[1], "--help")) { show_help(argv[0]); exit(0); } for (;;) { int ret; ret = getopt(argc, argv, "cdt:gsf:r:n:v:b:D"); if (ret < 0) { break; } switch(ret) { case 's': // default to all silent log_add_filter_rule(g_logformat, "*:s"); break; case 'c': is_clear_log = 1; mode = O_WRONLY; break; case 'd': g_nonblock = true; break; case 't': g_nonblock = true; g_tail_lines = atoi(optarg); break; case 'g': getLogSize = 1; break; case 'b': { char* buf = (char*) malloc(strlen(LOG_FILE_DIR) + strlen(optarg) + 1); if (buf == NULL) { fprintf(stderr,"Can't malloc LOG_FILE_DIR\n"); exit(-1); } strcpy(buf, LOG_FILE_DIR); strcat(buf, optarg); // snprintf(buf, strlen(LOG_FILE_DIR) + strlen(optarg) + 1, "%s%s", LOG_FILE_DIR, optarg); if (devices) { dev = devices; while (dev->next) { dev = dev->next; } dev->next = (struct log_device_t *)malloc( sizeof(struct log_device_t)); if (dev->next == NULL) { fprintf(stderr,"Can't malloc log_device\n"); exit(-1); } dev->next->device = buf; dev->next->fd = -1; dev->next->printed = false; dev->next->queue = NULL; dev->next->next = NULL; } else { devices = (struct log_device_t *)malloc( sizeof(struct log_device_t)); if (devices == NULL) { fprintf(stderr,"Can't malloc log_device\n"); exit(-1); } devices->device = buf; devices->fd = -1; devices->printed = false; devices->queue = NULL; devices->next = NULL; } g_dev_count++; } break; case 'f': // redirect output to a file g_output_filename = optarg; break; case 'r': // if (optarg == NULL) { // fprintf(stderr,"optarg == null\n"); // g_log_rotate_size_kbytes = DEFAULT_LOG_ROTATE_SIZE_KBYTES; // } else { //long logRotateSize; //char *lastDigit; if (!isdigit(optarg[0])) { fprintf(stderr,"Invalid parameter to -r\n"); show_help(argv[0]); exit(-1); } g_log_rotate_size_kbytes = atoi(optarg); // } break; case 'n': if (!isdigit(optarg[0])) { fprintf(stderr,"Invalid parameter to -r\n"); show_help(argv[0]); exit(-1); } g_max_rotated_logs = atoi(optarg); break; case 'v': err = set_log_format (optarg); if (err < 0) { fprintf(stderr,"Invalid parameter to -v\n"); show_help(argv[0]); exit(-1); } has_set_log_format = 1; break; default: fprintf(stderr,"Unrecognized Option\n"); show_help(argv[0]); exit(-1); break; } } if (!devices) { devices = (struct log_device_t *)malloc( sizeof(struct log_device_t)); if (devices == NULL) { fprintf(stderr,"Can't malloc log_device\n"); exit(-1); } devices->device = strdup("/dev/"LOGGER_LOG_MAIN); devices->fd = -1; devices->printed = false; devices->queue = NULL; devices->next = NULL; g_dev_count = 1; int accessmode = (mode & O_RDONLY) ? R_OK : 0 | (mode & O_WRONLY) ? W_OK : 0; // only add this if it's available if (0 == access("/dev/"LOGGER_LOG_SYSTEM, accessmode)) { devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t)); if (devices->next == NULL) { fprintf(stderr,"Can't malloc log_device\n"); exit(-1); } devices->next->device = strdup("/dev/"LOGGER_LOG_SYSTEM); devices->next->fd = -1; devices->next->printed = false; devices->next->queue = NULL; devices->next->next = NULL; g_dev_count ++; } if (0 == access("/dev/"LOGGER_LOG_APPS, accessmode)) { devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t)); if (devices->next == NULL) { fprintf(stderr,"Can't malloc log_device\n"); exit(-1); } devices->next->device = strdup("/dev/"LOGGER_LOG_APPS); devices->next->fd = -1; devices->next->printed = false; devices->next->queue = NULL; devices->next->next = NULL; g_dev_count ++; } /* // only add this if it's available int fd; if ((fd = open("/dev/"LOGGER_LOG_SYSTEM, mode)) != -1) { devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t)); devices->next->device = strdup("/dev/"LOGGER_LOG_SYSTEM); devices->next->fd = -1; devices->next->printed = false; devices->next->queue = NULL; devices->next->next = NULL; g_dev_count ++; close(fd); } */ } if (g_log_rotate_size_kbytes != 0 && g_output_filename == NULL) { fprintf(stderr,"-r requires -f as well\n"); show_help(argv[0]); exit(-1); } setup_output(); if (has_set_log_format == 0) { err = set_log_format("brief"); } /* const char* logFormat = getenv("DLOG_PRINTF_LOG"); if (logFormat != NULL) { err = set_log_format("brief"); if (err < 0) { fprintf(stderr, "invalid format in DLOG_PRINTF_LOG '%s'\n", logFormat); } } } if (forceFilters) { err = log_add_filter_string(g_logformat, forceFilters); if (err < 0) { fprintf (stderr, "Invalid filter expression in -logcat option\n"); exit(0); } } else if (argc == optind) { // Add from environment variable char *env_tags_orig = getenv("DLOG_LOG_TAGS"); if (env_tags_orig != NULL) { err = log_add_filter_string(g_logformat, env_tags_orig); if (err < 0) { fprintf(stderr, "Invalid filter expression in DLOG_LOG_TAGS\n"); show_help(argv[0]); exit(-1); } } } else { // Add from commandline */ fprintf(stderr,"arc = %d, optind = %d ,Kb %d, rotate %d\n", argc, optind,g_log_rotate_size_kbytes,g_max_rotated_logs); if(argc == optind ) { // Add from environment variable //char *env_tags_orig = getenv("DLOG_TAGS"); log_add_filter_string(g_logformat, "*:d"); } else { for (i = optind ; i < argc ; i++) { err = log_add_filter_string(g_logformat, argv[i]); if (err < 0) { fprintf (stderr, "Invalid filter expression '%s'\n", argv[i]); show_help(argv[0]); exit(-1); } } } /* } */ dev = devices; while (dev) { dev->fd = open(dev->device, mode); if (dev->fd < 0) { fprintf(stderr, "Unable to open log device '%s': %s\n", dev->device, strerror(errno)); exit(EXIT_FAILURE); } if (is_clear_log) { int ret; ret = clear_log(dev->fd); if (ret) { perror("ioctl"); exit(EXIT_FAILURE); } } if (getLogSize) { int size, readable; size = get_log_size(dev->fd); if (size < 0) { perror("ioctl"); exit(EXIT_FAILURE); } readable = get_log_readable_size(dev->fd); if (readable < 0) { perror("ioctl"); exit(EXIT_FAILURE); } printf("%s: ring buffer is %dKb (%dKb consumed), " "max entry is %db, max payload is %db\n", dev->device, size / 1024, readable / 1024, (int) LOGGER_ENTRY_MAX_LEN, (int) LOGGER_ENTRY_MAX_PAYLOAD); } dev = dev->next; } if (getLogSize) { return 0; } if (is_clear_log) { return 0; } read_log_lines(devices); return 0; }
int main() { // Initial blocks uint8_t blocks[5][2] = { {2,1}, {3,5}, {4,5}, {4,6}, {9,8}}; // Initial start position uint8_t startx = WIDTH / 2; uint8_t starty = HEIGHT / 2; int readc = 0, quit = 0, playerid = PLAYER1; int textpos = 0; // Game area gamearea* game = new_gamearea(WIDTH,HEIGHT,5,blocks); // Player player* pl1 = new_player(playerid,startx,starty,HEALTH); initscr(); // Start ncurses noecho(); // Disable echoing of terminal input cbreak(); // Individual keystrokes intrflush(stdscr, FALSE); // Prevent interrupt flush keypad(stdscr,TRUE); // Allow keypad usage start_color(); // Initialize colors // Color pairs init_pair(colorpair id,foreground color, background color) init_pair(PLAYER1,PLAYER1,COLOR_BLACK); // Player1 = COLOR_RED (1) init_pair(PLAYER2,PLAYER2,COLOR_BLACK); // Player2 = COLOR_GREEN (2) init_pair(PLAYER3,PLAYER3,COLOR_BLACK); // Player3 = COLOR_YELLOW (3) init_pair(PLAYER4,PLAYER4,COLOR_BLACK); // Player4 = COLOR_BLUE (4) init_pair(PLAYER_HIT_COLOR,COLOR_RED,COLOR_YELLOW); init_pair(WALL_COLOR,COLOR_WHITE,COLOR_WHITE); // Prepare everything clear_log(); prepare_horizontal_line(WIDTH); ui_draw_grid(game, pl1); fd_set readfs; int rval = 0; while(1) { FD_ZERO(&readfs); FD_SET(fileno(stdin),&readfs); // Block until we have something if((rval = select(fileno(stdin)+1,&readfs,NULL,NULL,NULL)) > 0) { // From user if(FD_ISSET(fileno(stdin),&readfs)) { readc = getch(); // Get each keypress pl1->hitwall = 0; switch(readc) { case KEY_LEFT: if(is_position_a_wall(game,pl1->posx-1,pl1->posy)) pl1->hitwall = 1; else pl1->posx--; break; case KEY_RIGHT: if(is_position_a_wall(game,pl1->posx+1,pl1->posy)) pl1->hitwall = 1; else pl1->posx++; break; case KEY_UP: if(is_position_a_wall(game,pl1->posx,pl1->posy-1)) pl1->hitwall = 1; else pl1->posy--; break; case KEY_DOWN: if(is_position_a_wall(game,pl1->posx,pl1->posy+1)) pl1->hitwall = 1; else pl1->posy++; break; // Function keys, here F1 is reacted to case KEY_F(1): status = status ^ 1; break; case 27: // Escape key quit = 1; break; case '/': // User wants to write something memset(&textbuffer,0,BUFFER); textinput = 1; textpos = 0; break; // Erase text case KEY_BACKSPACE: case KEY_DC: textpos--; textbuffer[textpos] = '\0'; break; // Push the line to log with enter case KEY_ENTER: case '\n': textinput = 0; if(strlen(textbuffer) > 0) add_log(textbuffer,textpos); textpos = 0; memset(&textbuffer,0,BUFFER); break; // Add the character to textbuffer if we were inputting text default: if(textinput == 1) { textbuffer[textpos] = readc; textpos++; if(textpos == BUFFER-1) { textpos = 0; textinput = 0; } } break; } } } // Hit a wall, change player if(pl1->hitwall) { pl1->health--; if(pl1->id == PLAYER4) pl1->id = PLAYER1; else pl1->id++; } // Update screen ui_draw_grid(game, pl1); // Suicide if(pl1->health == 0) { ui_draw_end(1); break; } // Surrended if(quit) { ui_draw_end(0); break; } } free_gamearea(game); free_player(pl1); free_horizontal_line(); sleep(1); endwin(); // End ncurses return 0; }
int main (int argc, char *argv[]) { int i; progname = argv[0]; while ((i = getopt (argc, argv, "fhvu:m:s:t:M:F")) != -1) { switch (i) { case 'F': filter_member_fan = 1; break; case 'v': verbosity += 1; break; case 'f': // vkprintf(2, "setting skip_rotate\n"); skip_rotate = 1; break; case 'h': usage (); return 2; case 'u': username = optarg; break; case 'm': if (sscanf (optarg, "%d,%d", ©_rem, ©_mod) != 2 || copy_rem < 0 || copy_rem >= copy_mod) { usage(); return 2; } break; case 's': jump_log_pos = atoll (optarg); break; case 't': keep_log_limit_pos = log_limit_pos = atoll (optarg); break; case 'M': if (!strncmp(optarg, "firstint", 9)) { split_mode = SPLIT_FIRSTINT; } else if (!strncmp(optarg, "liked", 6)) { split_mode = SPLIT_LIKED; } else { usage(); return 2; } break; default: assert (0); return 2; } } if (optind >= argc || optind + 2 < argc) { usage(); return 2; } if (filter_member_fan) { vkprintf (1, "fix member_fans, fan_members mode\n"); char *p = strrchr (argv[optind], '/'); p = (p == NULL) ? argv[optind] : (p + 1); if (!strncmp (p, "member_fans", 11)) { want_write = member_fans_want_write; } else if (!strncmp (p, "fan_members", 11)) { want_write = fan_members_want_write; } else { kprintf ("binlogname should starts from member_fans of fan_members when command line switch -F used.\n"); exit (1); } } if (log_limit_pos >= 0) { if (jump_log_pos > log_limit_pos) { fprintf (stderr, "fatal: log start position %lld after stop position %lld\n", jump_log_pos, log_limit_pos); return 2; } } if (username && change_user (username) < 0) { fprintf (stderr, "fatal: cannot change user to %s\n", username ? username : "******"); return 1; } if (engine_preload_filelist (argv[optind], binlogname) < 0) { fprintf (stderr, "cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]); exit (1); } Binlog = open_binlog (engine_replica, 0); if (!Binlog) { fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, 0LL); exit (1); } binlogname = Binlog->info->filename; if (verbosity) { fprintf (stderr, "replaying binlog file %s (size %lld)\n", binlogname, Binlog->info->file_size); } clear_log(); init_log_data (0, 0, 0); if (optind + 1 < argc) { targ_fname = argv[optind+1]; targ_fd = open (targ_fname, O_WRONLY | O_APPEND | O_CREAT, 0644); if (targ_fd < 0) { fprintf (stderr, "cannot create %s: %m\n", targ_fname); return 1; } targ_orig_size = lseek (targ_fd, 0, SEEK_END); targ_existed = (targ_orig_size > 0); } else { targ_fname = "stdout"; targ_fd = 1; } if (jump_log_pos > 0) { log_limit_pos = 256; immediate_exit = 1; i = replay_log (0, 1); if (!list_id_ints) { fprintf (stderr, "fatal: cannot parse first LEV_START entry"); exit (1); } log_limit_pos = keep_log_limit_pos; immediate_exit = 0; clear_log (); close_binlog (Binlog, 1); Binlog = 0; Binlog = open_binlog (engine_replica, jump_log_pos); if (!Binlog) { fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, jump_log_pos); exit (1); } binlogname = Binlog->info->filename; if (verbosity) { fprintf (stderr, "replaying binlog file %s (size %lld) from log position %lld\n", binlogname, Binlog->info->file_size, jump_log_pos); } init_log_data (jump_log_pos, 0, 0); } i = replay_log (0, 1); if (i < 0) { fprintf (stderr, "fatal: error reading binlog\n"); exit (1); } if (log_limit_pos >= 0 && log_readto_pos != log_limit_pos) { fprintf (stderr, "fatal: binlog read up to position %lld instead of %lld\n", log_readto_pos, log_limit_pos); exit (1); } if (!targ_orig_size && !jump_log_pos) { vkprintf (1, "Writing CRC32 to the end of target binlog.\n"); struct lev_crc32 *C = write_alloc (20); C->type = LEV_CRC32; C->timestamp = last_timestamp; C->pos = wr_bytes; C->crc32 = ~wr_crc32_complement; wr_bytes += 20; wr_rec++; } flush_out (); if (targ_fd != 1) { if (fdatasync (targ_fd) < 0) { fprintf (stderr, "error syncing %s: %m", targ_fname); exit (1); } close (targ_fd); } if (verbosity > 0) { output_stats (); } return 0; }
int main (int argc, char *argv[]) { int i; progname = argv[0]; while ((i = getopt (argc, argv, "hvu:m:s:t:p")) != -1) { switch (i) { case 'p': fits = positive_counter_fits; break; case 'v': verbosity = 1; break; case 'h': usage(); return 2; case 'u': username = optarg; break; case 'm': if (sscanf (optarg, "%d,%d", ©_rem, ©_mod) != 2 || copy_rem < 0 || copy_rem >= copy_mod) { usage(); return 2; } break; case 's': jump_log_pos = atoll (optarg); break; case 't': log_limit_pos = atoll (optarg); break; } } if (copy_mod < 0) { usage (); return 2; } if (optind >= argc || optind + 2 < argc) { usage(); return 2; } if (log_limit_pos >= 0) { if (jump_log_pos > log_limit_pos) { fprintf (stderr, "fatal: log start position %lld after stop position %lld\n", jump_log_pos, log_limit_pos); return 2; } } if (username && change_user (username) < 0) { fprintf (stderr, "fatal: cannot change user to %s\n", username ? username : "******"); return 1; } if (engine_preload_filelist (argv[optind], binlogname) < 0) { fprintf (stderr, "cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]); exit (1); } Binlog = open_binlog (engine_replica, jump_log_pos); if (!Binlog) { fprintf (stderr, "fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, 0LL); exit (1); } binlogname = Binlog->info->filename; if (verbosity) { fprintf (stderr, "replaying binlog file %s (size %lld)\n", binlogname, Binlog->info->file_size); } clear_log(); init_log_data (jump_log_pos, 0, 0); if (jump_log_pos > 0) { init_stats_data (0); } if (optind + 1 < argc) { targ_fname = argv[optind+1]; targ_fd = open (targ_fname, O_WRONLY | O_APPEND | O_CREAT, 0644); if (targ_fd < 0) { fprintf (stderr, "cannot create %s: %m\n", targ_fname); return 1; } targ_orig_size = lseek (targ_fd, 0, SEEK_END); targ_existed = (targ_orig_size > 0); } else { targ_fname = "stdout"; targ_fd = 1; } i = replay_log (0, 1); if (i < 0) { fprintf (stderr, "fatal: error reading binlog\n"); exit (1); } if (log_limit_pos >= 0 && log_readto_pos != log_limit_pos) { fprintf (stderr, "fatal: binlog read up to position %lld instead of %lld\n", log_readto_pos, log_limit_pos); exit (1); } flush_out (); if (targ_fd != 1) { if (fdatasync (targ_fd) < 0) { fprintf (stderr, "error syncing %s: %m", targ_fname); exit (1); } close (targ_fd); } if (verbosity > 0) { output_stats (); } return 0; }
int main (int argc, char *argv[]) { int i; char new_binlog = 0; set_debug_handlers (); progname = argv[0]; while ((i = getopt (argc, argv, "a:b:c:l:p:dhu:vEM:")) != -1) { switch (i) { case 'E': new_binlog = 1; break; case 'M': if (sscanf (optarg, "%d", &i) != 1 || i < 1) { kprintf ("invalid -M arg: %s", optarg); usage (); } max_lru_size = i; break; case 'a': binlogname = optarg; break; case 'b': backlog = atoi (optarg); if (backlog <= 0) backlog = BACKLOG; break; case 'c': maxconn = atoi (optarg); if (maxconn <= 0 || maxconn > MAX_CONNECTIONS) { maxconn = MAX_CONNECTIONS; } break; case 'd': daemonize ^= 1; break; case 'h': usage (); break; case 'l': logname = optarg; break; case 'p': port = atoi(optarg); break; case 'u': username = optarg; break; case 'v': verbosity++; break; } } if (argc != optind + 1) { usage (); } if (raise_file_rlimit (maxconn + 16) < 0) { kprintf ("fatal: cannot raise open file limit to %d\n", maxconn+16); exit (1); } aes_load_pwd_file (0); if (change_user (username) < 0) { kprintf ("fatal: cannot change user to %s\n", username ? username : "******"); exit (1); } if (new_binlog) { copyexec_results_make_empty_binlog (argv[optind]); exit (0); } init_dyn_data (); if (engine_preload_filelist (argv[optind], binlogname) < 0) { kprintf ("cannot open binlog files for %s\n", binlogname ? binlogname : argv[optind]); exit (1); } vkprintf (3, "engine_preload_filelist done\n"); //Binlog reading Binlog = open_binlog (engine_replica, jump_log_pos); if (!Binlog) { kprintf ("fatal: cannot find binlog for %s, log position %lld\n", engine_replica->replica_prefix, jump_log_pos); exit (1); } binlogname = Binlog->info->filename; vkprintf (1, "replaying binlog file %s (size %lld) from position %lld\n", binlogname, Binlog->info->file_size, jump_log_pos); binlog_load_time = -mytime(); clear_log (); init_log_data (jump_log_pos, jump_log_ts, jump_log_crc32); vkprintf (1, "replay log events started\n"); i = replay_log (0, 1); vkprintf (1, "replay log events finished\n"); if (i < 0) { kprintf ("fatal: error reading binlog\n"); exit (1); } binlog_load_time += mytime(); binlog_loaded_size = log_readto_pos - jump_log_pos; if (!binlog_disabled) { clear_read_log(); } clear_write_log (); start_time = time (0); start_server (); return 0; }
void CMainFrame::OnEditClearLog() { clear_log(); }
int main(int argc, char *argv[]) { signal (SIGINT, signal_handler); //printf("\033[?1049h\033[H"); clear_log(); my_log("Software switch starting..."); my_log(pcap_lib_version()); int option = 0, ret; char c; pthread_t config_thread; char errbuf[PCAP_ERRBUF_SIZE]; p1 = create_port_struct(1); p2 = create_port_struct(2); while ((option = getopt(argc, argv,"h l 1:2: m")) != -1) { switch (option) { case '1' : strcpy(p1->name, optarg); break; case '2' : strcpy(p2->name, optarg); break; case 'l': list_interfaces(); exit(0); case 'm': mock_rule(); break; case 'h': default: print_usage(); exit(EXIT_FAILURE); } } p1->handle = pcap_create(p1->name, errbuf); if ( (ret = pcap_setdirection(p1->handle, PCAP_D_IN)) != 0){ printf("pcap_setdirection returned %i\n", ret); my_log("pcap_setdirection failed"); pcap_perror(p1->handle, 0); //exit(-1); } if ( pcap_set_promisc(p1->handle, 1) != 0){ printf("pcap_set_promisc returned \n%s\n", pcap_geterr(p1->handle)); my_log("pcap_set_promisc failed"); pcap_perror(p1->handle, 0); exit(-1); } if ( pcap_set_immediate_mode(p1->handle, 1) != 0){ printf("pcap_set_immediate_mode returned \n%s\n", pcap_geterr(p1->handle)); my_log("pcap_set_immediate_mode failed"); pcap_perror(p1->handle, 0); exit(-1); } if ( pcap_activate(p1->handle)){ printf("Failed to open interface %s\n", pcap_geterr(p1->handle)); exit(-1); } else { sprintf(log_b, "Handle activated for %s", p1->name); my_log(log_b); } p2->handle = pcap_create(p2->name, errbuf); if ( pcap_setdirection(p2->handle, PCAP_D_OUT) != 0){ my_log("pcap_setdirection failed"); pcap_perror(p2->handle, 0); //exit(-1); } if ( pcap_set_promisc(p2->handle, 1) != 0){ my_log("pcap_set_promisc failed"); pcap_perror(p2->handle, 0); exit(-1); } if ( pcap_set_immediate_mode(p2->handle, 1) != 0){ my_log("pcap_set_immediate_mode failed"); pcap_perror(p2->handle, 0); exit(-1); } if ( pcap_activate(p2->handle)){ printf("Failed to open interface %s\n", pcap_geterr(p2->handle)); exit(-1); } else { sprintf(log_b, "Handle activated for %s", p2->name); my_log(log_b); } //exit(0); my_log("Deleting mac table.."); clear_mac(); sprintf(log_b, "Default action is %s", (DEFAULT_ACTION == R_ALLOW)? "R_ALLOW" : "R_DENY"); my_log(log_b); my_log("Creating threads..."); pthread_mutex_init(&mutex, NULL); if ( pthread_create(&(p1->thread), 0, port_listener, (void *)p1) ){ my_log("Error creating p1 thread"); exit(-1); } if ( pthread_create(&(p2->thread), 0, port_listener, (void *)p2) ){ my_log("Error creating p2 thread"); exit(-1); } pthread_create(&config_thread, 0, config, 0); while (1) { mac_delete_old_entries(5); if(pause_rendering == 1) continue; // render here system("clear"); print_mac(); print_rules(); print_stats_header(); print_stats(p1->in, "1 IN"); print_stats(p1->out, "1 OUT"); print_stats(p2->in, "2 IN"); print_stats(p2->out, "2 OUT"); printf("p1in: %i\tp1out: %i\tp2in: %i\tp2out: %i\n", p1in, p1out, p2in, p2out); sleep(1); } pthread_join(config_thread, 0); pthread_join(p1->thread, 0); pthread_join(p2->thread, 0); //printf("\033[?1049l"); // go back return 0; }