Author: harti
Date: Sat Dec 20 17:30:32 2008
New Revision: 186360
URL: http://svn.freebsd.org/changeset/base/186360
Log:
Flatten the libbegemot vendor area.
Added:
vendor/libbegemot/1.1.1/rpoll.c
- copied unchanged from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.c
vendor/libbegemot/1.1.1/rpoll.h
- copied unchanged from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.h
vendor/libbegemot/1.1.1/rpoll.man
- copied unchanged from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.man
vendor/libbegemot/dist/rpoll.c
- copied unchanged from r186358,
vendor/libbegemot/dist/contrib/libbegemot/rpoll.c
vendor/libbegemot/dist/rpoll.h
- copied unchanged from r186358,
vendor/libbegemot/dist/contrib/libbegemot/rpoll.h
vendor/libbegemot/dist/rpoll.man
- copied unchanged from r186358,
vendor/libbegemot/dist/contrib/libbegemot/rpoll.man
Deleted:
vendor/libbegemot/1.1.1/contrib/
vendor/libbegemot/dist/contrib/
Copied: vendor/libbegemot/1.1.1/rpoll.c (from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.c)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libbegemot/1.1.1/rpoll.c Sat Dec 20 17:30:32 2008
(r186360, copy of r186358, vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.c)
@@ -0,0 +1,714 @@
+/*
+ * Copyright (c)1996-2002 by Hartmut Brandt
+ * All rights reserved.
+ *
+ * Author: Hartmut Brandt
+ *
+ * Redistribution of this software and documentation and use in source and
+ * binary forms, with or without modification, are permitted provided that
+ * the following conditions are met:
+ *
+ * 1. Redistributions of source code or documentation must retain the above
+ * copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
+ * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * These functions try to hide the poll/select/setitimer interface from the
+ * user. You associate callback functions with file descriptors and timers.
+ *
+ * $Begemot: libbegemot/rpoll.c,v 1.14 2004/09/21 15:59:00 brandt Exp $
+ */
+# include <stdio.h>
+# include <stdlib.h>
+# include <stddef.h>
+# include <stdarg.h>
+# include <signal.h>
+# include <string.h>
+# include <errno.h>
+# include <time.h>
+# include <assert.h>
+# include <unistd.h>
+# include <sys/time.h>
+
+/*
+ * There happens to be linuxes which read siginfo.h when including
+ * signal.h, which, for no appearent reason, defines these symbols.
+ */
+# ifdef POLL_IN
+# undef POLL_IN
+# endif
+# ifdef POLL_OUT
+# undef POLL_OUT
+# endif
+
+# include "rpoll.h"
+
+/*
+# define DEBUG
+*/
+
+# ifdef USE_POLL
+# ifdef NEED_POLL_XOPEN_TWIDDLE
+# define __USE_XOPEN
+# endif
+# include <poll.h>
+# ifdef NEED_POLL_XOPEN_TWIDDLE
+# undef __USE_XOPEN
+# endif
+# include <stropts.h>
+# endif
+
+/*
+ * the second define is for Linux, which sometimes fails to
+ * declare INFTIM.
+ */
+# if defined(USE_SELECT) || !defined(INFTIM)
+# define INFTIM (-1)
+# endif
+
+# if defined(SIGPOLL)
+# define SIGNAL SIGPOLL
+# else
+# if defined(SIGIO)
+# define SIGNAL SIGIO
+# endif
+# endif
+
+# ifdef USE_POLL
+# define poll_in (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)
+# define poll_out (POLLOUT | POLLWRNORM | POLLWRBAND)
+# define poll_except (POLLERR | POLLHUP)
+# endif
+
+# ifdef BROKEN_SELECT_PROTO
+# define SELECT_CAST(P) (int *)P
+# else
+# define SELECT_CAST(P) P
+# endif
+
+
+typedef signed long long tval_t;
+
+static inline tval_t GETMSECS(void);
+
+static inline tval_t
+GETMSECS(void) {
+ struct timeval tval;
+
+ (void)gettimeofday(&tval, NULL);
+ return (tval_t)tval.tv_sec*1000+tval.tv_usec/1000;
+}
+
+/*
+ * Simple fatal exit.
+ */
+static void
+_panic(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(stderr, "panic: ");
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+
+ exit(1);
+}
+
+static void *
+_xrealloc(void *p, size_t s)
+{
+ void *ptr;
+
+ if(p == NULL) {
+ if((ptr=malloc(s)) == NULL && (s!=0 || (ptr=malloc(1)) == NULL))
+ _panic("out of memory: xrealloc(%lx, %lu)",
+ (unsigned long)p, (unsigned long)s);
+ } else if(s == 0) {
+ free(p);
+ if((ptr=malloc(s)) == NULL && (ptr=malloc(1)) == NULL)
+ _panic("out of memory: xrealloc(%lx, %lu)",
+ (unsigned long)p, (unsigned long)s);
+ } else {
+ if((ptr = realloc(p, s)) == NULL)
+ _panic("out of memory: xrealloc(%lx, %lu)",
+ (unsigned long)p, (unsigned long)s);
+ }
+
+ return ptr;
+}
+
+/*
+ * This structure holds one registration record for files
+ */
+typedef struct {
+ int fd; /* file descriptor (-1 if struct unused) */
+ int mask; /* event flags */
+ void * arg; /* client arg */
+ poll_f func; /* handler */
+# ifdef USE_POLL
+ struct pollfd *pfd; /* pointer to corresponding poll() structure */
+# endif
+} PollReg_t;
+
+/*
+ * Now for timers
+ */
+typedef struct {
+ u_int msecs; /* millisecond value of the timer */
+ int repeat; /* one shot or repeat? */
+ void *arg; /* client arg */
+ timer_f func; /* handler, 0 means disfunct */
+ tval_t when; /* next time to trigger in msecs! */
+} PollTim_t;
+
+/* how many records should our table grow at once? */
+# define POLL_REG_GROW 100
+
+# ifdef USE_POLL
+static struct pollfd * pfd; /* fd list for poll() */
+# endif
+
+# ifdef USE_SELECT
+static fd_set rset, wset, xset; /* file descriptor sets for
select() */
+static int maxfd; /* maximum fd number */
+# endif
+
+static int in_dispatch;
+
+static PollReg_t * regs; /* registration records */
+static u_int regs_alloc; /* how many are allocated */
+static u_int regs_used; /* upper used limit */
+static sigset_t bset; /* blocked signals */
+static int rebuild; /* rebuild table on next dispatch() */
+
+static int * tfd; /* sorted entries */
+static u_int tfd_alloc; /* number of entries allocated */
+static u_int tfd_used; /* number of entries used */
+static PollTim_t * tims; /* timer registration records */
+static u_int tims_alloc; /* how many are allocated */
+static u_int tims_used; /* how many are used */
+static int resort; /* resort on next dispatch */
+
+int rpoll_trace;
+int rpoll_policy; /* if 0 start sched callbacks from 0 else try round
robin */
+
+static void poll_build(void);
+static void poll_blocksig(void);
+static void poll_unblocksig(void);
+static void sort_timers(void);
+
+
+/*
+ * Private function to block SIGPOLL or SIGIO for a short time.
+ * Don't forget to call poll_unblock before return from the calling function.
+ * Don't change the mask between this calls (your changes will be lost).
+ */
+static void
+poll_blocksig(void)
+{
+ sigset_t set;
+
+ sigemptyset(&set);
+ sigaddset(&set, SIGNAL);
+
+ if(sigprocmask(SIG_BLOCK, &set, &bset))
+ _panic("sigprocmask(SIG_BLOCK): %s", strerror(errno));
+}
+
+/*
+ * unblock the previously blocked signal
+ */
+static void
+poll_unblocksig(void)
+{
+ if(sigprocmask(SIG_SETMASK, &bset, NULL))
+ _panic("sigprocmask(SIG_SETMASK): %s", strerror(errno));
+}
+
+/*
+ * Register the file descriptor fd. If the event corresponding to
+ * mask arrives func is called with arg.
+ * If fd is already registered with that func and arg, only the mask
+ * is changed.
+ * We block the IO-signal, so the dispatch function can be called from
+ * within the signal handler.
+ */
+int
+poll_register(int fd, poll_f func, void *arg, int mask)
+{
+ PollReg_t * p;
+
+ poll_blocksig();
+
+ /* already registered? */
+ for(p = regs; p < ®s[regs_alloc]; p++)
+ if(p->fd == fd && p->func == func && p->arg == arg) {
+ p->mask = mask;
+ break;
+ }
+
+ if(p == ®s[regs_alloc]) {
+ /* no - register */
+
+ /* find a free slot */
+ for(p = regs; p < ®s[regs_alloc]; p++)
+ if(p->fd == -1)
+ break;
+
+ if(p == ®s[regs_alloc]) {
+ size_t newsize = regs_alloc + POLL_REG_GROW;
+ regs = _xrealloc(regs, sizeof(regs[0]) * newsize);
+ for(p = ®s[regs_alloc]; p < ®s[newsize]; p++) {
+ p->fd = -1;
+# ifdef USE_POLL
+ p->pfd = NULL;
+# endif
+ }
+ p = ®s[regs_alloc];
+ regs_alloc = newsize;
+ }
+
+ p->fd = fd;
+ p->arg = arg;
+ p->mask = mask;
+ p->func = func;
+
+ regs_used++;
+ rebuild = 1;
+ }
+
+ poll_unblocksig();
+
+ if(rpoll_trace)
+ fprintf(stderr, "poll_register(%d, %#lx, %#lx, %#x)->%d",
+ fd, (u_long)func, (u_long)arg, mask, p - regs);
+ return p - regs;
+}
+
+/*
+ * remove registration
+ */
+void
+poll_unregister(int handle)
+{
+ if(rpoll_trace)
+ fprintf(stderr, "poll_unregister(%d)", handle);
+
+ poll_blocksig();
+
+ regs[handle].fd = -1;
+# ifdef USE_POLL
+ regs[handle].pfd = NULL;
+# endif
+ rebuild = 1;
+ regs_used--;
+
+ poll_unblocksig();
+}
+
+/*
+ * Build the structures used by poll() or select()
+ */
+static void
+poll_build(void)
+{
+ PollReg_t * p;
+
+# ifdef USE_POLL
+ struct pollfd * f;
+
+ f = pfd = _xrealloc(pfd, sizeof(pfd[0]) * regs_used);
+
+ for(p = regs; p < ®s[regs_alloc]; p++)
+ if(p->fd >= 0) {
+ f->fd = p->fd;
+ f->events = 0;
+ if(p->mask & POLL_IN)
+ f->events |= poll_in;
+ if(p->mask & POLL_OUT)
+ f->events |= poll_out;
+ if(p->mask & POLL_EXCEPT)
+ f->events |= poll_except;
+ f->revents = 0;
+ p->pfd = f++;
+ }
+ assert(f == &pfd[regs_used]);
+# endif
+
+# ifdef USE_SELECT
+ FD_ZERO(&rset);
+ FD_ZERO(&wset);
+ FD_ZERO(&xset);
+ maxfd = -1;
+ for(p = regs; p < ®s[regs_alloc]; p++)
+ if(p->fd >= 0) {
+ if(p->fd > maxfd)
+ maxfd = p->fd;
+ if(p->mask & POLL_IN)
+ FD_SET(p->fd, &rset);
+ if(p->mask & POLL_OUT)
+ FD_SET(p->fd, &wset);
+ if(p->mask & POLL_EXCEPT)
+ FD_SET(p->fd, &xset);
+ }
+# endif
+}
+
+int
+poll_start_timer(u_int msecs, int repeat, timer_f func, void *arg)
+{
+ PollTim_t *p;
+
+ /* find unused entry */
+ for(p = tims; p < &tims[tims_alloc]; p++)
+ if(p->func == NULL)
+ break;
+
+ if(p == &tims[tims_alloc]) {
+ if(tims_alloc == tims_used) {
+ size_t newsize = tims_alloc + POLL_REG_GROW;
+ tims = _xrealloc(tims, sizeof(tims[0]) * newsize);
+ for(p = &tims[tims_alloc]; p < &tims[newsize]; p++)
+ p->func = NULL;
+ p = &tims[tims_alloc];
+ tims_alloc = newsize;
+ }
+ }
+
+ /* create entry */
+ p->msecs = msecs;
+ p->repeat = repeat;
+ p->arg = arg;
+ p->func = func;
+ p->when = GETMSECS() + msecs;
+
+ tims_used++;
+
+ resort = 1;
+
+ if(rpoll_trace)
+ fprintf(stderr, "poll_start_timer(%u, %d, %#lx, %#lx)->%u",
+ msecs, repeat, (u_long)func, (u_long)arg, p - tims);
+
+ return p - tims;
+}
+
+/*
+ * Here we have to look into the sorted table, whether any entry there points
+ * into the registration table for the deleted entry. This is needed,
+ * because a unregistration can occure while we are scanning through the
+ * table in dispatch(). Do this only, if we are really there - resorting
+ * will sort out things if we are called from outside the loop.
+ */
+void
+poll_stop_timer(int handle)
+{
+ u_int i;
+
+ if(rpoll_trace)
+ fprintf(stderr, "poll_stop_timer(%d)", handle);
+
+ tims[handle].func = NULL;
+ tims_used--;
+
+ resort = 1;
+
+ if(!in_dispatch)
+ return;
+
+ for(i = 0; i < tfd_used; i++)
+ if(tfd[i] == handle) {
+ tfd[i] = -1;
+ break;
+ }
+}
+
+/*
+ * Squeeze and sort timer table.
+ * Should perhaps use a custom sort.
+ */
+static int
+tim_cmp(const void *p1, const void *p2)
+{
+ int t1 = *(const int *)p1;
+ int t2 = *(const int *)p2;
+
+ return tims[t1].when < tims[t2].when ? -1
+ : tims[t1].when > tims[t2].when ? +1
+ : 0;
+}
+
+/*
+ * Reconstruct the tfd-array. This will be an sorted array of indexes
+ * to the used entries in tims. The next timer to expire will be infront
+ * of the array. tfd_used is the number of used entries. The array is
+ * re-allocated if needed.
+ */
+static void
+sort_timers(void)
+{
+ int *pp;
+ u_int i;
+
+ if(tims_used > tfd_alloc) {
+ tfd_alloc = tims_used;
+ tfd = _xrealloc(tfd, sizeof(int *) * tfd_alloc);
+ }
+
+ pp = tfd;
+
+ for(i = 0; i < tims_alloc; i++)
+ if(tims[i].func)
+ *pp++ = i;
+ assert(pp - tfd == (ptrdiff_t)tims_used);
+
+ tfd_used = tims_used;
+ if(tfd_used > 1)
+ qsort(tfd, tfd_used, sizeof(int), tim_cmp);
+}
+
+/*
+ * Poll the file descriptors and dispatch to the right function
+ * If wait is true the poll blocks until somewhat happens.
+ * Don't use a pointer here, because the called function may cause
+ * a reallocation! The check for pfd != NULL is required, because
+ * a sequence of unregister/register could make the wrong callback
+ * to be called. So we clear pfd in unregister and check here.
+ */
+void
+poll_dispatch(int wait)
+{
+ u_int i, idx;
+ int ret;
+ tval_t now;
+ int tout;
+ static u_int last_index;
+
+# ifdef USE_SELECT
+ fd_set nrset, nwset, nxset;
+ struct timeval tv;
+# endif
+
+ in_dispatch = 1;
+
+ if(rebuild) {
+ rebuild = 0;
+ poll_build();
+ }
+ if(resort) {
+ resort = 0;
+ sort_timers();
+ }
+
+ /* in wait mode - compute the timeout */
+ if(wait) {
+ if(tfd_used) {
+ now = GETMSECS();
+# ifdef DEBUG
+ {
+ fprintf(stderr, "now=%"QUADFMT"u", now);
+ for(i = 0; i < tims_used; i++)
+ fprintf(stderr, "timers[%2d] =
%"QUADFMT"d", i, tfd[i]->when - now);
+ }
+# endif
+ if((tout = tims[tfd[0]].when - now) < 0)
+ tout = 0;
+ } else
+ tout = INFTIM;
+ } else
+ tout = 0;
+
+# ifdef DEBUG
+ fprintf(stderr, "rpoll -- selecting with tout=%u", tout);
+# endif
+
+# ifdef USE_POLL
+ ret = poll(pfd, regs_used, tout);
+# endif
+
+# ifdef USE_SELECT
+ nrset = rset;
+ nwset = wset;
+ nxset = xset;
+ if(tout != INFTIM) {
+ tv.tv_sec = tout / 1000;
+ tv.tv_usec = (tout % 1000) * 1000;
+ }
+ ret = select(maxfd+1,
+ SELECT_CAST(&nrset),
+ SELECT_CAST(&nwset),
+ SELECT_CAST(&nxset), (tout==INFTIM) ? 0 : &tv);
+# endif
+
+ if(ret == -1) {
+ if(errno == EINTR)
+ return;
+ _panic("poll/select: %s", strerror(errno));
+ }
+
+ /* dispatch files */
+ if(ret > 0) {
+ for(i = 0; i < regs_alloc; i++) {
+ idx = rpoll_policy ? ((last_index+i) % regs_alloc) : i;
+
+ assert(idx < regs_alloc);
+
+ if(regs[idx].fd >= 0) {
+ int mask = 0;
+
+# ifdef USE_POLL
+ if(regs[idx].pfd) {
+ if(regs[idx].pfd->revents & poll_in)
+ mask |= POLL_IN;
+ if(regs[idx].pfd->revents & poll_out)
+ mask |= POLL_OUT;
+ if(regs[idx].pfd->revents & poll_except)
+ mask |= POLL_EXCEPT;
+ }
+# endif
+# ifdef USE_SELECT
+ if(FD_ISSET(regs[idx].fd, &nrset))
+ mask |= POLL_IN;
+ if(FD_ISSET(regs[idx].fd, &nwset))
+ mask |= POLL_OUT;
+ if(FD_ISSET(regs[idx].fd, &nxset))
+ mask |= POLL_EXCEPT;
+# endif
+ assert(idx < regs_alloc);
+
+ if(mask) {
+ if(rpoll_trace)
+ fprintf(stderr,
"poll_dispatch() -- "
+ "file %d/%d",
+ regs[idx].fd, idx);
+ (*regs[idx].func)(regs[idx].fd, mask,
regs[idx].arg);
+ }
+ }
+
+ }
+ last_index++;
+ }
+
+ /* dispatch timeouts */
+ if(tfd_used) {
+ now = GETMSECS();
+ for(i = 0; i < tfd_used; i++) {
+ if(tfd[i] < 0)
+ continue;
+ if(tims[tfd[i]].when > now)
+ break;
+ if(rpoll_trace)
+ fprintf(stderr, "rpoll_dispatch() -- timeout
%d",tfd[i]);
+ (*tims[tfd[i]].func)(tfd[i], tims[tfd[i]].arg);
+ if(tfd[i] < 0)
+ continue;
+ if(tims[tfd[i]].repeat)
+ tims[tfd[i]].when = now + tims[tfd[i]].msecs;
+ else {
+ tims[tfd[i]].func = NULL;
+ tims_used--;
+ tfd[i] = -1;
+ }
+ resort = 1;
+ }
+ }
+ in_dispatch = 0;
+}
+
+
+# ifdef TESTME
+struct timeval start, now;
+int t0, t1;
+
+double elaps(void);
+void infunc(int fd, int mask, void *arg);
+
+double
+elaps(void)
+{
+ gettimeofday(&now, NULL);
+
+ return (double)(10 * now.tv_sec + now.tv_usec / 100000 - 10 *
start.tv_sec - start.tv_usec / 100000)
+ / 10;
+}
+
+void
+infunc(int fd, int mask, void *arg)
+{
+ char buf[1024];
+ int ret;
+
+ mask = mask;
+ arg = arg;
+ if((ret = read(fd, buf, sizeof(buf))) < 0)
+ _panic("read: %s", strerror(errno));
+ write(1, "stdin:", 6);
+ write(1, buf, ret);
+}
+
+void tfunc0(int tid, void *arg);
+void tfunc1(int tid, void *arg);
+
+void
+tfunc0(int tid, void *arg)
+{
+ printf("%4.1f -- %d: %s\n", elaps(), tid, (char *)arg);
+}
+void
+tfunc1(int tid, void *arg)
+{
+ printf("%4.1f -- %d: %s\n", elaps(), tid, (char *)arg);
+}
+
+void first(int tid, void *arg);
+void second(int tid, void *arg);
+
+void
+second(int tid, void *arg)
+{
+ printf("%4.1f -- %d: %s\n", elaps(), tid, (char *)arg);
+ poll_start_timer(5500, 0, first, "first");
+ poll_stop_timer(t1);
+ t0 = poll_start_timer(1000, 1, tfunc0, "1 second");
+}
+void
+first(int tid, void *arg)
+{
+ printf("%4.1f -- %d: %s\n", elaps(), tid, (char *)arg);
+ poll_start_timer(3700, 0, second, "second");
+ poll_stop_timer(t0);
+ t1 = poll_start_timer(250, 1, tfunc1, "1/4 second");
+}
+
+int
+main(int argc, char *argv[])
+{
+ argc = argc;
+ argv = argv;
+ gettimeofday(&start, NULL);
+ poll_register(0, infunc, NULL, POLL_IN);
+ t0 = poll_start_timer(1000, 1, tfunc0, "1 second");
+ poll_start_timer(2500, 0, first, "first");
+
+ while(1)
+ poll_dispatch(1);
+
+ return 0;
+}
+# endif
Copied: vendor/libbegemot/1.1.1/rpoll.h (from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.h)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libbegemot/1.1.1/rpoll.h Sat Dec 20 17:30:32 2008
(r186360, copy of r186358, vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.h)
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c)1996-2002 by Hartmut Brandt
+ * All rights reserved.
+ *
+ * Author: Hartmut Brandt
+ *
+ * Redistribution of this software and documentation and use in source and
+ * binary forms, with or without modification, are permitted provided that
+ * the following conditions are met:
+ *
+ * 1. Redistributions of source code or documentation must retain the above
+ * copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
+ * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * $Begemot: libbegemot/rpoll.h,v 1.5 2004/09/21 15:49:26 brandt Exp $
+ */
+# ifndef rpoll_h_
+# define rpoll_h_
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+typedef void (*poll_f)(int fd, int mask, void *arg);
+typedef void (*timer_f)(int, void *);
+
+int poll_register(int fd, poll_f func, void *arg, int mask);
+void poll_unregister(int);
+void poll_dispatch(int wait);
+int poll_start_timer(u_int msecs, int repeat, timer_f func, void *arg);
+void poll_stop_timer(int);
+
+# if defined(POLL_IN)
+# undef POLL_IN
+# endif
+# if defined(POLL_OUT)
+# undef POLL_OUT
+# endif
+
+# define POLL_IN 1
+# define POLL_OUT 2
+# define POLL_EXCEPT 4
+
+extern int rpoll_policy;
+extern int rpoll_trace;
+
+# ifdef __cplusplus
+}
+# endif
+
+# endif
Copied: vendor/libbegemot/1.1.1/rpoll.man (from r186358,
vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.man)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libbegemot/1.1.1/rpoll.man Sat Dec 20 17:30:32 2008
(r186360, copy of r186358, vendor/libbegemot/1.1.1/contrib/libbegemot/rpoll.man)
@@ -0,0 +1,188 @@
+'\"
+'\" Copyright (c)1996-2002 by Hartmut Brandt
+'\" All rights reserved.
+'\"
+'\" Author: Hartmut Brandt
+'\"
+'\" Redistribution of this software and documentation and use in source and
+'\" binary forms, with or without modification, are permitted provided that
+'\" the following conditions are met:
+'\"
+'\" 1. Redistributions of source code or documentation must retain the above
+'\" copyright notice, this list of conditions and the following disclaimer.
+'\" 2. Redistributions in binary form must reproduce the above copyright
+'\" notice, this list of conditions and the following disclaimer in the
+'\" documentation and/or other materials provided with the distribution.
+'\"
+'\" THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
+'\" AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+'\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND
+'\" FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+'\" THE AUTHOR OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+'\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT
+'\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+'\" OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+'\" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+'\" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE,
+'\" EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+'\"
+'\" $Begemot: libbegemot/rpoll.man,v 1.4 2004/09/21 15:59:00 brandt Exp $
+'\"
+.TH rpoll l "21 Oct 1996" "BEGEMOT" "BEGEMOT Library"
+.SH NAME
+rpoll - callback functions for file descriptors and timers
+.SH SYNOPSIS
+.LP
+.B "# include <rpoll.h>"
+.LP
+.BR "typedef void (*poll_f)(int " "fd" ", int " "mask" ", void *" "arg);"
+.br
+.BR "typedef void (*timer_f)(int " "tid" ", void *" "arg);"
+.LP
+.BR "int poll_register(int " "fd" ", poll_f "
+.RB "func" ", void *" "arg" ", int " "mask" ");"
+.LP
+.BR "void poll_unregister(int " "handle" ");"
+.LP
+.BR "int poll_start_timer(u_int " "msecs" ", int " "repeat" ", timer_f "
"func,"
+.if n .ti +.5i
+.BR "void *" "arg);"
+.LP
+.BR "void poll_stop_timer(int " "handle" ");"
+.LP
+.BR "void poll_dispatch(int " "wait" ");"
+.SH DESCRIPTION
+Many programs need to read from several file descriptors at the same time.
+Typically in these programs one of
+.BR select (3c)
+or
+.BR poll (2)
+is used.
+These calls are however clumsy to use and the usage of one of these calls is
+probably not portable to other systems - not all systems support both calls.
+.LP
+The
+.BR rpoll (l)
+family of functions is designed to overcome these restrictions.
+They support the well known and understood technique of event driven
+programing and, in addition to
+.BR select (3c)
+and
+.BR poll (2)
+also support timers.
+.LP
+Each event on a file descriptor or each timer event is translated into a call
to a user
+defined callback function. These functions need to be registered.
+A file descriptor is registered with
+.BR poll_register .
+.I fd
+is the file descriptor to watch,
+.I mask
+is an event mask.
+It may be any combination of
+.B POLL_IN
+to get informed, when input on the file descriptor is possible,
+.B POLL_OUT
+to get informed, when output is possible or
+.B POLL_EXCEPT
+to get informed, when an exceptional condition occures.
+An example of an exceptional condition is the arrival of urgent data.
+(Note, that an end of file condition is signaled via POLL_IN).
+.I func
+is the user function to be called and
+.I arg
+is a user supplied argument for this function.
+The callback functions is called with the file descriptor, a mask
+describing the actual events (from the set supplied in the registration) and
+the user argument.
+.B poll_register
+returns a handle, which may be used later to de-register the file descriptor.
+A file descriptor may be registered more than once, if the function, the user
arguments
+or both differ in the call to
+.BR poll_register .
+If
+.I func
+and
+.I arg
+are the same, then no new registration is done, instead the event mask of the
registration
+is changed to reflect the new mask.
+.LP
+A registered file descriptor may be de-registered by calling
+.B poll_unregister
+with the handle returned by
+.BR poll_register .
+.LP
+A timer is created with
+.BR poll_start_timer .
+.I msecs
+is the number of milliseconds, after which the timer event will be generated.
+.I repeat
+selects one-short behavior (if 0) or a repeatable timer (if not 0). A
one-short timer
+will automatically unregistered after expiry.
+.I func
+is the user function which will be called with a timer id and the user supplied
+.IR arg .
+.B poll_start_timer
+returnes a timer id, which may be used to cancel the timer with
+.BR poll_stop_timer .
+A one-short timer should be canceled only if it has not yet fired.
+.LP
+.B poll_dispatch
+must be called to actually dispatch events.
+.I wait
+is a flag, which should be 0, if only a poll should be done. In this case, the
function returns,
+after polling the registered file descriptors and timers. If
+.I wait
+is not 0,
+.B poll_dispatch
+waits until an event occures. All events are dispatch (i.e. callback functions
called) and
+.B poll_dispatch returns.
+.LP
+Typical use is:
+.LP
+.RS
+.nf
+.ft 3
+while(1)
+ poll_dispatch(1);
+.ft 1
+.fi
+.RE
+.SH "SEE ALSO"
+.BR poll (2), select (3C)
+.SH "RETURN VALUES"
+.B poll_register
+and
+.B poll_start_timer
+return a handle which may be used to unregister the file descriptor or cancel
the timer.
+.LP
+Both functions and
+.B poll_dispatch
+call
+.BR xrealloc (l)
+and can end in
+.BR panic (l).
+.SH "ERRORS"
+System call or memory allocation errors are fatal and are handle by calling
+.BR panic (l).
+The one exception is a return of EINTR from
+.BR select (3c)
+or
+.BR poll (2)
+in
+.BR poll_dispatch .
+In this case
+.B poll_dispatch
+simply returns.
+.SH "BUGS"
+Obscure sequences of
+.B poll_start_timer
+and
+.B poll_stop_timer
+in callback functions may probably break the code.
+.LP
+The semantics of
+.B POLL_EXCEPT
+are not clear.
+.SH AUTHORS
+Hartmut Brandt, ha...@freebsd.org
Copied: vendor/libbegemot/dist/rpoll.c (from r186358,
vendor/libbegemot/dist/contrib/libbegemot/rpoll.c)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ vendor/libbegemot/dist/rpoll.c Sat Dec 20 17:30:32 2008
(r186360, copy of r186358, vendor/libbegemot/dist/contrib/libbegemot/rpoll.c)
@@ -0,0 +1,740 @@
+/*
+ * Copyright (c)1996-2002 by Hartmut Brandt
+ * All rights reserved.
+ *
+ * Author: Hartmut Brandt
+ *
+ * Redistribution of this software and documentation and use in source and
+ * binary forms, with or without modification, are permitted provided that
+ * the following conditions are met:
+ *
+ * 1. Redistributions of source code or documentation must retain the above
+ * copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
+ * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-all@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"
