X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?p=secnet.git;a=blobdiff_plain;f=util.h;h=a5a82a431e8eed383e24b6d55f122ac2ea779154;hp=c2f10f83d33e0fa697f09d7a43353f77dfeec417;hb=328ae477c72b63616f28de2ff3ead9bf8d4752ba;hpb=927950400bd569326c3babf4e29038523fa464a6

diff --git a/util.h b/util.h
index c2f10f8..a5a82a4 100644
--- a/util.h
+++ b/util.h
@@ -29,9 +29,34 @@ extern void *buf_prepend(struct buffer_if *buf, int32_t amount);
 extern void *buf_unappend(struct buffer_if *buf, int32_t amount);
 extern void *buf_unprepend(struct buffer_if *buf, int32_t amount);
 
+/*
+ * void BUF_ADD_BYTES(append,    struct buffer_if*, const void*, int32_t size);
+ * void BUF_ADD_BYTES(prepend,   struct buffer_if*, const void*, int32_t size);
+ * void BUF_GET_BYTES(unappend,  struct buffer_if*,       void*, int32_t size);
+ * void BUF_GET_BYTES(unprepend, struct buffer_if*,       void*, int32_t size);
+ *     // all of these evaluate size twice
+ *
+ * void BUF_ADD_OBJ(append,    struct_buffer_if*, const OBJECT& something);
+ * void BUF_ADD_OBJ(prepend,   struct_buffer_if*, const OBJECT& something);
+ * void BUF_GET_OBJ(unappend,  struct_buffer_if*,       OBJECT& something);
+ * void BUF_GET_OBJ(unprepend, struct_buffer_if*,       OBJECT& something);
+ */
+#define BUF_ADD_BYTES(appendprepend, bufp, datap, size)			\
+    (buf_un##appendprepend /* ensures we have correct direction */,	\
+     memcpy(buf_##appendprepend((bufp),(size)),(datap),(size)))
+#define BUF_ADD_OBJ(appendprepend, bufp, obj) \
+    BUF_ADD_BYTES(appendprepend,(bufp),&(obj),sizeof((obj)))
+#define BUF_GET_BYTES(unappendunprepend, bufp, datap, size)		\
+    (BUF_GET__DOESNOTEXIST__buf_un##unappendunprepend,			\
+     memcpy((datap),buf_##unappendunprepend((bufp),(size)),(size)))
+#define BUF_GET_OBJ(unappendunprepend, bufp, obj) \
+    BUF_ADD_BYTES(unappendunprepend,&(obj),(bufp),sizeof((obj)))
+#define BUF_GET__DOESNOTEXIST__buf_ununappend  0
+#define BUF_GET__DOESNOTEXIST__buf_ununprepend 0
+
 static inline int32_t buf_remaining_space(const struct buffer_if *buf)
 {
-    return (buf->base + buf->len) - buf->start;
+    return (buf->base + buf->alloclen) - (buf->start + buf->size);
 }
 
 extern void buffer_readonly_view(struct buffer_if *n, const void*, int32_t len);
@@ -56,6 +81,78 @@ extern void send_nak(const struct comm_addr *dest, uint32_t our_index,
 
 extern int consttime_memeq(const void *s1, const void *s2, size_t n);
 
+const char *iaddr_to_string(const union iaddr *ia);
+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);			\
@@ -64,4 +161,10 @@ extern int consttime_memeq(const void *s1, const void *s2, size_t n);
 #define MAX(a,b) MINMAX((a),(b),>)
 #define MIN(a,b) MINMAX((a),(b),<)
 
+#define MAX_RAW(a,b) ((a)>(b)?(a):(b))
+#define MIN_RAW(a,b) ((a)<(b)?(a):(b))
+
+static inline bool_t iswouldblock(int e)
+    { return e==EWOULDBLOCK || e==EAGAIN; }
+
 #endif /* util_h */