void parse_options(int argc, char **argv)
{
int c;
struct in_addr ip;
static struct option long_options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "binary", no_argument, NULL, 'B' },
{ "hex", no_argument, NULL, 'X' },
{ "ascii", no_argument, NULL, 'A' },
{ "text", no_argument, NULL, 'T' },
{ "ebcdic", no_argument, NULL, 'E' },
{ "html", no_argument, NULL, 'H' },
{ "utf8", required_argument, NULL, 'U' },
{ "zero", no_argument, NULL, 'Z' },
{ "xml", no_argument, NULL, 'x' },
{ "analyze", no_argument, NULL, 'a' },
{ "connections", no_argument, NULL, 'c' },
{ "filter", required_argument, NULL, 'f' },
{ "filcon", required_argument, NULL, 'F' },
{ "no-headers", no_argument, NULL, 'n' },
{ "only-source", no_argument, NULL, 's' },
{ "only-dest", no_argument, NULL, 'd' },
{ "show-mac", no_argument, NULL, 'm' },
{ "show-client", no_argument, NULL, 'i' },
{ "color", no_argument, NULL, 'k' },
{ "reverse", no_argument, NULL, 'r' },
{ "proto", required_argument, NULL, 't' },
{ "only-local", required_argument, NULL, 'l' },
{ "only-remote", required_argument, NULL, 'L' },
{ "outfile", required_argument, NULL, 'o' },
{ "concat", no_argument, NULL, 'C' },
{ "decode", no_argument, NULL, 'D' },
{ "user", required_argument, NULL, 'u' },
{ "regex", required_argument, NULL, 'e' },
{ "passwords", no_argument, NULL, 'p' },
{ "client", required_argument, NULL, 'I' },
{ 0 , 0 , 0 , 0}
};
optind = 0;
while ((c = getopt_long (argc, argv, "AaBCcDdEe:F:f:HhiI:kLlmno:prsTt:U:u:vXxZ", long_options, (int *)0)) != EOF) {
switch (c) {
case 'a':
GBL.analyze = 1;
break;
case 'c':
GBL.connections = 1;
break;
case 'D':
GBL.connections = 1;
GBL.decode = 1;
NOT_IMPLEMENTED();
break;
case 'f':
target_compile(optarg);
break;
case 'F':
filcon_compile(optarg);
break;
case 's':
GBL.only_source = 1;
break;
case 'd':
GBL.only_dest = 1;
break;
case 'k':
GBL.color = 1;
break;
case 'r':
GBL.reverse = 1;
break;
case 't':
GBL_TARGET->proto = strdup(optarg);
break;
case 'n':
GBL.no_headers = 1;
break;
case 'm':
GBL.showmac = 1;
break;
case 'i':
GBL.showclient = 1;
break;
case 'I':
if (inet_aton(optarg, &ip) == 0) {
FATAL_ERROR("Invalid client ip address");
return;
}
ip_addr_init(&GBL.client, AF_INET, (u_char *)&ip);
break;
case 'l':
GBL.only_local = 1;
break;
case 'L':
GBL.only_remote = 1;
break;
case 'u':
GBL.user = strdup(optarg);
break;
case 'p':
GBL.passwords = 1;
break;
case 'e':
set_display_regex(optarg);
break;
case 'o':
GBL_LOGFILE = strdup(optarg);
break;
case 'C':
GBL.concat = 1;
break;
case 'B':
GBL.format = &bin_format;
break;
case 'X':
GBL.format = &hex_format;
break;
case 'A':
GBL.format = &ascii_format;
break;
case 'T':
GBL.format = &text_format;
break;
case 'E':
GBL.format = &ebcdic_format;
break;
case 'H':
GBL.format = &html_format;
break;
case 'U':
set_utf8_encoding((u_char*)optarg);
GBL.format = &utf8_format;
break;
case 'Z':
GBL.format = &zero_format;
break;
case 'x':
GBL.xml = 1;
break;
case 'h':
el_usage();
break;
case 'v':
printf("%s %s\n", GBL_PROGRAM, EC_VERSION);
exit(0);
break;
case ':': // missing parameter
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
exit(0);
break;
case '?': // unknown option
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
exit(0);
break;
}
}
/* file concatenation */
if (GBL.concat) {
if (argv[optind] == NULL)
FATAL_ERROR("You MUST specify at least one logfile");
/* this function does not return */
concatenate(optind, argv);
}
/* normal file operation */
if (argv[optind])
open_log(argv[optind]);
else
FATAL_ERROR("You MUST specify a logfile\n");
/* default to ASCII view */
if (GBL.format == NULL)
GBL.format = &ascii_format;
return;
}
int main(int argc, char* arg[]){
char* compiler; /* the compiler - from enviroment flag "DMD" */
char* cmd_arg_case; /* additional arguments - from the testcase file */
char* buffer; /* general purpose buffer */
size_t bufferLen;
int index;
int modus; /* test modus: RUN NORUN COMPILE NOCOMPILE */
char* case_file;
int case_result;
int torture_result[sizeof(torture)/sizeof(char*)];
char* torture_block_global;
char* torture_block_case;
char* torture_require;
char* error_file; /* expected sourcefile containing the error */
char* error_line; /* expected error line */
char* gdb; /* the debugger - from environment flag "GDB" */
char* gdb_script; /* gdb command sequence */
char* gdb_pattern_raw; /* POSIX regexp expected in GDB's output */
#ifdef REG_EXTENDED
regex_t* gdb_pattern;
#endif
compiler = NULL;
cmd_arg_case = NULL;
buffer = NULL;
bufferLen = 0;
modus = -1;
case_file = NULL;
torture_block_global = NULL;
torture_block_case = NULL;
torture_require = NULL;
error_file = NULL;
error_line = NULL;
gdb = NULL;
gdb_script = NULL;
gdb_pattern_raw = NULL;
#ifdef REG_EXTENDED
gdb_pattern = NULL;
#endif
/* check arguments */
if(argc != 3){
err:
fprintf(stderr, "DStress test executer (revision 1083)\n"
"Copyright by Thomas Kuehne <*****@*****.**> 2005, 2006\n"
"\n");
if(argc!=0){
fprintf(stderr,
"%s <run|norun|compile|nocompile> <source>\n",
arg[0]);
}else{
fprintf(stderr,
"dstress <run|norun|compile|nocompile>"
" <source>\n");
}
fprintf(stderr, "\n"
"== eniroment settings (usually $NAME or %%NAME%%) ==\n"
"* DMD - compiler (including standard arguments)\n"
"* GDB - debugger (including standard arguments)\n");
fprintf(stderr, "\n"
"== case setting (line in the case source) ==\n"
"* __DSTRESS_DFLAGS__ - additional compiler arguments\n"
"only evaluated if it is a \"nocompile\" or \"norun\" test:\n"
"* __DSTRESS_ELINE__ - expected source line to throw an error message\n"
"* __DSTRESS_EFILE__ - expected source file to throw an error message\n"
" (defaults to the case file)\n");
fprintf(stderr,
"only evaluated if it is a \"run\" or \"norun\" test:\n"
"* __GDB_SCRIPT__ - command sequence to feed to the debugger\n"
" (use \\n to encode a line break)\n"
"* __GDB_PATTERN__ - expected regular expression in the debugger's\n"
" output\n");
fprintf(stderr, "\n"
"== note ==\n"
"* the current directory is required to contain the sub-directory \"obj\"\n"
" (used for temporary files)\n"
);
exit(EXIT_FAILURE);
}
modus = 0;
if(0==strncmp(arg[1], TORTURE_PREFIX, strlen(TORTURE_PREFIX))){
modus |= MODE_TORTURE;
arg[1] += strlen(TORTURE_PREFIX);
}
if(0==strcmp(arg[1], "run")){
modus |= MODE_RUN;
}else if(0==strcmp(arg[1], "norun")){
modus |= MODE_NORUN;
}else if(0==strcmp(arg[1], "compile")){
modus |= MODE_COMPILE;
}else if(0==strcmp(arg[1], "nocompile")){
modus |= MODE_NOCOMPILE;
}else{
goto err;
}
/* gen flags */
case_file = cleanPathSeperator(arg[2]);
compiler = getCompiler();
gdb = getGDB();
torture_block_global = getTortureBlock();
buffer = loadFile(case_file, &bufferLen);
bufferLen = 0;
cmd_arg_case = cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_DFLAGS__"));
error_line = getCaseFlag(buffer, "__DSTRESS_ELINE__");
error_file = cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_EFILE__"));
gdb_script = getCaseFlag(buffer, "__GDB_SCRIPT__");
gdb_pattern_raw = getCaseFlag(buffer, "__GDB_PATTERN__");
torture_block_case = getCaseFlag(buffer, "__DSTRESS_TORTURE_BLOCK__");
torture_require = getCaseFlag(buffer, "__DSTRESS_TORTURE_REQUIRE__");
free(buffer);
/* tmp_dir */
if(!cmd_arg_case || !cmd_arg_case[0]){
tmp_dir = TMP_DIR;
}else{
pid_t pid;
pid = getpid();
bufferLen = strlen(TMP_DIR) + 4 + sizeof(pid_t) * 4;
buffer = (char*) malloc(bufferLen);
snprintf(buffer, bufferLen, "%s/_%X", TMP_DIR, pid);
tmp_dir = cleanPathSeperator(buffer);
if(mkdir(tmp_dir, 0770)){
fprintf(stderr, "failed to create tmp dir: %s (%d, %s)\n",
tmp_dir, errno, strerror(errno));
return EXIT_FAILURE;
}
}
/* set implicit source file */
if(strcmp(error_line, "")!=0 && strcmp(error_file, "")==0){
error_file=case_file;
}
/* gdb pattern */
#ifdef REG_EXTENDED
if(gdb_pattern_raw!=NULL && gdb_pattern_raw[0]!='\x00'){
gdb_pattern = (regex_t*) malloc(sizeof(regex_t));
if(regcomp(gdb_pattern, gdb_pattern_raw, REG_EXTENDED | REG_NOSUB)){
fprintf(stderr, "failed to compile regular expression:"
"\n\t%s\n", gdb_pattern_raw);
exit(EXIT_FAILURE);
}else if(gdb_script==NULL){
fprintf(stderr, "GDB pattern without GDB script\n");
exit(EXIT_FAILURE);
}
}else{
gdb_pattern = NULL;
}
/* gdb script */
if(gdb_script!=NULL && gdb_script[0]!='\x00'){
if(gdb_pattern==NULL){
fprintf(stderr, "GDB script without GDB pattern\n");
exit(EXIT_FAILURE);
}
buffer=gdb_script;
for(; *buffer; buffer++){
if(buffer[0]=='\\'){
if(buffer[1]=='n'){
buffer[0]=' ';
buffer[1]='\n';
}
buffer++;
}
}
bufferLen = strlen(gdb_script)+11;
buffer = (char*) malloc(bufferLen);
snprintf(buffer, bufferLen, "%s\n\nquit\ny\n\n", gdb_script);
gdb_script=buffer;
}else if(gdb_script){
free(gdb_script);
gdb_script = NULL;
}
#else
if(gdb_script && strlen(gdb_script)){
if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
fprintf(stderr, "WARNING: GDB/regex support inactive\n");
}else{
fprintf(stderr, "GDB script without GDB pattern\n");
exit(EXIT_FAILURE);
}
}else if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
fprintf(stderr, "GDB pattern without GDB script\n");
exit(EXIT_FAILURE);
}
#endif /* REG_EXTENDED else */
#ifdef DEBUG
fprintf(stderr, "case : \"%s\"\n", case_file);
fprintf(stderr, "compiler: \"%s\"\n", compiler);
fprintf(stderr, "DFLAGS C: \"%s\"\n", cmd_arg_case);
fprintf(stderr, "ELINE : \"%s\"\n", error_line);
fprintf(stderr, "EFILE : \"%s\"\n", error_file);
#ifdef REG_EXTENDED
fprintf(stderr, "GDB Scri: \"%s\"\n", gdb_script);
fprintf(stderr, "GDB Patt: \"%s\"\n", gdb_pattern_raw);
#endif
fprintf(stderr, "block G : \"%s\"\n", torture_block_global);
fprintf(stderr, "block C : \"%s\"\n", torture_block_case);
fprintf(stderr, "modus : %x\n", modus);
#endif
/* let's get serious */
#ifdef USE_WINDOWS
originalStdout = GetStdHandle(STD_OUTPUT_HANDLE);
originalStderr = GetStdHandle(STD_ERROR_HANDLE);
#endif
if(modus & MODE_TORTURE){
if((modus & (MODE_COMPILE | MODE_NOCOMPILE))
&& (modus & (MODE_RUN | MODE_NORUN)))
{
fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
exit(EXIT_FAILURE);
}else if(!(modus & (MODE_COMPILE | MODE_NOCOMPILE | MODE_RUN | MODE_NORUN))){
fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
exit(EXIT_FAILURE);
}
bufferLen = strlen(torture[(sizeof(torture) / sizeof(char*))-1])
+ 128 + strlen(cmd_arg_case) + 3;
if(torture_block_case!=NULL && strlen(torture_block_case)<1){
torture_block_case=NULL;
}
buffer = (char*) malloc(bufferLen);
for(index=0; index < sizeof(torture)/sizeof(char*); index++){
if((torture_block_global && strstr(torture[index], torture_block_global))
|| (torture_block_case && strstr(torture[index], torture_block_case))
|| (torture_require && !strstr(torture[index], torture_require)))
{
torture_result[index]=RES_UNTESTED;
continue;
}
buffer[0]=0;
snprintf(buffer, bufferLen, "%s %s", torture[index], cmd_arg_case);
if(modus & (MODE_COMPILE | MODE_NOCOMPILE)){
torture_result[index] = target_compile(modus,
compiler, buffer, case_file,
error_file, error_line);
}else if(modus & (MODE_RUN | MODE_NORUN)){
torture_result[index] = target_run(modus,
compiler, buffer, case_file,
error_file, error_line
#ifdef REG_EXTENDED
, gdb, gdb_script, gdb_pattern
#endif
);
}
printf("Torture-Sub-%i/" ZU "-", index+1,
sizeof(torture)/sizeof(char*));
printResult(torture_result[index], modus, case_file,
stdout);
printf("--------\n");
}
}else{
if(torture_require && torture_require[0]){
if(!cmd_arg_case || !cmd_arg_case[0]){
cmd_arg_case = torture_require;
}else{
bufferLen = strlen(cmd_arg_case);
bufferLen += strlen(torture_require);
bufferLen += 2;
buffer = (char*) malloc(bufferLen);
snprintf(buffer, bufferLen, "%s %s", cmd_arg_case, torture_require);
cmd_arg_case = buffer;
}
}
if(modus & (MODE_RUN | MODE_NORUN)){
case_result = target_run(modus, compiler, cmd_arg_case,
case_file, error_file, error_line
#ifdef REG_EXTENDED
, gdb, gdb_script, gdb_pattern
#endif
);
}else if(modus & (MODE_COMPILE | MODE_NOCOMPILE)){
case_result = target_compile(modus, compiler,
cmd_arg_case, case_file, error_file,
error_line);
}else{
fprintf(stderr, "BUG: unhandled non-torture modus %x\n", modus);
exit(EXIT_FAILURE);
}
printf("Torture-Sub-1/" ZU "-",
sizeof(torture)/sizeof(char*));
printResult(case_result, modus, case_file, stdout);
}
if(strcmp(TMP_DIR, tmp_dir)){
bufferLen = strlen(tmp_dir);
bufferLen += strlen(RM_DIR);
bufferLen += 2;
buffer = (char*) malloc(bufferLen);
snprintf(buffer, bufferLen, "%s %s", RM_DIR, tmp_dir);
system(buffer);
}
exit(EXIT_SUCCESS);
}
