int cbcreate(struct bsdconv_instance *ins, struct bsdconv_hash_entry *arg){ struct my_s *r=THIS_CODEC(ins)->priv=malloc(sizeof(struct my_s)); int i; r->min_len=1; r->after=NULL; r->before=NULL; char *filter="PRINT"; char *after="010A"; char *before=NULL; while(arg){ if(strcasecmp(arg->key, "FOR")==0){ filter=arg->ptr; }else if(strcasecmp(arg->key, "MIN-LEN")==0 && sscanf(arg->ptr, "%d", &i)==1){ r->min_len=i; }else if(strcasecmp(arg->key, "AFTER")==0){ after=arg->ptr; }else if(strcasecmp(arg->key, "BEFORE")==0){ before=arg->ptr; }else{ free(r); return EINVAL; } arg=arg->next; } r->filter=load_filter(filter); if(r->filter==NULL){ free(r); return EOPNOTSUPP; } if(after){ r->after=str2data(after, &i, ins); if(i){ if(r->after) DATA_FREE(ins, r->after); free(r); return i; } } if(before){ r->before=str2data(before, &i, ins); if(i){ if(r->after) DATA_FREE(ins, r->after); if(r->before) DATA_FREE(ins, r->before); free(r); return i; } } DATA_MALLOC(ins, r->qh); r->qh->flags=0; r->qh->next=NULL; return 0; }
int cbcreate(struct bsdconv_instance *ins, struct bsdconv_hash_entry *arg){ struct my_s *r=malloc(sizeof(struct my_s)); THIS_CODEC(ins)->priv=r; r->filter=NULL; r->mark=0; char *filter=NULL; while(arg){ if(strcasecmp(arg->key, "MARK")==0){ r->mark=1; }else if(strcasecmp(arg->key, "FOR")==0){ filter=arg->ptr; }else{ free(r); return EINVAL; } arg=arg->next; } if(filter!=NULL){ r->filter=load_filter(filter); if(r->filter==NULL){ free(r); return EOPNOTSUPP; } } return 0; }
void LogstorageConfigCreatorForm::on_pushButton_Delete_clicked() { remove_filter(false); // make index 0 active ui->comboBox_filter->setCurrentIndex(0); load_filter(0); }
void reload_config (void) { log_message ("reload_config: reloading configuration files"); config (0); /* since the motd is stored in memory, reread it */ motd_close (); motd_init (); #ifndef ROUTING_ONLY /* reread filter file */ load_filter (); load_block (); #endif load_server_auth (); /* since the servers file may have changed, ensure that there is * no nickname that matches an alias for a server. */ list_foreach (Server_Auth, (list_callback_t) nick_check, 0); }
int main(int argc, char** argv){ int i; char buffer[256]; char* tk; FILTERCHAIN* tmp_chn; FILTERCHAIN* del_chn; HARNESS_INSTANCE* hinstance; if(harness_init(argc,argv,&hinstance)){ printf("Error: Initialization failed.\n"); skygw_log_write(LOGFILE_ERROR,"Error: Initialization failed.\n"); skygw_logmanager_done(); skygw_logmanager_exit(); return 1; } if(instance.verbose){ printf("\n\n\tFilter Test Harness\n\n"); } while(instance.running){ printf("Harness> "); memset(buffer,0,256); fgets(buffer,256,stdin); tk = strtok(buffer," \n"); switch(user_input(tk)) { case RUNFILTERS: if(instance.head->next == NULL){ printf("No filters loaded.\n"); break; } if(instance.buffer == NULL){ if(instance.infile<0){ manual_query(); }else{ load_query(); } } route_buffers(); break; case LOAD_FILTER: tk = strtok(NULL," \n"); tmp_chn = load_filter_module(tk); if(!tmp_chn || !load_filter(tmp_chn,instance.conf)){ printf("Error creating filter instance.\n"); skygw_log_write(LOGFILE_ERROR,"Error: Error creating filter instance.\n"); }else{ instance.head = tmp_chn; } break; case DELETE_FILTER: tk = strtok(NULL," \n\0"); tmp_chn = instance.head; del_chn = instance.head; if(tk){ if(strcmp(instance.head->name,tk) == 0){ instance.head = instance.head->next; }else{ while(del_chn->next){ if(strcmp(del_chn->name,tk) == 0){ tmp_chn->next = del_chn->next; break; }else{ tmp_chn = del_chn; del_chn = del_chn->next; } } } if(del_chn && del_chn->next){ printf("Deleted %s.\n",del_chn->name); if(del_chn->instance){ del_chn->instance->freeSession(del_chn->filter,del_chn->session); } free(del_chn->filter); free(del_chn->down); free(del_chn->name); free(del_chn); }else{ printf("No matching filter found.\n"); } } break; case LOAD_CONFIG: tk = strtok(NULL," \n\0"); if(!load_config(tk)){ free_filters(); } break; case SET_INFILE: tk = strtok(NULL," \n\0"); if(instance.infile >= 0){ close(instance.infile); free(instance.infile_name); } if(tk!= NULL){ free_buffers(); instance.infile = open_file(tk,0); if(instance.infile >= 0){ load_query(); instance.infile_name = strdup(tk); if(instance.verbose){ printf("Loaded %d queries from file '%s'\n",instance.buffer_count,instance.infile_name); } } }else{ instance.infile = -1; printf("Queries are read from: command line\n"); } break; case SET_OUTFILE: tk = strtok(NULL," \n\0"); if(instance.outfile >= 0){ close(instance.outfile); free(instance.outfile_name); } if(tk!= NULL){ instance.outfile = open_file(tk,1); if(instance.outfile >= 0){ instance.outfile_name = strdup(tk); printf("Output is logged to: %s\n",tk); } }else{ instance.outfile = -1; printf("Output logging disabled.\n"); } break; case SESS_COUNT: tk = strtok(NULL," \n\0"); free_buffers(); free_filters(); instance.session_count = atoi(tk); printf("Sessions set to: %d\n", instance.session_count); break; case THR_COUNT: instance.running = 0; pthread_mutex_unlock(&instance.work_mtx); for(i = 0;i<instance.thrcount;i++){ pthread_join(instance.thrpool[i],NULL); } pthread_mutex_lock(&instance.work_mtx); instance.running = 1; tk = strtok(NULL," \n\0"); instance.thrcount = atoi(tk); void* t_thr_pool; if(!(t_thr_pool = realloc(instance.thrpool,instance.thrcount * sizeof(pthread_t)))){ printf("Error: Out of memory\n"); skygw_log_write(LOGFILE_ERROR,"Error: Out of memory\n"); instance.running = 0; break; } instance.thrpool = t_thr_pool; int thr_num = 1; for(i = 0;i<instance.thrcount;i++){ pthread_create(&instance.thrpool[i], NULL, (void*)work_buffer, (void*)thr_num++); } printf("Threads set to: %d\n", instance.thrcount); break; case QUIT: instance.running = 0; pthread_mutex_unlock(&instance.work_mtx); for(i = 0;i<instance.thrcount;i++){ pthread_join(instance.thrpool[i],NULL); } break; case UNDEFINED: printf("Command not found, enter \"help\" for a list of commands\n"); break; default: break; } } if(instance.infile >= 0){ close(instance.infile); } if(instance.outfile >= 0){ close(instance.outfile); } free_buffers(); free_filters(); skygw_logmanager_done(); skygw_logmanager_exit(); free(instance.head); return 0; }
int main(int argc, char **argv) { struct audio_format audio_format; struct audio_format_string af_string; bool success; GError *error = NULL; struct filter *filter; const struct audio_format *out_audio_format; char buffer[4096]; size_t frame_size; if (argc < 3 || argc > 4) { g_printerr("Usage: run_filter CONFIG NAME [FORMAT] <IN\n"); return 1; } audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2); /* initialize GLib */ g_thread_init(NULL); g_log_set_default_handler(my_log_func, NULL); /* read configuration file (mpd.conf) */ config_global_init(); success = config_read_file(argv[1], &error); if (!success) { g_printerr("%s:", error->message); g_error_free(error); return 1; } /* parse the audio format */ if (argc > 3) { success = audio_format_parse(&audio_format, argv[3], false, &error); if (!success) { g_printerr("Failed to parse audio format: %s\n", error->message); g_error_free(error); return 1; } } /* initialize the filter */ filter = load_filter(argv[2]); if (filter == NULL) return 1; /* open the filter */ out_audio_format = filter_open(filter, &audio_format, &error); if (out_audio_format == NULL) { g_printerr("Failed to open filter: %s\n", error->message); g_error_free(error); filter_free(filter); return 1; } g_printerr("audio_format=%s\n", audio_format_to_string(out_audio_format, &af_string)); frame_size = audio_format_frame_size(&audio_format); /* play */ while (true) { ssize_t nbytes; size_t length; const void *dest; nbytes = read(0, buffer, sizeof(buffer)); if (nbytes <= 0) break; dest = filter_filter(filter, buffer, (size_t)nbytes, &length, &error); if (dest == NULL) { g_printerr("Filter failed: %s\n", error->message); filter_close(filter); filter_free(filter); return 1; } nbytes = write(1, dest, length); if (nbytes < 0) { g_printerr("Failed to write: %s\n", strerror(errno)); filter_close(filter); filter_free(filter); return 1; } } /* cleanup and exit */ filter_close(filter); filter_free(filter); config_global_finish(); return 0; }
int load_config( char* fname) { CONFIG* iter; CONFIG_ITEM* item; int config_ok = 1,inirval; free_filters(); if((inirval = ini_parse(fname,handler,instance.conf)) < 0){ printf("Error parsing configuration file!\n"); if(inirval == -1) printf("Inih file open error.\n"); else if(inirval == -2) printf("inih memory error.\n"); MXS_ERROR("Error parsing configuration file!\n"); config_ok = 0; goto cleanup; } if(instance.verbose){ printf("Configuration loaded from %s\n\n",fname); } if(instance.conf == NULL){ printf("Nothing valid was read from the file.\n"); MXS_NOTICE("Nothing valid was read from the file.\n"); config_ok = 0; goto cleanup; } instance.conf = process_config(instance.conf); if(instance.conf){ if(instance.verbose){ printf("Modules Loaded:\n"); } iter = instance.conf; }else{ printf("No filters found in the configuration file.\n"); MXS_NOTICE("No filters found in the configuration file.\n"); config_ok = 0; goto cleanup; } while(iter){ item = iter->item; while(item){ if(!strcmp("module",item->name)){ if(instance.mod_dir){ char* modstr = malloc(sizeof(char)*(strlen(instance.mod_dir) + strlen(item->value) + 1)); strcpy(modstr,instance.mod_dir); strcat(modstr,"/"); strcat(modstr,item->value); instance.head = load_filter_module(modstr); free(modstr); }else{ instance.head = load_filter_module(item->value); } if(!instance.head || !load_filter(instance.head,instance.conf)){ printf("Error creating filter instance!\nModule: %s\n",item->value); MXS_ERROR("Error creating filter instance!\nModule: %s\n",item->value); config_ok = 0; goto cleanup; }else{ if(instance.verbose){ printf("\t%s\n",iter->section); } } } item = item->next; } iter = iter->next; } while(instance.conf){ item = instance.conf->item; while(item){ item = instance.conf->item; instance.conf->item = instance.conf->item->next; free(item->name); free(item->value); free(item); item = instance.conf->item; } instance.conf = instance.conf->next; } cleanup: while(instance.conf){ iter = instance.conf; instance.conf = instance.conf->next; item = iter->item; while(item){ free(item->name); free(item->value); free(item); iter->item = iter->item->next; item = iter->item; } free(iter); } instance.conf = NULL; return config_ok; }
/** @brief * * @param args contains the parsed cmd-line options & arguments. * @param argc number of cmd-line arguments. * @param argv list of cmd-line arguments * @param optind index of the first non-option cmd-line argument. * * @return exit status for main() to return. */ int filterkeys(struct cmdargs *args, int argc, char *argv[], int optind) { FILE *ffile, *outfile; dbfr_t *filter_reader, *stream_reader; char *t_keybuf; int i, acum_len; if (args->outfile) { if ((outfile = fopen(args->outfile, "w")) == NULL) { perror(args->outfile); exit(EXIT_FILE_ERR); } } else { outfile = stdout; } /* choose field delimiter */ if (!(delim = (args->delim ? args->delim : getenv("DELIMITER")))) delim = default_delim; expand_chars(delim); delim_len = strlen(delim); /* get the filter file */ int fd = open64(args->filter_file, O_RDONLY); if (fd != -1) { ffile = fdopen(fd, "r"); } else { if (!strcmp(args->filter_file, "-")) { ffile = stdin; } else { warn("Opening filter file %s", args->filter_file); return EXIT_FILE_ERR; } } filter_reader = dbfr_init( ffile ); /* input files */ if (!(ffile = (optind < argc ? nextfile(argc, argv, &optind, "r") : stdin))) return EXIT_FILE_ERR; stream_reader = dbfr_init( ffile ); if (configure_filterkeys(&fk_conf, args, filter_reader, stream_reader) != 0) { fprintf(stderr, "%s: error setting up configuration.\n", argv[0]); return EXIT_HELP; } load_filter(&fk_conf, filter_reader); dbfr_close( filter_reader ); if (args->preserve_header) { /* if indexes where supplied read the header */ if (args->akeys && args->bkeys) dbfr_getline(stream_reader); fputs(stream_reader->current_line, outfile); } t_keybuf = (char *) xmalloc(fk_conf.key_buffer_sz); while (ffile) { while (dbfr_getline(stream_reader) > 0) { for (acum_len = 0, i = 0; i < fk_conf.key_count && fk_conf.key_buffer_sz > acum_len; i++) { acum_len += get_line_field(t_keybuf + acum_len, stream_reader->current_line, fk_conf.key_buffer_sz - acum_len, fk_conf.bindexes[i], delim); if (i != fk_conf.key_count -1) { strcat(t_keybuf + acum_len, delim); acum_len += delim_len; } } if (acum_len > 0) { int found = (ht_get(&fk_conf.filter, t_keybuf) == (void*) 0xDEADBEEF ? 1 : 0); if (found ^ args->invert) fputs(stream_reader->current_line, outfile); } } dbfr_close(stream_reader); if ((ffile = nextfile(argc, argv, &optind, "r"))) { stream_reader = dbfr_init( ffile ); /* reconfigure fields (needed if labels were used) */ /* TODO(rgranata): implement reconfigure field if (reconfigure_filterkeys(&fk_conf, args, NULL, stream_reader) != 0) { fprintf(stderr, "%s: error parsing field arguments.\n", argv[0]); return EXIT_HELP; } */ if (args->preserve_header) dbfr_getline(stream_reader); } } if (t_keybuf) free(t_keybuf); ht_destroy(&fk_conf.filter); return 0; }
void parse_options(int argc, char **argv) { int c; static struct option long_options[] = { { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'v' }, { "iface", required_argument, NULL, 'i' }, { "lifaces", no_argument, NULL, 'I' }, { "netmask", required_argument, NULL, 'n' }, { "address", required_argument, NULL, 'A' }, { "write", required_argument, NULL, 'w' }, { "read", required_argument, NULL, 'r' }, { "pcapfilter", required_argument, NULL, 'f' }, { "reversed", no_argument, NULL, 'R' }, { "proto", required_argument, NULL, 't' }, { "plugin", required_argument, NULL, 'P' }, { "filter", required_argument, NULL, 'F' }, #ifdef HAVE_EC_LUA { "lua-script", required_argument, NULL, 0 }, { "lua-args", required_argument, NULL, 0 }, #endif { "superquiet", no_argument, NULL, 'Q' }, { "quiet", no_argument, NULL, 'q' }, { "script", required_argument, NULL, 's' }, { "silent", no_argument, NULL, 'z' }, #ifdef WITH_IPV6 { "ip6scan", no_argument, NULL, '6' }, #endif { "unoffensive", no_argument, NULL, 'u' }, { "nosslmitm", no_argument, NULL, 'S' }, { "load-hosts", required_argument, NULL, 'j' }, { "save-hosts", required_argument, NULL, 'k' }, { "wifi-key", required_argument, NULL, 'W' }, { "config", required_argument, NULL, 'a' }, { "dns", no_argument, NULL, 'd' }, { "regex", required_argument, NULL, 'e' }, { "visual", required_argument, NULL, 'V' }, { "ext-headers", no_argument, NULL, 'E' }, { "log", required_argument, NULL, 'L' }, { "log-info", required_argument, NULL, 'l' }, { "log-msg", required_argument, NULL, 'm' }, { "compress", no_argument, NULL, 'c' }, { "text", no_argument, NULL, 'T' }, { "curses", no_argument, NULL, 'C' }, { "daemon", no_argument, NULL, 'D' }, { "gtk", no_argument, NULL, 'G' }, { "mitm", required_argument, NULL, 'M' }, { "only-mitm", no_argument, NULL, 'o' }, { "bridge", required_argument, NULL, 'B' }, { "broadcast", required_argument, NULL, 'b' }, { "promisc", no_argument, NULL, 'p' }, { "gateway", required_argument, NULL, 'Y' }, { "certificate", required_argument, NULL, 0 }, { "private-key", required_argument, NULL, 0 }, { 0 , 0 , 0 , 0} }; for (c = 0; c < argc; c++) DEBUG_MSG("parse_options -- [%d] [%s]", c, argv[c]); /* OPTIONS INITIALIZATION */ GBL_PCAP->promisc = 1; GBL_FORMAT = &ascii_format; GBL_OPTIONS->ssl_mitm = 1; GBL_OPTIONS->broadcast = 0; GBL_OPTIONS->ssl_cert = NULL; GBL_OPTIONS->ssl_pkey = NULL; /* OPTIONS INITIALIZED */ optind = 0; int option_index = 0; while ((c = getopt_long (argc, argv, "A:a:bB:CchDdEe:F:f:GhIi:j:k:L:l:M:m:n:oP:pQqiRr:s:STt:uV:vW:w:Y:z6", long_options, &option_index)) != EOF) { /* used for parsing arguments */ char *opt_end = optarg; while (opt_end && *opt_end) opt_end++; /* enable a loaded filter script? */ switch (c) { case 'M': set_mitm(optarg); break; case 'o': set_onlymitm(); //select_text_interface(); break; case 'b': set_broadcast(); break; case 'B': set_iface_bridge(optarg); break; case 'p': set_promisc(); break; #ifndef JUST_LIBRARY case 'T': select_text_interface(); break; case 'C': select_curses_interface(); break; case 'G': select_gtk_interface(); break; case 'D': select_daemon_interface(); break; #endif case 'R': set_reversed(); break; case 't': set_proto(optarg); break; case 'P': set_plugin(optarg); break; case 'i': set_iface(optarg); break; case 'I': /* this option is only useful in the text interface */ set_lifaces(); break; case 'Y': set_secondary(optarg); break; case 'n': set_netmask(optarg); break; case 'A': set_address(optarg); break; case 'r': set_read_pcap(optarg); break; case 'w': set_write_pcap(optarg); break; case 'f': set_pcap_filter(optarg); break; case 'F': load_filter(opt_end, optarg); break; case 'L': set_loglevel_packet(optarg); case 'l': set_loglevel_info(optarg); break; case 'm': set_loglevel_true(optarg); break; case 'c': set_compress(); break; case 'e': opt_set_regex(optarg); break; case 'Q': set_superquiet(); /* no break, quiet must be enabled */ case 'q': set_quiet(); break; case 's': set_script(optarg); break; case 'z': set_silent(); break; #ifdef WITH_IPV6 case '6': set_ip6scan(); break; #endif case 'u': set_unoffensive(); break; case 'S': disable_sslmitm(); break; case 'd': set_resolve(); break; case 'j': load_hosts(optarg); break; case 'k': save_hosts(optarg); break; case 'V': opt_set_format(optarg); break; case 'E': set_ext_headers(); break; case 'W': set_wifi_key(optarg); break; case 'a': set_conf_file(optarg); break; case 'h': ec_usage(); break; case 'v': printf("%s %s\n", GBL_PROGRAM, GBL_VERSION); clean_exit(0); break; /* Certificate and private key options */ case 0: if (!strcmp(long_options[option_index].name, "certificate")) { GBL_OPTIONS->ssl_cert = strdup(optarg); } else if (!strcmp(long_options[option_index].name, "private-key")) { GBL_OPTIONS->ssl_pkey = strdup(optarg); #ifdef HAVE_EC_LUA } else if (!strcmp(long_options[option_index].name,"lua-args")) { ec_lua_cli_add_args(strdup(optarg)); } else if (!strcmp(long_options[option_index].name,"lua-script")) { ec_lua_cli_add_script(strdup(optarg)); break; #endif } else { fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); clean_exit(-1); } break; case ':': // missing parameter fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); clean_exit(-1); break; case '?': // unknown option fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); clean_exit(-1); break; } } DEBUG_MSG("parse_options: options parsed"); /* TARGET1 and TARGET2 parsing */ if (argv[optind]) { GBL_OPTIONS->target1 = strdup(argv[optind]); DEBUG_MSG("TARGET1: %s", GBL_OPTIONS->target1); if (argv[optind+1]) { GBL_OPTIONS->target2 = strdup(argv[optind+1]); DEBUG_MSG("TARGET2: %s", GBL_OPTIONS->target2); } } /* create the list form the TARGET format (MAC/IPrange/PORTrange) */ compile_display_filter(); DEBUG_MSG("parse_options: targets parsed"); /* check for other options */ if (GBL_SNIFF->start == NULL) set_unified_sniff(); if (GBL_OPTIONS->read && GBL_PCAP->filter) FATAL_ERROR("Cannot read from file and set a filter on interface"); if (GBL_OPTIONS->read && GBL_SNIFF->type != SM_UNIFIED ) FATAL_ERROR("You can read from a file ONLY in unified sniffing mode !"); if (GBL_OPTIONS->mitm && GBL_SNIFF->type != SM_UNIFIED ) FATAL_ERROR("You can't do mitm attacks in bridged sniffing mode !"); if (GBL_SNIFF->type == SM_BRIDGED && GBL_PCAP->promisc == 0) FATAL_ERROR("During bridged sniffing the iface must be in promisc mode !"); if (GBL_OPTIONS->quiet && GBL_UI->type != UI_TEXT) FATAL_ERROR("The quiet option is useful only with text only UI"); if (GBL_OPTIONS->load_hosts && GBL_OPTIONS->save_hosts) FATAL_ERROR("Cannot load and save at the same time the hosts list..."); if (GBL_OPTIONS->unoffensive && GBL_OPTIONS->mitm) FATAL_ERROR("Cannot use mitm attacks in unoffensive mode"); if (GBL_OPTIONS->read && GBL_OPTIONS->mitm) FATAL_ERROR("Cannot use mitm attacks while reading from file"); #ifndef JUST_LIBRARY if (GBL_UI->init == NULL) FATAL_ERROR("Please select an User Interface"); #endif /* force text interface for only mitm attack */ /* Do not select text interface for only MiTM mode if (GBL_OPTIONS->only_mitm) { if (GBL_OPTIONS->mitm) select_text_interface(); else FATAL_ERROR("Only mitm requires at least one mitm method"); } */ DEBUG_MSG("parse_options: options combination looks good"); return; }