spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/events/events_network_selectstats.c

@@ -0,0 +1,106 @@
+#include <sys/time.h>
+
+#include "monoclock.h"
+
+#include "events.h"
+#include "events_internal.h"
+
+/* Time when inter-select duration clock started. */
+static struct timeval st;
+static int running = 0;
+
+/* Statistics on inter-select durations. */
+static double N = 0.0;
+static double mu = 0.0;
+static double M2 = 0.0;
+static double max = 0.0;
+
+/**
+ * events_network_selectstats_startclock(void):
+ * Start the inter-select duration clock: There is a selectable event.
+ */
+void
+events_network_selectstats_startclock(void)
+{
+
+	/* If the clock is already running, return silently. */
+	if (running)
+		return;
+
+	/* Get the current time; return silently on error. */
+	if (monoclock_get(&st))
+		return;
+
+	/* The clock is now running. */
+	running = 1;
+}
+
+/**
+ * events_network_selectstats_stopclock(void):
+ * Stop the inter-select duration clock: There are no selectable events.
+ */
+void
+events_network_selectstats_stopclock(void)
+{
+
+	/* The clock is no longer running. */
+	running = 0;
+}
+
+/**
+ * events_network_selectstats_select(void):
+ * Update inter-select duration statistics in relation to an upcoming
+ * select(2) call.
+ */
+void
+events_network_selectstats_select(void)
+{
+	struct timeval tnow;
+	double t, d;
+
+	/* If the clock is not running, return silently. */
+	if (!running)
+		return;
+
+	/* If we can't get the current time, fail silently. */
+	if (monoclock_get(&tnow))
+		goto done;
+
+	/* Compute inter-select duration in seconds. */
+	t = (tnow.tv_sec - st.tv_sec) + (tnow.tv_usec - st.tv_usec) * 0.000001;
+
+	/* Adjust statistics.  We track running mean, variance * N, and max. */
+	N += 1.0;
+	d = t - mu;
+	mu += d / N;
+	M2 += d * (t - mu);
+	if (max < t)
+		max = t;
+
+done:
+	/* The clock is no longer running. */
+	running = 0;	
+}
+
+/**
+ * events_network_selectstats(N, mu, va, max):
+ * Return statistics on the inter-select durations since the last time this
+ * function was called.
+ */
+void
+events_network_selectstats(double * _N, double * _mu, double * _va,
+    double * _max)
+{
+
+	/* Copy statistics out. */
+	*_N = N;
+	*_mu = mu;
+	if (N > 1.0)
+		*_va = M2 / (N - 1.0);
+	else
+		*_va = 0.0;
+	*_max = max;
+
+	/* Zero statistics. */
+	N = mu = M2 = max = 0.0;
+}

data/ext/spiped/spiped-source/libcperciva/events/events_timer.c

@@ -0,0 +1,273 @@
+#include <sys/time.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "monoclock.h"
+#include "timerqueue.h"
+
+#include "events_internal.h"
+#include "events.h"
+
+struct timerrec {
+	struct eventrec * r;
+	void * cookie;
+	struct timeval tv_orig;
+};
+
+static struct timerqueue * Q = NULL;
+
+/* Set tv := <current time> + tdelta. */
+static int
+gettimeout(struct timeval * tv, struct timeval * tdelta)
+{
+
+	if (monoclock_get(tv))
+		goto err0;
+	tv->tv_sec += tdelta->tv_sec;
+	if ((tv->tv_usec += tdelta->tv_usec) >= 1000000) {
+		tv->tv_usec -= 1000000;
+		tv->tv_sec += 1;
+	}
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_timer_register(func, cookie, timeo):
+ * Register ${func}(${cookie}) to be run ${timeo} in the future.  Return a
+ * cookie which can be passed to events_timer_cancel or events_timer_reset.
+ */
+void *
+events_timer_register(int (*func)(void *), void * cookie,
+    const struct timeval * timeo)
+{
+	struct eventrec * r;
+	struct timerrec * t;
+	struct timeval tv;
+
+	/* Create the timer queue if it doesn't exist yet. */
+	if (Q == NULL) {
+		if ((Q = timerqueue_init()) == NULL)
+			goto err0;
+	}
+
+	/* Bundle into an eventrec record. */
+	if ((r = events_mkrec(func, cookie)) == NULL)
+		goto err0;
+
+	/* Create a timer record. */
+	if ((t = malloc(sizeof(struct timerrec))) == NULL)
+		goto err1;
+	t->r = r;
+	memcpy(&t->tv_orig, timeo, sizeof(struct timeval));
+
+	/* Compute the absolute timeout. */
+	if (gettimeout(&tv, &t->tv_orig))
+		goto err2;
+
+	/* Add this to the timer queue. */
+	if ((t->cookie = timerqueue_add(Q, &tv, t)) == NULL)
+		goto err2;
+
+	/* Success! */
+	return (t);
+
+err2:
+	free(t);
+err1:
+	events_freerec(r);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * events_timer_register_double(func, cookie, timeo):
+ * As events_timer_register, but ${timeo} is a double-precision floating point
+ * value specifying a number of seconds.
+ */
+void *
+events_timer_register_double(int (*func)(void *), void * cookie,
+    double timeo)
+{
+	struct timeval tv;
+
+	/* Convert timeo to a struct timeval. */
+	tv.tv_sec = timeo;
+	tv.tv_usec = (timeo - tv.tv_sec) * 1000000.0;
+
+	/* Schedule the timeout. */
+	return (events_timer_register(func, cookie, &tv));
+}
+
+/**
+ * events_timer_cancel(cookie):
+ * Cancel the timer for which the cookie ${cookie} was returned by
+ * events_timer_register.
+ */
+void
+events_timer_cancel(void * cookie)
+{
+	struct timerrec * t = cookie;
+
+	/* Remove from the timer queue. */
+	timerqueue_delete(Q, t->cookie);
+
+	/* Free the eventrec and timer records. */
+	events_freerec(t->r);
+	free(t);
+}
+
+/**
+ * events_timer_reset(cookie):
+ * Reset the timer for which the cookie ${cookie} was returned by
+ * events_timer_register to its initial value.
+ */
+int
+events_timer_reset(void * cookie)
+{
+	struct timerrec * t = cookie;
+	struct timeval tv;
+
+	/* Compute the new timeout. */
+	if (gettimeout(&tv, &t->tv_orig))
+		goto err0;
+
+	/* Adjust the timer. */
+	timerqueue_increase(Q, t->cookie, &tv);
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_timer_min(timeo):
+ * Return via ${timeo} a pointer to the minimum time which must be waited
+ * before a timer will expire; or to NULL if there are no timers.  The caller
+ * is responsible for freeing the returned pointer.
+ */
+int
+events_timer_min(struct timeval ** timeo)
+{
+	struct timeval tnow;
+	const struct timeval * tv;
+
+	/* If we have no queue, we have no timers; return NULL. */
+	if (Q == NULL) {
+		*timeo = NULL;
+		goto done;
+	}
+
+	/* Get the minimum timer from the queue. */
+	tv = timerqueue_getmin(Q);
+
+	/* If there are no timers, return NULL. */
+	if (tv == NULL) {
+		*timeo = NULL;
+		goto done;
+	}
+
+	/* Allocate space for holding the returned timeval. */
+	if ((*timeo = malloc(sizeof(struct timeval))) == NULL)
+		goto err0;
+
+	/* Get the current time... */
+	if (monoclock_get(&tnow))
+		goto err1;
+
+	/* ... and compare it to the minimum timer. */
+	if ((tnow.tv_sec > tv->tv_sec) ||
+	    ((tnow.tv_sec == tv->tv_sec) && (tnow.tv_usec > tv->tv_usec))) {
+		/* The timer has already expired, so return zero. */
+		(*timeo)->tv_sec = 0;
+		(*timeo)->tv_usec = 0;
+	} else {
+		/* Compute the difference. */
+		(*timeo)->tv_sec = tv->tv_sec - tnow.tv_sec;
+		(*timeo)->tv_usec = tv->tv_usec - tnow.tv_usec;
+		if (tv->tv_usec < tnow.tv_usec) {
+			(*timeo)->tv_usec += 1000000;
+			(*timeo)->tv_sec -= 1;
+		}
+	}
+
+done:
+	/* Success! */
+	return (0);
+
+err1:
+	free(*timeo);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_timer_get(r):
+ * Return via ${r} a pointer to an eventrec structure corresponding to an
+ * expired timer, and delete said timer; or to NULL if there are no expired
+ * timers.  The caller is responsible for freeing the returned pointer.
+ */
+int
+events_timer_get(struct eventrec ** r)
+{
+	struct timeval tnow;
+	struct timerrec * t;
+
+	/* If we have no queue, we have no timers; return NULL. */
+	if (Q == NULL) {
+		*r = NULL;
+		goto done;
+	}
+
+	/* Get current time. */
+	if (monoclock_get(&tnow))
+		goto err0;
+
+	/* Get an expired timer, if there is one. */
+	t = timerqueue_getptr(Q, &tnow);
+
+	/* If there is an expired timer... */
+	if (t != NULL) {
+		/* ... pass back the eventrec and free the timer. */
+		*r = t->r;
+		free(t);
+	} else {
+		/* Otherwise, return NULL. */
+		*r = NULL;
+	}
+
+done:
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_timer_shutdown(void):
+ * Clean up and free memory.  This call is not necessary on program exit and
+ * is only expected to be useful when checking for memory leaks.
+ */
+void
+events_timer_shutdown(void)
+{
+
+	/* If we have a queue and it is empty, free it. */
+	if ((Q != NULL) && (timerqueue_getmin(Q) == NULL)) {
+		timerqueue_free(Q);
+		Q = NULL;
+	}
+}

data/ext/spiped/spiped-source/libcperciva/network/network.h

@@ -0,0 +1,95 @@
+#ifndef _NETWORK_H_
+#define _NETWORK_H_
+
+#include <sys/select.h>
+
+#include <stddef.h>
+#include <stdint.h>
+#include <unistd.h>
+
+/* Opaque address structure. */
+struct sock_addr;
+
+/**
+ * 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, int (*)(void *, int), void *);
+
+/**
+ * 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 *);
+
+/**
+ * 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 *,
+    int (*)(void *, int), void *);
+
+/**
+ * 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 *, const struct timeval *,
+    int (*)(void *, int), void *);
+
+/**
+ * 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 *);
+
+/**
+ * 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, uint8_t *, size_t, size_t,
+    int (*)(void *, ssize_t), void *);
+
+/**
+ * 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 *);
+
+/**
+ * network_write(fd, buf, buflen, minwrite, callback, cookie):
+ * Asynchronously write up to ${buflen} bytes of data from ${buf} to ${fd}.
+ * When at least ${minwrite} bytes have been written or on error, invoke
+ * ${callback}(${cookie}, lenwrit), where lenwrit is -1 on error and the
+ * number of bytes written (between ${minwrite} and ${buflen} inclusive)
+ * otherwise.  Return a cookie which can be passed to network_write_cancel in
+ * order to cancel the write.
+ */
+void * network_write(int, const uint8_t *, size_t, size_t,
+    int (*)(void *, ssize_t), void *);
+
+/**
+ * network_write_cancel(cookie):
+ * Cancel the buffer write for which the cookie ${cookie} was returned by
+ * network_write.  Do not invoke the callback associated with the write.
+ */
+void network_write_cancel(void *);
+
+#endif /* !_NETWORK_H_ */