int main(int argc, char **argv){
/* extract program name from path. e.g. /path/to/MArCd -> MArCd */
const char* separator = strrchr(argv[0], '/');
if ( separator ){
program_name = separator + 1;
} else {
program_name = argv[0];
}
struct filter filter;
if ( filter_from_argv(&argc, argv, &filter) != 0 ){
return 0; /* error already shown */
}
int op, option_index = -1;
while ( (op = getopt_long(argc, argv, shortopts, longopts, &option_index)) != -1 ){
switch (op){
case 0: /* long opt */
case '?': /* unknown opt */
break;
case '1':
case '2':
case '3':
case '4':
{
const unsigned int mask = (7<<FORMAT_LAYER_BIT);
flags &= ~mask; /* reset all layer bits */
flags |= (op-'0')<<FORMAT_LAYER_BIT;
break;
}
case 'd': /* --calender */
flags |= FORMAT_DATE_STR | FORMAT_DATE_UTC;
break;
case 'D': /* --localtime */
flags |= FORMAT_DATE_STR | FORMAT_DATE_LOCALTIME;
break;
case 'a': /* --absolute */
flags &= ~FORMAT_REL_TIMESTAMP;
break;
case 'r': /* --relative */
flags |= FORMAT_REL_TIMESTAMP;
break;
case 'H': /* --headers */
flags |= FORMAT_HEADER;
break;
case 'p': /* --packets */
max_packets = atoi(optarg);
break;
case 'c': /* --packets */
max_matched_packets = atoi(optarg);
break;
case 't': /* --timeout */
{
int tmp = atoi(optarg);
timeout.tv_sec = tmp / 1000;
timeout.tv_usec = tmp % 1000 * 1000;
}
break;
case 'x': /* --hexdump */
flags |= FORMAT_HEXDUMP;
break;
case 'i': /* --iface */
iface = optarg;
break;
case ARGUMENT_VERSION: /* --version */
show_version();
return 0;
case 'h': /* --help */
show_usage();
return 0;
default:
fprintf (stderr, "%s: argument '-%c' declared but not handled\n", argv[0], op);
}
}
int ret;
/* Open stream(s) */
struct stream* stream;
if ( (ret=stream_from_getopt(&stream, argv, optind, argc, iface, "-", program_name, 0)) != 0 ) {
return ret; /* Error already shown */
}
const stream_stat_t* stat = stream_get_stat(stream);
stream_print_info(stream, stderr);
/* handle C-c */
signal(SIGINT, handle_sigint);
/* setup formatter */
struct format format;
format_setup(&format, flags);
uint64_t matched = 0;
while ( keep_running ) {
/* A short timeout is used to allow the application to "breathe", i.e
* terminate if SIGINT was received. */
struct timeval tv = timeout;
/* Read the next packet */
cap_head* cp;
ret = stream_read(stream, &cp, NULL, &tv);
if ( ret == EAGAIN ){
continue; /* timeout */
} else if ( ret != 0 ){
break; /* shutdown or error */
}
/* identify connection even if filter doesn't match so id will be
* deterministic when changing the filter */
connection_id(cp);
if ( filter_match(&filter, cp->payload, cp) ){
format_pkg(stdout, &format, cp);
matched++;
} else {
format_ignore(stdout, &format, cp);
}
if ( max_packets > 0 && stat->matched >= max_packets) {
/* Read enough pkts lets break. */
break;
}
if ( max_matched_packets > 0 && matched >= max_matched_packets) {
/* Read enough pkts lets break. */
break;
}
}
/* if ret == -1 the stream was closed properly (e.g EOF or TCP shutdown)
* In addition EINTR should not give any errors because it is implied when the
* user presses C-c */
if ( ret > 0 && ret != EINTR ){
fprintf(stderr, "stream_read() returned 0x%08X: %s\n", ret, caputils_error_string(ret));
}
/* Write stats */
fprintf(stderr, "%"PRIu64" packets read.\n", stat->read);
fprintf(stderr, "%"PRIu64" packets matched filter.\n", matched);
/* Release resources */
stream_close(stream);
filter_close(&filter);
return 0;
}
/**
* Unit tests of SelectFormat class.
*/
void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
{
const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
UnicodeString patternTestData[SELECT_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE("fem {femValue} other{even}"),
UNICODE_STRING_SIMPLE("other{odd or even}"),
UNICODE_STRING_SIMPLE("odd{The number {0, number, integer} is odd.}other{The number {0, number, integer} is even.}"),
UNICODE_STRING_SIMPLE("odd{The number {1} is odd}other{The number {1} is even}"),
};
UnicodeString formatArgs[NUM_OF_FORMAT_ARGS] = {
UNICODE_STRING_SIMPLE("fem"),
UNICODE_STRING_SIMPLE("other"),
UNICODE_STRING_SIMPLE("odd")
};
UnicodeString expFormatResult[][NUM_OF_FORMAT_ARGS] = {
{
UNICODE_STRING_SIMPLE("femValue"),
UNICODE_STRING_SIMPLE("even"),
UNICODE_STRING_SIMPLE("even")
},
{
UNICODE_STRING_SIMPLE("odd or even"),
UNICODE_STRING_SIMPLE("odd or even"),
UNICODE_STRING_SIMPLE("odd or even"),
},
{
UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
UNICODE_STRING_SIMPLE("The number {0, number, integer} is odd."),
},
{
UNICODE_STRING_SIMPLE("The number {1} is even"),
UNICODE_STRING_SIMPLE("The number {1} is even"),
UNICODE_STRING_SIMPLE("The number {1} is odd"),
}
};
UnicodeString checkSyntaxData[SELECT_SYNTAX_DATA] = {
UNICODE_STRING_SIMPLE("odd{foo}"),
UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
UNICODE_STRING_SIMPLE("odd{foo1}other{foo2}}"),
UNICODE_STRING_SIMPLE("odd{foo1}other{{foo2}"),
UNICODE_STRING_SIMPLE("odd{fo{o1}other{foo2}}")
};
UErrorCode status = U_ZERO_ERROR;
VERBOSE_USTRING(SIMPLE_PATTERN);
SelectFormat* selFmt = new SelectFormat( SIMPLE_PATTERN , status);
if (U_FAILURE(status)) {
dataerrln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
return;
}
// ======= Test SelectFormat pattern syntax.
logln("SelectFormat Unit Test : Testing SelectFormat pattern syntax.");
for (int32_t i=0; i<SELECT_SYNTAX_DATA; ++i) {
status = U_ZERO_ERROR;
VERBOSE_INT(i);
VERBOSE_USTRING(checkSyntaxData[i]);
selFmt->applyPattern(checkSyntaxData[i], status);
if (U_SUCCESS(status)){
errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]);
}
}
// ICU 4.8 does not check for duplicate keywords any more.
status = U_ZERO_ERROR;
selFmt->applyPattern("odd{foo} odd{bar} other{foobar}", status);
FieldPosition format_ignore(FieldPosition::DONT_CARE);
UnicodeString format_result;
selFmt->format(UnicodeString("odd"), format_result, format_ignore, status);
assertEquals("should use first occurrence of the 'odd' keyword", "foo", format_result);
format_result.remove();
selFmt->applyPattern("odd{foo} other{bar} other{foobar}", status);
selFmt->format(UnicodeString("other"), format_result, format_ignore, status);
assertEquals("should use first occurrence of the 'other' keyword", "bar", format_result);
delete selFmt;
selFmt = NULL;
logln("SelectFormat Unit Test : Creating format object for Testing applying various patterns");
status = U_ZERO_ERROR;
selFmt = new SelectFormat( SIMPLE_PATTERN , status);
//SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
return;
}
// ======= Test applying and formatting with various pattern
logln("SelectFormat Unit test: Testing applyPattern() and format() ...");
UnicodeString result;
FieldPosition ignore(FieldPosition::DONT_CARE);
for(int32_t i=0; i<SELECT_PATTERN_DATA; ++i) {
status = U_ZERO_ERROR;
selFmt->applyPattern(patternTestData[i], status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit Test failed to apply pattern- "+patternTestData[i] );
continue;
}
//Format with the keyword array
for(int32_t j=0; j<3; j++) {
result.remove();
selFmt->format( formatArgs[j], result , ignore , status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit test failed in format() with argument: "+ formatArgs[j] + " and error is " + u_errorName(status) );
}else{
if( result != expFormatResult[i][j] ){
errln("ERROR: SelectFormat Unit test failed in format() with unexpected result\n with argument: "+ formatArgs[j] + "\n result obtained: " + result + "\n and expected is: " + expFormatResult[i][j] );
}
}
}
}
//Test with an invalid keyword
// one which contains Pattern_Syntax or Pattern_White_Space.
logln("SelectFormat Unit test: Testing format() with keyword method and with invalid keywords...");
status = U_ZERO_ERROR;
result.remove();
UnicodeString keywords[] = {
"9Keyword-_",
"-Keyword-_",
"_Keyword-_",
"\\u00E9Keyword-_",
"Key word-_",
" Keyword-_",
"Key*word-_",
"*Keyword-_"
};
delete selFmt;
selFmt = NULL;
selFmt = new SelectFormat( SIMPLE_PATTERN , status);
for (int32_t i = 0; i < UPRV_LENGTHOF(keywords); i++ ){
status = U_ZERO_ERROR;
selFmt->format( keywords[i], result , ignore , status);
if (!U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+
keywords[i]+" ("+u_errorName(status)+")");
}
}
delete selFmt;
}
