spiped 0.0.0

data/ext/spiped/spiped-source/STYLE

@@ -0,0 +1,151 @@
+Code style
+==========
+
+In general, FreeBSD style(9) should be followed unless it is irrelevant
+(e.g., $FreeBSD$ tags).
+
+Functions with external linkage are declared like this:
+	/**
+	 * module_func(arg1, arg2):
+	 * Description of what the function does, referring to arguments as
+	 * ${arg1} or suchlike.
+	 */
+	int module_func(void *, int);
+
+The identical comment appears in the C file where the function is defined.
+
+Static functions may have the above form of comment, or simply a
+/* Brief description of what the function does. */
+line before the function.
+
+In general, functions should return (int)(-1) or NULL to indicate error.
+
+Errors should be printed via warnp (if errno is relevant) or warn0 (if errno
+is not relevant) when they are first detected and also at higher levels where
+useful.  As an exception to this, malloc failures (i.e., errno = ENOMEM) can
+result in failure being passed back up the call chain without being printed
+immediately.  (Naturally, other errors can be passed back where a function
+definition so specifies; e.g., ENOENT in cases where a file not existing is
+not erronous.)
+
+The first statement in main(), after variable declarations, should be
+"WARNP_INIT;" in order to set the program name used for printing warnings.
+
+In general, functions should be structured with one return statement per
+status, e.g., one return() for success and one return() for failure.  Errors
+should be handled by using goto to enter the error return path, e.g.,
+	int
+	foo(int bar)
+	{
+
+		if (something fails)
+			goto err0;
+		/* ... */
+		if (something else fails)
+			goto err1;
+		/* ... */
+		if (yet another operation fails)
+			goto err2;
+
+		/* Success! */
+		return (0);
+
+	err2:
+		/* Clean up something. */
+	err1:
+		/* Clean up something else. */
+	err0:
+		/* Failure! */
+		return (-1);
+	}
+
+As an exception to the above, if there is only one way for the function to
+fail, the idioms
+	return (baz(bar));
+and
+	int rc;
+
+	rc = baz(bar);
+	/* ... cleanup code here ... */
+	return (rc);
+are allowed; furthermore, in cases such as foo_free(), the idiom
+	if (we shouldn't do anything)
+		return;
+is preferred over
+	if (we shouldn't do anything)
+		goto done;
+at the start of a function.
+
+Headers should be included in the following groups, with a blank line after
+each (non-empty) group:
+1. <sys/*.h>, with <sys/types.h> first followed by others alphabetically.
+2. <net/*.h>, in alphabetical order.
+3. <*.h>, in alphabetical order.
+4. header files from /lib/, in alphabetical order.
+5. header files from the program being built, in alphabetical order.
+6. header files (usually just one) defining the interface for this C file.
+
+If ssize_t is needed, <unistd.h> should be included to provide it.
+
+If size_t is needed, <stddef.h> should be included to provide it unless
+<stdio.h>, <stdlib.h>, <string.h>, or <unistd.h> is already required.
+
+If the C99 integer types (uint8_t, int64_t, etc.) are required, <stdint.h>
+should be included to provide them unless <inttypes.h> is already required.
+
+The type 'char' should only be used to represent human-readable characters
+(input from users, output to users, pathnames, et cetera).  The type
+'char *' should normally be a NUL-terminated string.  The types 'signed
+char' and 'unsigned char' should never be used; C99 integer types should
+be used instead.
+
+When a variable is declared to have a pointer type, there should be a space
+between the '*' and the variable name, e.g.,
+	int
+	main(int argc, char * argv[])
+	{
+		char * opt_p = NULL;
+Note that this is inconsistent with FreeBSD style(9).  When used as a unary
+operator, '*' is not separated from its argument, e.g.,
+	while (*p != '\0')
+		p++;
+
+When a struct is referenced, the idiom
+	/* Opaque types. */
+	struct foo;
+
+	struct bar * bar_from_foo(struct foo *);
+is preferable to
+	#include "foo.h"	/* needed for struct foo */
+
+	struct bar * bar_from_foo(struct foo *);
+unless there is some reason why the internal layout of struct foo is needed
+(e.g., if struct bar contains a struct foo rather than a struct foo *).  Such
+struct declarations should be sorted alphabetically.
+
+The file foo.c should only export symbols of the following forms:
+	foo_*	-- most symbols should be of this form.
+	FOO_* / BAR_FOO_*
+		-- allowed in cases where FOO or BAR_FOO is idiomatic (e.g.,
+		   MD5, HMAC_SHA256).
+	foo() / defoo() / unfoo()
+		-- where "foo" is a verb and this improves code clarity.
+
+Functions named foo_free should return void, and foo_free(NULL) should have
+no effect.
+
+If static variables need to be initialized to 0 (or NULL) then they should be
+explicitly declared that way; implicit initialization should not be used.
+
+In non-trivial code, comments should be included which describe in English
+what is being done by the surrounding code with sufficient detail that if the
+code were removed, it could be replaced based on reading the comments without
+requiring any significant creativity.
+
+Comments and documentation should be written in en-GB-oed; i.e., with
+the 'u' included in words such as "honour", "colour", and "neighbour",
+and the ending '-ize' in words such as "organize" and "realize".  The
+Oxford (aka. serial) comma should be used in lists.  Quotation marks
+should be placed logically, i.e., not including punctuation marks which
+do not form a logical part of the quoted text.  Two spaces should be used
+after a period which ends a sentence.

data/ext/spiped/spiped-source/lib/dnsthread/dnsthread.c

@@ -0,0 +1,464 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "events.h"
+#include "noeintr.h"
+#include "sock.h"
+#include "warnp.h"
+
+#include "dnsthread.h"
+
+/* Thread management structure. */
+struct dnsthread_internal {
+	/* Threading glue. */
+	pthread_t thr;		/* Thread ID. */
+	pthread_mutex_t	mtx;	/* Controls access to this structure. */
+	pthread_cond_t cv;	/* Thread sleeps on this. */
+
+	/* State management. */
+	int state;		/* THREAD_* as below. */
+	int wakeupsock[2];	/* Writes to [0], reads from [1]. */
+
+	/* Address resolution variables. */
+	char * addr;		/* Address to be resolved. */
+	struct sock_addr ** sas;	/* Results. */
+	int res_errno;		/* Errno to be passed back on failure. */
+
+	/* Callback to occur when resolution is complete. */
+	int (*callback)(void *, struct sock_addr **);	/* Callback. */
+	void * cookie;		/* Cookie. */
+};
+
+/* Cookie used by dnsthread_resolve. */
+struct resolve_cookie {
+	int (*callback)(void *, struct sock_addr **);
+	void * cookie;
+	DNSTHREAD T;
+};
+
+/*
+ * Thread states.  _resolveone moves the thread from SLEEPING to HASWORK;
+ * workthread moves the thread from HASWORK to SLEEPING; and _kill moves the
+ * thread from either state to SUICIDE.
+ */
+#define	THREAD_SLEEPING 0
+#define THREAD_HASWORK 1
+#define THREAD_SUICIDE 2
+
+/* Callback functions used below. */
+static int callback_resolveone(void * cookie);
+static int callback_resolve(void *, struct sock_addr **);
+
+/* Address resolution thread. */
+static void *
+workthread(void * cookie)
+{
+	struct dnsthread_internal * T = cookie;
+	char * addr;
+	struct sock_addr ** sas;
+	int res_errno = 0;
+	int rc;
+	uint8_t zero = 0;
+
+	/* Grab the mutex. */
+	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_lock: %s", strerror(rc));
+		exit(1);
+	}
+
+	/* Infinite loop doing work until told to suicide. */
+	do {
+		/*
+		 * Sleep on the condition variable as long as we're in the
+		 * SLEEPING state.
+		 */
+		while (T->state == THREAD_SLEEPING) {
+			/* Sleep until we're woken up. */
+			if ((rc = pthread_cond_wait(&T->cv, &T->mtx)) != 0) {
+				warn0("pthread_cond_wait: %s", strerror(rc));
+				exit(1);
+			}
+		}
+
+		/* If we need to kill ourself, stop looping. */
+		if (T->state == THREAD_SUICIDE)
+			break;
+
+		/* Grab the work. */
+		addr = T->addr;
+
+		/* Release the mutex. */
+		if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+			warn0("pthread_mutex_unlock: %s", strerror(rc));
+			exit(1);
+		}
+
+		/* Perform the address resolution. */
+		if ((sas = sock_resolve(addr)) == NULL)
+			res_errno = errno;
+
+		/* Grab the mutex again. */
+		if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+			warn0("pthread_mutex_lock: %s", strerror(rc));
+			exit(1);
+		}
+
+		/* Write the answer back. */
+		T->sas = sas;
+		T->res_errno = res_errno;
+
+		/* Send a completion message. */
+		if (noeintr_write(T->wakeupsock[0], &zero, 1) != 1) {
+			warnp("Error writing to wakeup socket");
+			exit(1);
+		}
+
+		/* Return to sleeping, unless we were instructed to die. */
+		if (T->state != THREAD_SUICIDE)
+			T->state = THREAD_SLEEPING;
+	} while (1);
+
+	/* Close the socket pair. */
+	close(T->wakeupsock[1]);
+	close(T->wakeupsock[0]);
+
+	/* Destroy the condition variable. */
+	if ((rc = pthread_cond_destroy(&T->cv)) != 0) {
+		warn0("pthread_cond_destroy: %s", strerror(rc));
+		exit(1);
+	}
+
+	/* Release the mutex. */
+	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_unlock: %s", strerror(rc));
+		exit(1);
+	}
+
+	/* Destroy the mutex. */
+	if ((rc = pthread_mutex_destroy(&T->mtx)) != 0) {
+		warn0("pthread_mutex_destroy: %s", strerror(rc));
+		exit(1);
+	}
+
+	/* Free the control structure. */
+	free(T);
+
+	/* Successful thread termination. */
+	return (NULL);
+}
+
+/**
+ * dnsthread_spawn(void):
+ * Spawn a thread for performing address resolution.  Return a token which can
+ * be passed to dnsthread_resolveone and dnsthread_kill.
+ */
+DNSTHREAD
+dnsthread_spawn(void)
+{
+	struct dnsthread_internal * T;
+	int rc;
+
+	/* Allocate a thread management structure. */
+	if ((T = malloc(sizeof(struct dnsthread_internal))) == NULL)
+		goto err0;
+
+	/* Create and lock a mutex. */
+	if ((rc = pthread_mutex_init(&T->mtx, NULL)) != 0) {
+		warn0("pthread_mutex_init: %s", strerror(rc));
+		goto err1;
+	}
+	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_lock: %s", strerror(rc));
+		goto err2;
+	}
+
+	/* Create state-changed condition variable. */
+	if ((rc = pthread_cond_init(&T->cv, NULL)) != 0) {
+		warn0("pthread_cond_init: %s", strerror(rc));
+		goto err3;
+	}
+
+	/* Create wakeup socketpair. */
+	if (socketpair(AF_UNIX, SOCK_STREAM, 0, T->wakeupsock)) {
+		warnp("socketpair");
+		goto err4;
+	}
+
+	/* The thread starts out sleeping. */
+	T->state = THREAD_SLEEPING;
+
+	/* Create the thread. */
+	if ((rc = pthread_create(&T->thr, NULL, workthread, T)) != 0) {
+		warn0("pthread_create: %s", strerror(rc));
+		goto err5;
+	}
+
+	/* Unlock the mutex. */
+	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_unlock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* Success! */
+	return (T);
+
+err5:
+	close(T->wakeupsock[1]);
+	close(T->wakeupsock[0]);
+err4:
+	pthread_cond_destroy(&T->cv);
+err3:
+	pthread_mutex_unlock(&T->mtx);
+err2:
+	pthread_mutex_destroy(&T->mtx);
+err1:
+	free(T);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * dnsthread_resolveone(T, addr, callback, cookie):
+ * Using the thread for which ${T} was returned by dnsthread_spawn, resolve
+ * the address ${addr}, which must be in one of the forms accepted by the
+ * sock_resolve function.  If ${T} is already resolving an address, do not
+ * resolve this address and instead return with errno == EALREADY.  Upon
+ * completion, invoke ${callback}(${cookie}, sas), where ${sas} is a
+ * NULL-terminated array of pointers to sock_addr structures or NULL on
+ * resolution failure.
+ */
+int
+dnsthread_resolveone(DNSTHREAD T, const char * addr,
+    int (* callback)(void *, struct sock_addr **), void * cookie)
+{
+	int err = 0;
+	int rc;
+
+	/* Grab the mutex. */
+	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_lock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* If the resolver is already busy, fail. */
+	if (T->state == THREAD_HASWORK) {
+		err = EALREADY;
+		goto ealready;
+	}
+
+	/* Duplicate the address to be resolved. */
+	if ((T->addr = strdup(addr)) == NULL)
+	    goto err1;
+
+	/* Remember what callback we'll need to do eventually. */
+	T->callback = callback;
+	T->cookie = cookie;
+
+	/* There is now work for the thread to do. */
+	T->state = THREAD_HASWORK;
+
+	/* Wake up the worker thread. */
+	if ((rc = pthread_cond_signal(&T->cv)) != 0) {
+		warn0("pthread_cond_signal: %s", strerror(rc));
+		goto err1;
+	}
+
+	/* We want a callback when the worker thread pokes us. */
+	if (events_network_register(callback_resolveone, T, T->wakeupsock[1],
+	    EVENTS_NETWORK_OP_READ)) {
+		warnp("Error registering wakeup listener");
+		goto err1;
+	}
+
+ealready:
+	/* Release the mutex. */
+	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_unlock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* If err was set earlier, store the value in errno. */
+	if (err)
+		errno = err;
+
+	/* Success! */
+	return (0);
+
+err1:
+	pthread_mutex_unlock(&T->mtx);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/* Callback for dnsthread_resolveone, from wakeup socket. */
+static int
+callback_resolveone(void * cookie)
+{
+	struct dnsthread_internal * T = cookie;
+	struct sock_addr ** sas;
+	uint8_t zero;
+	int res_errno = 0;
+	int (*callback)(void *, struct sock_addr **);
+	void * cb_cookie;
+	int rc;
+
+	/* Drain the byte from the socketpair. */
+	if (read(T->wakeupsock[1], &zero, 1) != 1) {
+		warn0("Error reading from wakeup socket");
+		goto err0;
+	}
+
+	/* Grab the mutex. */
+	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_lock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* Free the (strduped) address which was to be resolved. */
+	free(T->addr);
+
+	/* Grab the result. */
+	sas = T->sas;
+	res_errno = T->res_errno;
+
+	/* Grab the callback. */
+	callback = T->callback;
+	cb_cookie = T->cookie;
+
+	/* Release the mutex. */
+	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_unlock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* Perform the callback. */
+	if (sas == NULL)
+		errno = res_errno;
+	return ((callback)(cb_cookie, sas));
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * dnsthread_kill(T):
+ * Instruct an address resolution thread to die.  If the thread does not have
+ * an address resolution operation currently pending, wait for the thread to
+ * die before returning.
+ */
+int
+dnsthread_kill(DNSTHREAD T)
+{
+	int rc;
+	int ostate;
+	pthread_t thr;
+
+	/* Lock the control structure. */
+	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_lock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* Remember what state the thread is currently in. */
+	ostate = T->state;
+
+	/* Grab the thread ID. */
+	thr = T->thr;
+
+	/* Tell the thread to die, and wake it up. */
+	T->state = THREAD_SUICIDE;
+	if ((rc = pthread_cond_signal(&T->cv)) != 0) {
+		warn0("pthread_cond_signal: %s", strerror(rc));
+		goto err1;
+	}
+
+	/* Unlock the control structure. */
+	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
+		warn0("pthread_mutex_unlock: %s", strerror(rc));
+		goto err0;
+	}
+
+	/* If the thread was sleeping, wait for it to wake up and die. */
+	if (ostate == THREAD_SLEEPING) {
+		if ((rc = pthread_join(thr, NULL)) != 0) {
+			warn0("pthread_join: %s", strerror(rc));
+			goto err0;
+		}
+	}
+
+	/* Success! */
+	return (0);
+
+err1:
+	pthread_mutex_unlock(&T->mtx);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * dnsthread_resolve(addr, callback, cookie):
+ * Perform a non-blocking address resolution of ${addr}.  This function may
+ * spawn a thread internally.
+ */
+int
+dnsthread_resolve(const char * addr,
+    int (* callback)(void *, struct sock_addr **), void * cookie)
+{
+	struct resolve_cookie * R;
+
+	/* Bake a cookie. */
+	if ((R = malloc(sizeof(struct resolve_cookie))) == NULL)
+		goto err0;
+	R->callback = callback;
+	R->cookie = cookie;
+
+	/* Spawn a thread. */
+	if ((R->T = dnsthread_spawn()) == NULL)
+		goto err1;
+
+	/* Launch the request. */
+	if (dnsthread_resolveone(R->T, addr, callback_resolve, R))
+		goto err2;
+
+	/* Success! */
+	return (0);
+
+err2:
+	dnsthread_kill(R->T);
+err1:
+	free(R);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/* Callback for dnsthread_resolve, from dnsthread_resolveone. */
+static int
+callback_resolve(void * cookie, struct sock_addr ** sas)
+{
+	struct resolve_cookie * R = cookie;
+	int rc;
+
+	/* Invoke the upstream callback. */
+	rc = (R->callback)(R->cookie, sas);
+
+	/* Kill the resolver thread. */
+	if (dnsthread_kill(R->T))
+		rc = -1;
+
+	/* Free our cookie. */
+	free(R);
+
+	/* Return upstream return code or failure. */
+	return (rc);
+}