int main(int argc, char *argv[])
{
static char report[1024];
printf("PJSIP Performance Measurement Tool v%s\n"
"(c)2006 pjsip.org\n\n",
PJ_VERSION);
if (create_app() != 0)
return 1;
if (init_options(argc, argv) != 0)
return 1;
if (init_sip() != 0)
return 1;
if (init_media() != 0)
return 1;
pj_log_set_level(app.log_level);
if (app.log_level > 4) {
pjsip_endpt_register_module(app.sip_endpt, &msg_logger);
}
/* Misc infos */
if (app.client.dst_uri.slen != 0) {
if (app.client.method.id == PJSIP_INVITE_METHOD) {
if (app.client.stateless) {
PJ_LOG(3,(THIS_FILE,
"Info: --stateless option makes no sense for INVITE,"
" ignored."));
}
}
}
if (app.client.dst_uri.slen) {
/* Client mode */
pj_status_t status;
char test_type[64];
unsigned msec_req, msec_res;
unsigned i;
/* Get the job name */
if (app.client.method.id == PJSIP_INVITE_METHOD) {
pj_ansi_strcpy(test_type, "INVITE calls");
} else if (app.client.stateless) {
pj_ansi_sprintf(test_type, "stateless %.*s requests",
(int)app.client.method.name.slen,
app.client.method.name.ptr);
} else {
pj_ansi_sprintf(test_type, "stateful %.*s requests",
(int)app.client.method.name.slen,
app.client.method.name.ptr);
}
printf("Sending %d %s to '%.*s' with %d maximum outstanding jobs, please wait..\n",
app.client.job_count, test_type,
(int)app.client.dst_uri.slen, app.client.dst_uri.ptr,
app.client.job_window);
for (i=0; i<app.thread_count; ++i) {
status = pj_thread_create(app.pool, NULL, &client_thread,
(void*)(long)i, 0, 0, &app.thread[i]);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create thread", status);
return 1;
}
}
for (i=0; i<app.thread_count; ++i) {
pj_thread_join(app.thread[i]);
app.thread[i] = NULL;
}
if (app.client.last_completion.sec) {
pj_time_val duration;
duration = app.client.last_completion;
PJ_TIME_VAL_SUB(duration, app.client.first_request);
msec_res = PJ_TIME_VAL_MSEC(duration);
} else {
msec_res = app.client.timeout * 1000;
}
if (msec_res == 0) msec_res = 1;
if (app.client.requests_sent.sec) {
pj_time_val duration;
duration = app.client.requests_sent;
PJ_TIME_VAL_SUB(duration, app.client.first_request);
msec_req = PJ_TIME_VAL_MSEC(duration);
} else {
msec_req = app.client.timeout * 1000;
}
if (msec_req == 0) msec_req = 1;
if (app.client.job_submitted < app.client.job_count)
puts("\ntimed-out!\n");
else
puts("\ndone.\n");
pj_ansi_snprintf(
report, sizeof(report),
"Total %d %s sent in %d ms at rate of %d/sec\n"
"Total %d responses receieved in %d ms at rate of %d/sec:",
app.client.job_submitted, test_type, msec_req,
app.client.job_submitted * 1000 / msec_req,
app.client.total_responses, msec_res,
app.client.total_responses*1000/msec_res);
write_report(report);
/* Print detailed response code received */
pj_ansi_sprintf(report, "\nDetailed responses received:");
write_report(report);
for (i=0; i<PJ_ARRAY_SIZE(app.client.response_codes); ++i) {
const pj_str_t *reason;
if (app.client.response_codes[i] == 0)
continue;
reason = pjsip_get_status_text(i);
pj_ansi_snprintf( report, sizeof(report),
" - %d responses: %7d (%.*s)",
i, app.client.response_codes[i],
(int)reason->slen, reason->ptr);
write_report(report);
}
/* Total responses and rate */
pj_ansi_snprintf( report, sizeof(report),
" ------\n"
" TOTAL responses: %7d (rate=%d/sec)\n",
app.client.total_responses,
app.client.total_responses*1000/msec_res);
write_report(report);
pj_ansi_sprintf(report, "Maximum outstanding job: %d",
app.client.stat_max_window);
write_report(report);
} else {
/* Server mode */
char s[10], *unused;
pj_status_t status;
unsigned i;
puts("pjsip-perf started in server-mode");
printf("Receiving requests on the following URIs:\n"
" sip:0@%.*s:%d%s for stateless handling\n"
" sip:1@%.*s:%d%s for stateful handling\n"
" sip:2@%.*s:%d%s for call handling\n",
(int)app.local_addr.slen,
app.local_addr.ptr,
app.local_port,
(app.use_tcp ? ";transport=tcp" : ""),
(int)app.local_addr.slen,
app.local_addr.ptr,
app.local_port,
(app.use_tcp ? ";transport=tcp" : ""),
(int)app.local_addr.slen,
app.local_addr.ptr,
app.local_port,
(app.use_tcp ? ";transport=tcp" : ""));
printf("INVITE with non-matching user part will be handled call-statefully\n");
for (i=0; i<app.thread_count; ++i) {
status = pj_thread_create(app.pool, NULL, &server_thread,
(void*)(long)i, 0, 0, &app.thread[i]);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create thread", status);
return 1;
}
}
puts("\nPress <ENTER> to quit\n");
fflush(stdout);
unused = fgets(s, sizeof(s), stdin);
PJ_UNUSED_ARG(unused);
app.thread_quit = PJ_TRUE;
for (i=0; i<app.thread_count; ++i) {
pj_thread_join(app.thread[i]);
app.thread[i] = NULL;
}
puts("");
}
destroy_app();
return 0;
}
/*
* Start the Lua interpreter, export IMAP core and system functions, load the
* Lua interface functions, load and execute imapfilter's configuration file.
*/
void
start_lua()
{
lua = luaL_newstate();
luaL_openlibs(lua);
luaopen_ifcore(lua);
luaopen_ifsys(lua);
luaopen_ifre(lua);
lua_settop(lua, 0);
init_options();
if (luaL_loadfile(lua, PATHNAME_COMMON) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_SET) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_REGEX) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_ACCOUNT) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_MAILBOX) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_MESSAGE) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_OPTIONS) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (luaL_loadfile(lua, PATHNAME_AUXILIARY) ||
lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
if (opts.oneline != NULL) {
if (luaL_loadbuffer(lua, opts.oneline, strlen(opts.oneline),
"=<command line>") || lua_pcall(lua, 0, LUA_MULTRET, 0))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
} else {
if (luaL_loadfile(lua, strcmp(opts.config, "-") == 0 ? NULL :
opts.config))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
lua_pushcfunction(lua, traceback_handler);
lua_insert(lua, 1);
if (lua_pcall(lua, 0, LUA_MULTRET, -2))
fatal(ERROR_CONFIG, "%s\n", lua_tostring(lua, -1));
}
if (opts.interactive)
interactive_mode();
}
int main(int argc, char *argv[])
{
int c;
char optstring[] = "hcdz0123456789o:S:kfqVvNnt";
int long_only_flag;
int ret = 0;
int bad_option = 0;
int bad_level = 0;
int bad_c = 0;
struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"stdout", no_argument, NULL, 'c'},
{"to-stdout", no_argument, NULL, 'c'},
{"compress", no_argument, NULL, 'z'},
{"decompress", no_argument, NULL, 'd'},
{"uncompress", no_argument, NULL, 'd'},
{"keep", no_argument, NULL, 'k'},
{"rm", no_argument, &long_only_flag, RM},
{"suffix", no_argument, NULL, 'S'},
{"fast", no_argument, NULL, '1'},
{"best", no_argument, NULL, '0' + ISAL_DEF_MAX_LEVEL},
{"force", no_argument, NULL, 'f'},
{"quiet", no_argument, NULL, 'q'},
{"version", no_argument, NULL, 'V'},
{"verbose", no_argument, NULL, 'v'},
{"no-name", no_argument, NULL, 'n'},
{"name", no_argument, NULL, 'N'},
{"test", no_argument, NULL, 't'},
/* Possible future extensions
{"recursive, no_argument, NULL, 'r'},
{"list", no_argument, NULL, 'l'},
{"benchmark", optional_argument, NULL, 'b'},
{"benchmark_end", required_argument, NULL, 'e'},
{"threads", optional_argument, NULL, 'T'},
*/
{0, 0, 0, 0}
};
init_options(&global_options);
opterr = 0;
while ((c = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
if (c >= '0' && c <= '9') {
if (c > '0' + ISAL_DEF_MAX_LEVEL)
bad_level = 1;
else
global_options.level = c - '0';
continue;
}
switch (c) {
case 0:
switch (long_only_flag) {
case RM:
global_options.remove = true;
break;
default:
bad_option = 1;
bad_c = c;
break;
}
break;
case 'o':
global_options.outfile_name = optarg;
global_options.outfile_name_len = strlen(global_options.outfile_name);
break;
case 'c':
global_options.use_stdout = true;
break;
case 'z':
global_options.mode = COMPRESS_MODE;
break;
case 'd':
global_options.mode = DECOMPRESS_MODE;
break;
case 'S':
global_options.suffix = optarg;
global_options.suffix_len = strlen(global_options.suffix);
break;
case 'k':
global_options.remove = false;
break;
case 'f':
global_options.force = true;
break;
case 'q':
global_options.quiet_level++;
break;
case 'v':
global_options.verbose_level++;
break;
case 'V':
print_version();
return 0;
case 'N':
global_options.name = YES_NAME;
break;
case 'n':
global_options.name = NO_NAME;
break;
case 't':
global_options.test = TEST;
global_options.mode = DECOMPRESS_MODE;
break;
case 'h':
usage(0);
default:
bad_option = 1;
bad_c = optopt;
break;
}
}
if (bad_option) {
log_print(ERROR, "igzip: invalid option ");
if (bad_c)
log_print(ERROR, "-%c\n", bad_c);
else
log_print(ERROR, ("\n"));
usage(BAD_OPTION);
}
if (bad_level) {
log_print(ERROR, "igzip: invalid compression level\n");
usage(BAD_LEVEL);
}
if (global_options.outfile_name && optind < argc - 1) {
log_print(ERROR,
"igzip: An output file may be specified with only one input file\n");
return 0;
}
if (global_options.mode == COMPRESS_MODE) {
if (optind >= argc)
compress_file();
while (optind < argc) {
global_options.infile_name = argv[optind];
global_options.infile_name_len = strlen(global_options.infile_name);
ret |= compress_file();
optind++;
}
} else if (global_options.mode == DECOMPRESS_MODE) {
if (optind >= argc)
decompress_file();
while (optind < argc) {
global_options.infile_name = argv[optind];
global_options.infile_name_len = strlen(global_options.infile_name);
ret |= decompress_file();
optind++;
}
}
return ret;
}
/*argc is a count of the arguments supplied to the program and argc[] is an array of pointers to the strings which are those arguments-its type is array of pointer to char
*/
void get_options (int argc, char* argv[])
{
int op;
bool is_valid = TRUE;
/*set memory for the point which is decleared in struct.h*/
AllocVar(po);
/*Initialize the point*/
init_options();
/*The getopt function gets the next option argument from the argument list specified by the argv and argc arguments.
*Normally these values come directly from the arguments received by main
*/
/*An option character in this string can be followed by a colon (:) to indicate that it takes a required argument.
*If an option character is followed by two colons (::), its argument is optional
*if an option character is followed by no colons, it does not need argument
*/
while ((op = getopt(argc, argv, "i:b:q:r:dsf:k:o:c:h")) >0)
{
switch (op)
{
/*optarg is set by getopt to point at the value of the option argument, for those options that accept arguments*/
case 'i': strcpy(po->FN, optarg); break;
case 'b': strcpy(po->BN, optarg); break;
/*atof can convert string to double*/
case 'q': po->QUANTILE = atof(optarg); break;
/*atoi can convert string to integer*/
case 'r': po->DIVIDED = atoi(optarg); break;
case 'd': po->IS_DISCRETE = TRUE; break;
case 's': po->IS_SWITCH = TRUE; break;
case 'f': po->FILTER = atof(optarg); break;
case 'k': po->COL_WIDTH = atoi(optarg); break;
case 'c': po->TOLERANCE = atof(optarg); break;
case 'o':
po->RPT_BLOCK = atoi(optarg);
po->SCH_BLOCK = 2*po->RPT_BLOCK;
/* ensure enough searching space */
/*if (po->SCH_BLOCK < 1000) po->SCH_BLOCK = 1000;*/
break;
/*puts writes the C string pointed by str to stdout and appends a newline character ('\n')*/
/*exit(0) causes the program to exit with a successful termination
*break is normally used to jump to the end of the current block of code
*exit is normally used to shut down the current process
*/
case 'h': puts(USAGE); exit(0);
/*if expression does not match any constant-expression, control is transferred to the statement(s) that follow the optional default label*/
default : is_valid = FALSE;
}
}
/* basic sanity check */
if (is_valid && po->FN[0] == ' ')
{
/*errAbort("You must specify input file (-i)");*/
puts(USAGE);
exit(0);
}
if (is_valid)
{
po->FP = mustOpen(po->FN, "r");
}
if (po->IS_SWITCH)
{
po->IS_DISCRETE = TRUE;
po->FB = mustOpen(po->BN, "r");
}
/* option value range check */
if ((po->QUANTILE >.5) || (po->QUANTILE <= 0))
{
err("-q quantile discretization should be (0,.5]");
is_valid = FALSE;
}
if ((po->FILTER > 1) || (po->FILTER < 0))
{
err("-f overlapping filtering should be [0,1.]");
is_valid = FALSE;
}
if ((po->TOLERANCE > 1) || (po->TOLERANCE <= .5))
{
err("-c noise ratio should be (.5,1]");
is_valid = FALSE;
}
if (po->COL_WIDTH < 2 && po->COL_WIDTH != -1)
{
err("-k minimum column width should be >=2");
is_valid = FALSE;
}
if (po->RPT_BLOCK <= 0)
{
err("-n number of blocks to report should be >0");
is_valid = FALSE;
}
if (!is_valid)
errAbort("Type -h to view possible options");
}
virtual void attached (HELEMENT he )
{
dom::element el = he;
init_options(el);
el.update();
}
int main(int argc, char **argv){
struct options *opt;
int ie=0;
FILE *fp;
char *line;
int c;
int num_RNG_edge = 0;
struct edge_d RNG_edge_d;
//struct edge_table RNG_tbl;
//float **dmat;
float **RNG_d_tbl;
float *min_stack;
int min_stack_len;
float maxmin = 0;
int i,j,k,l;
/* (* check options */
opt = alloc_options();
init_options(opt);
get_options(argc-1, argv+1, opt);
if((*opt).loop == 0){
(*opt).loop = (*opt).dsize;
}
if(argc == 1){
(*opt).help = 1;
}
if((*opt).help == 1){
help();
ie = 1;
}
if((*opt).stat == 1){
status();
ie = 1;
}
if((*opt).check == 1){
check_options(opt);
ie = 1;
}
if(ie == 1){
exit(0);
}
/* *) */
/* (* read RNG_d */
//must be rewrite
line = c_alloc_vec(LEN);
if((fp = fopen((*opt).ef,"r")) == NULL){
perror((*opt).ef);
exit(1);
}
num_RNG_edge = 0;
while((c=fgetc(fp)) != EOF){
if((char)c == '\n'){
num_RNG_edge++;
}
}
//printf("num_RNG_edge:%d:\n",num_RNG_edge);
fseek(fp,0U,SEEK_SET);
RNG_edge_d.p = i_alloc_vec(num_RNG_edge);
RNG_edge_d.t = i_alloc_vec(num_RNG_edge);
RNG_edge_d.d = f_alloc_vec(num_RNG_edge);
i = 0;
while((fgets(line,LEN,fp)) != NULL){
sscanf(line,"%d %d %f",RNG_edge_d.p+i,RNG_edge_d.t+i,RNG_edge_d.d+i);
i++;
}
fclose(fp);
//check
/*
for(i=0;i<num_RNG_edge;i++){
printf("%d %d %f\n",RNG_edge_d.p[i],RNG_edge_d.t[i],RNG_edge_d.d[i]);
}
*/
/* *) */
/* (* create RNG_d_tbl */
//must be rewite
RNG_d_tbl = f_calloc_mat((*opt).dsize,(*opt).dsize);
for(i=0;i<(*opt).dsize;i++){
for(j=0;j<(*opt).dsize;j++){
RNG_d_tbl[i][j] = -1;
}
}
for(i=0;i<num_RNG_edge;i++){
RNG_d_tbl[RNG_edge_d.p[i]][RNG_edge_d.t[i]] = RNG_edge_d.d[i];
RNG_d_tbl[RNG_edge_d.t[i]][RNG_edge_d.p[i]] = RNG_edge_d.d[i];
}
//check
/*
printf("dsize:%d:\n",(*opt).dsize);
for(i=0;i<(*opt).dsize;i++){
for(j=0;j<(*opt).dsize;j++){
printf(" %f",RNG_d_tbl[i][j]);
}
printf("\n");
}
*/
/* *) */
/* (* refine RNG_d_tbl */
min_stack = f_alloc_vec((*opt).dsize);
//for l in loop
for(l=0;l<(*opt).loop;l++){
//for i in row
for(i=0;i<(*opt).dsize;i++){
//for j in row
for(j=0;j<(*opt).dsize;j++){
//for k in column
//min_stack_len = 0;
maxmin = 0;
min_stack_len = 0;
for(k=0;k<(*opt).dsize;k++){
//comp(dmat[i] dmat[j])
//if dmat[i][k]!=0, dmat[j][k]!=0
//Func1
//if((RNG_d_tbl[i][k] != -1) && (RNG_d_tbl[j][k] != -1)){
if((RNG_d_tbl[i][k] >= 0) && (RNG_d_tbl[j][k] >= 0)){
//add max(pair) to min_stack; nim_stack_len++;
min_stack[min_stack_len] = max(RNG_d_tbl[i][k],RNG_d_tbl[j][k]);
min_stack_len++;
}
//end for k
}
//min of nim_stack
//Func2
maxmin = f_min_list(min_stack_len,min_stack); // ?? can rewrite maxmin ??
if((*opt).diag==1 && i==j){ maxmin = -1; } // ?? needs ??
//printf("maxmin:%f:\n",maxmin);
//rewrite RNG_d_tbl[i][j] <- nim(nin_stack);
if(min_stack_len > 0){
// must be replaced!!
//Func3
if(RNG_d_tbl[i][j] >= 0){
maxmin = min(maxmin,RNG_d_tbl[i][j]);
}
RNG_d_tbl[i][j] = maxmin;
}
//end for j
}
//end for i
}
//end for l
}
/* *) */
/* (* print results */
//printf("result after %d times loop:\n",l);
if((*opt).zeroself == 1){
for(i=0;i<(*opt).dsize;i++){
RNG_d_tbl[i][i] = 0;
}
}
for(i=0;i<(*opt).dsize;i++){
printf("%f",RNG_d_tbl[i][0]);
for(j=1;j<(*opt).dsize;j++){
printf(" %f",RNG_d_tbl[i][j]);
}
printf("\n");
}
/* *) */
return(0);
}
int main(int argc, char **argv){
if (setlocale(LC_ALL,"") == NULL){
fprintf(stderr,"locale unknown\n");
return -1;
}
init_options();
parse_options(argc, argv);
if (GlobalArgs.help){
display_usage();
}
if (GlobalArgs.cmd == NULL){
display_usage();
exit(1);
}
fprintf(stdout,"p = %d\n", GlobalArgs.P);
fprintf(stdout,"t = %f\n", GlobalArgs.threshold);
fprintf(stdout,"n = %f\n", GlobalArgs.nbsecs);
if (!strcmp(GlobalArgs.cmd, "build")){
if (GlobalArgs.dir_name == NULL || GlobalArgs.index_name == NULL){
fprintf(stderr,"not enough input args\n");
exit(1);
}
fprintf(stdout,"add files in %s dir to index %s\n",\
GlobalArgs.dir_name, GlobalArgs.index_name);
if (addtoaudioindex(GlobalArgs.dir_name,GlobalArgs.index_name,GlobalArgs.sr,\
GlobalArgs.nbsecs,GlobalArgs.P) < 0){
fprintf(stdout,"unable to complete command\n");
}
} else if (!strcmp(GlobalArgs.cmd, "combine")){
fprintf(stdout,"not yet implemented\n");
} else if (!strcmp(GlobalArgs.cmd, "stat")){
if (GlobalArgs.index_name == NULL){
fprintf(stderr,"no index name given\n");
exit(1);
}
fprintf(stdout,"information on table");
print_audioindex_info(GlobalArgs.index_name);
} else if (!strcmp(GlobalArgs.cmd, "query")){
if (GlobalArgs.dir_name == NULL || GlobalArgs.index_name == NULL){
fprintf(stderr,"not enough inptu args\n");
exit(1);
}
fprintf(stdout,"query files in %s against index %s\n",\
GlobalArgs.dir_name, GlobalArgs.index_name);
if (queryaudioindex(GlobalArgs.dir_name,GlobalArgs.index_name,GlobalArgs.sr,\
GlobalArgs.blocksize, GlobalArgs.nbsecs,GlobalArgs.threshold,GlobalArgs.P) < 0){
fprintf(stdout,"unable to complete query\n");
}
} else if (!strcmp(GlobalArgs.cmd, "start")){
fprintf(stdout," %s not yet implemented\n",GlobalArgs.cmd);
} else if (!strcmp(GlobalArgs.cmd, "stop")){
fprintf(stdout," %s not yet implemented\n", GlobalArgs.cmd);
} else {
fprintf(stdout," %s is unknown command\n", GlobalArgs.cmd);
display_usage();
}
return 0;
}
SANE_Status
sane_open (SANE_String_Const devicename, SANE_Handle * handle)
{
Mustek_Usb_Device *dev;
SANE_Status status;
Mustek_Usb_Scanner *s;
SANE_Int value;
DBG (5, "sane_open: start (devicename = `%s')\n", devicename);
if (devicename[0])
{
for (dev = first_dev; dev; dev = dev->next)
if (strcmp (dev->sane.name, devicename) == 0)
break;
if (!dev)
{
DBG (5,
"sane_open: couldn't find `%s' in devlist, trying attach)\n",
devicename);
RIE (attach (devicename, &dev, SANE_TRUE));
}
else
DBG (5, "sane_open: found `%s' in devlist\n", dev->name);
}
else
{
/* empty devicname -> use first device */
dev = first_dev;
if (dev)
DBG (5, "sane_open: empty devicename, trying `%s'\n", dev->name);
}
if (!dev)
return SANE_STATUS_INVAL;
if (dev->chip->scanner_type == MT_UNKNOWN)
{
DBG (0, "sane_open: the type of your scanner is unknown, edit "
"mustek_usb.conf before using the scanner\n");
return SANE_STATUS_INVAL;
}
s = malloc (sizeof (*s));
if (!s)
return SANE_STATUS_NO_MEM;
memset (s, 0, sizeof (*s));
s->hw = dev;
RIE (init_options (s));
/* insert newly opened handle into list of open handles: */
s->next = first_handle;
first_handle = s;
*handle = s;
strcpy (s->hw->device_name, dev->name);
RIE (usb_high_scan_turn_power (s->hw, SANE_TRUE));
RIE (usb_high_scan_back_home (s->hw));
s->hw->scan_buffer = (SANE_Byte *) malloc (SCAN_BUFFER_SIZE * 2);
if (!s->hw->scan_buffer)
{
DBG (5, "sane_open: couldn't malloc s->hw->scan_buffer (%d bytes)\n",
SCAN_BUFFER_SIZE * 2);
return SANE_STATUS_NO_MEM;
}
s->hw->scan_buffer_len = 0;
s->hw->scan_buffer_start = s->hw->scan_buffer;
s->hw->temp_buffer = (SANE_Byte *) malloc (SCAN_BUFFER_SIZE);
if (!s->hw->temp_buffer)
{
DBG (5, "sane_open: couldn't malloc s->hw->temp_buffer (%d bytes)\n",
SCAN_BUFFER_SIZE);
return SANE_STATUS_NO_MEM;
}
s->hw->temp_buffer_len = 0;
s->hw->temp_buffer_start = s->hw->temp_buffer;
for (value = 0; value < 256; value++)
{
s->linear_gamma_table[value] = value;
s->red_gamma_table[value] = value;
s->green_gamma_table[value] = value;
s->blue_gamma_table[value] = value;
s->gray_gamma_table[value] = value;
}
s->red_table = s->linear_gamma_table;
s->green_table = s->linear_gamma_table;
s->blue_table = s->linear_gamma_table;
s->gray_table = s->linear_gamma_table;
DBG (5, "sane_open: exit\n");
return SANE_STATUS_GOOD;
}
void get_options (int argc, char* argv[])
{
int op;
bool is_valid = TRUE;
AllocVar(po);
init_options();
while ((op = getopt(argc, argv, "i:q:r:dbe:f:k:o:c:hz")) >0)
{
switch (op)
{
case 'i': strcpy(po->FN, optarg); break;
case 'q': po->QUANTILE = atof(optarg); break;
case 'r': po->DIVIDED = atoi(optarg); break;
case 'd': po->IS_DISCRETE = TRUE; break;
case 'f': po->FILTER = atof(optarg); break;
case 'k': po->COL_WIDTH = atoi(optarg); break;
case 'c': po->TOLERANCE = atof(optarg); break;
case 'o':
po->RPT_BLOCK = atoi(optarg);
po->SCH_BLOCK = 2 * po->RPT_BLOCK;
/* ensure enough searching space */
/*if (po->SCH_BLOCK < 1000) po->SCH_BLOCK = 1000;*/
break;
case 'h': puts(USAGE); exit(0);
default : is_valid = FALSE;
}
}
/* basic sanity check */
if (is_valid && po->FN[0] == ' ')
{
errAbort("You must specify input file (-i)");
}
po->FP = mustOpen(po->FN, "r");
/* option value range check */
if ((po->QUANTILE >.5) || (po->QUANTILE <= 0))
{
err("-q quantile discretization should be (0,.5]");
is_valid = FALSE;
}
if ((po->FILTER > 1) || (po->FILTER < 0))
{
err("-f overlapping filtering should be [0,1.]");
is_valid = FALSE;
}
if ((po->TOLERANCE > 1) || (po->TOLERANCE <= .5))
{
err("-c conservativeness should be (.5,1]");
is_valid = FALSE;
}
if (po->COL_WIDTH < 2 && po->COL_WIDTH != -1)
{
err("-k minimum column width should be >=2");
is_valid = FALSE;
}
if (po->RPT_BLOCK <= 0)
{
err("-o number of blocks to report should be >0");
is_valid = FALSE;
}
if (!is_valid)
errAbort("Type -h to view possible options");
}
int main(int argc,char **argv)
{
sint i,j,k,n,s;
sint status;
char c;
char infile[FILENAMELEN+1];
char treefile[FILENAMELEN+1];
FILE *tree;
sint maxres,*gapptr=NULL;
IN_TREEPTR itree;
double dscore;
sint window;
OPT opt;
if(argc!=2) {
fprintf(stdout,"Usage: %s input_aln\n",argv[0]);
exit(1);
}
strcpy(infile,argv[1]);
window=8;
init_options(&opt);
/* read in the sequences */
seq_input(infile,opt.explicit_type,FALSE,&mult_aln);
if(mult_aln.nseqs<=0) {
error("No sequences in %s\n",infile);
exit(1);
}
/* count pairwise residue percent identities */
tmat = (double **) ckalloc( (mult_aln.nseqs+1) * sizeof (double *) );
for(i=0;i<mult_aln.nseqs;i++)
tmat[i] = (double *)ckalloc( (mult_aln.nseqs+1) * sizeof (double) );
for (i=0;i<mult_aln.nseqs;i++) {
for (j=i+1;j<mult_aln.nseqs;j++) {
dscore = countid1(mult_aln.seqs[i],mult_aln.seqs[j]);
tmat[j][i] = tmat[i][j] = (100.0 - dscore)/100.0;
}
}
/* make a tree from the percent identities (used for sequence weighting) */
/*strcpy(treefile,infile);
strcat(treefile,".ph");*/
strcpy(treefile,".ph");
if((tree = open_explicit_file(treefile))==NULL) exit(1);
guide_tree(tree,mult_aln.seqs,mult_aln.nseqs, tmat, QUICKNJ);
itree=(IN_TREEPTR)ckalloc(sizeof(IN_TREE));
status = read_tree(treefile, mult_aln.seqs, 0, mult_aln.nseqs,itree);
if (status < 0) exit(1);
seq_weight = calc_seq_weights(0,mult_aln.nseqs,itree,FALSE);
free_tree(itree);
remove(treefile);
/* find the start and end positions of each sequence */
is = (sint *)ckalloc((mult_aln.nseqs+1) * sizeof(sint));
ie = (sint *)ckalloc((mult_aln.nseqs+1) * sizeof(sint));
for(s=0;s<mult_aln.nseqs;s++) {
is[s]=0;
ie[s] = mult_aln.seqs[s].len;
for (i=0; i<mult_aln.seqs[s].len; i++) {
c = mult_aln.seqs[s].data[i];
if (!isalpha(c))
is[s]++;
else
break;
}
for (i=mult_aln.seqs[s].len-1; i>=0; i--) {
c = mult_aln.seqs[s].data[i];
if (!isalpha(c))
ie[s]--;
else
break;
}
}
matrix.format=0;
maxres = get_cl_matrix(FALSE, gon250mt, gapptr, TRUE, 100, &matrix);
/* get the global core blocks */
all_blocks(window);
for(i=0;i<mult_aln.nseqs;i++)
ckfree(tmat[i]);
ckfree(tmat);
}
int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int argc = __argc;
char **argv = __argv;
#else
int main(int argc, char *argv[])
{
#endif
int seed = time(NULL);
bool verifyexit = false;
bool check_all_mods = false;
// Set default file paths
#ifdef PREFIX
#define Q(STR) #STR
#define QUOTE(STR) Q(STR)
PATH_INFO::init_base_path(std::string(QUOTE(PREFIX)));
#else
PATH_INFO::init_base_path("");
#endif
#if (defined USE_HOME_DIR || defined USE_XDG_DIR)
PATH_INFO::init_user_dir();
#else
PATH_INFO::init_user_dir("./");
#endif
PATH_INFO::set_standard_filenames();
MAP_SHARING::setDefaults();
{
const char *section_default = nullptr;
const char *section_map_sharing = "Map sharing";
const char *section_user_directory = "User directories";
const arg_handler first_pass_arguments[] = {
{
"--seed", "<string of letters and or numbers>",
"Sets the random number generator's seed value",
section_default,
[&seed](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
const unsigned char *hash_input = (const unsigned char *) params[0];
seed = djb2_hash(hash_input);
return 1;
}
},
{
"--jsonverify", nullptr,
"Checks the cdda json files",
section_default,
[&verifyexit](int, const char **) -> int {
verifyexit = true;
return 0;
}
},
{
"--check-mods", nullptr,
"Checks the json files belonging to cdda mods",
section_default,
[&check_all_mods](int, const char **) -> int {
check_all_mods = true;
return 0;
}
},
{
"--basepath", "<path>",
"Base path for all game data subdirectories",
section_default,
[](int num_args, const char **params) {
if (num_args < 1) return -1;
PATH_INFO::init_base_path(params[0]);
PATH_INFO::set_standard_filenames();
return 1;
}
},
{
"--shared", nullptr,
"Activates the map-sharing mode",
section_map_sharing,
[](int, const char **) -> int {
MAP_SHARING::setSharing(true);
MAP_SHARING::setCompetitive(true);
MAP_SHARING::setWorldmenu(false);
return 0;
}
},
{
"--username", "<name>",
"Instructs map-sharing code to use this name for your character.",
section_map_sharing,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
MAP_SHARING::setUsername(params[0]);
return 1;
}
},
{
"--addadmin", "<username>",
"Instructs map-sharing code to use this name for your character and give you "
"access to the cheat functions.",
section_map_sharing,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
MAP_SHARING::addAdmin(params[0]);
return 1;
}
},
{
"--adddebugger", "<username>",
"Informs map-sharing code that you're running inside a debugger",
section_map_sharing,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
MAP_SHARING::addDebugger(params[0]);
return 1;
}
},
{
"--competitive", nullptr,
"Instructs map-sharing code to disable access to the in-game cheat functions",
section_map_sharing,
[](int, const char **) -> int {
MAP_SHARING::setCompetitive(true);
return 0;
}
},
{
"--userdir", "<path>",
"Base path for user-overrides to files from the ./data directory and named below",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::init_user_dir(params[0]);
PATH_INFO::set_standard_filenames();
return 1;
}
}
};
// The following arguments are dependent on one or more of the previous flags and are run
// in a second pass.
const arg_handler second_pass_arguments[] = {
{
"--worldmenu", nullptr,
"Enables the world menu in the map-sharing code",
section_map_sharing,
[](int, const char **) -> int {
MAP_SHARING::setWorldmenu(true);
return true;
}
},
{
"--datadir", "<directory name>",
"Sub directory from which game data is loaded",
nullptr,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("datadir", params[0]);
PATH_INFO::update_datadir();
return 1;
}
},
{
"--savedir", "<directory name>",
"Subdirectory for game saves",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("savedir", params[0]);
return 1;
}
},
{
"--configdir", "<directory name>",
"Subdirectory for game configuration",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("config_dir", params[0]);
PATH_INFO::update_config_dir();
return 1;
}
},
{
"--memorialdir", "<directory name>",
"Subdirectory for memorials",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("memorialdir", params[0]);
return 1;
}
},
{
"--optionfile", "<filename>",
"Name of the options file within the configdir",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("options", params[0]);
return 1;
}
},
{
"--keymapfile", "<filename>",
"Name of the keymap file within the configdir",
section_user_directory,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("keymap", params[0]);
return 1;
}
},
{
"--autopickupfile", "<filename>",
"Name of the autopickup options file within the configdir",
nullptr,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("autopickup", params[0]);
return 1;
}
},
{
"--motdfile", "<filename>",
"Name of the message of the day file within the motd directory",
nullptr,
[](int num_args, const char **params) -> int {
if (num_args < 1) return -1;
PATH_INFO::update_pathname("motd", params[0]);
return 1;
}
},
};
// Process CLI arguments.
const size_t num_first_pass_arguments =
sizeof(first_pass_arguments) / sizeof(first_pass_arguments[0]);
const size_t num_second_pass_arguments =
sizeof(second_pass_arguments) / sizeof(second_pass_arguments[0]);
int saved_argc = --argc; // skip program name
const char **saved_argv = (const char **)++argv;
while (argc) {
if(!strcmp(argv[0], "--help")) {
printHelpMessage(first_pass_arguments, num_first_pass_arguments,
second_pass_arguments, num_second_pass_arguments);
return 0;
} else {
bool arg_handled = false;
for (size_t i = 0; i < num_first_pass_arguments; ++i) {
auto &arg_handler = first_pass_arguments[i];
if (!strcmp(argv[0], arg_handler.flag)) {
argc--;
argv++;
int args_consumed = arg_handler.handler(argc, (const char **)argv);
if (args_consumed < 0) {
printf("Failed parsing parameter '%s'\n", *(argv - 1));
exit(1);
}
argc -= args_consumed;
argv += args_consumed;
arg_handled = true;
break;
}
}
// Skip other options.
if (!arg_handled) {
--argc;
++argv;
}
}
}
while (saved_argc) {
bool arg_handled = false;
for (size_t i = 0; i < num_second_pass_arguments; ++i) {
auto &arg_handler = second_pass_arguments[i];
if (!strcmp(saved_argv[0], arg_handler.flag)) {
--saved_argc;
++saved_argv;
int args_consumed = arg_handler.handler(saved_argc, saved_argv);
if (args_consumed < 0) {
printf("Failed parsing parameter '%s'\n", *(argv - 1));
exit(1);
}
saved_argc -= args_consumed;
saved_argv += args_consumed;
arg_handled = true;
break;
}
}
// Ingore unknown options.
if (!arg_handled) {
--saved_argc;
++saved_argv;
}
}
}
if (!assure_dir_exist(FILENAMES["user_dir"].c_str())) {
printf("Can't open or create %s. Check permissions.\n",
FILENAMES["user_dir"].c_str());
exit(1);
}
setupDebug();
if (setlocale(LC_ALL, "") == NULL) {
DebugLog(D_WARNING, D_MAIN) << "Error while setlocale(LC_ALL, '').";
}
// Options strings loaded with system locale
init_options();
load_options();
set_language(true);
if (initscr() == NULL) { // Initialize ncurses
DebugLog( D_ERROR, DC_ALL ) << "initscr failed!";
return 1;
}
init_interface();
noecho(); // Don't echo keypresses
cbreak(); // C-style breaks (e.g. ^C to SIGINT)
keypad(stdscr, true); // Numpad is numbers
#if !(defined TILES || defined _WIN32 || defined WINDOWS)
// For tiles or windows, this is handled already in initscr().
init_colors();
#endif
// curs_set(0); // Invisible cursor
set_escdelay(10); // Make escape actually responsive
std::srand(seed);
g = new game;
// First load and initialize everything that does not
// depend on the mods.
try {
g->load_static_data();
if (verifyexit) {
if(g->game_error()) {
exit_handler(-999);
}
exit_handler(0);
}
if (check_all_mods) {
// Here we load all the mods and check their
// consistency (both is done in check_all_mod_data).
g->init_ui();
popup_nowait("checking all mods");
g->check_all_mod_data();
if(g->game_error()) {
exit_handler(-999);
}
// At this stage, the mods (and core game data)
// are find and we could start playing, but this
// is only for verifying that stage, so we exit.
exit_handler(0);
}
} catch(std::string &error_message) {
if(!error_message.empty()) {
debugmsg("%s", error_message.c_str());
}
exit_handler(-999);
}
// Now we do the actual game.
g->init_ui();
if(g->game_error()) {
exit_handler(-999);
}
curs_set(0); // Invisible cursor here, because MAPBUFFER.load() is crash-prone
#if (!(defined _WIN32 || defined WINDOWS))
struct sigaction sigIntHandler;
sigIntHandler.sa_handler = exit_handler;
sigemptyset(&sigIntHandler.sa_mask);
sigIntHandler.sa_flags = 0;
sigaction(SIGINT, &sigIntHandler, NULL);
#endif
bool quit_game = false;
do {
if(!g->opening_screen()) {
quit_game = true;
}
while (!quit_game && !g->do_turn()) ;
if (g->game_quit() || g->game_error()) {
quit_game = true;
}
} while (!quit_game);
exit_handler(-999);
return 0;
}
int main(int argc, char ** argv)
{
int exit_code = EXIT_FAILURE;
char * version = strdup("version 1.0");
const char * usage = "usage: %s [options] host\n";
void * algorithm_options;
traceroute_options_t traceroute_options;
traceroute_options_t * ptraceroute_options;
mda_options_t mda_options;
probe_t * probe;
pt_loop_t * loop;
int family;
address_t dst_addr;
options_t * options;
char * dst_ip;
const char * algorithm_name;
const char * protocol_name;
bool use_icmp, use_udp, use_tcp;
// Prepare the commande line options
if (!(options = init_options(version))) {
fprintf(stderr, "E: Can't initialize options\n");
goto ERR_INIT_OPTIONS;
}
// Retrieve values passed in the command-line
if (options_parse(options, usage, argv) != 1) {
fprintf(stderr, "%s: destination required\n", basename(argv[0]));
goto ERR_OPT_PARSE;
}
// We assume that the target IP address is always the last argument
dst_ip = argv[argc - 1];
algorithm_name = algorithm_names[0];
protocol_name = protocol_names[0];
// Checking if there is any conflicts between options passed in the commandline
if (!check_options(is_icmp, is_tcp, is_udp, is_ipv4, is_ipv6, dst_port[3], src_port[3], protocol_name, algorithm_name)) {
goto ERR_CHECK_OPTIONS;
}
use_icmp = is_icmp || strcmp(protocol_name, "icmp") == 0;
use_tcp = is_tcp || strcmp(protocol_name, "tcp") == 0;
use_udp = is_udp || strcmp(protocol_name, "udp") == 0;
// If not any ip version is set, call address_guess_family.
// If only one is set to true, set family to AF_INET or AF_INET6
if (is_ipv4) {
family = AF_INET;
} else if (is_ipv6) {
family = AF_INET6;
} else {
// Get address family if not defined by the user
if (!address_guess_family(dst_ip, &family)) goto ERR_ADDRESS_GUESS_FAMILY;
}
// Translate the string IP / FQDN into an address_t * instance
if (address_from_string(family, dst_ip, &dst_addr) != 0) {
fprintf(stderr, "E: Invalid destination address %s\n", dst_ip);
goto ERR_ADDRESS_IP_FROM_STRING;
}
// Probe skeleton definition: IPv4/UDP probe targetting 'dst_ip'
if (!(probe = probe_create())) {
fprintf(stderr,"E: Cannot create probe skeleton");
goto ERR_PROBE_CREATE;
}
// Prepare the probe skeleton
probe_set_protocols(
probe,
get_ip_protocol_name(family), // "ipv4" | "ipv6"
get_protocol_name(family, use_icmp, use_tcp, use_udp), // "icmpv4" | "icmpv6" | "tcp" | "udp"
NULL
);
probe_set_field(probe, ADDRESS("dst_ip", &dst_addr));
if (send_time[3]) {
if(send_time[0] <= 10) { // seconds
probe_set_delay(probe, DOUBLE("delay", send_time[0]));
} else { // milli-seconds
probe_set_delay(probe, DOUBLE("delay", 0.001 * send_time[0]));
}
}
// ICMPv* do not support src_port and dst_port fields nor payload.
if (!use_icmp) {
uint16_t sport = 0,
dport = 0;
if (use_udp) {
// Option -U sets port to 53 (DNS) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : UDP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_udp ? UDP_DST_PORT_USING_U : UDP_DEFAULT_DST_PORT);
} else if (use_tcp) {
// Option -T sets port to 80 (http) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : TCP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_tcp ? TCP_DST_PORT_USING_T : TCP_DEFAULT_DST_PORT);
}
// Update ports
probe_set_fields(
probe,
I16("src_port", sport),
I16("dst_port", dport),
NULL
);
// Resize payload (it will be use to set our customized checksum in the {TCP, UDP} layer)
probe_payload_resize(probe, 2);
}
// Algorithm options (dedicated options)
if (strcmp(algorithm_name, "paris-traceroute") == 0) {
traceroute_options = traceroute_get_default_options();
ptraceroute_options = &traceroute_options;
algorithm_options = &traceroute_options;
algorithm_name = "traceroute";
} else if ((strcmp(algorithm_name, "mda") == 0) || options_mda_get_is_set()) {
mda_options = mda_get_default_options();
ptraceroute_options = &mda_options.traceroute_options;
algorithm_options = &mda_options;
options_mda_init(&mda_options);
} else {
fprintf(stderr, "E: Unknown algorithm");
goto ERR_UNKNOWN_ALGORITHM;
}
// Algorithm options (common options)
options_traceroute_init(ptraceroute_options, &dst_addr);
// Create libparistraceroute loop
if (!(loop = pt_loop_create(loop_handler, NULL))) {
fprintf(stderr, "E: Cannot create libparistraceroute loop");
goto ERR_LOOP_CREATE;
}
// Set network options (network and verbose)
options_network_init(loop->network, is_debug);
printf("%s to %s (", algorithm_name, dst_ip);
address_dump(&dst_addr);
printf("), %u hops max, %u bytes packets\n",
ptraceroute_options->max_ttl,
(unsigned int)packet_get_size(probe->packet)
);
// Add an algorithm instance in the main loop
if (!pt_add_instance(loop, algorithm_name, algorithm_options, probe)) {
fprintf(stderr, "E: Cannot add the chosen algorithm");
goto ERR_INSTANCE;
}
// Wait for events. They will be catched by handler_user()
if (pt_loop(loop, 0) < 0) {
fprintf(stderr, "E: Main loop interrupted");
goto ERR_PT_LOOP;
}
exit_code = EXIT_SUCCESS;
// Leave the program
ERR_PT_LOOP:
ERR_INSTANCE:
// pt_loop_free() automatically removes algorithms instances,
// probe_replies and events from the memory.
// Options and probe must be manually removed.
pt_loop_free(loop);
ERR_LOOP_CREATE:
ERR_UNKNOWN_ALGORITHM:
probe_free(probe);
ERR_PROBE_CREATE:
ERR_ADDRESS_IP_FROM_STRING:
ERR_ADDRESS_GUESS_FAMILY:
if (errno) perror(gai_strerror(errno));
ERR_CHECK_OPTIONS:
ERR_OPT_PARSE:
ERR_INIT_OPTIONS:
free(version);
exit(exit_code);
}
/**
* @brief Main function logic
*
* Parse command line options and start running threads
*/
int
main(int argc, char* argv[])
{
int opt, idx, limit, only_calls, no_incomplete, i;
const char *device, *outfile;
char bpf[512];
const char *keyfile;
const char *match_expr;
int match_insensitive = 0, match_invert = 0;
int no_interface = 0, quiet = 0, rtp_capture = 0;
vector_t *infiles = vector_create(0, 1);
// Program otptions
static struct option long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'V' },
{ "device", required_argument, 0, 'd' },
{ "input", required_argument, 0, 'I' },
{ "output", required_argument, 0, 'O' },
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
{ "keyfile", required_argument, 0, 'k' },
#endif
{ "calls", no_argument, 0, 'c' },
{ "rtp", no_argument, 0, 'r' },
{ "limit", no_argument, 0, 'l' },
{ "icase", no_argument, 0, 'i' },
{ "invert", no_argument, 0, 'v' },
{ "no-interface", no_argument, 0, 'N' },
{ "dump-config", no_argument, 0, 'D' },
#ifdef USE_EEP
{ "eep-listen", required_argument, 0, 'L' },
{ "eep-send", required_argument, 0, 'H' },
#endif
{ "quiet", no_argument, 0, 'q' },
};
// Initialize configuration options
init_options();
// Get initial values for configurable arguments
device = setting_get_value(SETTING_CAPTURE_DEVICE);
outfile = setting_get_value(SETTING_CAPTURE_OUTFILE);
keyfile = setting_get_value(SETTING_CAPTURE_KEYFILE);
limit = setting_get_intvalue(SETTING_CAPTURE_LIMIT);
only_calls = setting_enabled(SETTING_SIP_CALLS);
no_incomplete = setting_enabled(SETTING_SIP_NOINCOMPLETE);
rtp_capture = setting_enabled(SETTING_CAPTURE_RTP);
// Parse command line arguments
opterr = 0;
char *options = "hVd:I:O:pqtW:k:crl:ivNqDL:H:";
while ((opt = getopt_long(argc, argv, options, long_options, &idx)) != -1) {
switch (opt) {
case 'h':
usage();
return 0;
case 'V':
version();
return 0;
case 'd':
device = optarg;
break;
case 'I':
vector_append(infiles, optarg);
break;
case 'O':
outfile = optarg;
break;
case 'l':
if(!(limit = atoi(optarg))) {
fprintf(stderr, "Invalid limit value.\n");
return 0;
}
break;
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
case 'k':
keyfile = optarg;
break;
#endif
case 'c':
only_calls = 1;
setting_set_value(SETTING_SIP_CALLS, SETTING_ON);
break;
case 'r':
rtp_capture = 1;
setting_set_value(SETTING_CAPTURE_RTP, SETTING_ON);
break;
case 'i':
match_insensitive++;
break;
case 'v':
match_invert++;
break;
case 'N':
no_interface = 1;
setting_set_value(SETTING_CAPTURE_STORAGE, "none");
break;
case 'q':
quiet = 1;
break;
case 'D':
key_bindings_dump();
settings_dump();
return 0;
// Dark options for dummy ones
case 'p':
case 't':
case 'W':
break;
#ifdef USE_EEP
case 'L':
capture_eep_set_server_url(optarg);
break;
case 'H':
capture_eep_set_client_url(optarg);
break;
#endif
case '?':
if (strchr(options, optopt)) {
fprintf(stderr, "-%c option requires an argument.\n", optopt);
} else if (isprint(optopt)) {
fprintf(stderr, "Unknown option -%c.\n", optopt);
} else {
fprintf(stderr, "Unknown option character '\\x%x'.\n", optopt);
}
return 1;
default:
break;
}
}
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
// Set capture decrypt key file
capture_set_keyfile(keyfile);
// Check if we have a keyfile and is valid
if (keyfile && !tls_check_keyfile(keyfile)) {
fprintf(stderr, "%s does not contain a valid RSA private key.\n", keyfile);
return 1;
}
#endif
// Check if given argument is a file
if (argc == 2 && (access(argv[1], F_OK) == 0)) {
// Old legacy option to open pcaps without other arguments
printf("%s seems to be a file: You forgot -I flag?\n", argv[1]);
return 0;
}
// Initialize SIP Messages Storage
sip_init(limit, only_calls, no_incomplete);
// Set capture options
capture_init(limit, rtp_capture);
#ifdef USE_EEP
// Initialize EEP if enabled
capture_eep_init();
#endif
// If we have an input file, load it
if (vector_count(infiles)) {
for (i = 0; i < vector_count(infiles); i++) {
// Try to load file
if (capture_offline(vector_item(infiles, i), outfile) != 0)
return 1;
}
} else {
// Check if all capture data is valid
if (capture_online(device, outfile) != 0)
return 1;
}
// Remove Input files vector
vector_destroy(infiles);
// More arguments pending!
if (argv[optind]) {
// Assume first pending argument is match expression
match_expr = argv[optind++];
// Try to build the bpf filter string with the rest
memset(bpf, 0, sizeof(bpf));
for (i = optind; i < argc; i++)
sprintf(bpf + strlen(bpf), "%s ", argv[i]);
// Check if this BPF filter is valid
if (capture_set_bpf_filter(bpf) != 0) {
// BPF Filter invalid, check incluiding match_expr
match_expr = 0; // There is no need to parse all payload at this point
// Build the bpf filter string
memset(bpf, 0, sizeof(bpf));
for (i = optind - 1; i < argc; i++)
sprintf(bpf + strlen(bpf), "%s ", argv[i]);
// Check bpf filter is valid again
if (capture_set_bpf_filter(bpf) != 0) {
fprintf(stderr, "Couldn't install filter %s: %s\n", bpf, capture_last_error());
return 1;
}
}
// Set the capture filter
if (match_expr)
if (sip_set_match_expression(match_expr, match_insensitive, match_invert)) {
fprintf(stderr, "Unable to parse expression %s\n", match_expr);
return 1;
}
}
// Start a capture thread
if (capture_launch_thread() != 0) {
ncurses_deinit();
fprintf(stderr, "Failed to launch capture thread.\n");
return 1;
}
if (!no_interface) {
// Initialize interface
ncurses_init();
// This is a blocking call.
// Create the first panel and wait for user input
ui_create_panel(PANEL_CALL_LIST);
wait_for_input();
} else {
setbuf(stdout, NULL);
while(capture_get_status() != CAPTURE_OFFLINE) {
if (!quiet)
printf("\rDialog count: %d", sip_calls_count());
usleep(500 * 1000);
}
if (!quiet)
printf("\rDialog count: %d\n", sip_calls_count());
}
// Capture deinit
capture_deinit();
// Deinitialize interface
ncurses_deinit();
// Deinitialize configuration options
deinit_options();
// Deallocate sip stored messages
sip_deinit();
// Leaving!
return 0;
}
static char *
readargs(int argc, char *argv[], struct opts *newopts,
struct disk_params *params)
{
int opt, dolist;
/*
Note that the global options aren't initialized yet, do not
call any function which might try to read them unless you
like segfaults. This includes the verbosity option check
that is done before printing error messages.
*/
dolist = 0;
init_options(newopts);
memset(params, 0, sizeof *params);
while(0 < (opt = getopt(argc, argv, "C:fhH:klL:qrsS:vVw:xz:"))) {
switch(opt) {
case 'C':
params->cyls = strtol(optarg, NULL, 0);
if (0 >= params->cyls)
usage("illegal cylinder count: %s", optarg);
break;
case 'f':
newopts->plainfile = 1;
break;
case 'h':
newopts->humansize = 1;
break;
case 'H':
params->heads = strtol(optarg, NULL, 0);
if (0 >= params->heads)
usage("illegal tracks per cylinder (ie: head) "
"count: %s", optarg);
break;
case 'k':
newopts->sloppyio = 1;
break;
case 'l':
dolist = 1;
break;
case 'L':
newopts->label = optarg;
break;
case 'q':
newopts->verbosity--;
break;
case 'r':
newopts->relaxed = 1;
break;
case 's':
newopts->swapcols = 1;
break;
case 'S':
params->sects = strtol(optarg, NULL, 0);
if (0 >= params->sects)
usage("illegal sectors per track count (sectors): %s", optarg);
break;
case 'v':
newopts->verbosity++;
break;
case 'V':
printf("%s version %s\n"
"Copyright (c) 2007-2017 Joshua R. Elsasser\n",
PACKAGE_NAME, PACKAGE_VERSION);
exit(EXIT_SUCCESS);
break;
case 'w':
newopts->serialize = optarg;
break;
case 'x':
newopts->printhex = 1;
break;
case 'z':
params->sectsize = strtol(optarg, NULL, 0);
if (0 >= params->sectsize)
usage("illegal sector size: %s", optarg);
break;
default:
usage(NULL);
break;
}
}
if (dolist) {
/* XXX argument validation? */
set_options(newopts);
os_list_devices(stdout);
exit(EXIT_SUCCESS);
}
if (newopts->label && !newopts->serialize)
usage("-w is required for -L");
if (optind + 1 == argc)
return (argv[optind]);
else
usage(NULL);
return (NULL);
}
SETUP()
{
static int option_changed;
optval_t def = { .str_val = "/tmp" };
init_options(&option_changed, NULL);
def.str_val = "/tmp";
add_option("fusehome", "fh", "descr", OPT_STR, OPT_GLOBAL, 0, NULL,
&fusehome_handler, def);
def.int_val = 0;
add_option("number", "nu", "descr", OPT_BOOL, OPT_GLOBAL, 0, NULL,
&number_handler, def);
add_option("numberwidth", "nuw", "descr", OPT_INT, OPT_GLOBAL, 0, NULL,
&numberwidth_global, def);
add_option("numberwidth", "nuw", "descr", OPT_INT, OPT_LOCAL, 0, NULL,
&numberwidth_local, def);
fuse_home = NULL;
number_width_global = 0;
number_width_local = 0;
}
TEARDOWN()
{
clear_options();
}
static void
fusehome_handler(OPT_OP op, optval_t val)
{
fuse_home = val.str_val;
}
static void
number_handler(OPT_OP op, optval_t val)
{
number = val.bool_val;
}
static void
numberwidth_global(OPT_OP op, optval_t val)
{
number_width_global = val.int_val;
}
static void
numberwidth_local(OPT_OP op, optval_t val)
{
number_width_local = val.int_val;
}
TEST(set_global_option_without_prefix)
{
assert_success(let_variables("&fusehome = 'value'"));
assert_string_equal("value", fuse_home);
}
TEST(set_global_option_with_global_prefix)
{
assert_success(let_variables("&g:fusehome = 'value'"));
assert_string_equal("value", fuse_home);
}
TEST(set_global_option_with_local_prefix)
{
assert_failure(let_variables("&l:fusehome = 'value'"));
assert_string_equal(NULL, fuse_home);
}
TEST(set_global_and_local_option_without_prefix)
{
assert_success(let_variables("&numberwidth = 2"));
assert_int_equal(2, number_width_global);
assert_int_equal(2, number_width_local);
}
TEST(set_global_and_local_option_with_global_prefix)
{
assert_success(let_variables("&g:numberwidth = 2"));
assert_int_equal(2, number_width_global);
assert_int_equal(0, number_width_local);
}
TEST(set_global_and_local_option_with_local_prefix)
{
assert_success(let_variables("&l:numberwidth = 2"));
assert_int_equal(0, number_width_global);
assert_int_equal(2, number_width_local);
}
TEST(appending_works_for_strings)
{
assert_success(let_variables("&fusehome = 'value'"));
assert_string_equal("value", fuse_home);
assert_success(let_variables("&fusehome .= 'more'"));
assert_string_equal("valuemore", fuse_home);
}
TEST(incdec_does_not_work_for_strings)
{
assert_failure(let_variables("&fusehome += 3"));
assert_failure(let_variables("&fusehome -= 3"));
}
TEST(incdec_works_for_numbers)
{
assert_success(let_variables("&numberwidth += 2"));
assert_int_equal(2, number_width_local);
assert_success(let_variables("&numberwidth += 4"));
assert_int_equal(6, number_width_local);
assert_success(let_variables("&numberwidth -= 5"));
assert_int_equal(1, number_width_local);
}
TEST(appending_does_not_work_for_numbers)
{
assert_failure(let_variables("&numberwidth .= 2"));
}
TEST(appending_does_not_work_for_bools)
{
assert_failure(let_variables("&number .= 2"));
}
TEST(addition_does_not_work_for_bools)
{
assert_failure(let_variables("&number += 2"));
}
#if 0
/* For the future. */
TEST(set_of_a_boolean_option)
{
assert_failure(let_variables("&number = 'a'"));
assert_success(let_variables("&number = '1'"));
assert_true(number);
assert_success(let_variables("&number = '0'"));
assert_false(number);
}
int main(int argc, char **argv)
{
extern int optind;
int c = 0;
int all = 0;
int group = 0;
int reverse = 0;
int running = 0;
int rows = 0;
int col = 0;
int limit = -1;
char select[4096];
char header[BUFSIZ];
char css_buffer[BUFSIZ];
char *ip = (char *) 0;
char *from = (char *) 0;
char *to = (char *) 0;
time_t current_time;
struct tm *t;
FILE *css_file;
sqlite3 *db;
sqlite3_stmt *statement;
memset(select, '\0', sizeof(select));
strncpy(progname, argv[0], sizeof(progname) - 1);
init_options();
if(load_config(EASHD_CONFIG) < 0)
exit(EXIT_FAILURE);
if(sql_init_db(option.sessiondb) < 0)
exit(EXIT_FAILURE);
while((c = getopt(argc, argv, "ac:f:g?hi:l:t:rwvV")) != EOF)
{
switch(c)
{
case 'a':
all = 1;
break;
case 'c':
css = strdup(optarg);
break;
case 'f':
from = strdup(optarg);
break;
case 'g':
group = 1;
break;
case 'i':
ip = strdup(optarg);
break;
case 'h':
case '?':
fprintf(stdout, "Usage: %.63s [-a] [-c css] [-f from] [-gh] [-i IP] [-l limit] [-t to] [-rwv]\n", basename(progname));
fprintf(stdout, "Enterprise Audit Shell Report\n\n");
fprintf(stdout, " -a\tshow all sessions.\n");
fprintf(stdout, " -c\tpoint to another css file.\n");
fprintf(stdout, " -f\tlimit records by the 'From' field. E.g. `%.63s -f root'\n", basename(progname));
fprintf(stdout, " -g\tgroup by username.\n");
fprintf(stdout, " -h\tdisplay this help synopsis.\n");
fprintf(stdout, " -i\tlimit records by the 'IP' field. E.g. `%.63s -i 127.0.0.1'\n", basename(progname));
fprintf(stdout, " -l\tlimit the number of records in general. E.g. `%.63s -l 10'\n", basename(progname));
fprintf(stdout, " -t\tlimit records by the 'To' field. E.g. `%.63s -t root'\n", basename(progname));
fprintf(stdout, " -r\treverse sort.\n");
fprintf(stdout, " -v\tdisplay version information.\n");
exit(EXIT_SUCCESS);
break;
case 'l':
limit = atoi(optarg);
break;
case 't':
to = strdup(optarg);
break;
case 'r':
reverse = 1;
break;
case 'v':
case 'V':
print_version(&option, *argv);
exit(EXIT_SUCCESS);
break;
default:
fprintf(stderr, "Try `%.63s -h' for more information.\n", basename(progname));
exit(EXIT_FAILURE);
break;
}
}
argc -= optind;
argv += optind;
if(*argv)
{
exit(detail_report(atoi(*argv)));
}
if(sqlite3_open(option.sessiondb, &db))
{
fprintf(stderr, "sqlite3_open: %.100s", sqlite3_errmsg(db));
exit(EXIT_FAILURE);
}
snprintf(select, sizeof(select) - 1,
"SELECT created,real_pw_name,original_pw_name,ip,id,stype,status,file_session,hash_session FROM USER WHERE status != ? %.63s%.63s%.63s%.63s LIMIT ?;",
ip ? "AND ip=? " : "",
from ? "AND original_pw_name=? " : "",
to ? "AND real_pw_name=? " : "",
group ?
reverse ?
"ORDER BY original_pw_name DESC,created DESC,ip " : "ORDER BY original_pw_name ASC,created ASC,ip "
:
reverse ?
"ORDER BY created DESC,original_pw_name,ip " : "ORDER BY created ASC,original_pw_name,ip ");
sqlite3_busy_timeout(db, 2000);
if(sqlite3_prepare(db, select, -1, &statement, NULL) != SQLITE_OK)
{
fprintf(stderr, "sqlite3_prepare: %.100s\n", sqlite3_errmsg(db));
sqlite3_close(db);
exit(EXIT_FAILURE);
}
col = 1;
sqlite3_bind_text(statement, col++, "R", -1, SQLITE_TRANSIENT);
if(ip)
sqlite3_bind_text(statement, col++, ip, -1, SQLITE_TRANSIENT);
if(from)
sqlite3_bind_text(statement, col++, from, -1, SQLITE_TRANSIENT);
if(to)
sqlite3_bind_text(statement, col++, to, -1, SQLITE_TRANSIENT);
sqlite3_bind_int(statement, col++, limit);
if((css_file = fopen(css ? css : "/etc/eas/css/report.css", "r")) == (FILE *) 0)
{
fprintf(stderr, "%.63s: %.127s: %.100s (%i)\n", basename(progname), css ? css : "/etc/eas/css/report.css", strerror(errno), errno);
sqlite3_close(db);
exit(EXIT_FAILURE);
}
current_time = time(0);
t = localtime(¤t_time);
/* ISO8601 */
strftime(header, sizeof(header) - 1, "%Y-%m-%d %H:%M:%S", t);
fprintf(stdout, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n");
fprintf(stdout, "<html>\n");
fprintf(stdout, "<head>\n");
fprintf(stdout, "<title>%.127s</title>\n", header);
fprintf(stdout, "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\">\n");
memset(css_buffer, '\0', sizeof(css_buffer));
while(fgets(css_buffer, sizeof(css_buffer) - 1, css_file))
{
fprintf(stdout, css_buffer);
memset(css_buffer, '\0', sizeof(css_buffer));
}
fclose(css_file);
fprintf(stdout, "</head>\n");
fprintf(stdout, "<body>\n");
fprintf(stdout, "<h2>Enterprise Audit Shell Audit Report</h2>\n");
fprintf(stdout, "<h3>%.127s</h3>\n", header);
fprintf(stdout, "<table cellspacing=\"0\" summary=\"Enterprise Audit Shell Report - %s\">\n", header);
fprintf(stdout, "<thead>\n");
fprintf(stdout, "<tr>\n");
fprintf(stdout, "\t<th class=\"hdate\">Date</th>\n");
fprintf(stdout, "\t<th class=\"hfrom\">From</th>\n");
fprintf(stdout, "\t<th class=\"hto\">To</th>\n");
fprintf(stdout, "\t<th class=\"hip\">IP</th>\n");
fprintf(stdout, "\t<th class=\"htype\">Type</th>\n");
fprintf(stdout, "\t<th class=\"hsignature\">Signature</th>\n");
fprintf(stdout, "\t<th class=\"hrowid\">ID</th>\n");
fprintf(stdout, "</tr>\n");
fprintf(stdout, "</thead>\n");
fprintf(stdout, "<tbody>\n");
running = 1;
while(running)
{
int OK = 0;
char type[BUFSIZ];
memset(type, '\0', sizeof(type));
switch(sqlite3_step(statement))
{
case SQLITE_DONE:
running = 0;
break;
case SQLITE_ROW:
rows++;
/*
* 0 created
* 1 real_pw_name
* 2 original_pw_name
* 3 ip
* 4 id
*/
memset(client.cid.created, '\0', sizeof(client.cid.created));
memset(client.cid.real_pw_name, '\0', sizeof(client.cid.real_pw_name));
memset(client.cid.original_pw_name, '\0', sizeof(client.cid.original_pw_name));
memset(client.cid.ip, '\0', sizeof(client.cid.ip));
memset(client.cid.type, '\0', sizeof(client.cid.type));
memset(client.cid.status, '\0', sizeof(client.cid.status));
memset(client.cid.file_session, '\0', sizeof(client.cid.file_session));
memset(client.cid.hash_session, '\0', sizeof(client.cid.hash_session));
if(sqlite3_column_text(statement, 0))
strncpy(client.cid.created, (char *) sqlite3_column_text(statement, 0),
sizeof(client.cid.created) - 1);
if(sqlite3_column_text(statement, 1))
strncpy(client.cid.real_pw_name, (char *) sqlite3_column_text(statement, 1),
sizeof(client.cid.real_pw_name) - 1);
if(sqlite3_column_text(statement, 2))
strncpy(client.cid.original_pw_name, (char *) sqlite3_column_text(statement, 2),
sizeof(client.cid.original_pw_name) - 1);
if(sqlite3_column_text(statement, 3))
strncpy(client.cid.ip, (char *) sqlite3_column_text(statement, 3),
sizeof(client.cid.ip) - 1);
client.cid.rowid = sqlite3_column_int(statement, 4);
if(sqlite3_column_text(statement, 5))
strncpy(client.cid.type, (char *) sqlite3_column_text(statement, 5),
sizeof(client.cid.type) - 1);
if(sqlite3_column_text(statement, 6))
strncpy(client.cid.status, (char *) sqlite3_column_text(statement, 6),
sizeof(client.cid.status) - 1);
if(sqlite3_column_text(statement, 7))
strncpy(client.cid.file_session, (char *) sqlite3_column_text(statement, 7),
sizeof(client.cid.file_session) - 1);
if(sqlite3_column_text(statement, 8))
strncpy(client.cid.hash_session, (char *) sqlite3_column_text(statement, 8),
sizeof(client.cid.hash_session) - 1);
if(create_SHA1(client.cid.file_session, option.strict_inode, option.strict_mode, option.strict_owner, option.strict_ctime, option.strict_mtime))
{
char a[BUFSIZ];
strncpy(a, create_SHA1(client.cid.file_session, option.strict_inode, option.strict_mode, option.strict_owner, option.strict_ctime, option.strict_mtime), sizeof(a) - 1);
if(!strcmp(a, client.cid.hash_session))
OK = 1;
else
OK = 0;
}
else
{
OK = 0;
}
if(!strcmp(client.cid.type, "SESSION"))
strcpy(type, "Session");
else if(!strcmp(client.cid.type, "COMMAND"))
strcpy(type, "Command");
else if(!strcmp(client.cid.type, "LOGIN"))
strcpy(type, "Login");
else
strcpy(type, "Unknown");
fprintf(stdout, "<tr class=\"%.63s\">\n", rows % 2 ? "odd" : "even");
fprintf(stdout, "\t<th class=\"date\">%.19s</th>\n", client.cid.created);
fprintf(stdout, "\t<td class=\"from\">%.15s</td>\n", client.cid.original_pw_name);
fprintf(stdout, "\t<td class=\"to\">%.15s</td>\n", client.cid.real_pw_name);
fprintf(stdout, "\t<td class=\"ip\">%.15s</td>\n", client.cid.ip);
fprintf(stdout, "\t<td class=\"type\">%.15s</td>\n", type);
fprintf(stdout, "\t<td class=\"%.63s\">%.32s</td>\n", OK ? "verified" : "invalid", OK ? "Verified" : "Invalid");
fprintf(stdout, "\t<td class=\"rowid\">%.9i</td>\n", client.cid.rowid);
fprintf(stdout, "</tr>\n");
break;
default:
running = 0;
fprintf(stderr, "sqlite3_step: %.100s\n", sqlite3_errmsg(db));
break;
}
}
sqlite3_finalize(statement);
sqlite3_close(db);
if(rows == 0)
fprintf(stdout, "<tr>\n\t<td class=\"norows\" colspan=7>No sessions found for the criteria.</td>\n</tr>");
fprintf(stdout, "<tr>\n");
fprintf(stdout, "\t<th class=\"empty\"> </th>\n");
fprintf(stdout, "\t<th class=\"total\" colspan=6> </th>\n");
fprintf(stdout, "</tr>\n");
fprintf(stdout, "<tbody>\n");
fprintf(stdout, "</table>\n");
fprintf(stdout, "</body>\n");
fprintf(stdout, "</html>\n");
exit(EXIT_SUCCESS);
}
int
main( int argc, char** argv )
{
int status = EXIT_SUCCESS;
GOptionContext *context;
GError *error = NULL;
NAObjectAction *action;
GSList *msg = NULL;
GSList *im;
gchar *help;
gint errors;
#if !GLIB_CHECK_VERSION( 2,36, 0 )
g_type_init();
#endif
setlocale( LC_ALL, "" );
console_init_log_handler();
context = init_options();
if( argc == 1 ){
g_set_prgname( argv[0] );
help = g_option_context_get_help( context, FALSE, NULL );
g_print( "\n%s", help );
g_free( help );
exit( status );
}
if( !g_option_context_parse( context, &argc, &argv, &error )){
g_printerr( _( "Syntax error: %s\n" ), error->message );
g_error_free (error);
exit_with_usage();
}
if( version ){
na_core_utils_print_version();
exit( status );
}
errors = 0;
if( !label || !g_utf8_strlen( label, -1 )){
g_printerr( _( "Error: an action label is mandatory.\n" ));
errors += 1;
}
if( enabled && disabled ){
g_printerr( CANNOT_BOTH, "--enabled", "--disabled" );
errors += 1;
} else if( !disabled ){
enabled = TRUE;
}
if( target_selection && nocontext ){
g_printerr( CANNOT_BOTH, "--context", "--nocontext" );
errors += 1;
} else if( !nocontext ){
target_selection = TRUE;
}
if( target_location && nolocation ){
g_printerr( CANNOT_BOTH, "--location", "--nolocation" );
errors += 1;
}
if( target_toolbar && notoolbar ){
g_printerr( CANNOT_BOTH, "--toolbar", "--notoolbar" );
errors += 1;
}
if( matchcase && nocase ){
g_printerr( CANNOT_BOTH, "--match-case", "--nocase" );
errors += 1;
} else if( !nocase ){
matchcase = TRUE;
}
if( accept_multiple && strlen( selection_count )){
g_printerr( CANNOT_BOTH, "--accept-multiple", "--selection-count" );
errors += 1;
}
if( onlyshow_array && notshow_array ){
g_printerr( CANNOT_BOTH, "--only-show-in", "--not-show-in" );
errors += 1;
}
if( output_stdout && output_desktop ){
g_printerr( _( "Error: only one output option may be specified.\n" ));
errors += 1;
}
if( errors ){
exit_with_usage();
}
action = get_action_from_cmdline();
if( output_desktop ){
output_to_desktop( action, &msg );
} else {
output_to_stdout( action, &msg );
}
if( msg ){
for( im = msg ; im ; im = im->next ){
g_printerr( "%s\n", ( gchar * ) im->data );
}
na_core_utils_slist_free( msg );
status = EXIT_FAILURE;
}
g_object_unref( action );
g_option_context_free( context );
exit( status );
}
SETUP()
{
static int option_changed;
optval_t def = { .str_val = "/tmp" };
cfg.slow_fs_list = strdup("");
init_builtin_functions();
stats.line = wcsdup(L"set ");
stats.index = wcslen(stats.line);
stats.curs_pos = 0;
stats.len = stats.index;
stats.cmd_pos = -1;
stats.complete_continue = 0;
stats.history_search = 0;
stats.line_buf = NULL;
stats.complete = &complete_cmd;
init_commands();
execute_cmd("command bar a");
execute_cmd("command baz b");
execute_cmd("command foo c");
init_options(&option_changed);
add_option("fusehome", "fh", OPT_STR, 0, NULL, fusehome_handler, def);
assert_int_equal(0, chdir("test-data/existing-files"));
}
TEARDOWN()
{
assert_int_equal(0, chdir("../.."));
free(cfg.slow_fs_list);
cfg.slow_fs_list = NULL;
free(stats.line);
reset_cmds();
clear_options();
function_reset_all();
}
static void
fusehome_handler(OPT_OP op, optval_t val)
{
}
TEST(leave_spaces_at_begin)
{
char *buf;
vle_compl_reset();
assert_int_equal(1, complete_cmd(" qui", NULL));
buf = vle_compl_next();
assert_string_equal("quit", buf);
free(buf);
buf = vle_compl_next();
assert_string_equal("quit", buf);
free(buf);
}
TEST(only_user)
{
char *buf;
vle_compl_reset();
assert_int_equal(8, complete_cmd("command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
vle_compl_reset();
assert_int_equal(9, complete_cmd(" command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
vle_compl_reset();
assert_int_equal(10, complete_cmd(" command ", NULL));
buf = vle_compl_next();
assert_string_equal("bar", buf);
free(buf);
}
TEST(test_set_completion)
{
vle_compl_reset();
assert_success(line_completion(&stats));
assert_wstring_equal(L"set all", stats.line);
}
TEST(no_sdquoted_completion_does_nothing)
{
free(stats.line);
stats.line = wcsdup(L"command '");
stats.len = wcslen(stats.line);
stats.index = stats.len;
vle_compl_reset();
assert_success(line_completion(&stats));
assert_wstring_equal(L"command '", stats.line);
}
static void
prepare_for_line_completion(const wchar_t str[])
{
free(stats.line);
stats.line = wcsdup(str);
stats.len = wcslen(stats.line);
stats.index = stats.len;
stats.complete_continue = 0;
vle_compl_reset();
}
int
main( int argc, char** argv )
{
int status = EXIT_SUCCESS;
GOptionContext *context;
GError *error = NULL;
gchar *help;
gint errors;
NAObjectItem *item;
NAIExporter *exporter;
#if !GLIB_CHECK_VERSION( 2,36, 0 )
g_type_init();
#endif
setlocale( LC_ALL, "" );
console_init_log_handler();
context = init_options();
if( argc == 1 ){
g_set_prgname( argv[0] );
help = g_option_context_get_help( context, FALSE, NULL );
g_print( "\n%s", help );
g_free( help );
exit( status );
}
if( !g_option_context_parse( context, &argc, &argv, &error )){
g_printerr( _( "Syntax error: %s\n" ), error->message );
g_error_free (error);
exit_with_usage();
}
g_option_context_free( context );
if( version ){
na_core_utils_print_version();
exit( status );
}
errors = 0;
if( !id || !strlen( id )){
g_printerr( _( "Error: a menu or action id is mandatory.\n" ));
errors += 1;
}
item = get_item( id );
if( !item ){
errors += 1;
}
if( !format || !strlen( format )){
format = "Desktop1";
}
exporter = na_exporter_find_for_format( pivot, format );
if( !exporter ){
/* i18n: %s stands for the id of the export format, and is not translatable */
g_printerr( _( "Error: %s: unknown export format.\n" ), format );
errors += 1;
}
if( errors ){
exit_with_usage();
}
export_item( item, format );
exit( status );
}
int main(int argc, char *argv[])
{
char *c;
struct encoder_ctx enc_ctx[2];
struct cc_subtitle dec_sub;
#ifdef ENABLE_FFMPEG
void *ffmpeg_ctx = NULL;
#endif
struct lib_ccx_ctx *ctx;
struct lib_cc_decode *dec_ctx = NULL;
init_options (&ccx_options);
parse_configuration(&ccx_options);
parse_parameters (&ccx_options, argc, argv);
// Initialize libraries
ctx = init_libraries(&ccx_options);
dec_ctx = ctx->dec_ctx;
// Prepare write structures
init_write(&ctx->wbout1,ccx_options.wbout1.filename);
init_write(&ctx->wbout2,ccx_options.wbout2.filename);
int show_myth_banner = 0;
memset (&cea708services[0],0,CCX_DECODERS_708_MAX_SERVICES*sizeof (int)); // Cannot (yet) be moved because it's needed in parse_parameters.
memset (&dec_sub, 0,sizeof(dec_sub));
if (ctx->num_input_files==0 && ccx_options.input_source==CCX_DS_FILE)
{
usage ();
fatal (EXIT_NO_INPUT_FILES, "(This help screen was shown because there were no input files)\n");
}
if (ctx->num_input_files>1 && ccx_options.live_stream)
{
fatal(EXIT_TOO_MANY_INPUT_FILES, "Live stream mode accepts only one input file.\n");
}
if (ctx->num_input_files && ccx_options.input_source==CCX_DS_NETWORK)
{
fatal(EXIT_TOO_MANY_INPUT_FILES, "UDP mode is not compatible with input files.\n");
}
if (ccx_options.input_source==CCX_DS_NETWORK || ccx_options.input_source==CCX_DS_TCP)
{
ccx_options.buffer_input=1; // Mandatory, because each datagram must be read complete.
}
if (ctx->num_input_files && ccx_options.input_source==CCX_DS_TCP)
{
fatal(EXIT_TOO_MANY_INPUT_FILES, "TCP mode is not compatible with input files.\n");
}
if (ctx->num_input_files > 0)
{
ctx->wbout1.multiple_files = 1;
ctx->wbout1.first_input_file = ctx->inputfile[0];
ctx->wbout2.multiple_files = 1;
ctx->wbout2.first_input_file = ctx->inputfile[0];
}
// teletext page number out of range
if ((tlt_config.page != 0) && ((tlt_config.page < 100) || (tlt_config.page > 899))) {
fatal (EXIT_NOT_CLASSIFIED, "Teletext page number could not be lower than 100 or higher than 899\n");
}
if (ccx_options.output_filename!=NULL)
{
// Use the given output file name for the field specified by
// the -1, -2 switch. If -12 is used, the filename is used for
// field 1.
if (ccx_options.extract==2)
ctx->wbout2.filename=ccx_options.output_filename;
else
ctx->wbout1.filename=ccx_options.output_filename;
}
switch (ccx_options.write_format)
{
case CCX_OF_RAW:
ctx->extension = ".raw";
break;
case CCX_OF_SRT:
ctx->extension = ".srt";
break;
case CCX_OF_SAMI:
ctx->extension = ".smi";
break;
case CCX_OF_SMPTETT:
ctx->extension = ".ttml";
break;
case CCX_OF_TRANSCRIPT:
ctx->extension = ".txt";
break;
case CCX_OF_RCWT:
ctx->extension = ".bin";
break;
case CCX_OF_SPUPNG:
ctx->extension = ".xml";
break;
case CCX_OF_NULL:
ctx->extension = "";
break;
case CCX_OF_DVDRAW:
ctx->extension = ".dvdraw";
break;
default:
fatal (CCX_COMMON_EXIT_BUG_BUG, "write_format doesn't have any legal value, this is a bug.\n");
}
params_dump(ctx);
// default teletext page
if (tlt_config.page > 0) {
// dec to BCD, magazine pages numbers are in BCD (ETSI 300 706)
tlt_config.page = ((tlt_config.page / 100) << 8) | (((tlt_config.page / 10) % 10) << 4) | (tlt_config.page % 10);
}
if (ctx->auto_stream==CCX_SM_MCPOODLESRAW && ccx_options.write_format==CCX_OF_RAW)
{
fatal (EXIT_INCOMPATIBLE_PARAMETERS, "-in=raw can only be used if the output is a subtitle file.\n");
}
if (ctx->auto_stream==CCX_SM_RCWT && ccx_options.write_format==CCX_OF_RCWT && ccx_options.output_filename==NULL)
{
fatal (EXIT_INCOMPATIBLE_PARAMETERS,
"CCExtractor's binary format can only be used simultaneously for input and\noutput if the output file name is specified given with -o.\n");
}
subline = (unsigned char *) malloc (SUBLINESIZE);
switch (ccx_options.input_source)
{
case CCX_DS_FILE:
ctx->basefilename = (char *) malloc (strlen (ctx->inputfile[0])+1);
break;
case CCX_DS_STDIN:
ctx->basefilename = (char *) malloc (strlen (ctx->basefilename_for_stdin)+1);
break;
case CCX_DS_NETWORK:
case CCX_DS_TCP:
ctx->basefilename = (char *) malloc (strlen (ctx->basefilename_for_network)+1);
break;
}
if (ctx->basefilename == NULL)
fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
switch (ccx_options.input_source)
{
case CCX_DS_FILE:
strcpy (ctx->basefilename, ctx->inputfile[0]);
break;
case CCX_DS_STDIN:
strcpy (ctx->basefilename, ctx->basefilename_for_stdin);
break;
case CCX_DS_NETWORK:
case CCX_DS_TCP:
strcpy (ctx->basefilename, ctx->basefilename_for_network);
break;
}
for (c=ctx->basefilename+strlen (ctx->basefilename)-1; ctx->basefilename &&
*c!='.'; c--) {;} // Get last .
if (*c=='.')
*c=0;
if (ctx->wbout1.filename==NULL)
{
ctx->wbout1.filename = (char *) malloc (strlen (ctx->basefilename)+3+strlen (ctx->extension));
ctx->wbout1.filename[0]=0;
}
if (ctx->wbout2.filename==NULL)
{
ctx->wbout2.filename = (char *) malloc (strlen (ctx->basefilename)+3+strlen (ctx->extension));
ctx->wbout2.filename[0]=0;
}
if (ctx->buffer == NULL || ctx->pesheaderbuf==NULL ||
ctx->wbout1.filename == NULL || ctx->wbout2.filename == NULL ||
subline==NULL || init_file_buffer() )
{
fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
}
if (ccx_options.send_to_srv)
{
connect_to_srv(ccx_options.srv_addr, ccx_options.srv_port, ccx_options.tcp_desc);
}
if (ccx_options.write_format!=CCX_OF_NULL)
{
/* # DVD format uses one raw file for both fields, while Broadcast requires 2 */
if (ccx_options.write_format==CCX_OF_DVDRAW)
{
if (ctx->wbout1.filename[0]==0)
{
strcpy (ctx->wbout1.filename,ctx->basefilename);
strcat (ctx->wbout1.filename,".raw");
}
if (ctx->cc_to_stdout)
{
ctx->wbout1.fh=STDOUT_FILENO;
mprint ("Sending captions to stdout.\n");
}
else
{
mprint ("Creating %s\n", ctx->wbout1.filename);
ctx->wbout1.fh=open (ctx->wbout1.filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
if (ctx->wbout1.fh==-1)
{
fatal(CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Failed\n");
}
}
}
else
{
if (ctx->cc_to_stdout && ccx_options.extract==12)
fatal (EXIT_INCOMPATIBLE_PARAMETERS, "You can't extract both fields to stdout at the same time in broadcast mode.");
if (ccx_options.write_format == CCX_OF_SPUPNG && ctx->cc_to_stdout)
fatal (EXIT_INCOMPATIBLE_PARAMETERS, "You cannot use -out=spupng with -stdout.");
if (ccx_options.extract!=2)
{
if (ctx->cc_to_stdout)
{
ctx->wbout1.fh=STDOUT_FILENO;
mprint ("Sending captions to stdout.\n");
}
else if (!ccx_options.send_to_srv)
{
if (ctx->wbout1.filename[0]==0)
{
strcpy (ctx->wbout1.filename,ctx->basefilename);
if (ccx_options.extract==12) // _1 only added if there's two files
strcat (ctx->wbout1.filename,"_1");
strcat (ctx->wbout1.filename,(const char *) ctx->extension);
}
mprint ("Creating %s\n", ctx->wbout1.filename);
ctx->wbout1.fh=open (ctx->wbout1.filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
if (ctx->wbout1.fh==-1)
{
fatal(CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Failed (errno=%d)\n", errno);
}
}
switch (ccx_options.write_format)
{
case CCX_OF_RAW:
writeraw(BROADCAST_HEADER, sizeof(BROADCAST_HEADER), &ctx->wbout1);
break;
case CCX_OF_DVDRAW:
break;
case CCX_OF_RCWT:
if (init_encoder(enc_ctx, &ctx->wbout1))
fatal(EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
set_encoder_subs_delay(enc_ctx, ctx->subs_delay);
set_encoder_last_displayed_subs_ms(enc_ctx, ctx->last_displayed_subs_ms);
set_encoder_startcredits_displayed(enc_ctx, ctx->startcredits_displayed);
break;
default:
if (!ccx_options.no_bom){
if (ccx_options.encoding == CCX_ENC_UTF_8){ // Write BOM
writeraw(UTF8_BOM, sizeof(UTF8_BOM), &ctx->wbout1);
}
if (ccx_options.encoding == CCX_ENC_UNICODE){ // Write BOM
writeraw(LITTLE_ENDIAN_BOM, sizeof(LITTLE_ENDIAN_BOM), &ctx->wbout1);
}
}
if (init_encoder(enc_ctx, &ctx->wbout1)){
fatal(EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
}
set_encoder_subs_delay(enc_ctx, ctx->subs_delay);
set_encoder_last_displayed_subs_ms(enc_ctx, ctx->last_displayed_subs_ms);
set_encoder_startcredits_displayed(enc_ctx, ctx->startcredits_displayed);
}
}
if (ccx_options.extract == 12 && ccx_options.write_format != CCX_OF_RAW)
mprint (" and \n");
if (ccx_options.extract!=1)
{
if (ctx->cc_to_stdout)
{
ctx->wbout1.fh=STDOUT_FILENO;
mprint ("Sending captions to stdout.\n");
}
else if(ccx_options.write_format == CCX_OF_RAW
&& ccx_options.extract == 12)
{
memcpy(&ctx->wbout2, &ctx->wbout1,sizeof(ctx->wbout1));
}
else if (!ccx_options.send_to_srv)
{
if (ctx->wbout2.filename[0]==0)
{
strcpy (ctx->wbout2.filename,ctx->basefilename);
if (ccx_options.extract==12) // _ only added if there's two files
strcat (ctx->wbout2.filename,"_2");
strcat (ctx->wbout2.filename,(const char *) ctx->extension);
}
mprint ("Creating %s\n", ctx->wbout2.filename);
ctx->wbout2.fh=open (ctx->wbout2.filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
if (ctx->wbout2.fh==-1)
{
fatal(CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Failed\n");
}
if(ccx_options.write_format == CCX_OF_RAW)
writeraw (BROADCAST_HEADER,sizeof (BROADCAST_HEADER),&ctx->wbout2);
}
switch (ccx_options.write_format)
{
case CCX_OF_RAW:
case CCX_OF_DVDRAW:
break;
case CCX_OF_RCWT:
if( init_encoder(enc_ctx+1,&ctx->wbout2) )
fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
set_encoder_subs_delay(enc_ctx+1, ctx->subs_delay);
set_encoder_last_displayed_subs_ms(enc_ctx+1, ctx->last_displayed_subs_ms);
set_encoder_startcredits_displayed(enc_ctx+1, ctx->startcredits_displayed);
break;
default:
if (!ccx_options.no_bom){
if (ccx_options.encoding == CCX_ENC_UTF_8){ // Write BOM
writeraw(UTF8_BOM, sizeof(UTF8_BOM), &ctx->wbout2);
}
if (ccx_options.encoding == CCX_ENC_UNICODE){ // Write BOM
writeraw(LITTLE_ENDIAN_BOM, sizeof(LITTLE_ENDIAN_BOM), &ctx->wbout2);
}
}
if (init_encoder(enc_ctx + 1, &ctx->wbout2)){
fatal(EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
}
set_encoder_subs_delay(enc_ctx+1, ctx->subs_delay);
set_encoder_last_displayed_subs_ms(enc_ctx+1, ctx->last_displayed_subs_ms);
set_encoder_startcredits_displayed(enc_ctx+1, ctx->startcredits_displayed);
}
}
}
}
if (ccx_options.transcript_settings.xds)
{
if (ccx_options.write_format != CCX_OF_TRANSCRIPT)
{
ccx_options.transcript_settings.xds = 0;
mprint ("Warning: -xds ignored, XDS can only be exported to transcripts at this time.\n");
}
}
if (ccx_options.teletext_mode == CCX_TXT_IN_USE) // Here, it would mean it was forced by user
telxcc_init(ctx);
ctx->fh_out_elementarystream = NULL;
if (ccx_options.out_elementarystream_filename!=NULL)
{
if ((ctx->fh_out_elementarystream = fopen (ccx_options.out_elementarystream_filename,"wb"))==NULL)
{
fatal(CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to open clean file: %s\n", ccx_options.out_elementarystream_filename);
}
}
// Initialize HDTV caption buffer
init_hdcc();
if (ccx_options.line_terminator_lf)
encoded_crlf_length = encode_line(encoded_crlf, (unsigned char *) "\n");
else
encoded_crlf_length = encode_line(encoded_crlf, (unsigned char *) "\r\n");
encoded_br_length = encode_line(encoded_br, (unsigned char *) "<br>");
time_t start, final;
time(&start);
dec_ctx->processed_enough=0;
if (ccx_options.binary_concat)
{
ctx->total_inputsize=gettotalfilessize(ctx);
if (ctx->total_inputsize==-1)
fatal (EXIT_UNABLE_TO_DETERMINE_FILE_SIZE, "Failed to determine total file size.\n");
}
#ifndef _WIN32
signal_ctx = ctx;
m_signal(SIGINT, sigint_handler);
#endif
while (switch_to_next_file(ctx, 0) && !dec_ctx->processed_enough)
{
prepare_for_new_file(ctx);
#ifdef ENABLE_FFMPEG
close_input_file(ctx);
ffmpeg_ctx = init_ffmpeg(ctx->inputfile[0]);
if(ffmpeg_ctx)
{
do
{
int ret = 0;
unsigned char *bptr = ctx->buffer;
int len = ff_get_ccframe(ffmpeg_ctx, bptr, 1024);
int cc_count = 0;
if(len == AVERROR(EAGAIN))
{
continue;
}
else if(len == AVERROR_EOF)
break;
else if(len == 0)
continue;
else if(len < 0 )
{
mprint("Error extracting Frame\n");
break;
}
else
cc_count = len/3;
ret = process_cc_data(dec_ctx, bptr, cc_count, &dec_sub);
if(ret >= 0 && dec_sub.got_output)
{
encode_sub(enc_ctx, &dec_sub);
dec_sub.got_output = 0;
}
}while(1);
continue;
}
else
{
mprint ("\rFailed to initialized ffmpeg falling back to legacy\n");
}
#endif
if (ctx->auto_stream == CCX_SM_AUTODETECT)
{
detect_stream_type(ctx);
switch (ctx->stream_mode)
{
case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
mprint ("\rFile seems to be an elementary stream, enabling ES mode\n");
break;
case CCX_SM_TRANSPORT:
mprint ("\rFile seems to be a transport stream, enabling TS mode\n");
break;
case CCX_SM_PROGRAM:
mprint ("\rFile seems to be a program stream, enabling PS mode\n");
break;
case CCX_SM_ASF:
mprint ("\rFile seems to be an ASF, enabling DVR-MS mode\n");
break;
case CCX_SM_WTV:
mprint ("\rFile seems to be a WTV, enabling WTV mode\n");
break;
case CCX_SM_MCPOODLESRAW:
mprint ("\rFile seems to be McPoodle raw data\n");
break;
case CCX_SM_RCWT:
mprint ("\rFile seems to be a raw caption with time data\n");
break;
case CCX_SM_MP4:
mprint ("\rFile seems to be a MP4\n");
break;
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
mprint ("\rFile seems to be an hexadecimal dump\n");
break;
#endif
case CCX_SM_MYTH:
case CCX_SM_AUTODETECT:
fatal(CCX_COMMON_EXIT_BUG_BUG, "Cannot be reached!");
break;
}
}
else
{
ctx->stream_mode=ctx->auto_stream;
}
/* -----------------------------------------------------------------
MAIN LOOP
----------------------------------------------------------------- */
// The myth loop autodetect will only be used with ES or PS streams
switch (ccx_options.auto_myth)
{
case 0:
// Use whatever stream mode says
break;
case 1:
// Force stream mode to myth
ctx->stream_mode=CCX_SM_MYTH;
break;
case 2:
// autodetect myth files, but only if it does not conflict with
// the current stream mode
switch (ctx->stream_mode)
{
case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
case CCX_SM_PROGRAM:
if ( detect_myth(ctx) )
{
ctx->stream_mode=CCX_SM_MYTH;
}
break;
default:
// Keep stream_mode
break;
}
break;
}
// Disable sync check for raw formats - they have the right timeline.
// Also true for bin formats, but -nosync might have created a
// broken timeline for debug purposes.
// Disable too in MP4, specs doesn't say that there can't be a jump
switch (ctx->stream_mode)
{
case CCX_SM_MCPOODLESRAW:
case CCX_SM_RCWT:
case CCX_SM_MP4:
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
#endif
ccx_common_timing_settings.disable_sync_check = 1;
break;
default:
break;
}
switch (ctx->stream_mode)
{
case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 1; // Force GOP timing for ES
ccx_common_timing_settings.is_elementary_stream = 1;
case CCX_SM_TRANSPORT:
case CCX_SM_PROGRAM:
case CCX_SM_ASF:
case CCX_SM_WTV:
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 0;
mprint ("\rAnalyzing data in general mode\n");
general_loop(ctx, &enc_ctx);
break;
case CCX_SM_MCPOODLESRAW:
mprint ("\rAnalyzing data in McPoodle raw mode\n");
raw_loop(ctx, &enc_ctx);
break;
case CCX_SM_RCWT:
mprint ("\rAnalyzing data in CCExtractor's binary format\n");
rcwt_loop(ctx, &enc_ctx);
break;
case CCX_SM_MYTH:
mprint ("\rAnalyzing data in MythTV mode\n");
show_myth_banner = 1;
myth_loop(ctx, &enc_ctx);
break;
case CCX_SM_MP4:
mprint ("\rAnalyzing data with GPAC (MP4 library)\n");
close_input_file(ctx); // No need to have it open. GPAC will do it for us
processmp4 (ctx, ctx->inputfile[0],&enc_ctx);
break;
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
close_input_file(ctx); // processhex will open it in text mode
processhex (ctx, ctx->inputfile[0]);
break;
#endif
case CCX_SM_AUTODETECT:
fatal(CCX_COMMON_EXIT_BUG_BUG, "Cannot be reached!");
break;
}
mprint("\n");
dbg_print(CCX_DMT_DECODER_608, "\nTime stamps after last caption block was written:\n");
dbg_print(CCX_DMT_DECODER_608, "Last time stamps: PTS: %s (%+2dF) ",
print_mstime( (LLONG) (sync_pts/(MPEG_CLOCK_FREQ/1000)
+frames_since_ref_time*1000.0/current_fps) ),
frames_since_ref_time);
dbg_print(CCX_DMT_DECODER_608, "GOP: %s \n", print_mstime(gop_time.ms) );
// Blocks since last PTS/GOP time stamp.
dbg_print(CCX_DMT_DECODER_608, "Calc. difference: PTS: %s (%+3lldms incl.) ",
print_mstime( (LLONG) ((sync_pts-min_pts)/(MPEG_CLOCK_FREQ/1000)
+ fts_offset + frames_since_ref_time*1000.0/current_fps)),
fts_offset + (LLONG) (frames_since_ref_time*1000.0/current_fps) );
dbg_print(CCX_DMT_DECODER_608, "GOP: %s (%+3dms incl.)\n",
print_mstime((LLONG)(gop_time.ms
-first_gop_time.ms
+get_fts_max()-fts_at_gop_start)),
(int)(get_fts_max()-fts_at_gop_start));
// When padding is active the CC block time should be within
// 1000/29.97 us of the differences.
dbg_print(CCX_DMT_DECODER_608, "Max. FTS: %s (without caption blocks since then)\n",
print_mstime(get_fts_max()));
if (ctx->stat_hdtv)
{
mprint ("\rCC type 0: %d (%s)\n", dec_ctx->cc_stats[0], cc_types[0]);
mprint ("CC type 1: %d (%s)\n", dec_ctx->cc_stats[1], cc_types[1]);
mprint ("CC type 2: %d (%s)\n", dec_ctx->cc_stats[2], cc_types[2]);
mprint ("CC type 3: %d (%s)\n", dec_ctx->cc_stats[3], cc_types[3]);
}
mprint ("\nTotal frames time: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(total_frames_count*1000/current_fps) ),
total_frames_count, current_fps);
if (ctx->total_pulldownframes)
mprint ("incl. pulldown frames: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(ctx->total_pulldownframes*1000/current_fps) ),
ctx->total_pulldownframes, current_fps);
if (pts_set >= 1 && min_pts != 0x01FFFFFFFFLL)
{
LLONG postsyncms = (LLONG) (ctx->frames_since_last_gop*1000/current_fps);
mprint ("\nMin PTS: %s\n",
print_mstime( min_pts/(MPEG_CLOCK_FREQ/1000) - fts_offset));
if (pts_big_change)
mprint ("(Reference clock was reset at some point, Min PTS is approximated)\n");
mprint ("Max PTS: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms));
mprint ("Length: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms
- min_pts/(MPEG_CLOCK_FREQ/1000) + fts_offset ));
}
// dvr-ms files have invalid GOPs
if (gop_time.inited && first_gop_time.inited && ctx->stream_mode != CCX_SM_ASF)
{
mprint ("\nInitial GOP time: %s\n",
print_mstime(first_gop_time.ms));
mprint ("Final GOP time: %s%+3dF\n",
print_mstime(gop_time.ms),
ctx->frames_since_last_gop);
mprint ("Diff. GOP length: %s%+3dF",
print_mstime(gop_time.ms - first_gop_time.ms),
ctx->frames_since_last_gop);
mprint (" (%s)\n",
print_mstime(gop_time.ms - first_gop_time.ms
+(LLONG) ((ctx->frames_since_last_gop)*1000/29.97)) );
}
if (ctx->false_pict_header)
mprint ("\nNumber of likely false picture headers (discarded): %d\n",ctx->false_pict_header);
if (ctx->stat_numuserheaders)
mprint("\nTotal user data fields: %d\n", ctx->stat_numuserheaders);
if (ctx->stat_dvdccheaders)
mprint("DVD-type user data fields: %d\n", ctx->stat_dvdccheaders);
if (ctx->stat_scte20ccheaders)
mprint("SCTE-20 type user data fields: %d\n", ctx->stat_scte20ccheaders);
if (ctx->stat_replay4000headers)
mprint("ReplayTV 4000 user data fields: %d\n", ctx->stat_replay4000headers);
if (ctx->stat_replay5000headers)
mprint("ReplayTV 5000 user data fields: %d\n", ctx->stat_replay5000headers);
if (ctx->stat_hdtv)
mprint("HDTV type user data fields: %d\n", ctx->stat_hdtv);
if (ctx->stat_dishheaders)
mprint("Dish Network user data fields: %d\n", ctx->stat_dishheaders);
if (ctx->stat_divicom)
{
mprint("CEA608/Divicom user data fields: %d\n", ctx->stat_divicom);
mprint("\n\nNOTE! The CEA 608 / Divicom standard encoding for closed\n");
mprint("caption is not well understood!\n\n");
mprint("Please submit samples to the developers.\n\n\n");
}
// Add one frame as fts_max marks the beginning of the last frame,
// but we need the end.
fts_global += fts_max + (LLONG) (1000.0/current_fps);
// CFS: At least in Hauppage mode, cb_field can be responsible for ALL the
// timing (cb_fields having a huge number and fts_now and fts_global being 0 all
// the time), so we need to take that into account in fts_global before resetting
// counters.
if (cb_field1!=0)
fts_global += cb_field1*1001/3;
else
fts_global += cb_field2*1001/3;
// Reset counters - This is needed if some captions are still buffered
// and need to be written after the last file is processed.
cb_field1 = 0; cb_field2 = 0; cb_708 = 0;
fts_now = 0;
fts_max = 0;
} // file loop
close_input_file(ctx);
if (ctx->fh_out_elementarystream!=NULL)
fclose (ctx->fh_out_elementarystream);
flushbuffer (ctx, &ctx->wbout1, false);
flushbuffer (ctx, &ctx->wbout2, false);
prepare_for_new_file (ctx); // To reset counters used by handle_end_of_data()
telxcc_close(ctx);
if (ctx->wbout1.fh!=-1)
{
if (ccx_options.write_format==CCX_OF_SMPTETT || ccx_options.write_format==CCX_OF_SAMI ||
ccx_options.write_format==CCX_OF_SRT || ccx_options.write_format==CCX_OF_TRANSCRIPT
|| ccx_options.write_format==CCX_OF_SPUPNG )
{
handle_end_of_data(dec_ctx->context_cc608_field_1, &dec_sub);
if (dec_sub.got_output)
{
encode_sub(enc_ctx,&dec_sub);
dec_sub.got_output = 0;
}
}
else if(ccx_options.write_format==CCX_OF_RCWT)
{
// Write last header and data
writercwtdata (dec_ctx, NULL);
}
dinit_encoder(enc_ctx);
}
if (ctx->wbout2.fh!=-1)
{
if (ccx_options.write_format==CCX_OF_SMPTETT || ccx_options.write_format==CCX_OF_SAMI ||
ccx_options.write_format==CCX_OF_SRT || ccx_options.write_format==CCX_OF_TRANSCRIPT
|| ccx_options.write_format==CCX_OF_SPUPNG )
{
handle_end_of_data(dec_ctx->context_cc608_field_2, &dec_sub);
if (dec_sub.got_output)
{
encode_sub(enc_ctx,&dec_sub);
dec_sub.got_output = 0;
}
}
dinit_encoder(enc_ctx+1);
}
flushbuffer (ctx, &ctx->wbout1,true);
flushbuffer (ctx, &ctx->wbout2,true);
time (&final);
long proc_time=(long) (final-start);
mprint ("\rDone, processing time = %ld seconds\n", proc_time);
if (proc_time>0)
{
LLONG ratio=(get_fts_max()/10)/proc_time;
unsigned s1=(unsigned) (ratio/100);
unsigned s2=(unsigned) (ratio%100);
mprint ("Performance (real length/process time) = %u.%02u\n",
s1, s2);
}
dbg_print(CCX_DMT_708, "The 708 decoder was reset [%d] times.\n",resets_708);
if (ccx_options.teletext_mode == CCX_TXT_IN_USE)
mprint ( "Teletext decoder: %"PRIu32" packets processed, %"PRIu32" SRT frames written.\n", tlt_packet_counter, tlt_frames_produced);
if (dec_ctx->processed_enough)
{
mprint ("\rNote: Processing was cancelled before all data was processed because\n");
mprint ("\rone or more user-defined limits were reached.\n");
}
if (ccblocks_in_avc_lost>0)
{
mprint ("Total caption blocks received: %d\n", ccblocks_in_avc_total);
mprint ("Total caption blocks lost: %d\n", ccblocks_in_avc_lost);
}
mprint ("This is beta software. Report issues to carlos at ccextractor org...\n");
if (show_myth_banner)
{
mprint ("NOTICE: Due to the major rework in 0.49, we needed to change part of the timing\n");
mprint ("code in the MythTV's branch. Please report results to the address above. If\n");
mprint ("something is broken it will be fixed. Thanks\n");
}
dinit_libraries(&ctx);
return EXIT_OK;
}
int main(int argc, char *argv[]){
/* initialize options */
init_options();
/* parse command line args */
int c;
while((c = getopt(argc, argv, ":hve:p:lku")) != -1){
switch(c){
case 'h': help(argv);
exit(EXIT_SUCCESS);
case 'v': o.verbose = 1;
break;
case 'e': o.execcommand = 1;
o.command = optarg;
break;
case 'p': o.port = validate_port(optarg);
break;
case 'l': o.listen = 1;
break;
case 'k': o.keepopen = 1;
break;
case 'u': o.udp = 1;
break;
case ':': bye("-%c requires argument\n", optopt);
/* case ? */
default: bye("unknown option -%c\n", optopt);
}/* switch */
}/* while */
/* do some checking */
/* -k specified without -l */
if(o.keepopen && !o.listen){
bye("cannot specify -k without -l\n");
}
/* -p not specified with -l */
if(o.listen && !o.port){
bye("must specify -p with -l\n");
}
/* get IP-address and port in case of client mode */
if(!o.listen && optind < argc){
o.target = argv[optind++];
if(optind > argc){
bye("No port specified\n");
}
o.port = validate_port(argv[optind]);
} else if(!o.listen){
help(argv);
exit(EXIT_FAILURE);
}
if(o.listen)
start_server();
else
start_client();
return 0;
}/* main() */
// The RTcmix constructor with default SR, NCHANS, and RTBUFSAMPS
RTcmix::RTcmix()
{
init_options(false, NULL);
init(SR, NCHANS, RTBUFSAMPS, NULL, NULL, NULL);
}
int main(int argc, char *argv[])
{
struct lib_ccx_ctx *ctx;
struct lib_cc_decode *dec_ctx = NULL;
int ret = 0;
enum ccx_stream_mode_enum stream_mode;
init_options (&ccx_options);
parse_configuration(&ccx_options);
ret = parse_parameters (&ccx_options, argc, argv);
if (ret == EXIT_NO_INPUT_FILES)
{
usage ();
fatal (EXIT_NO_INPUT_FILES, "(This help screen was shown because there were no input files)\n");
}
else if (ret == EXIT_WITH_HELP)
{
return EXIT_OK;
}
else if (ret != EXIT_OK)
{
exit(ret);
}
// Initialize libraries
ctx = init_libraries(&ccx_options);
if (!ctx && errno == ENOMEM)
fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory\n");
else if (!ctx && errno == EINVAL)
fatal (CCX_COMMON_EXIT_BUG_BUG, "Invalid option to CCextractor Library\n");
else if (!ctx && errno == EPERM)
fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create Output File\n");
else if (!ctx && errno == EACCES)
fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create Output File\n");
else if (!ctx)
fatal (EXIT_NOT_CLASSIFIED, "Unable to create Library Context %d\n",errno);
int show_myth_banner = 0;
params_dump(ctx);
// default teletext page
if (tlt_config.page > 0) {
// dec to BCD, magazine pages numbers are in BCD (ETSI 300 706)
tlt_config.page = ((tlt_config.page / 100) << 8) | (((tlt_config.page / 10) % 10) << 4) | (tlt_config.page % 10);
}
if (ccx_options.transcript_settings.xds)
{
if (ccx_options.write_format != CCX_OF_TRANSCRIPT)
{
ccx_options.transcript_settings.xds = 0;
mprint ("Warning: -xds ignored, XDS can only be exported to transcripts at this time.\n");
}
}
time_t start, final;
time(&start);
if (ccx_options.binary_concat)
{
ctx->total_inputsize=gettotalfilessize(ctx);
if (ctx->total_inputsize==-1)
fatal (EXIT_UNABLE_TO_DETERMINE_FILE_SIZE, "Failed to determine total file size.\n");
}
#ifndef _WIN32
signal_ctx = ctx;
m_signal(SIGINT, sigint_handler);
#endif
while (switch_to_next_file(ctx, 0))
{
prepare_for_new_file(ctx);
stream_mode = ctx->demux_ctx->get_stream_mode(ctx->demux_ctx);
// Disable sync check for raw formats - they have the right timeline.
// Also true for bin formats, but -nosync might have created a
// broken timeline for debug purposes.
// Disable too in MP4, specs doesn't say that there can't be a jump
switch (stream_mode)
{
case CCX_SM_MCPOODLESRAW:
case CCX_SM_RCWT:
case CCX_SM_MP4:
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
#endif
ccx_common_timing_settings.disable_sync_check = 1;
break;
default:
break;
}
/* -----------------------------------------------------------------
MAIN LOOP
----------------------------------------------------------------- */
switch (stream_mode)
{
case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 1; // Force GOP timing for ES
ccx_common_timing_settings.is_elementary_stream = 1;
case CCX_SM_TRANSPORT:
case CCX_SM_PROGRAM:
case CCX_SM_ASF:
case CCX_SM_WTV:
case CCX_SM_GXF:
#ifdef ENABLE_FFMPEG
case CCX_SM_FFMPEG:
#endif
if (!ccx_options.use_gop_as_pts) // If !0 then the user selected something
ccx_options.use_gop_as_pts = 0;
mprint ("\rAnalyzing data in general mode\n");
general_loop(ctx);
break;
case CCX_SM_MCPOODLESRAW:
mprint ("\rAnalyzing data in McPoodle raw mode\n");
raw_loop(ctx);
break;
case CCX_SM_RCWT:
mprint ("\rAnalyzing data in CCExtractor's binary format\n");
rcwt_loop(ctx);
break;
case CCX_SM_MYTH:
mprint ("\rAnalyzing data in MythTV mode\n");
show_myth_banner = 1;
myth_loop(ctx);
break;
case CCX_SM_MP4:
mprint ("\rAnalyzing data with GPAC (MP4 library)\n");
close_input_file(ctx); // No need to have it open. GPAC will do it for us
processmp4 (ctx, &ctx->mp4_cfg, ctx->inputfile[0]);
if (ccx_options.print_file_reports)
print_file_report(ctx);
break;
#ifdef WTV_DEBUG
case CCX_SM_HEX_DUMP:
close_input_file(ctx); // processhex will open it in text mode
processhex (ctx, ctx->inputfile[0]);
break;
#endif
case CCX_SM_AUTODETECT:
fatal(CCX_COMMON_EXIT_BUG_BUG, "Cannot be reached!");
break;
}
#if 0
if (ctx->total_pulldownframes)
mprint ("incl. pulldown frames: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(ctx->total_pulldownframes*1000/current_fps) ),
ctx->total_pulldownframes, current_fps);
if (pts_set >= 1 && min_pts != 0x01FFFFFFFFLL)
{
LLONG postsyncms = (LLONG) (ctx->frames_since_last_gop*1000/current_fps);
mprint ("\nMin PTS: %s\n",
print_mstime( min_pts/(MPEG_CLOCK_FREQ/1000) - fts_offset));
if (pts_big_change)
mprint ("(Reference clock was reset at some point, Min PTS is approximated)\n");
mprint ("Max PTS: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms));
mprint ("Length: %s\n",
print_mstime( sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms
- min_pts/(MPEG_CLOCK_FREQ/1000) + fts_offset ));
}
// dvr-ms files have invalid GOPs
if (gop_time.inited && first_gop_time.inited && stream_mode != CCX_SM_ASF)
{
mprint ("\nInitial GOP time: %s\n",
print_mstime(first_gop_time.ms));
mprint ("Final GOP time: %s%+3dF\n",
print_mstime(gop_time.ms),
ctx->frames_since_last_gop);
mprint ("Diff. GOP length: %s%+3dF",
print_mstime(gop_time.ms - first_gop_time.ms),
ctx->frames_since_last_gop);
mprint (" (%s)\n",
print_mstime(gop_time.ms - first_gop_time.ms
+(LLONG) ((ctx->frames_since_last_gop)*1000/29.97)) );
}
if (ctx->false_pict_header)
mprint ("\nNumber of likely false picture headers (discarded): %d\n",ctx->false_pict_header);
if (ctx->stat_numuserheaders)
mprint("\nTotal user data fields: %d\n", ctx->stat_numuserheaders);
if (ctx->stat_dvdccheaders)
mprint("DVD-type user data fields: %d\n", ctx->stat_dvdccheaders);
if (ctx->stat_scte20ccheaders)
mprint("SCTE-20 type user data fields: %d\n", ctx->stat_scte20ccheaders);
if (ctx->stat_replay4000headers)
mprint("ReplayTV 4000 user data fields: %d\n", ctx->stat_replay4000headers);
if (ctx->stat_replay5000headers)
mprint("ReplayTV 5000 user data fields: %d\n", ctx->stat_replay5000headers);
if (ctx->stat_hdtv)
mprint("HDTV type user data fields: %d\n", ctx->stat_hdtv);
if (ctx->stat_dishheaders)
mprint("Dish Network user data fields: %d\n", ctx->stat_dishheaders);
if (ctx->stat_divicom)
{
mprint("CEA608/Divicom user data fields: %d\n", ctx->stat_divicom);
mprint("\n\nNOTE! The CEA 608 / Divicom standard encoding for closed\n");
mprint("caption is not well understood!\n\n");
mprint("Please submit samples to the developers.\n\n\n");
}
#endif
list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
{
mprint("\n");
dbg_print(CCX_DMT_DECODER_608, "\nTime stamps after last caption block was written:\n");
dbg_print(CCX_DMT_DECODER_608, "GOP: %s \n", print_mstime(gop_time.ms) );
dbg_print(CCX_DMT_DECODER_608, "GOP: %s (%+3dms incl.)\n",
print_mstime((LLONG)(gop_time.ms
-first_gop_time.ms
+get_fts_max(dec_ctx->timing)-fts_at_gop_start)),
(int)(get_fts_max(dec_ctx->timing)-fts_at_gop_start));
// When padding is active the CC block time should be within
// 1000/29.97 us of the differences.
dbg_print(CCX_DMT_DECODER_608, "Max. FTS: %s (without caption blocks since then)\n",
print_mstime(get_fts_max(dec_ctx->timing)));
if (dec_ctx->codec == CCX_CODEC_ATSC_CC)
{
mprint ("\nTotal frames time: %s (%u frames at %.2ffps)\n",
print_mstime( (LLONG)(total_frames_count*1000/current_fps) ),
total_frames_count, current_fps);
}
if (ctx->stat_hdtv)
{
mprint ("\rCC type 0: %d (%s)\n", dec_ctx->cc_stats[0], cc_types[0]);
mprint ("CC type 1: %d (%s)\n", dec_ctx->cc_stats[1], cc_types[1]);
mprint ("CC type 2: %d (%s)\n", dec_ctx->cc_stats[2], cc_types[2]);
mprint ("CC type 3: %d (%s)\n", dec_ctx->cc_stats[3], cc_types[3]);
}
// Add one frame as fts_max marks the beginning of the last frame,
// but we need the end.
dec_ctx->timing->fts_global += dec_ctx->timing->fts_max + (LLONG) (1000.0/current_fps);
// CFS: At least in Hauppage mode, cb_field can be responsible for ALL the
// timing (cb_fields having a huge number and fts_now and fts_global being 0 all
// the time), so we need to take that into account in fts_global before resetting
// counters.
if (cb_field1!=0)
dec_ctx->timing->fts_global += cb_field1*1001/3;
else if (cb_field2!=0)
dec_ctx->timing->fts_global += cb_field2*1001/3;
else
dec_ctx->timing->fts_global += cb_708*1001/3;
// Reset counters - This is needed if some captions are still buffered
// and need to be written after the last file is processed.
cb_field1 = 0; cb_field2 = 0; cb_708 = 0;
dec_ctx->timing->fts_now = 0;
dec_ctx->timing->fts_max = 0;
}
if(is_decoder_processed_enough(ctx) == CCX_TRUE)
break;
} // file loop
close_input_file(ctx);
prepare_for_new_file (ctx); // To reset counters used by handle_end_of_data()
time (&final);
long proc_time=(long) (final-start);
mprint ("\rDone, processing time = %ld seconds\n", proc_time);
#if 0
if (proc_time>0)
{
LLONG ratio=(get_fts_max()/10)/proc_time;
unsigned s1=(unsigned) (ratio/100);
unsigned s2=(unsigned) (ratio%100);
mprint ("Performance (real length/process time) = %u.%02u\n",
s1, s2);
}
#endif
dbg_print(CCX_DMT_708, "[CEA-708] The 708 decoder was reset [%d] times.\n", ctx->freport.data_from_708->reset_count);
if (is_decoder_processed_enough(ctx) == CCX_TRUE)
{
mprint ("\rNote: Processing was cancelled before all data was processed because\n");
mprint ("\rone or more user-defined limits were reached.\n");
}
mprint ("This is beta software. Report issues to carlos at ccextractor org...\n");
if (show_myth_banner)
{
mprint ("NOTICE: Due to the major rework in 0.49, we needed to change part of the timing\n");
mprint ("code in the MythTV's branch. Please report results to the address above. If\n");
mprint ("something is broken it will be fixed. Thanks\n");
}
dinit_libraries(&ctx);
return EXIT_OK;
}
// The RTcmix constructor with settable SR, NCHANS; default RTBUFSAMPS
RTcmix::RTcmix(float tsr, int tnchans)
{
init_options(false, NULL);
init(tsr, tnchans, RTBUFSAMPS, NULL, NULL, NULL);
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_status_t status;
global.port = 5060;
pj_log_set_level(4);
status = init_options(argc, argv);
if (status != PJ_SUCCESS)
return 1;
status = init_stack();
if (status != PJ_SUCCESS) {
app_perror("Error initializing stack", status);
return 1;
}
status = init_proxy();
if (status != PJ_SUCCESS) {
app_perror("Error initializing proxy", status);
return 1;
}
status = init_stateless_proxy();
if (status != PJ_SUCCESS) {
app_perror("Error initializing stateless proxy", status);
return 1;
}
#if PJ_HAS_THREADS
status = pj_thread_create(global.pool, "sproxy", &worker_thread,
NULL, 0, 0, &global.thread);
if (status != PJ_SUCCESS) {
app_perror("Error creating thread", status);
return 1;
}
while (!global.quit_flag) {
char line[10];
puts("\n"
"Menu:\n"
" q quit\n"
" d dump status\n"
" dd dump detailed status\n"
"");
if (fgets(line, sizeof(line), stdin) == NULL) {
puts("EOF while reading stdin, will quit now..");
global.quit_flag = PJ_TRUE;
break;
}
if (line[0] == 'q') {
global.quit_flag = PJ_TRUE;
} else if (line[0] == 'd') {
pj_bool_t detail = (line[1] == 'd');
pjsip_endpt_dump(global.endpt, detail);
#if STATEFUL
pjsip_tsx_layer_dump(detail);
#endif
}
}
pj_thread_join(global.thread);
#else
puts("\nPress Ctrl-C to quit\n");
for (;;) {
pj_time_val delay = {0, 0};
pjsip_endpt_handle_events(global.endpt, &delay);
}
#endif
destroy_stack();
return 0;
}
RTcmix::RTcmix(float tsr, int tnchans, int bsize,
const char *opt1, const char *opt2, const char *opt3)
{
init_options(false, NULL);
init(tsr, tnchans, bsize, opt1, opt2, opt3);
}
void parse_options(int argc, char **argv, char **query, char **path) {
int ch;
const char *pcre_err = NULL;
int pcre_err_offset = 0;
int path_len = 0;
int useless = 0;
int group = 1;
int help = 0;
int version = 0;
int opt_index = 0;
init_options();
struct option longopts[] = {
{ "ackmate", no_argument, &(opts.ackmate), 1 },
{ "ackmate-dir-filter", required_argument, NULL, 0 },
{ "after", required_argument, NULL, 'A' },
{ "all-types", no_argument, NULL, 'a' },
{ "before", required_argument, NULL, 'B' },
{ "break", no_argument, &(opts.print_break), 1 },
{ "nobreak", no_argument, &(opts.print_break), 0 },
{ "color", no_argument, &(opts.color), 1 },
{ "nocolor", no_argument, &(opts.color), 0 },
{ "column", no_argument, &(opts.column), 1 },
{ "context", optional_argument, &(opts.context), 2 },
{ "debug", no_argument, NULL, 'D' },
{ "depth", required_argument, NULL, 0 },
{ "follow", no_argument, &(opts.follow_symlinks), 1 },
{ "file-search-regex", required_argument, NULL, 'G' },
{ "group", no_argument, &(group), 1 },
{ "nogroup", no_argument, &(group), 0 },
{ "invert-match", no_argument, &(opts.invert_match), 1 },
{ "nofollow", no_argument, &(opts.follow_symlinks), 0 },
{ "heading", no_argument, &(opts.print_heading), 1 },
{ "noheading", no_argument, &(opts.print_heading), 0 },
{ "no-recurse", no_argument, NULL, 'n' },
{ "help", no_argument, NULL, 'h' },
{ "ignore-case", no_argument, NULL, 'i' },
{ "files-with-matches", no_argument, NULL, 'l' },
{ "literal", no_argument, &(opts.literal), 1 },
{ "match", no_argument, &useless, 0 },
{ "max-count", required_argument, NULL, 'm' },
{ "print-long-lines", no_argument, &(opts.print_long_lines), 1 },
{ "search-binary", no_argument, &(opts.search_binary_files), 1 },
{ "smart-case", no_argument, &useless, 0 },
{ "nosmart-case", no_argument, &useless, 0 },
{ "stats", no_argument, &(opts.stats), 1 },
{ "unrestricted", no_argument, NULL, 'u' },
{ "version", no_argument, &version, 1 },
{ NULL, 0, NULL, 0 }
};
if (argc < 2) {
usage();
exit(1);
}
/* stdin isn't a tty. something's probably being piped to ag */
if (!isatty(fileno(stdin))) {
opts.search_stream = 1;
}
/* If we're not outputting to a terminal. change output to:
* turn off colors
* print filenames on every line
*/
if (!isatty(fileno(stdout))) {
opts.color = 0;
group = 0;
}
while ((ch = getopt_long(argc, argv, "A:aB:C:DG:fhilm:nvVu", longopts, &opt_index)) != -1) {
switch (ch) {
case 'A':
opts.after = atoi(optarg);
break;
case 'a':
opts.search_all_files = 1;
opts.search_binary_files = 1;
break;
case 'B':
opts.before = atoi(optarg);
break;
case 'C':
opts.context = atoi(optarg);
break;
case 'D':
set_log_level(LOG_LEVEL_DEBUG);
break;
case 'f':
opts.print_filename_only = 1;
break;
case 'G':
opts.file_search_regex = pcre_compile(optarg, 0, &pcre_err, &pcre_err_offset, NULL);
if (opts.file_search_regex == NULL) {
log_err("pcre_compile of file-search-regex failed at position %i. Error: %s", pcre_err_offset, pcre_err);
exit(1);
}
opts.file_search_regex_extra = pcre_study(opts.file_search_regex, 0, &pcre_err);
if (opts.file_search_regex_extra == NULL) {
log_err("pcre_study of file-search-regex failed. Error: %s", pcre_err);
exit(1);
}
break;
case 'h':
help = 1;
break;
case 'i':
opts.casing = CASE_INSENSITIVE;
break;
case 'l':
opts.print_filename_only = 1;
break;
case 'm':
opts.max_matches_per_file = atoi(optarg);
break;
case 'n':
opts.recurse_dirs = 0;
break;
case 'u':
opts.search_binary_files = 1;
opts.search_unrestricted = 1;
break;
case 'v':
opts.invert_match = 1;
break;
case 'V':
version = 1;
break;
case 0: /* Long option */
if (strcmp(longopts[opt_index].name, "ackmate-dir-filter") == 0)
{
opts.ackmate_dir_filter = pcre_compile(optarg, 0, &pcre_err, &pcre_err_offset, NULL);
if (opts.ackmate_dir_filter == NULL) {
log_err("pcre_compile of ackmate-dir-filter failed at position %i. Error: %s", pcre_err_offset, pcre_err);
exit(1);
}
opts.ackmate_dir_filter_extra = pcre_study(opts.ackmate_dir_filter, 0, &pcre_err);
if (opts.ackmate_dir_filter_extra == NULL) {
log_err("pcre_study of ackmate-dir-filter failed. Error: %s", pcre_err);
exit(1);
}
break;
}
else if (strcmp(longopts[opt_index].name, "depth") == 0) {
opts.max_search_depth = atoi(optarg);
break;
}
/* Continue to usage if we don't recognize the option */
if (longopts[opt_index].flag != 0) {
break;
}
log_err("option %s does not take a value", longopts[opt_index].name);
default:
usage();
exit(1);
}
}
argc -= optind;
argv += optind;
if (help) {
usage();
exit(0);
}
if (version) {
print_version();
exit(0);
}
if (argc == 0) {
log_err("What do you want to search for?");
exit(1);
}
if (opts.context > 0) {
opts.before = opts.context;
opts.after = opts.context;
}
if (opts.ackmate) {
opts.color = 0;
opts.print_break = 1;
group = 1;
opts.search_stream = 0;
}
if (opts.print_heading == 0 || opts.print_break == 0) {
goto skip_group;
}
if (group) {
opts.print_heading = 1;
opts.print_break = 1;
}
else {
opts.print_heading = 0;
opts.print_break = 0;
}
skip_group:
if (opts.search_stream) {
opts.print_break = 0;
opts.print_heading = 0;
opts.print_line_numbers = 0;
}
opts.query = strdup(argv[0]);
opts.query_len = strlen(opts.query);
*query = opts.query;
if (opts.query_len == 0) {
log_err("Error: No query. What do you want to search for?");
exit(1);
}
if (argc > 1) {
*path = strdup(argv[1]);
path_len = strlen(*path);
/* kill trailing slash */
if (path_len > 0 && (*path)[path_len - 1] == '/') {
(*path)[path_len - 1] = '\0';
}
}
else {
*path = strdup(".");
}
}
SANE_Status soapht_open(SANE_String_Const device, SANE_Handle *handle)
{
struct hpmud_model_attributes ma;
int i, stat = SANE_STATUS_IO_ERROR;
DBG8("sane_hpaio_open(%s)\n", device);
if (session)
{
BUG("session in use\n");
return SANE_STATUS_DEVICE_BUSY;
}
if ((session = create_session()) == NULL)
return SANE_STATUS_NO_MEM;
/* Set session to specified device. */
snprintf(session->uri, sizeof(session->uri)-1, "hp:%s", device); /* prepend "hp:" */
/* Get actual model attributes from models.dat. */
hpmud_query_model(session->uri, &ma);
session->scan_type = ma.scantype;
if (hpmud_open_device(session->uri, ma.mfp_mode, &session->dd) != HPMUD_R_OK)
{
BUG("unable to open device %s\n", session->uri);
goto bugout;
free(session);
session = NULL;
return SANE_STATUS_IO_ERROR;
}
if (bb_load(session, SCAN_PLUGIN_SOAPHT))
{
stat = SANE_STATUS_IO_ERROR;
goto bugout;
}
/* Init sane option descriptors. */
init_options(session);
if (session->bb_open(session))
{
stat = SANE_STATUS_IO_ERROR;
goto bugout;
}
/* Set supported Scan Modes as determined by bb_open. */
soapht_control_option(session, SOAP_OPTION_SCAN_MODE, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set scan input sources as determined by bb_open. */
soapht_control_option(session, SOAP_OPTION_INPUT_SOURCE, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set supported resolutions. */
soapht_control_option(session, SOAP_OPTION_SCAN_RESOLUTION, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set supported brightness. */
soapht_control_option(session, SOAP_OPTION_BRIGHTNESS, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set supported contrast. */
soapht_control_option(session, SOAP_OPTION_CONTRAST, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set supported compression. (Note, cm1017 may say it supports MMR, but it doesn't) */
soapht_control_option(session, SOAP_OPTION_COMPRESSION, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Determine supported jpeg quality factor as determined by bb_open. */
soapht_control_option(session, SOAP_OPTION_JPEG_QUALITY, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
/* Set x,y extents. See bb_open */
soapht_control_option(session, SOAP_OPTION_TL_X, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
soapht_control_option(session, SOAP_OPTION_TL_Y, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
soapht_control_option(session, SOAP_OPTION_BR_X, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
soapht_control_option(session, SOAP_OPTION_BR_Y, SANE_ACTION_SET_AUTO, NULL, NULL); /* set default option */
*handle = (SANE_Handle *)session;
stat = SANE_STATUS_GOOD;
bugout:
if (stat != SANE_STATUS_GOOD)
{
if (session)
{
bb_unload(session);
if (session->dd > 0)
hpmud_close_device(session->dd);
free(session);
session = NULL;
}
}
return stat;
} /* saneht_open */
/**
* OpenVPN's main init-run-cleanup loop.
* @ingroup eventloop
*
* This function contains the two outer OpenVPN loops. Its structure is
* as follows:
* - Once-per-process initialization.
* - Outer loop, run at startup and then once per \c SIGHUP:
* - Level 1 initialization
* - Inner loop, run at startup and then once per \c SIGUSR1:
* - Call event loop function depending on client or server mode:
* - \c tunnel_point_to_point()
* - \c tunnel_server()
* - Level 1 cleanup
* - Once-per-process cleanup.
*
* @param argc - Commandline argument count.
* @param argv - Commandline argument values.
*/
int
main (int argc, char *argv[])
{
struct context c;
#if PEDANTIC
fprintf (stderr, "Sorry, I was built with --enable-pedantic and I am incapable of doing any real work!\n");
return 1;
#endif
CLEAR (c);
/* signify first time for components which can
only be initialized once per program instantiation. */
c.first_time = true;
/* initialize program-wide statics */
if (init_static ())
{
/*
* This loop is initially executed on startup and then
* once per SIGHUP.
*/
do
{
/* enter pre-initialization mode with regard to signal handling */
pre_init_signal_catch ();
/* zero context struct but leave first_time member alone */
context_clear_all_except_first_time (&c);
/* static signal info object */
CLEAR (siginfo_static);
c.sig = &siginfo_static;
/* initialize garbage collector scoped to context object */
gc_init (&c.gc);
/* initialize environmental variable store */
c.es = env_set_create (NULL);
#ifdef WIN32
env_set_add_win32 (c.es);
#endif
#ifdef ENABLE_MANAGEMENT
/* initialize management subsystem */
init_management (&c);
#endif
/* initialize options to default state */
init_options (&c.options, true);
/* parse command line options, and read configuration file */
parse_argv (&c.options, argc, argv, M_USAGE, OPT_P_DEFAULT, NULL, c.es);
#ifdef ENABLE_PLUGIN
/* plugins may contribute options configuration */
init_verb_mute (&c, IVM_LEVEL_1);
init_plugins (&c);
open_plugins (&c, true, OPENVPN_PLUGIN_INIT_PRE_CONFIG_PARSE);
#endif
/* init verbosity and mute levels */
init_verb_mute (&c, IVM_LEVEL_1);
/* set dev options */
init_options_dev (&c.options);
/* openssl print info? */
if (print_openssl_info (&c.options))
break;
/* --genkey mode? */
if (do_genkey (&c.options))
break;
/* tun/tap persist command? */
if (do_persist_tuntap (&c.options))
break;
/* sanity check on options */
options_postprocess (&c.options);
/* show all option settings */
show_settings (&c.options);
/* print version number */
msg (M_INFO, "%s", title_string);
/* misc stuff */
pre_setup (&c.options);
/* test crypto? */
if (do_test_crypto (&c.options))
break;
#ifdef ENABLE_MANAGEMENT
/* open management subsystem */
if (!open_management (&c))
break;
#endif
/* set certain options as environmental variables */
setenv_settings (c.es, &c.options);
/* finish context init */
context_init_1 (&c);
do
{
/* run tunnel depending on mode */
switch (c.options.mode)
{
case MODE_POINT_TO_POINT:
tunnel_point_to_point (&c);
break;
#if P2MP_SERVER
case MODE_SERVER:
tunnel_server (&c);
break;
#endif
default:
ASSERT (0);
}
/* indicates first iteration -- has program-wide scope */
c.first_time = false;
/* any signals received? */
if (IS_SIG (&c))
print_signal (c.sig, NULL, M_INFO);
/* pass restart status to management subsystem */
signal_restart_status (c.sig);
}
while (c.sig->signal_received == SIGUSR1);
uninit_options (&c.options);
gc_reset (&c.gc);
}
while (c.sig->signal_received == SIGHUP);
}
context_gc_free (&c);
env_set_destroy (c.es);
#ifdef ENABLE_MANAGEMENT
/* close management interface */
close_management ();
#endif
/* uninitialize program-wide statics */
uninit_static ();
openvpn_exit (OPENVPN_EXIT_STATUS_GOOD); /* exit point */
return 0; /* NOTREACHED */
}
void parse_options(int argc, char **argv, char **paths[]) {
int ch;
int i;
int path_len = 0;
int useless = 0;
int group = 1;
int help = 0;
int version = 0;
int opt_index = 0;
const char *home_dir = getenv("HOME");
char *ignore_file_path = NULL;
int needs_query = 1;
init_options();
struct option longopts[] = {
{ "ackmate", no_argument, &(opts.ackmate), 1 },
{ "ackmate-dir-filter", required_argument, NULL, 0 },
{ "after", required_argument, NULL, 'A' },
{ "all-text", no_argument, NULL, 't' },
{ "all-types", no_argument, NULL, 'a' },
{ "before", required_argument, NULL, 'B' },
{ "break", no_argument, &(opts.print_break), 1 },
{ "case-sensitive", no_argument, NULL, 's' },
{ "color", no_argument, &(opts.color), 1 },
{ "column", no_argument, &(opts.column), 1 },
{ "context", optional_argument, NULL, 'C' },
{ "debug", no_argument, NULL, 'D' },
{ "depth", required_argument, NULL, 0 },
{ "file-search-regex", required_argument, NULL, 'G' },
{ "files-with-matches", no_argument, NULL, 'l' },
{ "files-without-matches", no_argument, NULL, 'L' },
{ "follow", no_argument, &(opts.follow_symlinks), 1 },
{ "group", no_argument, &(group), 1 },
{ "heading", no_argument, &(opts.print_heading), 1 },
{ "help", no_argument, NULL, 'h' },
{ "hidden", no_argument, &(opts.search_hidden_files), 1 },
{ "ignore", required_argument, NULL, 0 },
{ "ignore-case", no_argument, NULL, 'i' },
{ "invert-match", no_argument, &(opts.invert_match), 1 },
{ "literal", no_argument, NULL, 'Q' },
{ "match", no_argument, &useless, 0 },
{ "max-count", required_argument, NULL, 'm' },
{ "no-recurse", no_argument, NULL, 'n' },
{ "nobreak", no_argument, &(opts.print_break), 0 },
{ "nocolor", no_argument, &(opts.color), 0 },
{ "nofollow", no_argument, &(opts.follow_symlinks), 0 },
{ "nogroup", no_argument, &(group), 0 },
{ "noheading", no_argument, &(opts.print_heading), 0 },
{ "parallel", no_argument, &(opts.parallel), 1},
{ "path-to-agignore", required_argument, NULL, 'p'},
{ "print-long-lines", no_argument, &(opts.print_long_lines), 1 },
{ "recurse", no_argument, NULL, 'r' },
{ "search-binary", no_argument, &(opts.search_binary_files), 1 },
{ "search-files", no_argument, &(opts.search_stream), 0 },
{ "skip-vcs-ignores", no_argument, NULL, 'U' },
{ "smart-case", no_argument, NULL, 'S' },
{ "stats", no_argument, &(opts.stats), 1 },
{ "unrestricted", no_argument, NULL, 'u' },
{ "version", no_argument, &version, 1 },
{ "word-regexp", no_argument, NULL, 'w' },
{ "workers", required_argument, NULL, 0 },
{ NULL, 0, NULL, 0 }
};
if (argc < 2) {
usage();
exit(1);
}
/* stdin isn't a tty. something's probably being piped to ag */
if (!isatty(fileno(stdin))) {
opts.search_stream = 1;
}
/* If we're not outputting to a terminal. change output to:
* turn off colors
* print filenames on every line
*/
if (!isatty(fileno(stdout))) {
opts.color = 0;
group = 0;
}
while ((ch = getopt_long(argc, argv, "A:aB:C:DG:g:fhiLlm:np:QRrSsvVtuUw", longopts, &opt_index)) != -1) {
switch (ch) {
case 'A':
opts.after = atoi(optarg);
break;
case 'a':
opts.search_all_files = 1;
opts.search_binary_files = 1;
break;
case 'B':
opts.before = atoi(optarg);
break;
case 'C':
if (optarg) {
opts.context = atoi(optarg);
if (opts.context == 0 && errno == EINVAL) {
/* This arg must be the search string instead of the context length */
optind--;
opts.context = DEFAULT_CONTEXT_LEN;
}
}
else {
opts.context = DEFAULT_CONTEXT_LEN;
}
break;
case 'D':
set_log_level(LOG_LEVEL_DEBUG);
break;
case 'f':
opts.follow_symlinks = 1;
break;
case 'g':
needs_query = 0;
opts.match_files = 1;
/* Fall through and build regex */
case 'G':
compile_study(&opts.file_search_regex, &opts.file_search_regex_extra, optarg, 0, 0);
break;
case 'h':
help = 1;
break;
case 'i':
opts.casing = CASE_INSENSITIVE;
break;
case 'L':
opts.invert_match = 1;
/* fall through */
case 'l':
opts.print_filename_only = 1;
break;
case 'm':
opts.max_matches_per_file = atoi(optarg);
break;
case 'n':
opts.recurse_dirs = 0;
break;
case 'p':
opts.path_to_agignore = optarg;
break;
case 'Q':
opts.literal = 1;
break;
case 'R':
case 'r':
opts.recurse_dirs = 1;
break;
case 'S':
opts.casing = CASE_SMART;
break;
case 's':
opts.casing = CASE_SENSITIVE;
break;
case 't':
opts.search_all_files = 1;
break;
case 'u':
opts.search_binary_files = 1;
opts.search_all_files = 1;
opts.search_hidden_files = 1;
break;
case 'U':
opts.skip_vcs_ignores = 1;
break;
case 'v':
opts.invert_match = 1;
break;
case 'V':
version = 1;
break;
case 'w':
opts.word_regexp = 1;
break;
case 0: /* Long option */
if (strcmp(longopts[opt_index].name, "ackmate-dir-filter") == 0) {
compile_study(&opts.ackmate_dir_filter, &opts.ackmate_dir_filter_extra, optarg, 0, 0);
break;
}
else if (strcmp(longopts[opt_index].name, "depth") == 0) {
opts.max_search_depth = atoi(optarg);
break;
}
else if (strcmp(longopts[opt_index].name, "ignore") == 0) {
add_ignore_pattern(root_ignores, optarg);
break;
}
else if (strcmp(longopts[opt_index].name, "workers") == 0) {
opts.workers = atoi(optarg);
break;
}
/* Continue to usage if we don't recognize the option */
if (longopts[opt_index].flag != 0) {
break;
}
log_err("option %s does not take a value", longopts[opt_index].name);
default:
usage();
exit(1);
}
}
argc -= optind;
argv += optind;
if (help) {
usage();
exit(0);
}
if (version) {
print_version();
exit(0);
}
if (needs_query && argc == 0) {
log_err("What do you want to search for?");
exit(1);
}
if (home_dir && !opts.search_all_files) {
log_debug("Found user's home dir: %s", home_dir);
asprintf(&ignore_file_path, "%s/%s", home_dir, ignore_pattern_files[0]);
load_ignore_patterns(root_ignores, ignore_file_path);
free(ignore_file_path);
}
if (opts.context > 0) {
opts.before = opts.context;
opts.after = opts.context;
}
if (opts.ackmate) {
opts.color = 0;
opts.print_break = 1;
group = 1;
opts.search_stream = 0;
}
if (opts.parallel) {
opts.search_stream = 0;
}
if (opts.print_heading == 0 || opts.print_break == 0) {
goto skip_group;
}
if (group) {
opts.print_heading = 1;
opts.print_break = 1;
}
else {
opts.print_heading = 0;
opts.print_break = 0;
}
skip_group:;
if (opts.search_stream) {
opts.print_break = 0;
opts.print_heading = 0;
opts.print_line_numbers = 0;
}
if (needs_query) {
opts.query = strdup(argv[0]);
argc--;
argv++;
}
else {
opts.query = strdup(".");
}
opts.query_len = strlen(opts.query);
log_debug("Query is %s", opts.query);
if (opts.query_len == 0) {
log_err("Error: No query. What do you want to search for?");
exit(1);
}
if (!is_regex(opts.query)) {
opts.literal = 1;
}
char *path = NULL;
opts.paths_len = argc;
if (argc > 0) {
*paths = calloc(sizeof(char*), argc + 1);
for (i = 0; i < argc; i++) {
path = strdup(argv[i]);
path_len = strlen(path);
/* kill trailing slash */
if (path_len > 1 && path[path_len - 1] == '/') {
path[path_len - 1] = '\0';
}
(*paths)[i] = path;
}
(*paths)[i] = NULL;
/* Make sure we search these paths instead of stdin. */
opts.search_stream = 0;
}
else {
path = strdup(".");
*paths = malloc(sizeof(char*) * 2);
(*paths)[0] = path;
(*paths)[1] = NULL;
}
}
