int
MainHelper::operator()()
{
parse_standard_options();
int res = 1;
try
{
setup_logging();
parse_command_line_arguments();
check_no_unrecognized();
print_version_data();
res = run();
}
catch (std::exception& e)
{
LOG_FATAL("caught exception: " << e.what());
}
catch (...)
{
LOG_FATAL("caught unknown exception");
}
at_exit();
google::protobuf::ShutdownProtobufLibrary();
return res;
}
int Main() {
ScopeExit at_exit(Logger::ExitLogger);
try {
Add(std::make_unique<FilesCommand>());
Add(std::make_unique<MessagesCommand>());
Add(std::make_unique<NetCommand>());
Add(std::make_unique<FixCommand>());
Add(std::make_unique<wwiv::wwivutil::fido::FidoCommand>());
if (!cmdline_.Parse()) { return 1; }
const std::string bbsdir(cmdline_.arg("bbsdir").as_string());
Config config(bbsdir);
if (!config.IsInitialized()) {
LOG(ERROR) << "Unable to load CONFIG.DAT.";
return 1;
}
command_config_.reset(new Configuration(bbsdir, &config));
if (!command_config_->initialized()) {
LOG(ERROR) << "Unable to load NETWORKS.";
return 1;
}
SetConfigs();
return cmdline_.Execute();
} catch (const std::exception& e) {
LOG(ERROR) << e.what();
}
return 1;
}
/* ARGSUSED */
static int
linprocfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
{
size_t size;
int error;
if (mp->mnt_flag & MNT_UPDATE)
return (EOPNOTSUPP);
if (mp->mnt_vfc->vfc_refcount == 1 && (error = at_exit(linprocfs_exit))) {
kprintf("linprocfs: cannot register linprocfs_exit with at_exit\n");
return(error);
}
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_kern_flag |= MNTK_NOSTKMNT;
mp->mnt_data = 0;
vfs_getnewfsid(mp);
vfs_add_vnodeops(mp, &linprocfs_vnode_vops, &mp->mnt_vn_norm_ops);
size = sizeof("linprocfs") - 1;
bcopy("linprocfs", mp->mnt_stat.f_mntfromname, size);
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
(void)linprocfs_statfs(mp, &mp->mnt_stat, cred);
return (0);
}
static void signal_trap(int sig)
{
Log2(PCSC_LOG_INFO, "Received signal: %d", sig);
/* do not wait if asked to terminate
* avoids waiting after the reader(s) in shutdown for example */
if (SIGTERM == sig)
{
Log1(PCSC_LOG_INFO, "Direct suicide");
at_exit();
}
if (SIGALRM == sig)
{
/* normal exit without error */
ExitValue = EXIT_SUCCESS;
}
/* the signal handler is called several times for the same Ctrl-C */
if (AraKiri == FALSE)
{
Log1(PCSC_LOG_INFO, "Preparing for suicide");
AraKiri = TRUE;
/* if still in the init/loading phase the AraKiri will not be
* seen by the main event loop
*/
if (Init)
{
Log1(PCSC_LOG_INFO, "Suicide during init");
at_exit();
}
}
else
{
/* if pcscd do not want to die */
static int lives = 2;
lives--;
/* no live left. Something is blocking the normal death. */
if (0 == lives)
{
Log1(PCSC_LOG_INFO, "Forced suicide");
at_exit();
}
}
}
/**
* @brief The Server's Message Queue Listener function.
*
* An endless loop calls the function \c ProcessEventsServer() to check for
* messages sent by clients.
* If the message is valid, \c CreateContextThread() is called to serve this
* request.
*/
static void SVCServiceRunLoop(void)
{
int rsp;
LONG rv;
uint32_t dwClientID; /* Connection ID used to reference the Client */
while (TRUE)
{
if (AraKiri)
{
/* stop the hotpug thread and waits its exit */
#ifdef USE_USB
(void)HPStopHotPluggables();
#endif
(void)SYS_Sleep(1);
/* now stop all the drivers */
RFCleanupReaders();
EHDeinitializeEventStructures();
ContextsDeinitialize();
at_exit();
}
switch (rsp = ProcessEventsServer(&dwClientID))
{
case 0:
Log2(PCSC_LOG_DEBUG, "A new context thread creation is requested: %d", dwClientID);
rv = CreateContextThread(&dwClientID);
if (rv != SCARD_S_SUCCESS)
Log1(PCSC_LOG_ERROR, "Problem during the context thread creation");
break;
case 2:
/*
* timeout in ProcessEventsServer(): do nothing
* this is used to catch the Ctrl-C signal at some time when
* nothing else happens
*/
break;
case -1:
Log1(PCSC_LOG_ERROR, "Error in ProcessEventsServer");
break;
case -2:
/* Nothing to do in case of a syscall interrupted
* It happens when SIGUSR1 (reload) or SIGINT (Ctrl-C) is received
* We just try again */
break;
default:
Log2(PCSC_LOG_ERROR, "ProcessEventsServer unknown retval: %d",
rsp);
break;
}
}
}
/*
* Initialize vnode cache
*/
void
pfs_vncache_load(void)
{
mtx_init(&pfs_vncache_mutex, "pseudofs_vncache", NULL,
MTX_DEF | MTX_RECURSE);
/* XXX at_exit() can fail with ENOMEN */
at_exit(pfs_exit);
}
int
ncp_init(void) {
ncp_conn_init();
if (at_exit(ncp_at_exit)) {
NCPFATAL("can't register at_exit handler\n");
return ENOMEM;
}
ncp_timer_handle = timeout(ncp_timer,NULL,NCP_TIMER_TICK);
return 0;
}
int main(int ac, char **av)
{
parse_args(ac, av);
setup_sighandler(SIGINT, 0, on_sigint);
setup_sighandler(SIGALRM, SA_RESTART, update_display);
alarm(1);
gl_env.last_update_time = time(NULL);
gl_env.logtop = new_logtop(gl_env.history_size);
if (!gl_env.quiet && !gl_env.line_by_line)
curses_setup();
run(gl_env.logtop);
at_exit();
return EXIT_SUCCESS;
}
static real
ginvae(arglist *al) /* like ginv, but enrolling At_reset and At_exit */
{
static int nginv;
AmplExports *ae = al->AE;
if (AEInext < AEIlast) {
AEInext->n = ++nginv;
AEInext->ae = ae;
at_reset(At_reset, AEInext);
at_exit(At_end, AEInext++);
}
return ginv(al);
}
void signal_trap(int sig)
{
/* the signal handler is called several times for the same Ctrl-C */
if (AraKiri == 0)
{
Log1(PCSC_LOG_INFO, "Preparing for suicide");
AraKiri = 1;
/* if still in the init/loading phase the AraKiri will not be
* seen by the main event loop
*/
if (Init)
{
Log1(PCSC_LOG_INFO, "Suicide during init");
at_exit();
}
}
}
/*
* In this function the input gets checked and the other functions are called
* in the correct order.
*/
int main (int argc, char **argv) {
maze_t* maze;
char *solver[] = {"random solver", "smart random solver", "left wall solver",
"right wall solver"
};
walker_t* walker;
int i, count, dir, printmaze;
if (argc < 2) {
printf("The filename of the maze should be passed as an argument\n");
return 0;
}
if (argc > 2) {
i = atoi(argv[2]);
if (i < 0) {
printf("Don't use negative numbers");
return 0;
}
}
else
i = 0;
if (argc > 3) {
printmaze = atoi(argv[3]);
}
else
printmaze = 1;
for(; i < AMNT_SOLVERS; i++) {
srand(SEED);
dir = NORTH;
maze = read_maze(argv[1]);
walker = init_walker(maze);
count = 0;
while (count < MAX_STEPS) {
count++;
switch(i) {
case 0:
dir = random_solver(maze, walker);
break;
case 1:
dir = smart_random_solver_1(maze, walker, dir);
break;
case 2:
dir = left_wall_solver(maze, walker, dir);
break;
case 3:
dir = right_wall_solver(maze, walker, dir);
break;
}
if(printmaze) {
print_maze(maze, walker->row, walker->col);
printf("%d\n", count);
}
if (at_exit(maze, walker))
break;
}
if (count < MAX_STEPS)
printf("Found exit using the %s after %d steps\n", solver[i], count);
printf("Press key to continue\n");
getchar();
}
return 0;
}
int
gen_rand_network_metrop(Network **RN_p,int real_vec13[14])
{
int rc=RC_OK;
int sin_num_of_switchs,dbl_num_of_switchs,num_at_t;
//int s2,t1,t2;
int i,j,l;
int k; // number of succesful switches
int w; // total number of switches
//int tries; //number of tries to find proper pair of edges to exchange
//int twin_i,twin_j;
Network *RN;
int rand_network_checked=FALSE;
Res_tbl met_res_tbl;
//int real_vec13[14];
int rand_vec13[14];
//int sub13[14];
//int add13[14];
//double E1,E2,dE;
double E1,E2;
int snover,dnover; // maximum # of graph changes at any temperature
//int nlimit,snlimit,dnlimit; // maximum # of succesful graph changes at any temperature
int snlimit,dnlimit; // maximum # of succesful graph changes at any temperature
//int make_change;
//int numsucc; // how many successful switches already made
double t; // the temperature
int success;
int dispair=0;
double dummy;
int switches_range;
double *switch_ratio_arr;
switch_ratio_arr=(double*)calloc(GNRL_ST.rnd_net_num+1,sizeof(double));
sin_num_of_switchs=0;
if(G_N->e_sin_num<=1)
sin_num_of_switchs=0;
else {
// num of switches is round(10*(1+rand)*#edges)
//num of edges in undirfecetd is actually *2 therefore divided by 2
switches_range=(int)(2*GNRL_ST.r_switch_factor*G_N->e_sin_num);
sin_num_of_switchs=(int)switches_range+get_rand((int)switches_range);
}
if(G_N->e_dbl_num<=1)
dbl_num_of_switchs=0;
else {
// num of switches is round(10*(1+rand)*#edges)
//num of edges in undirfecetd is actually *2 therefore divided by 2
switches_range=(int)(2*GNRL_ST.r_switch_factor*G_N->e_dbl_num/2);
dbl_num_of_switchs=(int)switches_range+get_rand((int)switches_range);
}
t=GNRL_ST.t_init;
if (GNRL_ST.use_stubs_method==TRUE)
{
success=0;
dispair=0;
while ((success==FALSE)&&(dispair<GEN_NETWORK_DISPAIR))
{
//printf("trying ron\n");
rc=gen_rand_network_stubs_method(&RN);
if(rc==RC_OK)
success=TRUE;
else
success=FALSE;
if (success==FALSE)
{
//printf("dispair - discard\n");
dispair++;
}
}
if (dispair==GEN_NETWORK_DISPAIR) // give up try switch method
gen_rand_network_switches_method_conserve_double_edges(&RN,&dummy);
else
{
success=update_network(RN,G_N);
if (!success)
{
printf("Error - degrees don't match\n");
at_exit(-1);
}
//shuffle_double_edges(RN);
if (DEBUG_LEVEL>20 && GNRL_ST.out_log_flag)
{
fprintf(GNRL_ST.log_fp,"The network :\n\n");
for (l=1;l<=(*RN).edges_num;l++)
fprintf(GNRL_ST.log_fp,"%d %d %d\n",(*RN).e_arr[l].t,(*RN).e_arr[l].s,1);
}
}
}
else
gen_rand_network_switches_method_conserve_double_edges(&RN, &dummy);
/**************************************************************/
/**************************************************************/
/**************************************************************/
/* Part II - metropolis algorithm. Perform switches with probability*/
/**************************************************************/
/**************************************************************/
/**************************************************************/
/**************************************************************/
/* metropolis parameters depend on num_of _switches*/
/* otuput real network to _METROP file */
init_res_tbl(&met_res_tbl);
list64_init(&met_res_tbl.real);
met_motifs_search_real(RN,&met_res_tbl,rand_vec13);
list64_free_mem(met_res_tbl.real);
E1=energy(real_vec13,rand_vec13);
w=0;
if(GNRL_ST.out_metrop_mat_flag) {
fprintf(GNRL_ST.mat_metrop_fp,"\nreal network\n");
fprintf(GNRL_ST.mat_metrop_fp,"E=%lf T=%lf\n",E1,t);
fprintf(GNRL_ST.mat_metrop_fp,"Real triadic census :\n ");
output13(real_vec13,GNRL_ST.mat_metrop_fp);
fprintf(GNRL_ST.mat_metrop_fp,"random network\n");
fprintf(GNRL_ST.mat_metrop_fp,"%lf,%lf \n",E1,t);
fprintf(GNRL_ST.mat_metrop_fp,"Initial random triadic census :\n ");
output13(rand_vec13,GNRL_ST.mat_metrop_fp);
}
/* nover=sin_num_of_switchs*GNRL_ST.iteration_factor;
nlimit=nover/10;
k=0;
num_at_t=0;
sin_metrop_switches(&RN,nover,nlimit,GNRL_ST.t_init,real_vec13,rand_vec13);
*/
if (dbl_num_of_switchs==0)
{
snover=sin_num_of_switchs*(int)GNRL_ST.iteration_factor;
snlimit=snover/10;
t=sin_metrop_switches(&RN,snover,snlimit,GNRL_ST.t_init,real_vec13,rand_vec13);
}
else
{
dnover=dbl_num_of_switchs*(int)GNRL_ST.iteration_factor/10;
dnlimit=dnover/10;
if (dnover<10)
{
dnover=dbl_num_of_switchs;
dnlimit=dnover;
}
t=dbl_metrop_switches(&RN,dnover,dnlimit,GNRL_ST.t_init,real_vec13,rand_vec13);
snover=sin_num_of_switchs*(int)GNRL_ST.iteration_factor/10;
snlimit=snover/10;
k=0;
num_at_t=0;
t=sin_metrop_switches(&RN,snover,snlimit,t,real_vec13,rand_vec13);
if(GNRL_ST.out_metrop_mat_flag) {
fprintf(GNRL_ST.mat_metrop_fp,"End E\n");
printf("End E\n");
}
for (i=1;i<10;i++)
{
E2=energy(real_vec13,rand_vec13);
if (E2>0)
{
t=dbl_metrop_switches(&RN,dnover,dnlimit,t,real_vec13,rand_vec13);
t=sin_metrop_switches(&RN,snover,snlimit,t,real_vec13,rand_vec13);
}
}
}
//check that there are no self edges. If there are any then start again
rand_network_checked = TRUE;
if(GNRL_ST.calc_self_edges == FALSE){
for(i=1;i<=RN->vertices_num;i++) {
if( MatGet(RN->mat,i,i)==1 ) {
printf("Self edges still exist building random graph again\n");
rand_network_checked=FALSE;
free_network_mem(RN);
break;
}
}
}
//merge lists to RN->e_arr
//
j=0;
for(i=1;i<=RN->e_dbl_num;i++) {
RN->e_arr[++j].s=RN->e_arr_dbl[i].s;
RN->e_arr[j].t=RN->e_arr_dbl[i].t;
}
for(i=1;i<=RN->e_sin_num;i++) {
RN->e_arr[++j].s=RN->e_arr_sin[i].s;
RN->e_arr[j].t=RN->e_arr_sin[i].t;
}
if(DEBUG_LEVEL>1 && GNRL_ST.out_metrop_mat_flag) {
fprintf(GNRL_ST.mat_metrop_fp,"The network :\n");
for (i=1;i<=RN->edges_num;i++)
fprintf(GNRL_ST.mat_metrop_fp,"%d %d %d\n",RN->e_arr[i].t,RN->e_arr[i].s,1);
fprintf(GNRL_ST.mat_metrop_fp,"End of network\n");
fprintf(GNRL_ST.mat_metrop_fp,"\n\n");
}
if(GNRL_ST.out_metrop_mat_flag) {
fprintf(GNRL_ST.mat_metrop_fp,"Real triadic census :\n ");
output13(real_vec13,GNRL_ST.mat_metrop_fp);
fprintf(GNRL_ST.mat_metrop_fp,"Final random triadic census :\n ");
output13(rand_vec13,GNRL_ST.mat_metrop_fp);
}
*RN_p=RN;
return RC_OK;
}
int main(int argc, char **argv)
{
int rv;
char setToForeground;
char HotPlug;
char *newReaderConfig;
struct stat fStatBuf;
int customMaxThreadCounter = 0;
int customMaxReaderHandles = 0;
int customMaxThreadCardHandles = 0;
int opt;
int limited_rights = FALSE;
int r;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
static struct option long_options[] = {
{"config", 1, NULL, 'c'},
{"foreground", 0, NULL, 'f'},
{"color", 0, NULL, 'T'},
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'v'},
{"apdu", 0, NULL, 'a'},
{"debug", 0, NULL, 'd'},
{"info", 0, NULL, 0},
{"error", 0, NULL, 'e'},
{"critical", 0, NULL, 'C'},
{"hotplug", 0, NULL, 'H'},
{"force-reader-polling", optional_argument, NULL, 0},
{"max-thread", 1, NULL, 't'},
{"max-card-handle-per-thread", 1, NULL, 's'},
{"max-card-handle-per-reader", 1, NULL, 'r'},
{"auto-exit", 0, NULL, 'x'},
{"reader-name-no-serial", 0, NULL, 'S'},
{"reader-name-no-interface", 0, NULL, 'I'},
{NULL, 0, NULL, 0}
};
#endif
#define OPT_STRING "c:fTdhvaeCHt:r:s:xSI"
newReaderConfig = NULL;
setToForeground = FALSE;
HotPlug = FALSE;
/*
* test the version
*/
if (strcmp(PCSCLITE_VERSION_NUMBER, VERSION) != 0)
{
printf("BUILD ERROR: The release version number PCSCLITE_VERSION_NUMBER\n");
printf(" in pcsclite.h (%s) does not match the release version number\n",
PCSCLITE_VERSION_NUMBER);
printf(" generated in config.h (%s) (see configure.in).\n", VERSION);
return EXIT_FAILURE;
}
/*
* By default we create a daemon (not connected to any output)
* so log to syslog to have error messages.
*/
DebugLogSetLogType(DEBUGLOG_SYSLOG_DEBUG);
/* if the process is setuid or setgid it may have some restrictions */
limited_rights = (getgid() != getegid()) && (getuid() != 0);
/*
* Handle any command line arguments
*/
#ifdef HAVE_GETOPT_LONG
while ((opt = getopt_long (argc, argv, OPT_STRING, long_options, &option_index)) != -1) {
#else
while ((opt = getopt (argc, argv, OPT_STRING)) != -1) {
#endif
switch (opt) {
#ifdef HAVE_GETOPT_LONG
case 0:
if (strcmp(long_options[option_index].name,
"force-reader-polling") == 0)
HPForceReaderPolling = optarg ? abs(atoi(optarg)) : 1;
break;
#endif
case 'c':
if (limited_rights)
{
Log1(PCSC_LOG_CRITICAL, "Can't use a user specified config file");
return EXIT_FAILURE;
}
Log2(PCSC_LOG_INFO, "using new config file: %s", optarg);
newReaderConfig = optarg;
break;
case 'f':
setToForeground = TRUE;
/* debug to stdout instead of default syslog */
DebugLogSetLogType(DEBUGLOG_STDOUT_DEBUG);
Log1(PCSC_LOG_INFO,
"pcscd set to foreground with debug send to stdout");
break;
case 'T':
DebugLogSetLogType(DEBUGLOG_STDOUT_COLOR_DEBUG);
Log1(PCSC_LOG_INFO, "Force colored logs");
break;
case 'd':
DebugLogSetLevel(PCSC_LOG_DEBUG);
break;
case 'e':
DebugLogSetLevel(PCSC_LOG_ERROR);
break;
case 'C':
DebugLogSetLevel(PCSC_LOG_CRITICAL);
break;
case 'h':
print_usage (argv[0]);
return EXIT_SUCCESS;
case 'v':
print_version ();
return EXIT_SUCCESS;
case 'a':
if (limited_rights)
{
Log1(PCSC_LOG_CRITICAL, "Can't log APDU (restricted)");
return EXIT_FAILURE;
}
(void)DebugLogSetCategory(DEBUG_CATEGORY_APDU);
break;
case 'H':
/* debug to stdout instead of default syslog */
DebugLogSetLogType(DEBUGLOG_STDOUT_DEBUG);
HotPlug = TRUE;
break;
case 't':
customMaxThreadCounter = optarg ? atoi(optarg) : 0;
if (limited_rights && (customMaxThreadCounter < PCSC_MAX_CONTEXT_THREADS))
customMaxThreadCounter = PCSC_MAX_CONTEXT_THREADS;
Log2(PCSC_LOG_INFO, "setting customMaxThreadCounter to: %d",
customMaxThreadCounter);
break;
case 'r':
customMaxReaderHandles = optarg ? atoi(optarg) : 0;
if (limited_rights && (customMaxReaderHandles < PCSC_MAX_READER_HANDLES))
customMaxReaderHandles = PCSC_MAX_READER_HANDLES;
Log2(PCSC_LOG_INFO, "setting customMaxReaderHandles to: %d",
customMaxReaderHandles);
break;
case 's':
customMaxThreadCardHandles = optarg ? atoi(optarg) : 0;
if (limited_rights && (customMaxThreadCardHandles < PCSC_MAX_CONTEXT_CARD_HANDLES))
customMaxThreadCardHandles = PCSC_MAX_CONTEXT_CARD_HANDLES;
Log2(PCSC_LOG_INFO, "setting customMaxThreadCardHandles to: %d",
customMaxThreadCardHandles);
break;
case 'x':
AutoExit = TRUE;
Log2(PCSC_LOG_INFO, "Auto exit after %d seconds of inactivity",
TIME_BEFORE_SUICIDE);
break;
case 'S':
Add_Serial_In_Name = FALSE;
break;
case 'I':
Add_Interface_In_Name = FALSE;
break;
default:
print_usage (argv[0]);
return EXIT_FAILURE;
}
}
if (argv[optind])
{
printf("Unknown option: %s\n", argv[optind]);
print_usage(argv[0]);
return EXIT_FAILURE;
}
/*
* Check if systemd passed us any file descriptors
*/
rv = sd_listen_fds(0);
if (rv > 1)
{
Log1(PCSC_LOG_CRITICAL, "Too many file descriptors received");
return EXIT_FAILURE;
}
else
{
if (rv == 1)
{
SocketActivated = TRUE;
Log1(PCSC_LOG_INFO, "Started by systemd");
}
else
SocketActivated = FALSE;
}
/*
* test the presence of /var/run/pcscd/pcscd.comm
*/
rv = stat(PCSCLITE_CSOCK_NAME, &fStatBuf);
if (rv == 0)
{
pid_t pid;
/* read the pid file to get the old pid and test if the old pcscd is
* still running
*/
pid = GetDaemonPid();
if (pid != -1)
{
if (HotPlug)
return SendHotplugSignal();
rv = kill(pid, 0);
if (0 == rv)
{
Log1(PCSC_LOG_CRITICAL,
"file " PCSCLITE_CSOCK_NAME " already exists.");
Log2(PCSC_LOG_CRITICAL,
"Another pcscd (pid: %d) seems to be running.", pid);
return EXIT_FAILURE;
}
else
if (ESRCH == errno)
{
/* the old pcscd is dead. make some cleanup */
clean_temp_files();
}
else
{
/* permission denied or other error */
Log2(PCSC_LOG_CRITICAL, "kill failed: %s", strerror(errno));
return EXIT_FAILURE;
}
}
else
{
if (HotPlug)
{
Log1(PCSC_LOG_CRITICAL, "file " PCSCLITE_RUN_PID " do not exist");
Log1(PCSC_LOG_CRITICAL, "Hotplug failed");
return EXIT_FAILURE;
}
}
}
else
if (HotPlug)
{
Log1(PCSC_LOG_CRITICAL, "Hotplug failed: pcscd is not running");
return EXIT_FAILURE;
}
/* like in daemon(3): changes the current working directory to the
* root ("/") */
r = chdir("/");
if (r < 0)
{
Log2(PCSC_LOG_CRITICAL, "chdir() failed: %s", strerror(errno));
return EXIT_FAILURE;
}
/*
* If this is set to one the user has asked it not to fork
*/
if (!setToForeground)
{
int pid;
int fd;
if (pipe(pipefd) == -1)
{
Log2(PCSC_LOG_CRITICAL, "pipe() failed: %s", strerror(errno));
return EXIT_FAILURE;
}
pid = fork();
if (-1 == pid)
{
Log2(PCSC_LOG_CRITICAL, "fork() failed: %s", strerror(errno));
return EXIT_FAILURE;
}
/* like in daemon(3): redirect standard input, standard output
* and standard error to /dev/null */
fd = open("/dev/null", O_RDWR);
if (fd != -1)
{
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
/* do not close stdin, stdout or stderr */
if (fd > 2)
close(fd);
}
if (pid)
/* in the father */
{
char buf;
int ret;
/* close write side */
close(pipefd[1]);
/* wait for the son to write the return code */
ret = read(pipefd[0], &buf, 1);
if (ret <= 0)
return 2;
close(pipefd[0]);
/* exit code */
return buf;
}
else
/* in the son */
{
/* close read side */
close(pipefd[0]);
}
}
/*
* cleanly remove /var/run/pcscd/files when exiting
* signal_trap() does just set a global variable used by the main loop
*/
(void)signal(SIGQUIT, signal_trap);
(void)signal(SIGTERM, signal_trap); /* default kill signal & init round 1 */
(void)signal(SIGINT, signal_trap); /* sent by Ctrl-C */
/* exits on SIGALARM to allow pcscd to suicide if not used */
(void)signal(SIGALRM, signal_trap);
/*
* If PCSCLITE_IPC_DIR does not exist then create it
*/
{
int mode = S_IROTH | S_IXOTH | S_IRGRP | S_IXGRP | S_IRWXU;
rv = mkdir(PCSCLITE_IPC_DIR, mode);
if ((rv != 0) && (errno != EEXIST))
{
Log2(PCSC_LOG_CRITICAL,
"cannot create " PCSCLITE_IPC_DIR ": %s", strerror(errno));
return EXIT_FAILURE;
}
/* set mode so that the directory is world readable and
* executable even is umask is restrictive
* The directory containes files used by libpcsclite */
(void)chmod(PCSCLITE_IPC_DIR, mode);
}
/*
* Allocate memory for reader structures
*/
rv = RFAllocateReaderSpace(customMaxReaderHandles);
if (SCARD_S_SUCCESS != rv)
at_exit();
#ifdef USE_SERIAL
/*
* Grab the information from the reader.conf
*/
if (newReaderConfig)
{
rv = RFStartSerialReaders(newReaderConfig);
if (rv != 0)
{
Log3(PCSC_LOG_CRITICAL, "invalid file %s: %s", newReaderConfig,
strerror(errno));
at_exit();
}
}
else
{
rv = RFStartSerialReaders(PCSCLITE_CONFIG_DIR);
if (rv == -1)
at_exit();
}
#endif
Log1(PCSC_LOG_INFO, "pcsc-lite " VERSION " daemon ready.");
/*
* Record our pid to make it easier
* to kill the correct pcscd
*
* Do not fork after this point or the stored pid will be wrong
*/
{
int f;
int mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
f = open(PCSCLITE_RUN_PID, O_RDWR | O_CREAT, mode);
if (f != -1)
{
char pid[PID_ASCII_SIZE];
ssize_t rr;
(void)snprintf(pid, sizeof(pid), "%u\n", (unsigned) getpid());
rr = write(f, pid, strlen(pid) + 1);
if (rr < 0)
{
Log2(PCSC_LOG_CRITICAL,
"writing " PCSCLITE_RUN_PID " failed: %s",
strerror(errno));
}
(void)close(f);
/* set mode so that the file is world readable even is umask is
* restrictive
* The file is used by libpcsclite */
(void)chmod(PCSCLITE_RUN_PID, mode);
}
else
Log2(PCSC_LOG_CRITICAL, "cannot create " PCSCLITE_RUN_PID ": %s",
strerror(errno));
}
/*
* post initialistion
*/
Init = FALSE;
/*
* Hotplug rescan
*/
(void)signal(SIGUSR1, signal_reload);
/*
* Initialize the comm structure
*/
if (SocketActivated)
rv = ListenExistingSocket(SD_LISTEN_FDS_START + 0);
else
rv = InitializeSocket();
if (rv)
{
Log1(PCSC_LOG_CRITICAL, "Error initializing pcscd.");
at_exit();
}
/*
* Initialize the contexts structure
*/
rv = ContextsInitialize(customMaxThreadCounter, customMaxThreadCardHandles);
if (rv == -1)
{
Log1(PCSC_LOG_CRITICAL, "Error initializing pcscd.");
at_exit();
}
(void)signal(SIGPIPE, SIG_IGN);
(void)signal(SIGHUP, SIG_IGN); /* needed for Solaris. The signal is sent
* when the shell is existed */
#if !defined(PCSCLITE_STATIC_DRIVER) && defined(USE_USB)
/*
* Set up the search for USB/PCMCIA devices
*/
rv = HPSearchHotPluggables();
#ifndef USE_SERIAL
if (rv)
at_exit();
#endif
rv = HPRegisterForHotplugEvents();
if (rv)
{
Log1(PCSC_LOG_ERROR, "HPRegisterForHotplugEvents failed");
at_exit();
}
RFWaitForReaderInit();
#endif
/*
* Set up the power management callback routine
*/
(void)PMRegisterForPowerEvents();
/* initialisation succeeded */
if (pipefd[1] >= 0)
{
char buf = 0;
ssize_t rr;
/* write a 0 (success) to father process */
rr = write(pipefd[1], &buf, 1);
if (rr < 0)
{
Log2(PCSC_LOG_ERROR, "write() failed: %s", strerror(errno));
}
close(pipefd[1]);
}
SVCServiceRunLoop();
Log1(PCSC_LOG_ERROR, "SVCServiceRunLoop returned");
return EXIT_FAILURE;
}
static void at_exit(void)
{
Log1(PCSC_LOG_INFO, "cleaning " PCSCLITE_IPC_DIR);
clean_temp_files();
if (pipefd[1] >= 0)
{
char buf;
ssize_t r;
/* write the error code to father process */
buf = ExitValue;
r = write(pipefd[1], &buf, 1);
if (r < 0)
{
Log2(PCSC_LOG_ERROR, "write() failed: %s", strerror(errno));
}
close(pipefd[1]);
}
exit(ExitValue);
}
/*
* Display the appropriate prompt.
*/
static void
prompt(void)
{
const char *p;
if (ungot != NULL) {
/*
* No prompt necessary if commands are from
* ungotten chars rather than from the user.
*/
return;
}
/*
* Make sure the screen is displayed.
*/
make_display();
bottompos = position(BOTTOM_PLUS_ONE);
/*
* If we've hit EOF on the last file and the -E flag is set, quit.
*/
if (get_quit_at_eof() == OPT_ONPLUS &&
eof_displayed() && !(ch_getflags() & CH_HELPFILE) &&
next_ifile(curr_ifile) == NULL_IFILE)
quit(QUIT_OK);
/*
* If the entire file is displayed and the -F flag is set, quit.
*/
if (quit_if_one_screen &&
entire_file_displayed() && !(ch_getflags() & CH_HELPFILE) &&
next_ifile(curr_ifile) == NULL_IFILE)
quit(QUIT_OK);
/*
* Select the proper prompt and display it.
*/
/*
* If the previous action was a forward movement,
* don't clear the bottom line of the display;
* just print the prompt since the forward movement guarantees
* that we're in the right position to display the prompt.
* Clearing the line could cause a problem: for example, if the last
* line displayed ended at the right screen edge without a newline,
* then clearing would clear the last displayed line rather than
* the prompt line.
*/
if (!forw_prompt)
clear_bot();
clear_cmd();
forw_prompt = 0;
p = prompt_string();
if (is_filtering())
putstr("& ");
if (p == NULL || *p == '\0') {
putchr(':');
} else {
at_enter(AT_STANDOUT);
putstr(p);
at_exit();
}
clear_eol();
}
static void on_sigint(int sig)
{
setup_sighandler(SIGINT, 0, NULL);
at_exit();
kill(getpid(), sig);
}
int
main(int argc, char *argv[]) {
int rc = 0;
Network *N = NULL;
time_measure_start(&GNRL_ST.total_time);
//process input arguments and init global structure
rc |= process_input_args(argc, argv);
if (GNRL_ST.quiet_mode == FALSE)
printf("mfinder Version %.2f\n\n", VERSION);
if (rc == RC_ERR)
at_exit(-1);
//general initialization
rc |= gnrl_init();
if (rc == RC_ERR)
at_exit(-1);
// load network from input file
if (GNRL_ST.quiet_mode == FALSE)
printf("Loading Network\n");
load_network(&G_N, input_network_fname);
duplicate_network(G_N, &N, "real_network");
init_random_seed();
if (rc == RC_ERR)
at_exit(-1);
if (GNRL_ST.quiet_mode == FALSE)
printf("Searching motifs size %d\nProcessing Real network...\n", GNRL_ST.mtf_sz);
//search motifs size n in Real network
if (GNRL_ST.dont_search_real != TRUE)
rc |= motifs_search_real(N);
if (rc == RC_ERR)
at_exit(-1);
/*
printf("RES TBL real\n");
for (l_id = list64_get_next(RES_TBL.real, NULL); l_id != NULL;
l_id = list64_get_next(RES_TBL.real, l_id))
{
printf("id: %d\ncount: %.0f\n", (int)((Motif*)l_id->p)->id,
((Motif*)l_id->p)->count);
}
*/
if (GNRL_ST.quiet_mode == FALSE)
printf("Processing Random networks\n");
if (GNRL_ST.rnd_net_num > 0) {
// create random networks with same single node statisticfs as the input network
if (GNRL_ST.r_grassberger == FALSE) {
//use switches or stubs
rc |= process_rand_networks(&RES_TBL, GNRL_ST.mtf_sz);
} else {
//use grassberger alg
weights_arr = (double*) calloc(GNRL_ST.rnd_net_num + 1, sizeof (double));
rc |= process_rand_networks_grassberger(&RES_TBL, GNRL_ST.mtf_sz, weights_arr);
}
if (rc == RC_ERR)
at_exit(-1);
}
if (GNRL_ST.quiet_mode == FALSE)
printf("Calculating Results...\n");
if (GNRL_ST.rnd_net_num >= 0) {
//calculate final results and dump them to the results file
if (!GNRL_ST.r_grassberger) {
calc_final_results(&RES_TBL, &final_res, &final_res_all, GNRL_ST.rnd_net_num);
} else {
//Nadav change for GRASS NEW
calc_final_results_grassberger(&RES_TBL, FALSE, res_sub_motif, &final_res, &final_res_all, GNRL_ST.rnd_net_num, weights_arr);
}
}
//calculate final results
time_measure_stop(&GNRL_ST.total_time);
//output results
rc |= output_results(final_res, final_res_all);
free_network_mem(G_N);
free(G_N);
final_res_free(final_res);
final_res_free(final_res_all);
if (GNRL_ST.r_grassberger)
free(weights_arr);
res_tbl_mem_free(&RES_TBL);
if (GNRL_ST.calc_roles == TRUE) {
free_mem_role_hash();
free_roles_res_tbl(GNRL_ST.rnd_net_num);
free_role_members();
}
if (rc == RC_ERR)
at_exit(-1);
exit(at_exit(rc));
}
void lib_shutdown() {
images_free();
renderer_enqueue(renderer_shutdown, NULL);
renderer_enqueue_sync(render_loop_exit, NULL);
at_exit();
}
int main(int argc, char **argv)
{
int rv;
char setToForeground;
char HotPlug;
char *newReaderConfig;
struct stat fStatBuf;
int opt;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
static struct option long_options[] = {
{"config", 1, 0, 'c'},
{"foreground", 0, 0, 'f'},
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{"apdu", 0, 0, 'a'},
{"debug", 0, 0, 'd'},
{"info", 0, 0, 0},
{"error", 0, 0, 'e'},
{"critical", 0, 0, 'C'},
{"hotplug", 0, 0, 'H'},
{"force-reader-polling", optional_argument, 0, 0},
{0, 0, 0, 0}
};
#endif
#define OPT_STRING "c:fdhvaeCH"
rv = 0;
newReaderConfig = NULL;
setToForeground = 0;
HotPlug = 0;
globalArgv = argv;
/*
* test the version
*/
if (strcmp(PCSCLITE_VERSION_NUMBER, VERSION) != 0)
{
printf("BUILD ERROR: The release version number PCSCLITE_VERSION_NUMBER\n");
printf(" in pcsclite.h (%s) does not match the release version number\n",
PCSCLITE_VERSION_NUMBER);
printf(" generated in config.h (%s) (see configure.in).\n", VERSION);
return EXIT_FAILURE;
}
/*
* By default we create a daemon (not connected to any output)
* The log will go to wherever securityd log output goes.
*/
DebugLogSetLogType(DEBUGLOG_NO_DEBUG);
/*
* Handle any command line arguments
*/
#ifdef HAVE_GETOPT_LONG
while ((opt = getopt_long (argc, argv, OPT_STRING, long_options, &option_index)) != -1) {
#else
while ((opt = getopt (argc, argv, OPT_STRING)) != -1) {
#endif
switch (opt) {
#ifdef HAVE_GETOPT_LONG
case 0:
if (strcmp(long_options[option_index].name,
"force-reader-polling") == 0)
HPForceReaderPolling = optarg ? abs(atoi(optarg)) : 1;
break;
#endif
case 'c':
Log2(PCSC_LOG_INFO, "using new config file: %s", optarg);
newReaderConfig = optarg;
break;
case 'f':
setToForeground = 1;
/* debug to stderr instead of default syslog */
Log1(PCSC_LOG_INFO,
"pcscd set to foreground with debug send to stderr");
break;
case 'd':
DebugLogSetLogType(DEBUGLOG_STDERR_DEBUG);
DebugLogSetLevel(PCSC_LOG_DEBUG);
break;
case 'e':
DebugLogSetLogType(DEBUGLOG_STDERR_DEBUG);
DebugLogSetLevel(PCSC_LOG_ERROR);
break;
case 'C':
DebugLogSetLogType(DEBUGLOG_STDERR_DEBUG);
DebugLogSetLevel(PCSC_LOG_CRITICAL);
break;
case 'h':
print_usage (argv[0]);
return EXIT_SUCCESS;
case 'v':
print_version ();
return EXIT_SUCCESS;
case 'a':
DebugLogSetCategory(DEBUG_CATEGORY_APDU);
break;
case 'H':
/* debug to stderr instead of default syslog */
DebugLogSetLogType(DEBUGLOG_STDERR_DEBUG);
HotPlug = 1;
break;
default:
print_usage (argv[0]);
return EXIT_FAILURE;
}
}
if (argv[optind])
{
printf("Unknown option: %s\n\n", argv[optind]);
print_usage(argv[0]);
return EXIT_SUCCESS;
}
/*
If this run of pcscd has the hotplug option, just send a signal to the
running one and exit
*/
if (HotPlug)
return ProcessHotplugRequest();
/*
* test the presence of /var/run/pcsc.comm
*/
rv = SYS_Stat(PCSCLITE_CSOCK_NAME, &fStatBuf);
if (rv == 0)
{
#ifdef USE_RUN_PID
pid_t pid;
/* read the pid file to get the old pid and test if the old pcscd is
* still running
*/
pid = GetDaemonPid();
if (pid != -1)
{
if (kill(pid, 0) == 0)
{
Log2(PCSC_LOG_CRITICAL,
"Another pcscd (pid: %d) seems to be running.", pid);
Log1(PCSC_LOG_CRITICAL,
"Remove " USE_RUN_PID " if pcscd is not running to clear this message.");
return EXIT_FAILURE;
}
else
/* the old pcscd is dead. Do some cleanup */
clean_temp_files();
}
#else
{
Log1(PCSC_LOG_CRITICAL,
"file " PCSCLITE_CSOCK_NAME " already exists.");
Log1(PCSC_LOG_CRITICAL,
"Maybe another pcscd is running?");
Log1(PCSC_LOG_CRITICAL,
"Remove " PCSCLITE_CSOCK_NAME "if pcscd is not running to clear this message.");
return EXIT_FAILURE;
}
#endif
}
/*
* If this is set to one the user has asked it not to fork
*/
if (!setToForeground)
{
if (SYS_Daemon(0, 0))
Log2(PCSC_LOG_CRITICAL, "SYS_Daemon() failed: %s",
strerror(errno));
}
/*
* cleanly remove /tmp/pcsc when exiting
*/
signal(SIGQUIT, signal_trap);
signal(SIGTERM, signal_trap);
signal(SIGINT, signal_trap);
signal(SIGHUP, signal_trap);
#ifdef USE_RUN_PID
/*
* Record our pid to make it easier
* to kill the correct pcscd
*/
{
FILE *f;
if ((f = fopen(USE_RUN_PID, "wb")) != NULL)
{
fprintf(f, "%u\n", (unsigned) getpid());
fclose(f);
}
}
#endif
/*
* If PCSCLITE_IPC_DIR does not exist then create it
*/
rv = SYS_Stat(PCSCLITE_IPC_DIR, &fStatBuf);
if (rv < 0)
{
rv = SYS_Mkdir(PCSCLITE_IPC_DIR, S_ISVTX | S_IRWXO | S_IRWXG | S_IRWXU);
if (rv != 0)
{
Log2(PCSC_LOG_CRITICAL,
"cannot create " PCSCLITE_IPC_DIR ": %s", strerror(errno));
return EXIT_FAILURE;
}
}
/* cleanly remove /var/run/pcsc.* files when exiting */
if (atexit(at_exit))
Log2(PCSC_LOG_CRITICAL, "atexit() failed: %s", strerror(errno));
/*
* Allocate memory for reader structures
*/
RFAllocateReaderSpace();
/*
Grab the information from the reader.conf. If a file has been specified
and there is any error, consider it fatal. If no file was explicitly
specified, ignore if file not present.
DBUpdateReaders returns:
1 if config file can't be opened
-1 if config file is broken
0 if all good
We skip this step if running in 64 bit mode, as serial readers are considered
legacy code.
*/
rv = RFStartSerialReaders(newReaderConfig?newReaderConfig:PCSCLITE_READER_CONFIG);
if (rv == -1)
{
Log3(PCSC_LOG_CRITICAL, "invalid file %s: %s", newReaderConfig,
strerror(errno));
at_exit();
}
else
if ((rv == 1) && newReaderConfig)
{
Log3(PCSC_LOG_CRITICAL, "file %s can't be opened: %s",
newReaderConfig, strerror(errno));
at_exit();
}
/*
* Set the default globals
*/
g_rgSCardT0Pci.dwProtocol = SCARD_PROTOCOL_T0;
g_rgSCardT1Pci.dwProtocol = SCARD_PROTOCOL_T1;
g_rgSCardRawPci.dwProtocol = SCARD_PROTOCOL_RAW;
Log1(PCSC_LOG_INFO, "pcsc-lite " VERSION " daemon ready.");
/*
* post initialistion
*/
Init = 0;
/*
* signal_trap() does just set a global variable used by the main loop
*/
signal(SIGQUIT, signal_trap);
signal(SIGTERM, signal_trap);
signal(SIGINT, signal_trap);
signal(SIGHUP, signal_trap);
signal(SIGUSR1, signal_reload);
SVCServiceRunLoop();
Log1(PCSC_LOG_ERROR, "SVCServiceRunLoop returned");
return EXIT_FAILURE;
}
void at_exit(void)
{
Log1(PCSC_LOG_INFO, "cleaning " PCSCLITE_IPC_DIR);
clean_temp_files();
SYS_Exit(EXIT_SUCCESS);
}
