spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/network/network_accept.c

@@ -0,0 +1,103 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include "events.h"
+
+#include "network.h"
+
+struct accept_cookie {
+	int (* callback)(void *, int);
+	void * cookie;
+	int fd;
+};
+
+/* Accept the connection and invoke the callback. */
+static int
+callback_accept(void * cookie)
+{
+	struct accept_cookie * C = cookie;
+	int s;
+	int rc;
+
+	/* Attempt to accept a new connection. */
+	if ((s = accept(C->fd, NULL, NULL)) == -1) {
+		/* If a connection isn't available, reset the callback. */
+		if ((errno == EAGAIN) ||
+		    (errno == EWOULDBLOCK) ||
+		    (errno == ECONNABORTED) ||
+		    (errno == EINTR))
+			goto tryagain;
+	}
+
+	/* Call the upstream callback. */
+	rc = (C->callback)(C->cookie, s);
+
+	/* Free the cookie. */
+	free(C);
+
+	/* Return status from upstream callback. */
+	return (rc);
+
+tryagain:
+	/* Reset the callback. */
+	return (events_network_register(callback_accept, C, C->fd,
+	    EVENTS_NETWORK_OP_READ));
+}
+
+/**
+ * network_accept(fd, callback, cookie):
+ * Asynchronously accept a connection on the socket ${fd}, which must be
+ * already marked as listening and non-blocking.  When a connection has been
+ * accepted or an error occurs, invoke ${callback}(${cookie}, s) where s is
+ * the accepted connection or -1 on error.  Return a cookie which can be
+ * passed to network_accept_cancel in order to cancel the accept.
+ */
+void *
+network_accept(int fd, int (* callback)(void *, int), void * cookie)
+{
+	struct accept_cookie * C;
+
+	/* Bake a cookie. */
+	if ((C = malloc(sizeof(struct accept_cookie))) == NULL)
+		goto err0;
+	C->callback = callback;
+	C->cookie = cookie;
+	C->fd = fd;
+
+	/*
+	 * Register a network event.  A connection arriving on a listening
+	 * socket is treated by select(2) as the socket becoming readable.
+	 */
+	if (events_network_register(callback_accept, C, C->fd,
+	    EVENTS_NETWORK_OP_READ))
+		goto err1;
+
+	/* Success! */
+	return (C);
+
+err1:
+	free(C);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * network_accept_cancel(cookie);
+ * Cancel the connection accept for which the cookie ${cookie} was returned
+ * by network_accept.  Do not invoke the callback associated with the accept.
+ */
+void
+network_accept_cancel(void * cookie)
+{
+	struct accept_cookie * C = cookie;
+
+	/* Cancel the network event. */
+	events_network_cancel(C->fd, EVENTS_NETWORK_OP_READ);
+
+	/* Free the cookie. */
+	free(C);
+}

data/ext/spiped/spiped-source/libcperciva/network/network_connect.c

@@ -0,0 +1,258 @@
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "events.h"
+#include "sock.h"
+
+#include "network.h"
+
+struct connect_cookie {
+	int (* callback)(void *, int);
+	void * cookie;
+	struct sock_addr * const * sas;
+	struct timeval timeo;
+	void * cookie_immediate;
+	int s;
+	int timeo_enabled;
+	void * cookie_timeo;
+};
+
+static int tryconnect(struct connect_cookie *);
+
+/* Invoke the upstream callback and clean up. */
+static int
+docallback(void * cookie)
+{
+	struct connect_cookie * C = cookie;
+	int rc;
+
+	/* Invoke the upstream callback. */
+	rc = (C->callback)(C->cookie, C->s);
+
+	/* Free the cookie. */
+	free(C);
+
+	/* Return status from upstream callback. */
+	return (rc);
+}
+
+/* An address failed to connect. */
+static int
+dofailed(struct connect_cookie * C)
+{
+
+	/* Close the socket which failed to connect. */
+	close(C->s);
+
+	/* We don't have an open socket any more. */
+	C->s = -1;
+
+	/* This address didn't work. */
+	C->sas++;
+
+	/* Try other addresses until we run out of options. */
+	return (tryconnect(C));
+}
+
+/* Callback when connect(2) succeeds or fails. */
+static int
+callback_connect(void * cookie)
+{
+	struct connect_cookie * C = cookie;
+	int sockerr;
+	socklen_t sockerrlen = sizeof(int);
+
+	/* Stop waiting for the timer callback. */
+	if (C->cookie_timeo != NULL) {
+		events_timer_cancel(C->cookie_timeo);
+		C->cookie_timeo = NULL;
+	}
+
+	/* Did we succeed? */
+	if (getsockopt(C->s, SOL_SOCKET, SO_ERROR, &sockerr, &sockerrlen))
+		goto err1;
+	if (sockerr != 0)
+		return (dofailed(C));
+
+	/*
+	 * Perform the callback (this can be done here rather than being
+	 * scheduled as an immediate callback, as we're already running from
+	 * callback context).
+	 */
+	return (docallback(C));
+
+err1:
+	close(C->s);
+	free(C);
+
+	/* Fatal error! */
+	return (-1);
+}
+
+/* Callback when a timer expires. */
+static int
+callback_timeo(void * cookie)
+{
+	struct connect_cookie * C = cookie;
+
+	/* We're not waiting for a timer callback any more. */
+	C->cookie_timeo = NULL;
+
+	/* Stop listening for this socket. */
+	events_network_cancel(C->s, EVENTS_NETWORK_OP_WRITE);
+
+	/* This connect attempt failed. */
+	return (dofailed(C));
+}
+
+/* Try to launch a connection.  Free the cookie on fatal errors. */
+static int
+tryconnect(struct connect_cookie * C)
+{
+
+	/* Try addresses until we find one which doesn't fail immediately. */
+	for (; C->sas[0] != NULL; C->sas++) {
+		/* Can we try to connect to this address? */
+		if ((C->s = sock_connect_nb(C->sas[0])) != -1)
+			break;
+	}
+
+	/* Did we run out of addresses to try? */
+	if (C->sas[0] == NULL)
+		goto failed;
+
+	/* If we've been asked to have a timeout, set one. */
+	if (C->timeo_enabled) {
+		if ((C->cookie_timeo = events_timer_register(callback_timeo,
+		    C, &C->timeo)) == NULL)
+			goto err1;
+	} else {
+		C->cookie_timeo = NULL;
+	}
+
+	/* Wait until this socket connects or fails to do so. */
+	if (events_network_register(callback_connect, C, C->s,
+	    EVENTS_NETWORK_OP_WRITE))
+		goto err2;
+
+	/* Success! */
+	return (0);
+
+failed:
+	/* Schedule a callback. */
+	if ((C->cookie_immediate =
+	    events_immediate_register(docallback, C, 0)) == NULL)
+		goto err1;
+
+	/* Failure successfully handled. */
+	return (0);
+
+err2:
+	if (C->cookie_timeo != NULL)
+		events_timer_cancel(C->cookie_timeo);
+err1:
+	if (C->s != -1)
+		close(C->s);
+	free(C);
+
+	/* Fatal error. */
+	return (-1);
+}
+
+/**
+ * network_connect(sas, callback, cookie):
+ * Iterate through the addresses in ${sas}, attempting to create and connect
+ * a non-blocking socket.  Once connected, invoke ${callback}(${cookie}, s)
+ * where s is the connected socket; upon fatal error or if there are no
+ * addresses remaining to attempt, invoke ${callback}(${cookie}, -1).  Return
+ * a cookie which can be passed to network_connect_cancel in order to cancel
+ * the connection attempt.
+ */
+void *
+network_connect(struct sock_addr * const * sas,
+    int (* callback)(void *, int), void * cookie)
+{
+
+	/* Let network_connect_timeo handle this. */
+	return (network_connect_timeo(sas, NULL, callback, cookie));
+}
+
+/**
+ * network_connect_timeo(sas, timeo, callback, cookie):
+ * Behave as network_connect, but wait a duration of at most ${timeo} for
+ * each address which is being attempted.
+ */
+void *
+network_connect_timeo(struct sock_addr * const * sas,
+    const struct timeval * timeo,
+    int (* callback)(void *, int), void * cookie)
+{
+	struct connect_cookie * C;
+
+	/* Bake a cookie. */
+	if ((C = malloc(sizeof(struct connect_cookie))) == NULL)
+		goto err0;
+	C->callback = callback;
+	C->cookie = cookie;
+	C->sas = sas;
+	C->cookie_immediate = NULL;
+	C->cookie_timeo = NULL;
+	C->s = -1;
+
+	/* Do we have a timeout? */
+	if (timeo != NULL) {
+		memcpy(&C->timeo, timeo, sizeof(struct timeval));
+		C->timeo_enabled = 1;
+	} else {
+		C->timeo_enabled = 0;
+	}
+
+	/* Try to connect to the first address. */
+	if (tryconnect(C))
+		goto err0;
+
+	/* Success! */
+	return (C);
+
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * network_connect_cancel(cookie):
+ * Cancel the connection attempt for which ${cookie} was returned by
+ * network_connect.  Do not invoke the associated callback.
+ */
+void
+network_connect_cancel(void * cookie)
+{
+	struct connect_cookie * C = cookie;
+
+	/* We should have either an immediate callback or a socket. */
+	assert((C->cookie_immediate != NULL) || (C->s != -1));
+	assert((C->cookie_immediate == NULL) || (C->s == -1));
+
+	/* Cancel any timer. */
+	if (C->cookie_timeo != NULL)
+		events_timer_cancel(C->cookie_timeo);
+
+	/* Cancel any immediate callback. */
+	if (C->cookie_immediate != NULL)
+		events_immediate_cancel(C->cookie_immediate);
+
+	/* Close any socket. */
+	if (C->s != -1) {
+		events_network_cancel(C->s, EVENTS_NETWORK_OP_WRITE);
+		close(C->s);
+	}
+
+	/* Free the cookie. */
+	free(C);
+}

data/ext/spiped/spiped-source/libcperciva/network/network_read.c

@@ -0,0 +1,155 @@
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "events.h"
+#include "warnp.h"
+
+#include "network.h"
+
+struct network_read_cookie {
+	int (*callback)(void *, ssize_t);
+	void * cookie;
+	int fd;
+	uint8_t * buf;
+	size_t buflen;
+	size_t minlen;
+	size_t bufpos;
+};
+
+/* Invoke the callback, clean up, and return the callback's status. */
+static int
+docallback(struct network_read_cookie * C, ssize_t nbytes)
+{
+	int rc;
+
+	/* Invoke the callback. */
+	rc = (C->callback)(C->cookie, nbytes);
+
+	/* Clean up. */
+	free(C);
+
+	/* Return the callback's status. */
+	return (rc);
+}
+
+/* The socket is ready for reading/writing. */
+static int
+callback_buf(void * cookie)
+{
+	struct network_read_cookie * C = cookie;
+	size_t oplen;
+	ssize_t len;
+
+	/* Attempt to read/write data to/from the buffer. */
+	oplen = C->buflen - C->bufpos;
+	len = recv(C->fd, C->buf + C->bufpos, oplen, 0);
+
+	/* Failure? */
+	if (len == -1) {
+		/* Was it really an error, or just a try-again? */
+		if ((errno == EAGAIN) ||
+		    (errno == EWOULDBLOCK) ||
+		    (errno == EINTR))
+			goto tryagain;
+
+		/* Something went wrong. */
+		goto failed;
+	} else if (len == 0) {
+		/* The socket was shut down by the remote host. */
+		goto eof;
+	}
+
+	/* We processed some data.  Do we need to keep going? */
+	if ((C->bufpos += len) < C->minlen)
+		goto tryagain;
+
+	/* Invoke the callback and return. */
+	return (docallback(C, C->bufpos));
+
+tryagain:
+	/* Reset the event. */
+	if (events_network_register(callback_buf, C, C->fd,
+	    EVENTS_NETWORK_OP_READ))
+		goto failed;
+
+	/* Callback was reset. */
+	return (0);
+
+eof:
+	/* Invoke the callback with an EOF status and return. */
+	return (docallback(C, 0));
+
+failed:
+	/* Invoke the callback with a failure status and return. */
+	return (docallback(C, -1));
+}
+
+/**
+ * network_read(fd, buf, buflen, minread, callback, cookie):
+ * Asynchronously read up to ${buflen} bytes of data from ${fd} into ${buf}.
+ * When at least ${minread} bytes have been read or on error, invoke
+ * ${callback}(${cookie}, lenread), where lenread is 0 on EOF or -1 on error,
+ * and the number of bytes read (between ${minread} and ${buflen} inclusive)
+ * otherwise.  Return a cookie which can be passed to network_read_cancel in
+ * order to cancel the read.
+ */
+void *
+network_read(int fd, uint8_t * buf, size_t buflen, size_t minread,
+    int (* callback)(void *, ssize_t), void * cookie)
+{
+	struct network_read_cookie * C;
+
+	/* Make sure buflen is non-zero. */
+	assert(buflen != 0);
+
+	/* Sanity-check: # bytes must fit into a ssize_t. */
+	assert(buflen <= SSIZE_MAX);
+
+	/* Bake a cookie. */
+	if ((C = malloc(sizeof(struct network_read_cookie))) == NULL)
+		goto err0;
+	C->callback = callback;
+	C->cookie = cookie;
+	C->fd = fd;
+	C->buf = buf;
+	C->buflen = buflen;
+	C->minlen = minread;
+	C->bufpos = 0;
+
+	/* Register a callback for network readiness. */
+	if (events_network_register(callback_buf, C, C->fd,
+	    EVENTS_NETWORK_OP_READ))
+		goto err1;
+
+	/* Success! */
+	return (C);
+
+err1:
+	free(C);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * network_read_cancel(cookie):
+ * Cancel the buffer read for which the cookie ${cookie} was returned by
+ * network_read.  Do not invoke the callback associated with the read.
+ */
+void
+network_read_cancel(void * cookie)
+{
+	struct network_read_cookie * C = cookie;
+
+	/* Kill the network event. */
+	events_network_cancel(C->fd, EVENTS_NETWORK_OP_READ);
+
+	/* Free the cookie. */
+	free(C);
+}