int main(int argc, char *argv[]) {
char *in_if = NULL;
char *out_if = NULL;
char *in_file = NULL;
char *out_file = NULL;
TableStateMachine *machine;
char *patterns = NULL;
int i;
char *param, *arg;
int auto_mode, no_report, batch, max_rules;
int num_workers;
// ************* BEGIN DEBUG
//struct pcap_pkthdr pkthdr;
//char pkt[2048];
//ProcessorData *processor;
// ************* END
auto_mode = 0;
no_report = 0;
num_workers = 1;
batch = 0;
max_rules = 0;
if (argc > 1) {
for (i = 1; i < argc; i++) {
param = strsep(&argv[i], "=");
arg = argv[i];
if (strcmp(param, "in") == 0) {
in_if = arg;
} else if (strcmp(param, "out") == 0) {
out_if = arg;
} else if (strcmp(param, "infile") == 0) {
in_file = arg;
} else if (strcmp(param, "outfile") == 0) {
out_file = arg;
} else if (strcmp(param, "rules") == 0) {
patterns = arg;
} else if (strcmp(param, "max") == 0) {
max_rules = atoi(arg);
} else if (strcmp(param, "workers") == 0) {
num_workers = atoi(arg);
} else if (strcmp(param, "noreport") == 0) {
no_report = 1;
} else if (strcmp(param, "batch") == 0) {
batch = 1;
} else if (strcmp(param, "auto") == 0) {
auto_mode = 1;
break;
}
}
}
if (auto_mode == 0 && ((in_if == NULL && in_file == NULL) || (out_if == NULL && out_file == NULL) || patterns == NULL || max_rules < 0 || num_workers < 1)) {
// Show usage
fprintf(stderr, USAGE, argv[0]);
exit(1);
} else if (auto_mode == 1) {
// Set defaults
in_if = "eth0:1";
out_if = "eth0:2";
patterns = "../../SnortPatternsFull2.json";
max_rules = 0;
num_workers = 1;
}
machine = generateTableStateMachine(patterns, max_rules, 0);
// ************* BEGIN DEBUG
//void process_packet(unsigned char *arg, const struct pcap_pkthdr *pkthdr, const unsigned char *packetptr)
//processor = init_processor(machine, NULL, NULL, 0);
//strcpy(pkt,"008g");
//process_packet((unsigned char *)processor, &pkthdr, (unsigned char*)pkt);
// ************* END
sniff(in_if, out_if, in_file, out_file, machine, num_workers, no_report, batch);
return 0;
}
int main(int argc, const char *argv[]) {
/*
main_findLongestPath();
return 0;
*/
StateMachine *machine;
#ifdef HYBRID_SCANNER
TableStateMachine *tableMachine;
double thresholds[128];
#endif
int options[NUM_OF_OPTIONS]; // [ c, d, r, s, a, f, l, b, m, p, n, v, t, u ]
const char *paths[NUM_OF_STRING_OPTIONS];
int values[NUM_OF_OPTIONS];
int i, idx;
machine = NULL;
if (argc < 3 || argc >= NUM_OF_OPTIONS) {
showUsage(argv[0]);
}
memset(options, 0, NUM_OF_OPTIONS * sizeof(int));
memset(paths, 0, NUM_OF_STRING_OPTIONS * sizeof(char*));
memset(values, 0, NUM_OF_OPTIONS * sizeof(int));
idx = -1;
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
showUsage(argv[0]);
}
switch (argv[i][1]) {
case OPTION_CREATE:
idx = IDX_CREATE;
break;
case OPTION_DUMP:
idx = IDX_DUMP;
break;
case OPTION_READ:
idx = IDX_READ;
break;
case OPTION_SCAN:
idx = IDX_SCAN;
break;
case OPTION_FULLTBL:
idx = IDX_FULLTBL;
break;
case OPTION_COMMON:
idx = IDX_COMMON;
break;
case OPTION_THRESHOLDS:
idx = IDX_THRESHOLDS;
break;
case OPTION_MAXLE:
idx = IDX_MAXLE;
break;
case OPTION_MAXBM:
idx = IDX_MAXBM;
break;
case OPTION_THREADS:
idx = IDX_THREADS;
break;
case OPTION_STEAL:
idx = IDX_STEAL;
break;
case OPTION_REPEAT:
idx = IDX_REPEAT;
break;
case OPTION_WG_SIZE:
idx = IDX_WG_SIZE;
break;
case OPTION_MAX_WGS:
idx = IDX_MAX_WGS;
break;
case OPTION_COMMON_NUM:
idx = IDX_COMMON_NUM;
break;
case OPTION_UNCOMMON_LIM:
idx = IDX_UNCOMMON_LIM;
break;
case OPTION_DROP_LEN:
idx = IDX_DROP_LEN;
break;
case OPTION_VERBOSE:
idx = IDX_VERBOSE;
break;
case OPTION_TIMING:
idx = IDX_TIMING;
break;
case OPTION_USE_COMP:
idx = IDX_USE_COMP;
break;
default:
showUsage(argv[0]);
}
options[idx] = 1;
if (idx < (NUM_OF_NUMERIC_OPTIONS + NUM_OF_STRING_OPTIONS)) {
// c, d, r, s, a, f, l, b, m, p
if (argv[i][2] != OPTION_SEPARATOR) {
showUsage(argv[0]);
}
if (idx < NUM_OF_STRING_OPTIONS) {
// String options
// c, d, r, s, a, f
paths[idx] = &(argv[i][3]);
} else {
// Numeric options
// l, b, m, p, n
values[idx] = atoi(&(argv[i][3]));
}
} else {
// Boolean options
// v, t, u
// do nothing here
}
}
if (!checkOptionsValidity(options)) {
showUsage(argv[0]);
}
if (!options[IDX_MAXLE]) {
values[IDX_MAXLE] = DEFAULT_MAX_GOTOS_LE;
}
if (!options[IDX_MAXBM]) {
values[IDX_MAXBM] = DEFAULT_MAX_GOTOS_BM;
}
if (!options[IDX_THREADS]) {
values[IDX_THREADS] = DEFAULT_NUM_THREADS;
}
if (!options[IDX_STEAL]) {
values[IDX_STEAL] = DEFAULT_STEAL;
}
if (!options[IDX_REPEAT]) {
values[IDX_REPEAT] = DEFAULT_REPEAT;
}
if (!options[IDX_WG_SIZE]) {
values[IDX_WG_SIZE] = DEFAULT_WG_SIZE;
}
if (!options[IDX_MAX_WGS]) {
values[IDX_MAX_WGS] = DEFAULT_MAX_WGS;
}
if (!options[IDX_COMMON_NUM]) {
fprintf(stderr, "Warning: no value is given as number of common states (-C), using default: %d.\n", DEFAULT_COMMON_NUM);
values[IDX_COMMON_NUM] = DEFAULT_COMMON_NUM;
}
if (!options[IDX_UNCOMMON_LIM]) {
fprintf(stderr, "Warning: no value is given as a threshold of uncommon states to mark heavy packets (-U), using default: %d%%.\n", DEFAULT_UNCOMMON_LIM);
values[IDX_UNCOMMON_LIM] = DEFAULT_UNCOMMON_LIM;
}
if (!options[IDX_DROP_LEN]) {
values[IDX_DROP_LEN] = DEFAULT_DROP_LEN;
}
#ifdef HYBRID_SCANNER
tableMachine = NULL;
#endif
if (options[IDX_CREATE]) {
machine = createStateMachine(paths[IDX_CREATE], values[IDX_MAXLE], values[IDX_MAXBM], options[IDX_VERBOSE]);
//machine = createSimpleStateMachine(paths[0], values[0], values[1], options[8]);
#ifndef HYBRID_SCANNER
} else if (options[IDX_READ]) {
machine = createStateMachineFromDump(paths[IDX_READ]);
} else if (options[IDX_FULLTBL]) {
machine = (StateMachine*)generateTableStateMachine(paths[IDX_FULLTBL], values[IDX_COMMON_NUM], 0, NULL, paths[IDX_COMMON], options[IDX_VERBOSE]);
}
#else
} else if (options[IDX_READ] && options[IDX_FULLTBL]) {
