#if defined(USE_UTASK_HACK)

struct task;

typedef struct task *sp_pthread_t;

#else /* !USE_UTASK_HACK */

#endif /* !USE_UTASK_HACK */

 * Simulate threads using setjmp/longjmp and sigaltstack.

 * This works for exactly two cooperative tasks, which is all that

 * PAM authentication needs.

 */

#include <setjmp.h>

#ifdef HAVE_POLL_H

#include <poll.h>

#endif

#define utask_jmp_buf	    sigjmp_buf

#define utask_setjmp(b)	    sigsetjmp(b, 0)

#define utask_longjmp(b,x)  siglongjmp(b, x)

/* A task structure; mainly a container for the jmpbuf to save task state */

struct task {

    const char *name;

    enum { UTASK_DEAD, UTASK_RUNNABLE, UTASK_EXITED } state;

    utask_jmp_buf jmpbuf;

    void *(*entry)(void *);

    void *entry_arg;

    void *return_val;

    char *stack;

    struct task *next, **nextp;

};

static struct task main_task  = { "main", UTASK_RUNNABLE };

static struct task other_task = { "other", UTASK_DEAD };

static struct task * volatile current_task = &main_task;

static struct task *sleeping_tasks;

/* Switches to a task. */

static void

utask_switch(struct task *new_task)

{

    struct task *old_task;

    if (current_task != new_task) {

       	old_task = current_task;

	current_task = new_task;

	if (utask_setjmp(old_task->jmpbuf) == 0)

	    utask_longjmp(current_task->jmpbuf, 1);

    }

}

/* Yields to next runnable task. (cancellation point) */

static void

pthread_yield()

{

    struct task *next_task;

    /* Determine which task to yield to. Easy since there are only 2 tasks */

    next_task = current_task->next;

    next_task = (current_task == &main_task ? &other_task : &main_task);

    if (next_task->state == UTASK_RUNNABLE)

	utask_switch(next_task);

}

/* Terminates the current task. */

static void

pthread_exit(void *arg)

{

    if (current_task == &main_task)

       	fatal("pthread_exit: main task exited");

    current_task->return_val = arg;

    current_task->state = UTASK_EXITED;

    pthread_yield();

}

/* Signal handler called for the USR1 signal raised from pthread_create() */

static void

sig_usr1(int ign)

{

    /* We're on a completely different stack now, so switch task pointers

     * to run the new task. */

    current_task->state = UTASK_RUNNABLE;

    pthread_yield();

    pthread_exit((*other_task.entry)(other_task.entry_arg));

}

/* Creates a second task/thread that runs on a separate stack. */

static int

pthread_create(struct task **t, void *attr, void *(*entry)(void *), void *arg)

{

    stack_t sigstk, oldsigstk;

    struct sigaction sigact, oldsigact;

    struct task *new_task;

    int stacksz, stackpad;

    if (current_task != &main_task)

	fatal("pthread_create: not called from main task");

    if (other_task.state == UTASK_RUNNABLE)

	fatal("pthread_create: other task still active");

    /* Choosing a new task structure is easy. */

    new_task = &other_task;

    new_task->entry = entry;

    new_task->entry_arg = arg;

    /* 4MB of stack with 8kB of padding either side */

    stacksz = 4 * 1024 * 1024;

    stackpad = 8 * 1024;

    if (!new_task->stack)

	new_task->stack = xmalloc(stacksz + stackpad * 2); /* 4MB */

    /* Set up an alternate signal stack, which is the stack that

     * sig_usr1() will run on. We use this to separate the tasks stacks, 

     * in a kind-of-portable way. */

    memset(&sigstk, 0, sizeof sigstk);

    sigstk.ss_sp = new_task->stack + stackpad;

    sigstk.ss_size = stacksz;

    sigstk.ss_flags = 0;

    if (sigaltstack(&sigstk, &oldsigstk) < 0)

	err(1, "sigaltstack");

    /* Set up SIGUSR1 to call sig_usr1() */

    memset(&sigact, 0, sizeof sigact);

    sigact.sa_handler = sig_usr1;

    sigact.sa_flags = /* SA_RESETHAND | */ SA_ONSTACK;

    if (sigaction(SIGUSR1, &sigact, &oldsigact) < 0)

	err(1, "sigaction");

    if (utask_setjmp(current_task->jmpbuf) == 0) {

	/* Trigger sig_usr1() */

	current_task = new_task;

	if (kill(getpid(), SIGUSR1) == -1)

	    err(1, "kill");

	while (new_task->state != UTASK_RUNNABLE)

	    pause();

	/* The signal handler returned (usually from pthread_exit()). */

	current_task = &main_task;

	utask_longjmp(current_task->jmpbuf, 1);

    }

    /* sig_usr1() will longjmp back to here via pthread_yield() */

    /* Restore the signal stack */

    if (sigaltstack(&oldsigstk, (stack_t *)0) < 0)

	err(1, "sigaltstack");

    /* Restore the signal handler to its old behaviour */

    if (sigaction(SIGUSR1, &oldsigact, (struct sigaction *)0) < 0)

	err(1, "sigaction");

    /* Yield back to the newly started task */

    pthread_yield();

    if (t)

	*t = new_task;

    return 0;

}

/* Waits for a task to exit. (cancellation point) */

static int

pthread_join(struct task *t, void **ret)

{

    pthread_yield();

    if (current_task != &main_task) 

	errx(1, "pthread_join: only callable from the main task");

    while (t->state == UTASK_RUNNABLE)

	pthread_yield();

    if (t->stack) {

	free(t->stack);

	t->stack = NULL;

    }

    if (ret)

	*ret = t->return_val;

    return 0;

}

/* Cancels a task. */

static int

pthread_cancel(struct task *t)

{

    /* Because these tasks are cooperative, they must be at 

     * a cancellation point */

    if (t->state == UTASK_RUNNABLE) {

	t->state = UTASK_DEAD;

	t->return_val = 0;

    }

    return 0;

}

/* Yields until a file descriptor becomes ready for read (cancellation point) */

static int

utask_yield_fd(int fd)

{

    struct pollfd pfd[1];

    int n;

    for (;;) {

	pfd[0].fd = fd;

	pfd[0].events = POLLIN;

	pfd[0].revents = 0;

	n = poll(pfd, 1, 0);

	if (n < 0) {

	    if (errno == EAGAIN)

		continue;

	    err(1, "utask_yield_fd: poll");

	} else if (n > 0)

	    return 1;

	pthread_yield();

    }

}

/* The only function below that needs to yield is ssh_msg_recv */

#define ssh_msg_recv(s,b) (utask_yield_fd(s), ssh_msg_recv(s,b))

#else

/*