int
main(int argc, char *argv[])
{
SVCXPRT *transp;
socklen_t salen;
int ok;
struct sockaddr_storage sa;
if (argc == 2 && !strcmp(argv[1], "-n"))
nodaemon = 1;
if (argc != 1 && !nodaemon)
usage();
if (geteuid() == 0) {
struct passwd *pep = getpwnam("nobody");
if (pep)
setuid(pep->pw_uid);
else
setuid(getuid());
}
/*
* See if inetd started us
*/
salen = sizeof(sa);
if (getsockname(0, (struct sockaddr *)&sa, &salen) < 0) {
from_inetd = 0;
}
if (!from_inetd) {
if (!nodaemon)
possess();
(void)rpcb_unset(WALLPROG, WALLVERS, NULL);
}
(void)signal(SIGCHLD, killkids);
openlog("rpc.rwalld", LOG_CONS|LOG_PID, LOG_DAEMON);
/* create and register the service */
if (from_inetd) {
transp = svc_tli_create(0, NULL, NULL, 0, 0);
if (transp == NULL) {
syslog(LOG_ERR, "couldn't create udp service.");
exit(1);
}
ok = svc_reg(transp, WALLPROG, WALLVERS,
wallprog_1, NULL);
} else
ok = svc_create(wallprog_1,
WALLPROG, WALLVERS, "udp");
if (!ok) {
syslog(LOG_ERR, "unable to register (WALLPROG, WALLVERS, %s)", (!from_inetd)?"udp":"(inetd)");
exit(1);
}
svc_run();
syslog(LOG_ERR, "svc_run returned");
exit(1);
}
void join(thread *ally)
{
int ret;
thread *match, **prior;
/* wait for thread to exit and return its resources */
if ((ret = pthread_join(ally->id, NULL)) != 0)
fail(ret);
/* find the thread in the threads list */
possess(&(threads_lock));
prior = &(threads);
while ((match = *prior) != NULL) {
if (match == ally)
break;
prior = &(match->next);
}
if (match == NULL)
fail(EINVAL);
/* remove thread from list and update exited count, free thread */
if (match->done)
threads_lock.value--;
*prior = match->next;
release(&(threads_lock));
my_free(ally);
}
/* not all POSIX implementations create threads as joinable by default, so that
is made explicit here */
thread *launch(void (*probe)(void *), void *payload)
{
int ret;
thread *th;
struct capsule *capsule;
pthread_attr_t attr;
/* construct the requested call and argument for the ignition() routine
(allocated instead of automatic so that we're sure this will still be
there when ignition() actually starts up -- ignition() will free this
allocation) */
capsule = my_malloc(sizeof(struct capsule));
capsule->probe = probe;
capsule->payload = payload;
/* assure this thread is in the list before join_all() or ignition() looks
for it */
possess(&(threads_lock));
/* create the thread and call ignition() from that thread */
th = my_malloc(sizeof(struct thread_s));
if ((ret = pthread_attr_init(&attr)) ||
(ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE)) ||
(ret = pthread_create(&(th->id), &attr, ignition, capsule)) ||
(ret = pthread_attr_destroy(&attr)))
fail(ret);
/* put the thread in the threads list for join_all() */
th->done = 0;
th->next = threads;
threads = th;
release(&(threads_lock));
return th;
}
/* mark the calling thread as done and alert join_all() */
local void reenter(void *dummy)
{
thread *match, **prior;
pthread_t me;
(void)dummy;
/* find this thread in the threads list by matching the thread id */
me = pthread_self();
possess(&(threads_lock));
prior = &(threads);
while ((match = *prior) != NULL) {
if (pthread_equal(match->id, me))
break;
prior = &(match->next);
}
if (match == NULL)
fail(EINVAL);
/* mark this thread as done and move it to the head of the list */
match->done = 1;
if (threads != match) {
*prior = match->next;
match->next = threads;
threads = match;
}
/* update the count of threads to be joined and alert join_all() */
twist(&(threads_lock), BY, +1);
}
static int safe_fwprintf(FILE *stream, const wchar_t *format, ...)
{
int retval;
va_list arglist;
possess(g_fwprintf_lock);
va_start(arglist, format);
retval = vfwprintf(stream, format, arglist);
va_end(arglist);
fflush(stream);
release(g_fwprintf_lock);
return retval;
}
/* This implementation of join_all() only attempts to join threads that have
announced that they have exited (see ignition()). When there are many
threads, this is faster than waiting for some random thread to exit while a
bunch of other threads have already exited. */
int join_all(void)
{
int ret, count;
thread *match, **prior;
/* grab the threads list and initialize the joined count */
count = 0;
possess(&(threads_lock));
/* do until threads list is empty */
while (threads != NULL) {
/* wait until at least one thread has reentered */
wait_for(&(threads_lock), NOT_TO_BE, 0);
/* find the first thread marked done (should be at or near the top) */
prior = &(threads);
while ((match = *prior) != NULL) {
if (match->done)
break;
prior = &(match->next);
}
if (match == NULL)
fail(EINVAL);
/* join the thread (will be almost immediate), remove from the threads
list, update the reenter count, and free the thread */
if ((ret = pthread_join(match->id, NULL)) != 0)
fail(ret);
threads_lock.value--;
*prior = match->next;
my_free(match);
count++;
}
/* let go of the threads list and return the number of threads joined */
release(&(threads_lock));
return count;
}
