From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Tue, 23 Sep 2014 23:33:52 +0000 (+0100)
Subject: util: Provide async_linebuf_read
X-Git-Tag: base.ipv6-polypath-fixes.v1~40
X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?p=secnet.git;a=commitdiff_plain;h=a0fac2f1c903f765c8b8596f1ec93beb52b72c7a

util: Provide async_linebuf_read

polypath is going to want to read output from the interface and
address reporting script.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>
---

diff --git a/util.c b/util.c
index 7d102b1..3ae5ff4 100644
--- a/util.c
+++ b/util.c
@@ -598,3 +598,89 @@ int iaddr_socklen(const union iaddr *ia)
     default:       abort();
     }
 }
+
+enum async_linebuf_result
+async_linebuf_read(struct pollfd *pfd, struct buffer_if *buf,
+		   const char **emsg_out)
+{
+    int revents=pfd->revents;
+
+#define BAD(m) do{ *emsg_out=(m); return async_linebuf_broken; }while(0)
+#define BADBIT(b) \
+    if (!(revents & b)) ; else BAD(#b)
+    BADBIT(POLLERR);
+    BADBIT(POLLHUP);
+    /* POLLNVAL is handled by the event loop - see afterpoll_fn comment */
+#undef BADBIT
+
+    if (!(revents & POLLIN))
+	return async_linebuf_nothing;
+
+    /*
+     * Data structure: A line which has been returned to the user is
+     * stored in buf at base before start.  But we retain the usual
+     * buffer meaning of size.  So:
+     *
+     *   | returned :    | input read,   |    unused    |
+     *   |  to user : \0 |  awaiting     |     buffer   |
+     *   |          :    |  processing   |      space   |
+     *   |          :    |               |              |
+     *   ^base           ^start          ^start+size    ^base+alloclen
+     */
+
+    BUF_ASSERT_USED(buf);
+
+    /* firstly, eat any previous */
+    if (buf->start != buf->base) {
+	memmove(buf->base,buf->start,buf->size);
+	buf->start=buf->base;
+    }
+
+    uint8_t *searched=buf->base;
+
+    /*
+     * During the workings here we do not use start.  We set start
+     * when we return some actual data.  So we have this:
+     *
+     *   | searched     | read, might   |  unused      |
+     *   |  for \n      |  contain \n   |   buffer     |
+     *   |  none found  |  but not \0   |    space     |
+     *   |              |               |              |
+     *   ^base          ^searched       ^base+size     ^base+alloclen
+     *  [^start]                        ^dataend
+     *
+     */
+    for (;;) {
+	uint8_t *dataend=buf->base+buf->size;
+	char *newline=memchr(searched,'\n',dataend-searched);
+	if (newline) {
+	    *newline=0;
+	    buf->start=newline+1;
+	    buf->size=dataend-buf->start;
+	    return async_linebuf_ok;
+	}
+	searched=dataend;
+	ssize_t space=(buf->base+buf->alloclen)-dataend;
+	if (!space) BAD("input line too long");
+	ssize_t r=read(pfd->fd,searched,space);
+	if (r==0) {
+	    *searched=0;
+	    *emsg_out=buf->size?"no newline at eof":0;
+	    buf->start=searched+1;
+	    buf->size=0;
+	    return async_linebuf_eof;
+	}
+	if (r<0) {
+	    if (errno==EINTR)
+		continue;
+	    if (iswouldblock(errno))
+		return async_linebuf_nothing;
+	    BAD(strerror(errno));
+	}
+	assert(r<=space);
+	if (memchr(searched,0,r)) BAD("nul in input data");
+	buf->size+=r;
+    }
+
+#undef BAD
+}
diff --git a/util.h b/util.h
index c52c5b3..b44b911 100644
--- a/util.h
+++ b/util.h
@@ -87,6 +87,72 @@ int iaddr_socklen(const union iaddr *ia);
 void string_item_to_iaddr(const item_t *item, uint16_t port, union iaddr *ia,
 			  const char *desc);
 
+
+/*----- line-buffered asynch input -----*/
+
+enum async_linebuf_result {
+    async_linebuf_nothing,
+    async_linebuf_ok,
+    async_linebuf_eof,
+    async_linebuf_broken,
+};
+
+enum async_linebuf_result
+async_linebuf_read(struct pollfd *pfd, struct buffer_if *buf,
+		   const char **emsg_out);
+   /* Implements reading whole lines, asynchronously.  Use like
+    * this:
+    *   - set up the fd, which should be readable, O_NONBLOCK
+    *   - set up and initialise buffer, which should be big enough
+    *     for one line plus its trailing newline, and be empty
+    *     with start==base
+    *   - in your beforepoll_fn, be interested in POLLIN
+    *   - in your afterpoll_fn, repeatedly call this function
+    *     until it doesn't return `nothing'
+    *   - after you're done, simply close fd and free or reset buf
+    * State on return from async_linebuf_read depends on return value:
+    *
+    *   async_linebuf_nothing:
+    *
+    *      No complete lines available right now.  You should return
+    *      from afterpoll.  buf should be left untouched until the
+    *      next call to async_linebuf_read.
+    *
+    *   async_linebuf_ok:
+    *
+    *      buf->base contains a input line as a nul-terminated string
+    *      (\n replaced by \0); *emsg_out==0.  You must call
+    *      async_linebuf_read again before returning from afterpoll.
+    *
+    *   async_linebuf_eof:
+    *
+    *      EOF on stream.  buf->base contains any partial
+    *      (non-newline-terminated) line; *emsg_out!=0 iff there was
+    *      such a partial line.  You can call async_linebuf_read again
+    *      if you like but it will probably just return eof again.
+    *
+    *   broken:
+    *
+    *      Fatal problem (might be overly long lines, nuls in input
+    *      data, bad bits in pfd->revents, errors from read, etc.)
+    *
+    *      *emsg_out is the error message describing the problem;
+    *      this message might be stored in buf, might be from
+    *      strerror, or might be a constant.
+    *
+    *      You must not call async_linebuf_read again.  buf contents
+    *      is undefined: it is only safe to reset or free.
+    *
+    * While using this function, do not look at buf->start or ->size
+    * or anything after the first '\0' in buf.
+    *
+    * If you decide to stop reading with async_linebuf_read that's
+    * fine and you can reset or free buf, but you risk missing some
+    * read-but-not-reported data.
+    */
+
+/*----- some handy macros -----*/
+
 #define MINMAX(ae,be,op) ({			\
 	typeof((ae)) a=(ae);			\
 	typeof((be)) b=(be);			\