int
main()
{
pth_t thread;
int rc;
int i, j, s;
arg = -1;
res = 0;
pth_init();
thread = pth_spawn(PTH_ATTR_DEFAULT, thread_routine, NULL);
for(i = 0; i < 100; i++) {
s = 0;
for(j = 0; j < 10000; j++) {
pth_mutex_acquire(&mutex, FALSE, NULL);
res = -1;
arg = j;
pth_mutex_release(&mutex);
pth_cond_notify(&c1, FALSE);
pth_mutex_acquire(&mutex, FALSE, NULL);
if(res < 0)
pth_cond_await(&c2, &mutex, NULL);
s += res;
arg = -1;
pth_mutex_release(&mutex);
}
}
printf("%d\n", s);
return 0;
}
void CThread::Run(void) {
if (m_ThreadState != ctsRunning) {
if (m_ThreadState == ctsSuspended) {
cerr << "CThread::CThread(POSIX) - does not support thread sleeping!" << endl;
}
m_ThreadState = ctsRunning;
#ifdef HAVE_PTH
pth_attr_t l_ThreadAttributes = pth_attr_new();
pth_attr_set(l_ThreadAttributes, PTH_ATTR_NAME, "thread");
pth_attr_set(l_ThreadAttributes, PTH_ATTR_STACK_SIZE, 64*1024);
pth_attr_set(l_ThreadAttributes, PTH_ATTR_JOINABLE, FALSE);
m_ThreadID = pth_spawn(l_ThreadAttributes, &CThreadExecute, (void *) this);
#else
#ifndef _THREAD_DCE
pthread_attr_t l_ThreadAttributes;
pthread_attr_init(&l_ThreadAttributes);
// pthread_attr_setscope(&l_ThreadAttributes, PTHREAD_SCOPE_SYSTEM);
pthread_attr_setdetachstate(&l_ThreadAttributes, PTHREAD_CREATE_DETACHED);
pthread_create(&m_ThreadID, &l_ThreadAttributes, &CThreadExecute, this);
pthread_attr_destroy(&l_ThreadAttributes);
#else
pthread_create(&m_ThreadID, NULL, &CThreadExecute, this);
::pthread_detach(&m_ThreadID);
#endif
#endif
m_ThreadState = ctsRunning;
if (m_ThreadStartMutex) m_ThreadStartMutex->UnLock();
} else cerr << "CThread::CThread(POSIX) - call of Run() in an invalid state!" << endl;
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void *),
void *arg)
{
*thread = pth_spawn( detach ? detach_attr : joined_attr,
start_routine, arg );
return *thread == NULL ? errno : 0;
}
int main(int argc, char *argv[])
{
pth_attr_t attr;
sigset_t sigs;
pth_init();
fprintf(stderr, "This is TEST_SIG, a Pth test using signals.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Hit CTRL-C three times to stop this test.\n");
fprintf(stderr, "But only after all threads were terminated.\n");
fprintf(stderr, "\n");
fprintf(stderr, "main: init\n");
/* block signals */
pth_sigmask(SIG_SETMASK, NULL, &sigs);
sigaddset(&sigs, SIGUSR1);
sigaddset(&sigs, SIGUSR2);
sigaddset(&sigs, SIGINT);
pth_sigmask(SIG_SETMASK, &sigs, NULL);
/* spawn childs */
attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_NAME, "child1");
child1 = pth_spawn(attr, child, (void *)"child1");
pth_attr_set(attr, PTH_ATTR_NAME, "child2");
child2 = pth_spawn(attr, child, (void *)"child2");
pth_attr_set(attr, PTH_ATTR_NAME, "inthandler");
pth_spawn(attr, inthandler, (void *)"inthandler");
pth_attr_destroy(attr);
/* wait until childs are finished */
while (pth_join(NULL, NULL));
fprintf(stderr, "main: exit\n");
pth_kill();
return 0;
}
void
mgt_dispatch_t::launch (int i, int fdout)
{
// warn << "mgt_dispatch_t::launch: " << i << "\n"; // debug
int closeit;
mtd_thread_arg_t *arg = launch_init (i, fdout, &closeit);
pth_attr_t attr = pth_attr_new ();
names[i] = strbuf ("dispatch thread ") << i;
pth_attr_set (attr, PTH_ATTR_NAME, names[i].cstr ());
pth_attr_set (attr, PTH_ATTR_STACK_SIZE, MTD_STACKSIZE);
pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE);
if (!(gts[i] = pth_spawn (attr, amt_vnew_threadv, static_cast<void *> (arg))))
fatal << "mtdispatch::launch: pth_spawn failed\n";
}
/* Pop up a message window similar to the confirm one but keep it open
until agent_popup_message_stop has been called. It is crucial for
the caller to make sure that the stop function gets called as soon
as the message is not anymore required because the message is
system modal and all other attempts to use the pinentry will fail
(after a timeout). */
int
agent_popup_message_start (ctrl_t ctrl, const char *desc, const char *ok_btn)
{
int rc;
char line[ASSUAN_LINELENGTH];
pth_attr_t tattr;
rc = start_pinentry (ctrl);
if (rc)
return rc;
if (desc)
snprintf (line, DIM(line)-1, "SETDESC %s", desc);
else
snprintf (line, DIM(line)-1, "RESET");
line[DIM(line)-1] = 0;
rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
if (rc)
return unlock_pinentry (rc);
if (ok_btn)
{
snprintf (line, DIM(line)-1, "SETOK %s", ok_btn);
line[DIM(line)-1] = 0;
rc = assuan_transact (entry_ctx, line, NULL,NULL,NULL,NULL,NULL,NULL);
if (rc)
return unlock_pinentry (rc);
}
tattr = pth_attr_new();
pth_attr_set (tattr, PTH_ATTR_JOINABLE, 1);
pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
pth_attr_set (tattr, PTH_ATTR_NAME, "popup-message");
popup_finished = 0;
popup_tid = pth_spawn (tattr, popup_message_thread, NULL);
if (!popup_tid)
{
rc = gpg_error_from_syserror ();
log_error ("error spawning popup message handler: %s\n",
strerror (errno) );
pth_attr_destroy (tattr);
return unlock_pinentry (rc);
}
pth_attr_destroy (tattr);
return 0;
}
TASK_DLLEXPORT Task *
Task_new(const char *name, long stacksize, void *data, void *(*run) (void *data), void (*destroy) (void *data))
{
Task *task = NEW(Task);
pth_t ptask;
pth_attr_t attr;
#ifdef _LDEBUG
printf("F=%s,L=%d\n", __FILE__, __LINE__);
#endif
if (pth_inited == 0)
{
if (pth_init() == 0)
return NULL;
pth_inited = 1;
}
if (stacksize < TASK_STACK_MIN)
stacksize = TASK_STACK_MIN;
++seqNo;
task->id = seqNo;
task->stacklen = stacksize;
task->name = strdup(name);
task->data = data;
task->run = run;
task->destroy = destroy;
attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_NAME, name);
pth_attr_set(attr, PTH_ATTR_STACK_SIZE, (unsigned int) stacksize);
ptask = pth_spawn(attr, task_pth_run, task);
pth_attr_destroy(attr);
if (ptask == NULL)
{
free(task);
return NULL;
}
task->ref = (void *) ptask;
#ifdef _LDEBUG
printf(" open ptask=%p,task=%p,name=%s,%p\n", (void *) ptask, (void *) task, task->name, task->name);
printf("F=%s,L=%d\n", __FILE__, __LINE__);
#endif
return task;
}
/* Fire up a thread to copy data between STREAM and a pipe's
descriptor FD. With DIRECTION set to true the copy takes place
from the stream to the pipe, otherwise from the pipe to the
stream. */
static gpg_error_t
start_feeder (estream_t stream, HANDLE hd, int direction)
{
#ifdef USE_NPTH
gpg_error_t err;
struct feeder_thread_parms *parm;
pth_attr_t tattr;
parm = xtrymalloc (sizeof *parm);
if (!parm)
return gpg_error_from_syserror ();
parm->stream = stream;
parm->stream_valid = 1;
parm->hd = hd;
parm->direction = direction;
if (es_onclose (stream, 1, feeder_onclose_notification, parm))
{
err = gpg_error_from_syserror ();
xfree (parm);
return err;
}
tattr = pth_attr_new ();
pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 64*1024);
pth_attr_set (tattr, PTH_ATTR_NAME, "exec-feeder");
log_debug ("spawning new feeder(%p, %p, %d)\n", stream, hd, direction);
if(!pth_spawn (tattr, feeder_thread, parm))
{
err = gpg_error_from_syserror ();
es_onclose (stream, 0, feeder_onclose_notification, parm);
xfree (parm);
}
else
err = 0;
pth_attr_destroy (tattr);
return err;
#else
(void)stream;
(void)hd;
(void)direction;
return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /* No Pth. */
#endif
}
/**
* The main function for creating a new task.
*/
task_pid_t task_create_gid (task_gid_t gid, task_function_t fn)
{
pth_t pid;
pth_attr_t attr;
int i;
#ifdef PTHDEBUG
printf ("task_create_gid: gid=%d, fn=%p\n", gid, fn);
#endif
/* Set the task attributes:
* - Not joinable : all tasks are independent
* - cancellable : task kill is permitted
* - priority : make certain tasks that the simulator itself
* uses higher priority, and all others equal in priority.
*/
attr = pth_attr_new ();
pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE);
pth_attr_set (attr, PTH_ATTR_CANCEL_STATE, PTH_CANCEL_ENABLE);
if (gid == GID_LINUX_REALTIME) /* time tracking */
pth_attr_set (attr, PTH_ATTR_PRIO, PTH_PRIO_STD + 2);
else if (gid == GID_LINUX_INTERFACE) /* user input */
pth_attr_set (attr, PTH_ATTR_PRIO, PTH_PRIO_STD + 1);
/* TODO - inside of calling the function directly, call a global
* function and pass it a pointer to the task_data_table entry
* as an argument. */
pid = pth_spawn (attr, fn, 0);
for (i=0; i < NUM_TASKS; i++)
if (task_data_table[i].pid == 0)
{
task_data_table[i].pid = pid;
task_data_table[i].gid = gid;
task_data_table[i].duration = TASK_DURATION_INF;
task_data_table[i].arg.u16 = 0;
task_data_table[i].duration = TASK_DURATION_BALL;
#ifdef CONFIG_UI
ui_write_task (i, gid);
#endif
return (pid);
}
fatal (ERR_NO_FREE_TASKS);
}
void
Thread::Start ()
{
if (tid)
{
pth_attr_t a = pth_attr_of (tid);
int state;
pth_attr_get (a, PTH_ATTR_STATE, &state);
pth_attr_destroy (a);
if (state != PTH_STATE_DEAD)
return;
Stop ();
}
pth_attr_t attr = pth_attr_new ();
pth_attr_set (attr, PTH_ATTR_PRIO, prio);
tid = pth_spawn (attr, &ThreadWrapper, this);
pth_attr_destroy (attr);
}
int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
{
pth_attr_t type;
/* Create a new attribute */
type = pth_attr_new();
if ( type == NULL ) {
SDL_SetError("Couldn't initialize pth attributes");
return(-1);
}
pth_attr_set(type, PTH_ATTR_JOINABLE, TRUE);
/* Create the thread and go! */
thread->handle = pth_spawn(type, RunThread, args);
if ( thread->handle == NULL ) {
SDL_SetError("Not enough resources to create thread");
return(-1);
}
return(0);
}
void
Thread::Start (bool detach)
{
if (joinable && tid)
{
pth_attr_t a = pth_attr_of (tid);
int state;
pth_attr_get (a, PTH_ATTR_STATE, &state);
pth_attr_destroy (a);
if (state != PTH_STATE_DEAD)
return;
Stop ();
}
pth_sem_init (&should_stop);
pth_attr_t attr = pth_attr_new ();
pth_attr_set (attr, PTH_ATTR_PRIO, prio);
joinable = !detach;
if (detach)
pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE);
tid = pth_spawn (attr, &ThreadWrapper, this);
pth_attr_destroy (attr);
}
int FrSimThread::startThread() {
printf("Base StartThread\n");
fflush(stdout);
// Should add attributes as class members
pth_attr_t attr;
attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_NAME, threadName.c_str());
pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 2048*1024);
pth_attr_set(attr, PTH_ATTR_JOINABLE, TRUE);
pth_t tid = pth_spawn(attr, newThreadInit, (void *)this);
if (tid == NULL) {
return(1);
}
FrSimThreadId *newId = new FrSimThreadId(tid);
id = newId;
return (0);
}
/* UNIX listener */
static void listener(IOCHAN h, int event)
{
COMSTACK line = (COMSTACK) iochan_getdata(h);
int res;
if (event == EVENT_INPUT)
{
COMSTACK new_line;
if ((res = cs_listen_check(line, 0, 0, control_block.check_ip,
control_block.daemon_name)) < 0)
{
yaz_log(YLOG_WARN|YLOG_ERRNO, "cs_listen failed");
return;
}
else if (res == 1)
{
yaz_log(YLOG_WARN, "cs_listen incomplete");
return;
}
new_line = cs_accept(line);
if (!new_line)
{
yaz_log(YLOG_FATAL, "Accept failed.");
iochan_setflags(h, EVENT_INPUT | EVENT_EXCEPT); /* reset listener */
return;
}
yaz_log(log_sessiondetail, "Connect from %s", cs_addrstr(new_line));
no_sessions++;
if (control_block.dynamic)
{
if ((res = fork()) < 0)
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "fork");
iochan_destroy(h);
return;
}
else if (res == 0) /* child */
{
char nbuf[100];
IOCHAN pp;
for (pp = pListener; pp; pp = iochan_getnext(pp))
{
COMSTACK l = (COMSTACK)iochan_getdata(pp);
cs_close(l);
iochan_destroy(pp);
}
sprintf(nbuf, "%s(%d)", me, no_sessions);
yaz_log_init_prefix(nbuf);
/* ensure that bend_stop is not called when each child exits -
only for the main process .. */
control_block.bend_stop = 0;
}
else /* parent */
{
cs_close(new_line);
return;
}
}
if (control_block.threads)
{
#if YAZ_POSIX_THREADS
pthread_t child_thread;
pthread_create(&child_thread, 0, new_session, new_line);
pthread_detach(child_thread);
#elif YAZ_GNU_THREADS
pth_attr_t attr;
pth_t child_thread;
attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_JOINABLE, FALSE);
pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 32*1024);
pth_attr_set(attr, PTH_ATTR_NAME, "session");
yaz_log(YLOG_DEBUG, "pth_spawn begin");
child_thread = pth_spawn(attr, new_session, new_line);
yaz_log(YLOG_DEBUG, "pth_spawn finish");
pth_attr_destroy(attr);
#else
new_session(new_line);
#endif
}
else
new_session(new_line);
}
else if (event == EVENT_TIMEOUT)
{
yaz_log(log_server, "Shutting down listener.");
iochan_destroy(h);
}
else
{
yaz_log(YLOG_FATAL, "Bad event on listener.");
iochan_destroy(h);
}
}
int main(int argc, char *argv[])
{
char caLine[MAXLINELEN];
pth_event_t ev = NULL;
pth_event_t evt = NULL;
pth_t t_worker = NULL;
pth_t t_ticker = NULL;
pth_attr_t t_attr;
pth_msgport_t mp = NULL;
pth_msgport_t mp_worker = NULL;
struct query *q = NULL;
int n;
if (!pth_init()) {
perror("pth_init");
exit(1);
}
/* murray added for tmp debug */
/*
pth_time_t intval, former;
printf("-------------------------\n");
pth_time_set(&former, PTH_TIME_NOW);
pth_usleep(300);
pth_time_set(&intval, PTH_TIME_NOW);
pth_time_sub(&intval, &former);
double val = pth_time_t2d(&intval);
printf("the intval is [%f]\n", val);
pth_debug2("the intval is [%f]\n", val);
return 0;
*/
fprintf(stderr, "This is TEST_MP, a Pth test using message ports.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Lines on stdin are send to a worker thread via message\n");
fprintf(stderr, "ports, translated to upper case by the worker thread and\n");
fprintf(stderr, "send back to the main thread via message ports.\n");
fprintf(stderr, "Additionally a useless ticker thread awakens every 5s.\n");
fprintf(stderr, "Enter \"quit\" on stdin for stopping this test.\n");
fprintf(stderr, "\n");
t_attr = pth_attr_new();
pth_attr_set(t_attr, PTH_ATTR_NAME, "worker");
pth_attr_set(t_attr, PTH_ATTR_JOINABLE, TRUE);
pth_attr_set(t_attr, PTH_ATTR_STACK_SIZE, 16*1024);
t_worker = pth_spawn(t_attr, worker, NULL);
pth_attr_set(t_attr, PTH_ATTR_NAME, "ticker");
t_ticker = pth_spawn(t_attr, ticker, NULL);
pth_attr_destroy(t_attr);
pth_yield(NULL);
mp_worker = pth_msgport_find("worker");
mp = pth_msgport_create("main");
q = (struct query *)malloc(sizeof(struct query));
ev = pth_event(PTH_EVENT_MSG, mp);
evt = NULL;
for (;;) {
if (evt == NULL)
evt = pth_event(PTH_EVENT_TIME, pth_timeout(20,0));
else
evt = pth_event(PTH_EVENT_TIME|PTH_MODE_REUSE, evt, pth_timeout(20,0));
n = pth_readline_ev(STDIN_FILENO, caLine, MAXLINELEN, evt);
if (n == -1 && pth_event_status(evt) == PTH_STATUS_OCCURRED) {
fprintf(stderr, "main: Hey, what are you waiting for? Type in something!\n");
continue;
}
if (n < 0) {
fprintf(stderr, "main: I/O read error on stdin\n");
break;
}
if (n == 0) {
fprintf(stderr, "main: EOF on stdin\n");
break;
}
caLine[n-1] = NUL;
if (strcmp(caLine, "quit") == 0) {
fprintf(stderr, "main: quit\n");
break;
}
fprintf(stderr, "main: out --> <%s>\n", caLine);
q->string = caLine;
q->head.m_replyport = mp;
pth_msgport_put(mp_worker, (pth_message_t *)q);
pth_wait(ev);
q = (struct query *)pth_msgport_get(mp);
fprintf(stderr, "main: in <-- <%s>\n", q->string);
}
free(q);
pth_event_free(ev, PTH_FREE_THIS);
pth_event_free(evt, PTH_FREE_THIS);
pth_msgport_destroy(mp);
pth_cancel(t_worker);
pth_join(t_worker, NULL);
pth_cancel(t_ticker);
pth_join(t_ticker, NULL);
pth_kill();
return 0;
}
int main(int argc, char *argv[])
{
int i;
sigset_t ss;
int sig;
pth_event_t ev;
/* initialize Pth library */
pth_init();
/* display test program header */
printf("This is TEST_PHILO, a Pth test showing the Five Dining Philosophers\n");
printf("\n");
printf("This is a demonstration showing the famous concurrency problem of the\n");
printf("Five Dining Philosophers as analysed 1965 by E.W.Dijkstra:\n");
printf("\n");
printf("Five philosophers are sitting around a round table, each with a bowl of\n");
printf("Chinese food in front of him. Between periods of talking they may start\n");
printf("eating whenever they want to, with their bowls being filled frequently.\n");
printf("But there are only five chopsticks available, one each to the left of\n");
printf("each bowl - and for eating Chinese food one needs two chopsticks. When\n");
printf("a philosopher wants to start eating, he must pick up the chopstick to\n");
printf("the left of his bowl and the chopstick to the right of his bowl. He\n");
printf("may find, however, that either one (or even both) of the chopsticks is\n");
printf("unavailable as it is being used by another philosopher sitting on his\n");
printf("right or left, so he has to wait.\n");
printf("\n");
printf("This situation shows classical contention under concurrency (the\n");
printf("philosophers want to grab the chopsticks) and the possibility of a\n");
printf("deadlock (all philosophers wait that the chopstick to their left becomes\n");
printf("available).\n");
printf("\n");
printf("The demonstration runs max. 60 seconds. To stop before, press CTRL-C.\n");
printf("\n");
printf("+----P1----+----P2----+----P3----+----P4----+----P5----+\n");
/* initialize the control table */
tab = (table *)malloc(sizeof(table));
if (!pth_mutex_init(&(tab->mutex))) {
perror("pth_mutex_init");
exit(1);
}
for (i = 0; i < PHILNUM; i++) {
(tab->self)[i] = i;
(tab->status)[i] = thinking;
if (!pth_cond_init(&((tab->condition)[i]))) {
perror("pth_cond_init");
exit(1);
}
}
/* spawn the philosopher threads */
for (i = 0; i < PHILNUM; i++) {
if (((tab->tid)[i] =
pth_spawn(PTH_ATTR_DEFAULT, philosopher,
&((tab->self)[i]))) == NULL) {
perror("pth_spawn");
exit(1);
}
}
/* wait until 60 seconds have elapsed or CTRL-C was pressed */
sigemptyset(&ss);
sigaddset(&ss, SIGINT);
ev = pth_event(PTH_EVENT_TIME, pth_timeout(60,0));
pth_sigwait_ev(&ss, &sig, ev);
pth_event_free(ev, PTH_FREE_ALL);
/* cancel and join the philosopher threads */
for (i = 0; i < PHILNUM; i++)
pth_cancel((tab->tid)[i]);
while (pth_join(NULL, NULL));
/* finish display */
printf("+----------+----------+----------+----------+----------+\n");
/* free the control table */
free(tab);
/* shutdown Pth library */
pth_kill();
return 0;
}
int main(int argc, char *argv[])
{
struct sockaddr_in sar;
struct protoent *pe;
struct sockaddr_in peer_addr;
socklen_t peer_len;
int sr;
int port;
/* initialize scheduler */
pth_init();
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, myexit);
signal(SIGTERM, myexit);
/* argument line parsing */
if (argc != 2) {
fprintf(stderr, "Usage: %s <port>\n", argv[0]);
exit(1);
}
port = atoi(argv[1]);
if (port <= 0 || port >= 65535) {
fprintf(stderr, "Illegal port: %d\n", port);
exit(1);
}
fprintf(stderr, "This is TEST_HTTPD, a Pth test using socket I/O.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Multiple connections are accepted on the specified port.\n");
fprintf(stderr, "For each connection a separate thread is spawned which\n");
fprintf(stderr, "reads a HTTP request the socket and writes back a constant\n");
fprintf(stderr, "(and useless) HTTP response to the socket.\n");
fprintf(stderr, "Additionally a useless ticker thread awakens every 5s.\n");
fprintf(stderr, "Watch the average scheduler load the ticker displays.\n");
fprintf(stderr, "Hit CTRL-C for stopping this test.\n");
fprintf(stderr, "\n");
/* run a just for fun ticker thread */
attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_NAME, "ticker");
pth_attr_set(attr, PTH_ATTR_JOINABLE, FALSE);
pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 64*1024);
pth_spawn(attr, ticker, NULL);
/* create TCP socket */
if ((pe = getprotobyname("tcp")) == NULL) {
perror("getprotobyname");
exit(1);
}
if ((s = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1) {
perror("socket");
exit(1);
}
/* bind socket to port */
sar.sin_family = AF_INET;
sar.sin_addr.s_addr = INADDR_ANY;
sar.sin_port = htons(port);
if (bind(s, (struct sockaddr *)&sar, sizeof(struct sockaddr_in)) == -1) {
perror("socket");
exit(1);
}
/* start listening on the socket with a queue of 10 */
if (listen(s, REQ_MAX) == -1) {
perror("listen");
exit(1);
}
/* finally loop for requests */
pth_attr_set(attr, PTH_ATTR_NAME, "handler");
fprintf(stderr, "listening on port %d (max %d simultaneous connections)\n", port, REQ_MAX);
for (;;) {
/* accept next connection */
peer_len = sizeof(peer_addr);
if ((sr = pth_accept(s, (struct sockaddr *)&peer_addr, &peer_len)) == -1) {
perror("accept");
pth_sleep(1);
continue;
}
if (pth_ctrl(PTH_CTRL_GETTHREADS) >= REQ_MAX) {
fprintf(stderr, "currently no more connections acceptable\n");
continue;
}
fprintf(stderr, "connection established (fd: %d, ip: %s, port: %d)\n",
sr, inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port));
/* spawn new handling thread for connection */
pth_spawn(attr, handler, (void *)((long)sr));
}
}
void* dnsrv_process_io(void* threadarg)
{
/* Get DNS IO info */
dns_io di = (dns_io)threadarg;
int retcode = 0;
int pid = 0;
int readlen = 0;
char readbuf[1024];
xstream xs = NULL;
sigset_t sigs;
#ifdef __CYGWIN__
dns_resend_list iternode = NULL;
#endif
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);
sigprocmask(SIG_BLOCK, &sigs, NULL);
/* Allocate an xstream for talking to the process */
xs = xstream_new(di->mempool, dnsrv_process_xstream_io, di);
/* Transmit root element to coprocess */
pth_write(di->out, "<stream>", 8);
/* Transmit resend entries to coprocess */
#ifdef __CYGWIN__
iternode = di->svclist;
while (iternode != NULL) {
if (iternode->service) {
sprintf(readbuf, "<resend service=\"%s\">%s</resend>",
iternode->service, iternode->host);
} else {
sprintf(readbuf, "<resend>%s</resend>",
iternode->host);
}
pth_write(di->out, readbuf, strlen(readbuf));
iternode = iternode->next;
}
#endif
/* Loop forever */
while (1)
{
/* Hostname lookup completed from coprocess */
readlen = pth_read(di->in, readbuf, sizeof(readbuf));
if (readlen <= 0)
{
log_debug(ZONE,"dnsrv: Read error on coprocess: %d %s",errno,strerror(errno));
break;
}
if (xstream_eat(xs, readbuf, readlen) > XSTREAM_NODE)
break;
}
/* If we reached this point, the coprocess probably is dead, so
process the SIG_CHLD */
pid = pth_waitpid(di->pid, &retcode, 0);
if(pid == -1)
{
log_debug(ZONE, "pth_waitpid returned -1: %s", strerror(errno));
}
else if(pid == 0)
{
log_debug(ZONE, "no child available to call waitpid on");
}
else
{
log_debug(ZONE, "pid %d, exit status: %d", pid, WEXITSTATUS(retcode));
}
/* Cleanup */
close(di->in);
close(di->out);
di->out = 0;
log_debug(ZONE,"child returned %d",WEXITSTATUS(retcode));
if(WIFEXITED(retcode)) /* if the child exited normally */
{
log_debug(ZONE, "child being restarted...");
/* Fork out resolver function/process */
di->pid = dnsrv_fork_and_capture(dnsrv_child_main, di);
/* Start IO thread */
pth_spawn(PTH_ATTR_DEFAULT, dnsrv_process_io, (void*)di);
return NULL;
}
log_debug(ZONE, "child dying...");
return NULL;
}
void dnsrv(instance i, xmlnode x)
{
xdbcache xc = NULL;
xmlnode config = NULL;
xmlnode iternode = NULL;
dns_resend_list tmplist = NULL;
/* Setup a struct to hold dns_io handles */
dns_io di;
di = pmalloco(i->p, sizeof(_dns_io));
di->mempool = i->p;
/* Load config from xdb */
xc = xdb_cache(i);
config = xdb_get(xc, jid_new(xmlnode_pool(x), "config@-internal"), "jabber:config:dnsrv");
/* Build a list of services/resend hosts */
iternode = xmlnode_get_lastchild(config);
while (iternode != NULL)
{
if (j_strcmp("resend", xmlnode_get_name(iternode)) != 0)
{
iternode = xmlnode_get_prevsibling(iternode);
continue;
}
/* Allocate a new list node */
tmplist = pmalloco(di->mempool, sizeof(_dns_resend_list));
tmplist->service = pstrdup(di->mempool, xmlnode_get_attrib(iternode, "service"));
tmplist->host = pstrdup(di->mempool, xmlnode_get_data(iternode));
/* Insert this node into the list */
tmplist->next = di->svclist;
di->svclist = tmplist;
/* Move to next child */
iternode = xmlnode_get_prevsibling(iternode);
}
log_debug(ZONE, "dnsrv debug: %s\n", xmlnode2str(config));
/* Setup the hash of dns_packet_list */
di->packet_table = xhash_new(j_atoi(xmlnode_get_attrib(config,"queuemax"),101));
di->packet_timeout = j_atoi(xmlnode_get_attrib(config,"queuetimeout"),60);
register_beat(di->packet_timeout, dnsrv_beat_packets, (void *)di);
/* Setup the internal hostname cache */
di->cache_table = xhash_new(j_atoi(xmlnode_get_attrib(config,"cachemax"),1999));
di->cache_timeout = j_atoi(xmlnode_get_attrib(config,"cachetimeout"),3600); /* 1 hour dns cache? XXX would be nice to get the right value from dns! */
xmlnode_free(config);
/* spawn a thread that get's forked, and wait for it since it sets up the fd's */
pth_join(pth_spawn(PTH_ATTR_DEFAULT,(void*)dnsrv_thread,(void*)di),NULL);
if(di->pid < 0)
{
log_error(i->id,"dnsrv failed to start, unable to fork and/or create pipes");
return;
}
/* Start IO thread */
pth_spawn(PTH_ATTR_DEFAULT, dnsrv_process_io, di);
/* Register an incoming packet handler */
register_phandler(i, o_DELIVER, dnsrv_deliver, (void*)di);
/* register a cleanup function */
pool_cleanup(i->p, dnsrv_shutdown, (void*)di);
}
#ifdef PTH_EX
/* optional support for exceptional handling */
__ex_ctx = pth_ex_ctx;
__ex_terminate = pth_ex_terminate;
#endif
/* spawn the scheduler thread */
t_attr = pth_attr_new();
pth_attr_set(t_attr, PTH_ATTR_PRIO, PTH_PRIO_MAX);
pth_attr_set(t_attr, PTH_ATTR_NAME, "**SCHEDULER**");
pth_attr_set(t_attr, PTH_ATTR_JOINABLE, FALSE);
pth_attr_set(t_attr, PTH_ATTR_CANCEL_STATE, PTH_CANCEL_DISABLE);
pth_attr_set(t_attr, PTH_ATTR_STACK_SIZE, 64*1024);
pth_attr_set(t_attr, PTH_ATTR_STACK_ADDR, NULL);
pth_sched = pth_spawn(t_attr, pth_scheduler, NULL);
if (pth_sched == NULL) {
pth_shield {
pth_attr_destroy(t_attr);
pth_scheduler_kill();
pth_syscall_kill();
}
return FALSE;
}
/* spawn a thread for the main program */
pth_attr_set(t_attr, PTH_ATTR_PRIO, PTH_PRIO_STD);
pth_attr_set(t_attr, PTH_ATTR_NAME, "main");
pth_attr_set(t_attr, PTH_ATTR_JOINABLE, TRUE);
pth_attr_set(t_attr, PTH_ATTR_CANCEL_STATE, PTH_CANCEL_ENABLE|PTH_CANCEL_DEFERRED);
pth_attr_set(t_attr, PTH_ATTR_STACK_SIZE, 0 /* special */);
int main(int argc, char *argv[])
{
if (argc < 5) {
return 1;
}
auto processNum = 4;
auto threadNum = atoi(argv[4]);
auto dtime = atol(argv[3]) * 1000;
auto isPth = std::string(argv[2]) == "pth";
auto taskNum = atoi(argv[1]);
long cycles = 0;
switch(taskNum) {
case 1: task = task1; break;
case 2: task = task2; break;
case 3: task = task3; break;
}
time_start();
for (auto i = 0; i < processNum; ++i) {
if (fork() != 0) {
continue;
}
if (isPth) {
pth_init();
pth_attr_t attr = pth_attr_new();
pth_attr_set(attr, PTH_ATTR_NAME, "task");
pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 64*1024);
pth_attr_set(attr, PTH_ATTR_JOINABLE, true);
pth_mutex_t mutex;
pth_mutex_init(&mutex);
pth_cond_init(&pthCond);
while (time_stop() < dtime) {
for (auto i = workingNum; i < threadNum; ++i) {
++workingNum;
pth_spawn(attr, task, &isPth);
}
int rc;
if ((rc = pth_mutex_acquire(&mutex, FALSE, NULL)) != 0) {
std::cout << "pthread_mutex_lock " << rc << " " << strerror(rc) << std::endl;
return 3;
}
if (workingNum == threadNum) {
if ((rc = pth_cond_await(&pthCond, &mutex, NULL)) != 0) {
std::cout << "pthread_cond_wait " << rc << " " << strerror(rc) << std::endl;
return 3;
}
}
if ((rc = pth_mutex_release(&mutex)) != 0) {
std::cout << "pthread_mutex_unlock " << rc << " " << strerror(rc) << std::endl;
return 3;
}
cycles += threadNum - workingNum;
}
}
else {
pthread_attr_t attr;
pthread_attr_setstacksize(&attr, 64*1024);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutexattr_t mutexattr;
pthread_mutex_init(&mutex, &mutexattr);
pthread_condattr_t condattr;
pthread_cond_init(&cond, &condattr);
pthread_t pid;
while (time_stop() < dtime) {
for (auto i = workingNum; i < threadNum; ++i) {
++workingNum;
if (pthread_create(&pid, NULL, task, &isPth) == -1) {
return 2;
}
}
int rc;
if ((rc = pthread_mutex_lock(&mutex)) != 0) {
std::cout << "pthread_mutex_lock " << rc << " " << strerror(rc) << std::endl;
return 3;
}
if (workingNum == threadNum) {
if ((rc = pthread_cond_wait(&cond, &mutex)) != 0) {
std::cout << "pthread_cond_wait " << rc << " " << strerror(rc) << std::endl;
return 3;
}
}
if ((rc = pthread_mutex_unlock(&mutex)) != 0) {
std::cout << "pthread_mutex_unlock " << rc << " " << strerror(rc) << std::endl;
return 3;
}
//pthread_join(pids.front(), NULL);
//pids.pop_front();
cycles += threadNum - workingNum;
}
}
std::cout << cycles << std::endl;
return 0;
}
for (auto i = 0; i < processNum; ++i) {
wait(NULL);
}
return 0;
}
int
main (int argc, char **argv )
{
ARGPARSE_ARGS pargs;
int orig_argc;
gpg_error_t err;
int may_coredump;
char **orig_argv;
FILE *configfp = NULL;
char *configname = NULL;
const char *shell;
unsigned int configlineno;
int parse_debug = 0;
const char *debug_level = NULL;
int default_config =1;
int greeting = 0;
int nogreeting = 0;
int multi_server = 0;
int is_daemon = 0;
int nodetach = 0;
int csh_style = 0;
char *logfile = NULL;
int debug_wait = 0;
int gpgconf_list = 0;
const char *config_filename = NULL;
int allow_coredump = 0;
int standard_socket = 0;
struct assuan_malloc_hooks malloc_hooks;
set_strusage (my_strusage);
gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
/* Please note that we may running SUID(ROOT), so be very CAREFUL
when adding any stuff between here and the call to INIT_SECMEM()
somewhere after the option parsing */
log_set_prefix ("scdaemon", 1|4);
/* Make sure that our subsystems are ready. */
i18n_init ();
init_common_subsystems (&argc, &argv);
/* Libgcrypt requires us to register the threading model first.
Note that this will also do the pth_init. */
gcry_threads_pth.init = fixed_gcry_pth_init;
err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
if (err)
{
log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
gpg_strerror (err));
}
/* Check that the libraries are suitable. Do it here because
the option parsing may need services of the library */
if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
{
log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
}
ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
malloc_hooks.malloc = gcry_malloc;
malloc_hooks.realloc = gcry_realloc;
malloc_hooks.free = gcry_free;
assuan_set_malloc_hooks (&malloc_hooks);
assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
assuan_set_system_hooks (ASSUAN_SYSTEM_PTH);
assuan_sock_init ();
setup_libassuan_logging (&opt.debug);
setup_libgcrypt_logging ();
gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
may_coredump = disable_core_dumps ();
/* Set default options. */
opt.allow_admin = 1;
opt.pcsc_driver = DEFAULT_PCSC_DRIVER;
#ifdef HAVE_W32_SYSTEM
standard_socket = 1; /* Under Windows we always use a standard
socket. */
#endif
shell = getenv ("SHELL");
if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
csh_style = 1;
opt.homedir = default_homedir ();
/* Check whether we have a config file on the commandline */
orig_argc = argc;
orig_argv = argv;
pargs.argc = &argc;
pargs.argv = &argv;
pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
while (arg_parse( &pargs, opts))
{
if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
parse_debug++;
else if (pargs.r_opt == oOptions)
{ /* yes there is one, so we do not try the default one, but
read the option file when it is encountered at the
commandline */
default_config = 0;
}
else if (pargs.r_opt == oNoOptions)
default_config = 0; /* --no-options */
else if (pargs.r_opt == oHomedir)
opt.homedir = pargs.r.ret_str;
}
/* initialize the secure memory. */
gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
maybe_setuid = 0;
/*
Now we are working under our real uid
*/
if (default_config)
configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
argc = orig_argc;
argv = orig_argv;
pargs.argc = &argc;
pargs.argv = &argv;
pargs.flags= 1; /* do not remove the args */
next_pass:
if (configname)
{
configlineno = 0;
configfp = fopen (configname, "r");
if (!configfp)
{
if (default_config)
{
if( parse_debug )
log_info (_("NOTE: no default option file `%s'\n"),
configname );
}
else
{
log_error (_("option file `%s': %s\n"),
configname, strerror(errno) );
exit(2);
}
xfree (configname);
configname = NULL;
}
if (parse_debug && configname )
log_info (_("reading options from `%s'\n"), configname );
default_config = 0;
}
while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
{
switch (pargs.r_opt)
{
case aGPGConfList: gpgconf_list = 1; break;
case aGPGConfTest: gpgconf_list = 2; break;
case oQuiet: opt.quiet = 1; break;
case oVerbose: opt.verbose++; break;
case oBatch: opt.batch=1; break;
case oDebug: opt.debug |= pargs.r.ret_ulong; break;
case oDebugAll: opt.debug = ~0; break;
case oDebugLevel: debug_level = pargs.r.ret_str; break;
case oDebugWait: debug_wait = pargs.r.ret_int; break;
case oDebugAllowCoreDump:
enable_core_dumps ();
allow_coredump = 1;
break;
case oDebugCCIDDriver:
#ifdef HAVE_LIBUSB
ccid_set_debug_level (ccid_set_debug_level (-1)+1);
#endif /*HAVE_LIBUSB*/
break;
case oDebugDisableTicker: ticker_disabled = 1; break;
case oDebugLogTid:
log_set_pid_suffix_cb (tid_log_callback);
break;
case oOptions:
/* config files may not be nested (silently ignore them) */
if (!configfp)
{
xfree(configname);
configname = xstrdup(pargs.r.ret_str);
goto next_pass;
}
break;
case oNoGreeting: nogreeting = 1; break;
case oNoVerbose: opt.verbose = 0; break;
case oNoOptions: break; /* no-options */
case oHomedir: opt.homedir = pargs.r.ret_str; break;
case oNoDetach: nodetach = 1; break;
case oLogFile: logfile = pargs.r.ret_str; break;
case oCsh: csh_style = 1; break;
case oSh: csh_style = 0; break;
case oServer: pipe_server = 1; break;
case oMultiServer: pipe_server = 1; multi_server = 1; break;
case oDaemon: is_daemon = 1; break;
case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
case oDisableCCID: opt.disable_ccid = 1; break;
case oDisableOpenSC: break;
case oDisableKeypad: opt.disable_keypad = 1; break;
case oAllowAdmin: /* Dummy because allow is now the default. */
break;
case oDenyAdmin: opt.allow_admin = 0; break;
case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
case oDisableApplication:
add_to_strlist (&opt.disabled_applications, pargs.r.ret_str);
break;
default:
pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
break;
}
}
if (configfp)
{
fclose( configfp );
configfp = NULL;
/* Keep a copy of the config name for use by --gpgconf-list. */
config_filename = configname;
configname = NULL;
goto next_pass;
}
xfree (configname);
configname = NULL;
if (log_get_errorcount(0))
exit(2);
if (nogreeting )
greeting = 0;
if (greeting)
{
es_fprintf (es_stderr, "%s %s; %s\n",
strusage(11), strusage(13), strusage(14) );
es_fprintf (es_stderr, "%s\n", strusage(15) );
}
#ifdef IS_DEVELOPMENT_VERSION
log_info ("NOTE: this is a development version!\n");
#endif
if (atexit (cleanup))
{
log_error ("atexit failed\n");
cleanup ();
exit (1);
}
set_debug (debug_level);
initialize_module_command ();
if (gpgconf_list == 2)
scd_exit (0);
if (gpgconf_list)
{
/* List options and default values in the GPG Conf format. */
char *filename = NULL;
char *filename_esc;
if (config_filename)
filename = xstrdup (config_filename);
else
filename = make_filename (opt.homedir, "scdaemon.conf", NULL);
filename_esc = percent_escape (filename, NULL);
es_printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
GC_OPT_FLAG_DEFAULT, filename_esc);
xfree (filename_esc);
xfree (filename);
es_printf ("verbose:%lu:\n"
"quiet:%lu:\n"
"debug-level:%lu:\"none:\n"
"log-file:%lu:\n",
GC_OPT_FLAG_NONE,
GC_OPT_FLAG_NONE,
GC_OPT_FLAG_DEFAULT,
GC_OPT_FLAG_NONE );
es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
es_printf ("pcsc-driver:%lu:\"%s:\n",
GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
#ifdef HAVE_LIBUSB
es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
#endif
es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE );
es_printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE );
es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0);
scd_exit (0);
}
/* Now start with logging to a file if this is desired. */
if (logfile)
{
log_set_file (logfile);
log_set_prefix (NULL, 1|2|4);
}
if (debug_wait && pipe_server)
{
log_debug ("waiting for debugger - my pid is %u .....\n",
(unsigned int)getpid());
gnupg_sleep (debug_wait);
log_debug ("... okay\n");
}
if (pipe_server)
{
/* This is the simple pipe based server */
ctrl_t ctrl;
pth_attr_t tattr;
int fd = -1;
#ifndef HAVE_W32_SYSTEM
{
struct sigaction sa;
sa.sa_handler = SIG_IGN;
sigemptyset (&sa.sa_mask);
sa.sa_flags = 0;
sigaction (SIGPIPE, &sa, NULL);
}
#endif
/* If --debug-allow-core-dump has been given we also need to
switch the working directory to a place where we can actually
write. */
if (allow_coredump)
{
if (chdir("/tmp"))
log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
else
log_debug ("changed working directory to `/tmp'\n");
}
/* In multi server mode we need to listen on an additional
socket. Create that socket now before starting the handler
for the pipe connection. This allows that handler to send
back the name of that socket. */
if (multi_server)
{
socket_name = create_socket_name (standard_socket,
"S.scdaemon",
"gpg-XXXXXX/S.scdaemon");
fd = FD2INT(create_server_socket (standard_socket,
socket_name, &socket_nonce));
}
tattr = pth_attr_new();
pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
ctrl = xtrycalloc (1, sizeof *ctrl);
if ( !ctrl )
{
log_error ("error allocating connection control data: %s\n",
strerror (errno) );
scd_exit (2);
}
ctrl->thread_startup.fd = GNUPG_INVALID_FD;
if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
{
log_error ("error spawning pipe connection handler: %s\n",
strerror (errno) );
xfree (ctrl);
scd_exit (2);
}
/* We run handle_connection to wait for the shutdown signal and
to run the ticker stuff. */
handle_connections (fd);
if (fd != -1)
close (fd);
}
else if (!is_daemon)
{
log_info (_("please use the option `--daemon'"
" to run the program in the background\n"));
}
else
{ /* Regular server mode */
int fd;
#ifndef HAVE_W32_SYSTEM
pid_t pid;
int i;
#endif
/* Create the socket. */
socket_name = create_socket_name (standard_socket,
"S.scdaemon",
"gpg-XXXXXX/S.scdaemon");
fd = FD2INT (create_server_socket (standard_socket,
socket_name, &socket_nonce));
fflush (NULL);
#ifndef HAVE_W32_SYSTEM
pid = fork ();
if (pid == (pid_t)-1)
{
log_fatal ("fork failed: %s\n", strerror (errno) );
exit (1);
}
else if (pid)
{ /* we are the parent */
char *infostr;
close (fd);
/* create the info string: <name>:<pid>:<protocol_version> */
if (estream_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
socket_name, (ulong) pid) < 0)
{
log_error ("out of core\n");
kill (pid, SIGTERM);
exit (1);
}
*socket_name = 0; /* don't let cleanup() remove the socket -
the child should do this from now on */
if (argc)
{ /* run the program given on the commandline */
if (putenv (infostr))
{
log_error ("failed to set environment: %s\n",
strerror (errno) );
kill (pid, SIGTERM );
exit (1);
}
execvp (argv[0], argv);
log_error ("failed to run the command: %s\n", strerror (errno));
kill (pid, SIGTERM);
exit (1);
}
else
{
/* Print the environment string, so that the caller can use
shell's eval to set it */
if (csh_style)
{
*strchr (infostr, '=') = ' ';
es_printf ( "setenv %s\n", infostr);
}
else
{
es_printf ( "%s; export SCDAEMON_INFO;\n", infostr);
}
xfree (infostr);
exit (0);
}
/* NOTREACHED */
} /* end parent */
/* This is the child. */
/* Detach from tty and put process into a new session. */
if (!nodetach )
{
/* Close stdin, stdout and stderr unless it is the log stream. */
for (i=0; i <= 2; i++)
{
if ( log_test_fd (i) && i != fd)
close (i);
}
if (setsid() == -1)
{
log_error ("setsid() failed: %s\n", strerror(errno) );
cleanup ();
exit (1);
}
}
{
struct sigaction sa;
sa.sa_handler = SIG_IGN;
sigemptyset (&sa.sa_mask);
sa.sa_flags = 0;
sigaction (SIGPIPE, &sa, NULL);
}
if (chdir("/"))
{
log_error ("chdir to / failed: %s\n", strerror (errno));
exit (1);
}
#endif /*!HAVE_W32_SYSTEM*/
handle_connections (fd);
close (fd);
}
return 0;
}
