X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?p=secnet.git;a=blobdiff_plain;f=util.h;h=816c05621571262924460c46ed3358819ecd051e;hp=d272a59aaf1a333cfc2db4c503b8a81f2c3e588d;hb=HEAD;hpb=7138d0c54cd2212439434d27cb2d6ea775c3039b diff --git a/util.h b/util.h index d272a59..f28a00d 100644 --- a/util.h +++ b/util.h @@ -1,7 +1,20 @@ -/* $Log: util.h,v $ - * Revision 1.1 1996/03/14 17:05:12 sde1000 - * Initial revision +/* + * This file is part of secnet. + * See README for full list of copyright holders. * + * secnet is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * secnet is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * version 3 along with secnet; if not, see + * https://www.gnu.org/licenses/gpl.html. */ #ifndef util_h @@ -10,6 +23,8 @@ #include "secnet.h" #include +#include "hackypar.h" + #define BUF_ASSERT_FREE(buf) do { buffer_assert_free((buf), \ __FILE__,__LINE__); } \ while(0) @@ -21,25 +36,251 @@ while(0) (buf)->size=0; } while(0) #define BUF_FREE(buf) do { (buf)->free=True; } while(0) -extern void buffer_assert_free(struct buffer_if *buffer, string_t file, - uint32_t line); -extern void buffer_assert_used(struct buffer_if *buffer, string_t file, - uint32_t line); -extern void buffer_new(struct buffer_if *buffer, uint32_t len); -extern void buffer_init(struct buffer_if *buffer, uint32_t max_start_pad); -extern void *buf_append(struct buffer_if *buf, uint32_t amount); -extern void *buf_prepend(struct buffer_if *buf, uint32_t amount); -extern void *buf_unappend(struct buffer_if *buf, uint32_t amount); -extern void *buf_unprepend(struct buffer_if *buf, uint32_t amount); +extern void buffer_assert_free(struct buffer_if *buffer, cstring_t file, + int line); +extern void buffer_assert_used(struct buffer_if *buffer, cstring_t file, + int line); +extern void buffer_new(struct buffer_if *buffer, int32_t len); +extern void buffer_init(struct buffer_if *buffer, int32_t max_start_pad); +extern void buffer_destroy(struct buffer_if *buffer); +extern void buffer_copy(struct buffer_if *dst, const struct buffer_if *src); +extern void *buf_append(struct buffer_if *buf, int32_t amount); +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); + +/* These construct a message in a buffer, truncating if necessary. + * _string is only safe for trusted input and *not* UTF-8 (sorry). + * _packet_string is safe for any input, including untrusted. + * _terminate arranges for the buffer to be null-terminated (and + * maybe for a trailing `...' to indicate truncation), and returns + * a pointer to the null-terminated string. */ +void truncmsg_add_string(struct buffer_if *buf, cstring_t s); +void truncmsg_add_packet_string(struct buffer_if*, int32_t, const uint8_t*); +const char *truncmsg_terminate(const struct buffer_if *buf); + -extern void buf_append_string(struct buffer_if *buf, string_t s); +struct priomsg { + /* U: uninitialised + * F: initialised but free (no memory allocated), no leak if discarded + * Z: contains no message yet + * M: contains some message; you may call truncmsg_add_* + */ + int prio; + struct buffer_if m; +}; + +void priomsg_new(struct priomsg *pm, int32_t maxlen); /* UF -> Z */ +void priomsg_destroy(struct priomsg *pm, int32_t maxlen); /* FZM -> F */ +void priomsg_reset(struct priomsg *pm); /* FZM -> Z */ +bool_t priomsg_update_p(struct priomsg *pm, int prio); /* ZM -> M */ + /* returns true iff message of priority prio ought to be added, + * caller should then call truncmsg_add_*. + * pm may be NULL, in which case it just returns false */ +const char *priomsg_getmessage(const struct priomsg *pm, const char *defmsg); + /* return value is null-terminated, valid until next call + * or until defmsg is no longer valid ZM */ + +bool_t priomsg_update_fixed(struct priomsg *pm, int prio, const char *m); + /* convenience combination of _update_p and truncmsg_add_string */ + +/* + * 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->alloclen) - (buf->start + buf->size); +} + +extern void buffer_readonly_view(struct buffer_if *n, const void*, int32_t len); +extern void buffer_readonly_clone(struct buffer_if *n, const struct buffer_if*); + /* Caller must only use unappend, unprepend et al. on n. + * New buffer state (in n) before this can be undefined. After use, + * it must NOT be freed. */ + +extern void buf_append_string(struct buffer_if *buf, cstring_t s); + /* Append a two-byte length and the string to the buffer. Length is in + * network byte order. */ + +static inline int hex_encode_size(int binsize) { return binsize*2 + 1; } +extern void hex_encode(const uint8_t *bin, int binsize, char *buf); + /* Convert a byte array to hex into a supplied buffer. */ +extern string_t hex_encode_alloc(const uint8_t *bin, int binsize); + /* Returns the result in a freshly allocated string. */ + +extern bool_t hex_decode(uint8_t *buffer, int32_t buflen, int32_t *outlen, + cstring_t hb, bool_t allow_odd_nibble); + /* Convert a hex string to binary, storing the result in buffer. If + * allow_odd_nibble then it is acceptable if the input is an odd number of + * digits, and an additional leading zero digit is assumed; otherwise, this + * is not acceptable and the conversion fails. + * + * The input is processed left to right until it is consumed, the buffer is + * full, or an error is encountered in the input. The length of output + * produced is stored in *outlen. Returns true if the entire input was + * processed without error; otherwise false. */ extern void read_mpbin(MP_INT *a, uint8_t *bin, int binsize); + /* Convert a buffer into its MP_INT representation */ extern char *write_mpstring(MP_INT *a); - -extern uint32_t write_mpbin(MP_INT *a, uint8_t *buffer, uint32_t buflen); + /* Convert a MP_INT into a hex string */ extern struct log_if *init_log(list_t *loglist); +extern void send_nak(const struct comm_addr *dest, uint32_t our_index, + uint32_t their_index, uint32_t msgtype, + struct buffer_if *buf, const char *logwhy); + +extern int consttime_memeq(const void *s1, const void *s2, size_t n); + +void hash_hash(const struct hash_if *hashi, const void *msg, int32_t len, + uint8_t *digest /* hi->hlen bytes */); + +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); + + +/*----- pathprefix_template -----*/ + +struct pathprefix_template { + char *buffer; + char *write_here; +}; + +void pathprefix_template_init(struct pathprefix_template *out, + const char *prefix, int maxsuffix); +static inline void pathprefix_template_setsuffix + (struct pathprefix_template *upd, const char *suffix) + { strcpy(upd->write_here,suffix); } + + +/* + * SBUF_DEFINE(int nbufs, size_t size); + * // Generates a number of definitions and statements organising + * // nbufs rotating char[size] buffers such that subsequent code + * // may refer to: + * char *const SBUF; + */ +#define SBUF_DEFINE(nbufs, size) \ + static int static_bufs__bufnum; \ + static char static_bufs__bufs[(nbufs)][(size)]; \ + static_bufs__bufnum++; \ + static_bufs__bufnum %= (nbufs); \ + static_bufs__bufs[static_bufs__bufnum] +#define SBUF (static_bufs__bufs[static_bufs__bufnum]) + +/*----- line-buffered asynch input -----*/ + +enum async_linebuf_result { + async_linebuf_nothing, + async_linebuf_ok, + async_linebuf_eof, + async_linebuf_broken, +}; + +const char *pollbadbit(int revents); /* returns 0, or bad bit description */ + +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 CL_GET_STR_ARG(ix,vn,what) \ + item_t *vn##_i=list_elem(args,ix); \ + if (!vn##_i) cfgfatal(loc,"make-public","need " what); \ + if (vn##_i->type!=t_string) cfgfatal(vn##_i->loc,"make-public", \ + what "must be string"); \ + const char *vn=vn##_i->data.string + +#define MINMAX(ae,be,op) ({ \ + typeof((ae)) a=(ae); \ + typeof((be)) b=(be); \ + a op b ? a : b; \ + }) +#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 */