9 #define BUF_ASSERT_FREE(buf) do { buffer_assert_free((buf), \
10 __FILE__,__LINE__); } \
12 #define BUF_ASSERT_USED(buf) do { buffer_assert_used((buf), \
13 __FILE__,__LINE__); } \
15 #define BUF_ALLOC(buf,own) do { buffer_assert_free((buf),__FILE__,__LINE__); \
16 (buf)->free=False; (buf)->owner=(own); (buf)->start=(buf)->base; \
17 (buf)->size=0; } while(0)
18 #define BUF_FREE(buf) do { (buf)->free=True; } while(0)
20 extern void buffer_assert_free(struct buffer_if
*buffer
, cstring_t file
,
22 extern void buffer_assert_used(struct buffer_if
*buffer
, cstring_t file
,
24 extern void buffer_new(struct buffer_if
*buffer
, int32_t len
);
25 extern void buffer_init(struct buffer_if
*buffer
, int32_t max_start_pad
);
26 extern void buffer_destroy(struct buffer_if
*buffer
);
27 extern void buffer_copy(struct buffer_if
*dst
, const struct buffer_if
*src
);
28 extern void *buf_append(struct buffer_if
*buf
, int32_t amount
);
29 extern void *buf_prepend(struct buffer_if
*buf
, int32_t amount
);
30 extern void *buf_unappend(struct buffer_if
*buf
, int32_t amount
);
31 extern void *buf_unprepend(struct buffer_if
*buf
, int32_t amount
);
34 * void BUF_ADD_BYTES(append, struct buffer_if*, const void*, int32_t size);
35 * void BUF_ADD_BYTES(prepend, struct buffer_if*, const void*, int32_t size);
36 * void BUF_GET_BYTES(unappend, struct buffer_if*, void*, int32_t size);
37 * void BUF_GET_BYTES(unprepend, struct buffer_if*, void*, int32_t size);
38 * // all of these evaluate size twice
40 * void BUF_ADD_OBJ(append, struct_buffer_if*, const OBJECT& something);
41 * void BUF_ADD_OBJ(prepend, struct_buffer_if*, const OBJECT& something);
42 * void BUF_GET_OBJ(unappend, struct_buffer_if*, OBJECT& something);
43 * void BUF_GET_OBJ(unprepend, struct_buffer_if*, OBJECT& something);
45 #define BUF_ADD_BYTES(appendprepend, bufp, datap, size) \
46 (buf_un##appendprepend /* ensures we have correct direction */, \
47 memcpy(buf_##appendprepend((bufp),(size)),(datap),(size)))
48 #define BUF_ADD_OBJ(appendprepend, bufp, obj) \
49 BUF_ADD_BYTES(appendprepend,(bufp),&(obj),sizeof((obj)))
50 #define BUF_GET_BYTES(unappendunprepend, bufp, datap, size) \
51 (BUF_GET__DOESNOTEXIST__buf_un##unappendunprepend, \
52 memcpy((datap),buf_##unappendunprepend((bufp),(size)),(size)))
53 #define BUF_GET_OBJ(unappendunprepend, bufp, obj) \
54 BUF_ADD_BYTES(unappendunprepend,&(obj),(bufp),sizeof((obj)))
55 #define BUF_GET__DOESNOTEXIST__buf_ununappend 0
56 #define BUF_GET__DOESNOTEXIST__buf_ununprepend 0
58 static inline int32_t buf_remaining_space(const struct buffer_if
*buf
)
60 return (buf
->base
+ buf
->alloclen
) - (buf
->start
+ buf
->size
);
63 extern void buffer_readonly_view(struct buffer_if
*n
, const void*, int32_t len
);
64 extern void buffer_readonly_clone(struct buffer_if
*n
, const struct buffer_if
*);
65 /* Caller must only use unappend, unprepend et al. on n.
66 * New buffer state (in n) before this can be undefined. After use,
67 * it must NOT be freed. */
69 extern void buf_append_string(struct buffer_if
*buf
, cstring_t s
);
71 extern void read_mpbin(MP_INT
*a
, uint8_t *bin
, int binsize
);
73 extern char *write_mpstring(MP_INT
*a
);
75 extern int32_t write_mpbin(MP_INT
*a
, uint8_t *buffer
, int32_t buflen
);
77 extern struct log_if
*init_log(list_t
*loglist
);
79 extern void send_nak(const struct comm_addr
*dest
, uint32_t our_index
,
80 uint32_t their_index
, uint32_t msgtype
,
81 struct buffer_if
*buf
, const char *logwhy
);
83 extern int consttime_memeq(const void *s1
, const void *s2
, size_t n
);
85 const char *iaddr_to_string(const union iaddr
*ia
);
86 int iaddr_socklen(const union iaddr
*ia
);
88 void string_item_to_iaddr(const item_t
*item
, uint16_t port
, union iaddr
*ia
,
92 /*----- line-buffered asynch input -----*/
94 enum async_linebuf_result
{
95 async_linebuf_nothing
,
101 const char *pollbadbit(int revents
); /* returns 0, or bad bit description */
103 enum async_linebuf_result
104 async_linebuf_read(struct pollfd
*pfd
, struct buffer_if
*buf
,
105 const char **emsg_out
);
106 /* Implements reading whole lines, asynchronously. Use like
108 * - set up the fd, which should be readable, O_NONBLOCK
109 * - set up and initialise buffer, which should be big enough
110 * for one line plus its trailing newline, and be empty
112 * - in your beforepoll_fn, be interested in POLLIN
113 * - in your afterpoll_fn, repeatedly call this function
114 * until it doesn't return `nothing'
115 * - after you're done, simply close fd and free or reset buf
116 * State on return from async_linebuf_read depends on return value:
118 * async_linebuf_nothing:
120 * No complete lines available right now. You should return
121 * from afterpoll. buf should be left untouched until the
122 * next call to async_linebuf_read.
126 * buf->base contains a input line as a nul-terminated string
127 * (\n replaced by \0); *emsg_out==0. You must call
128 * async_linebuf_read again before returning from afterpoll.
132 * EOF on stream. buf->base contains any partial
133 * (non-newline-terminated) line; *emsg_out!=0 iff there was
134 * such a partial line. You can call async_linebuf_read again
135 * if you like but it will probably just return eof again.
139 * Fatal problem (might be overly long lines, nuls in input
140 * data, bad bits in pfd->revents, errors from read, etc.)
142 * *emsg_out is the error message describing the problem;
143 * this message might be stored in buf, might be from
144 * strerror, or might be a constant.
146 * You must not call async_linebuf_read again. buf contents
147 * is undefined: it is only safe to reset or free.
149 * While using this function, do not look at buf->start or ->size
150 * or anything after the first '\0' in buf.
152 * If you decide to stop reading with async_linebuf_read that's
153 * fine and you can reset or free buf, but you risk missing some
154 * read-but-not-reported data.
157 /*----- some handy macros -----*/
159 #define MINMAX(ae,be,op) ({ \
160 typeof((ae)) a=(ae); \
161 typeof((be)) b=(be); \
164 #define MAX(a,b) MINMAX((a),(b),>)
165 #define MIN(a,b) MINMAX((a),(b),<)
167 #define MAX_RAW(a,b) ((a)>(b)?(a):(b))
168 #define MIN_RAW(a,b) ((a)<(b)?(a):(b))
170 static inline bool_t
iswouldblock(int e
)
171 { return e
==EWOULDBLOCK
|| e
==EAGAIN
; }