X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=secnet.git;a=blobdiff_plain;f=util.c;h=6742dad52de4d000b3b2476040c1dd2cca148aaa;hp=7e5a39a575e583344ef1b64338470b06b491b38b;hb=94ca562bb14422940ff1986ce8dfca87c222cb59;hpb=2fe58dfd10216a37f1ece081f926971882de112e diff --git a/util.c b/util.c index 7e5a39a..6742dad 100644 --- a/util.c +++ b/util.c @@ -1,164 +1,101 @@ -/* $Log: util.c,v $ - * Revision 1.2 1996/04/14 16:34:36 sde1000 - * Added syslog support - * mpbin/mpstring functions moved from dh.c - * - * Revision 1.1 1996/03/14 17:05:03 sde1000 - * Initial revision +/* + * util.c + * - output and logging support + * - program lifetime support + * - IP address and subnet munging routines + * - MPI convenience functions + */ +/* + * This file is + * Copyright (C) 1995--2001 Stephen Early * + * It is part of secnet, which is + * Copyright (C) 1995--2001 Stephen Early + * Copyright (C) 1998 Ross Anderson, Eli Biham, Lars Knudsen + * + * This program 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 2, or (at your option) + * any later version. + * + * This program 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 + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#include "config.h" +#include "secnet.h" #include -#include #include #include -#include #include -#include +#include #include +#include +#include #include "util.h" -#include "secnet.h" +#include "unaligned.h" +#include "magic.h" +#include "ipaddr.h" #define MIN_BUFFER_SIZE 64 #define DEFAULT_BUFFER_SIZE 4096 #define MAX_BUFFER_SIZE 131072 -static char *hexdigits="0123456789abcdef"; +static const char *hexdigits="0123456789abcdef"; -uint32_t message_level=M_WARNING|M_ERROR|M_FATAL; -uint32_t syslog_level=M_WARNING|M_ERROR|M_FATAL; -static uint32_t current_phase=0; +uint32_t current_phase=0; struct phase_hook { hook_fn *fn; void *state; - struct phase_hook *next; + LIST_ENTRY(phase_hook) entry; }; -static struct phase_hook *hooks[NR_PHASES]={NULL,}; - -static void vMessage(uint32_t class, char *message, va_list args) -{ - FILE *dest=stdout; - if (class & message_level) { - if (class&M_FATAL || class&M_ERROR || class&M_WARNING) { - dest=stderr; - } - vfprintf(dest,message,args); - } -/* XXX do something about syslog output here */ -#if 0 - /* Maybe send message to syslog */ - vsprintf(buff, message, args); - /* XXX Send each line as a separate log entry */ - log(syslog_prio[level], buff); -#endif /* 0 */ -} - -void Message(uint32_t class, char *message, ...) -{ - va_list ap; - - va_start(ap,message); - - vMessage(class,message,ap); - - va_end(ap); -} +static LIST_HEAD(, phase_hook) hooks[NR_PHASES]; -static void vfatal(int status, bool_t perror, char *message, va_list args) -{ - int err; - - err=errno; - - enter_phase(PHASE_SHUTDOWN); - if (perror) { - Message(M_FATAL, "secnet fatal error: "); - vMessage(M_FATAL, message, args); - Message(M_FATAL, ": %s\n",strerror(err)); - } - else { - Message(M_FATAL, "secnet fatal error: "); - vMessage(M_FATAL,message,args); - } - exit(status); -} - -void fatal(char *message, ...) -{ - va_list args; - va_start(args,message); - vfatal(current_phase,False,message,args); - va_end(args); -} - -void fatal_status(int status, char *message, ...) -{ - va_list args; - va_start(args,message); - vfatal(status,False,message,args); - va_end(args); -} - -void fatal_perror(char *message, ...) -{ - va_list args; - va_start(args,message); - vfatal(current_phase,True,message,args); - va_end(args); -} - -void fatal_perror_status(int status, char *message, ...) -{ - va_list args; - va_start(args,message); - vfatal(status,True,message,args); - va_end(args); -} - -void cfgfatal(struct cloc loc, string_t facility, char *message, ...) -{ - va_list args; - - va_start(args,message); - - enter_phase(PHASE_SHUTDOWN); - - if (loc.file && loc.line) { - Message(M_FATAL, "config error (%s, %s:%d): ",facility,loc.file, - loc.line); - } else if (!loc.file && loc.line) { - Message(M_FATAL, "config error (%s, line %d): ",facility,loc.line); - } else { - Message(M_FATAL, "config error (%s): ",facility); - } - - vMessage(M_FATAL,message,args); - va_end(args); - exit(current_phase); -} - -char *safe_strdup(char *s, char *message) +char *safe_strdup(const char *s, const char *message) { char *d; d=strdup(s); if (!d) { - fatal_perror(message); + fatal_perror("%s",message); } return d; } -void *safe_malloc(size_t size, char *message) +void *safe_malloc(size_t size, const char *message) { void *r; + if (!size) + return 0; r=malloc(size); if (!r) { - fatal_perror(message); + fatal_perror("%s",message); } return r; } +void *safe_realloc_ary(void *p, size_t size, size_t count, + const char *message) { + if (count >= INT_MAX/size) { + fatal("array allocation overflow: %s", message); + } + assert(size && count); + p = realloc(p, size*count); + if (!p) + fatal_perror("%s", message); + return p; +} + +void *safe_malloc_ary(size_t size, size_t count, const char *message) { + if (!size || !count) + return 0; + return safe_realloc_ary(0,size,count,message); +} /* Convert a buffer into its MP_INT representation */ void read_mpbin(MP_INT *a, uint8_t *bin, int binsize) @@ -218,7 +155,7 @@ static uint8_t hexval(uint8_t c) } /* Convert a MP_INT into a buffer; return length; truncate if necessary */ -uint32_t write_mpbin(MP_INT *a, uint8_t *buffer, uint32_t buflen) +int32_t write_mpbin(MP_INT *a, uint8_t *buffer, int32_t buflen) { char *hb; int i,j,l; @@ -240,195 +177,94 @@ uint32_t write_mpbin(MP_INT *a, uint8_t *buffer, uint32_t buflen) return i; } -bool_t subnet_match(struct subnet_list *list, uint32_t address) -{ - uint32_t i; - for (i=0; ientries; i++) { - if (list->list[i].prefix == (address&list->list[i].mask)) return True; - } - return False; -} - -/* The string buffer must be at least 16 bytes long */ -string_t ipaddr_to_string(uint32_t addr) -{ - uint8_t a,b,c,d; - string_t s; - - s=safe_malloc(16,"ipaddr_to_string"); - a=addr>>24; - b=addr>>16; - c=addr>>8; - d=addr; - snprintf(s, 16, "%d.%d.%d.%d", a, b, c, d); - return s; -} - -string_t subnet_to_string(struct subnet *sn) -{ - uint32_t mask=sn->mask, addr=sn->prefix; - uint8_t a,b,c,d; - string_t s; - int i; - - s=safe_malloc(19,"subnet_to_string"); - a=addr>>24; - b=addr>>16; - c=addr>>8; - d=addr; - for (i=0; mask; i++) { - mask=(mask<<1); - } - snprintf(s, 19, "%d.%d.%d.%d/%d", a, b, c, d, i); - return s; -} - -/* Take a list of log closures and merge them */ -struct loglist { - struct log_if *l; - struct loglist *next; -}; - -static void log_vmulti(void *state, int priority, char *message, va_list args) -{ - struct loglist *st=state, *i; - - for (i=st; i; i=i->next) { - i->l->vlog(i->l->st,priority,message,args); - } +#define DEFINE_SETFDFLAG(fn,FL,FLAG) \ +void fn(int fd) { \ + int r=fcntl(fd, F_GET##FL); \ + if (r<0) fatal_perror("fcntl(,F_GET" #FL ") failed"); \ + r=fcntl(fd, F_SET##FL, r|FLAG); \ + if (r<0) fatal_perror("fcntl(,F_SET" #FL ",|" #FLAG ") failed"); \ } -static void log_multi(void *st, int priority, char *message, ...) -{ - va_list ap; +DEFINE_SETFDFLAG(setcloexec,FD,FD_CLOEXEC); +DEFINE_SETFDFLAG(setnonblock,FL,O_NONBLOCK); - va_start(ap,message); - - log_vmulti(st,priority,message,ap); - - va_end(ap); +void pipe_cloexec(int fd[2]) { + int r=pipe(fd); + if (r) fatal_perror("pipe"); + setcloexec(fd[0]); + setcloexec(fd[1]); } -struct log_if *init_log(list_t *ll) -{ - int i=0; - item_t *item; - closure_t *cl; - struct loglist *l=NULL, *n; - struct log_if *r; - - while ((item=list_elem(ll,i++))) { - if (item->type!=t_closure) { - cfgfatal(item->loc,"init_log","item is not a closure"); - } - cl=item->data.closure; - if (cl->type!=CL_LOG) { - cfgfatal(item->loc,"init_log","closure is not a logger"); - } - n=safe_malloc(sizeof(*n),"init_log"); - n->l=cl->interface; - n->next=l; - l=n; - } - if (!l) { - fatal("init_log: none of the items in the list are loggers"); - } - r=safe_malloc(sizeof(*r), "init_log"); - r->st=l; - r->log=log_multi; - r->vlog=log_vmulti; - return r; -} - -struct logfile { - closure_t cl; - struct log_if ops; - FILE *f; -}; - -static void logfile_vlog(void *state, int priority, char *message, - va_list args) -{ - struct logfile *st=state; - - vfprintf(st->f,message,args); - fprintf(st->f,"\n"); -} - -static void logfile_log(void *state, int priority, char *message, ...) -{ - va_list ap; - - va_start(ap,message); - logfile_vlog(state,priority,message,ap); - va_end(ap); -} - -static list_t *logfile_apply(closure_t *self, struct cloc loc, dict_t *context, - list_t *data) -{ - struct logfile *st; - - st=safe_malloc(sizeof(*st),"logfile_apply"); - st->cl.description="logfile"; - st->cl.type=CL_LOG; - st->cl.apply=NULL; - st->cl.interface=&st->ops; - st->ops.st=st; - st->ops.log=logfile_log; - st->ops.vlog=logfile_vlog; - st->f=stderr; /* XXX ignore args */ - - return new_closure(&st->cl); -} - -static char *phases[NR_PHASES]={ +static const char *phases[NR_PHASES]={ "PHASE_INIT", "PHASE_GETOPTS", "PHASE_READCONFIG", "PHASE_SETUP", + "PHASE_DAEMONIZE", + "PHASE_GETRESOURCES", "PHASE_DROPPRIV", "PHASE_RUN", - "PHASE_SHUTDOWN" + "PHASE_SHUTDOWN", + "PHASE_CHILDPERSIST" }; void enter_phase(uint32_t new_phase) { struct phase_hook *i; - Message(M_DEBUG_PHASE,"entering %s... ", phases[new_phase]); + if (!LIST_EMPTY(&hooks[new_phase])) + Message(M_DEBUG_PHASE,"Running hooks for %s...\n", phases[new_phase]); current_phase=new_phase; - for (i=hooks[new_phase]; i; i=i->next) + LIST_FOREACH(i, &hooks[new_phase], entry) i->fn(i->state, new_phase); - Message(M_DEBUG_PHASE,"now in %s\n",phases[new_phase]); + Message(M_DEBUG_PHASE,"Now in %s\n",phases[new_phase]); +} + +void phase_hooks_init(void) +{ + int i; + for (i=0; ifn=fn; h->state=state; - h->next=hooks[phase]; - hooks[phase]=h; + LIST_INSERT_HEAD(&hooks[phase],h,entry); return True; } bool_t remove_hook(uint32_t phase, hook_fn *fn, void *state) { - fatal("remove_hook: not implemented\n"); + fatal("remove_hook: not implemented"); return False; } -void log(struct log_if *lf, int priority, char *message, ...) +void vslilog(struct log_if *lf, int priority, const char *message, va_list ap) +{ + lf->vlogfn(lf->st,priority,message,ap); +} + +void slilog(struct log_if *lf, int priority, const char *message, ...) { va_list ap; va_start(ap,message); - lf->vlog(lf->st,priority,message,ap); + vslilog(lf,priority,message,ap); va_end(ap); } @@ -437,47 +273,63 @@ struct buffer { struct buffer_if ops; }; -void buffer_assert_free(struct buffer_if *buffer, string_t file, uint32_t line) +void buffer_assert_free(struct buffer_if *buffer, cstring_t file, + int line) { if (!buffer->free) { - fatal("BUF_ASSERT_FREE, %s line %d, owned by %s\n", - file,line,buffer->owner); + fprintf(stderr,"secnet: BUF_ASSERT_FREE, %s line %d, owned by %s", + file,line,buffer->owner); + assert(!"buffer_assert_free failure"); } } -void buffer_assert_used(struct buffer_if *buffer, string_t file, uint32_t line) +void buffer_assert_used(struct buffer_if *buffer, cstring_t file, + int line) { if (buffer->free) { - fatal("BUF_ASSERT_USED, %s line %d, last owned by %s\n", - file,line,buffer->owner); + fprintf(stderr,"secnet: BUF_ASSERT_USED, %s line %d, last owned by %s", + file,line,buffer->owner); + assert(!"buffer_assert_used failure"); } } -void buffer_init(struct buffer_if *buffer, uint32_t max_start_pad) +void buffer_init(struct buffer_if *buffer, int32_t max_start_pad) { + assert(max_start_pad<=buffer->alloclen); buffer->start=buffer->base+max_start_pad; buffer->size=0; } -void *buf_append(struct buffer_if *buf, uint32_t amount) { +void buffer_destroy(struct buffer_if *buf) +{ + BUF_ASSERT_FREE(buf); + free(buf->base); + buf->start=buf->base=0; + buf->size=buf->alloclen=0; +} + +void *buf_append(struct buffer_if *buf, int32_t amount) { void *p; + assert(amount <= buf_remaining_space(buf)); p=buf->start + buf->size; buf->size+=amount; return p; } -void *buf_prepend(struct buffer_if *buf, uint32_t amount) { +void *buf_prepend(struct buffer_if *buf, int32_t amount) { + assert(amount <= buf->start - buf->base); buf->size+=amount; return buf->start-=amount; } -void *buf_unappend(struct buffer_if *buf, uint32_t amount) { +void *buf_unappend(struct buffer_if *buf, int32_t amount) { if (buf->size < amount) return 0; return buf->start+(buf->size-=amount); } -void *buf_unprepend(struct buffer_if *buf, uint32_t amount) { +void *buf_unprepend(struct buffer_if *buf, int32_t amount) { void *p; + if (buf->size < amount) return 0; p=buf->start; buf->start+=amount; buf->size-=amount; @@ -486,16 +338,17 @@ void *buf_unprepend(struct buffer_if *buf, uint32_t amount) { /* Append a two-byte length and the string to the buffer. Length is in network byte order. */ -void buf_append_string(struct buffer_if *buf, string_t s) +void buf_append_string(struct buffer_if *buf, cstring_t s) { - uint16_t len; + size_t len; len=strlen(s); - *(uint16_t *)buf_append(buf,2)=htons(len); - memcpy(buf_append(buf,len),s,len); + /* fixme: if string is longer than 65535, result is a corrupted packet */ + buf_append_uint16(buf,len); + BUF_ADD_BYTES(append,buf,s,len); } -void buffer_new(struct buffer_if *buf, uint32_t len) +void buffer_new(struct buffer_if *buf, int32_t len) { buf->free=True; buf->owner=NULL; @@ -503,11 +356,39 @@ void buffer_new(struct buffer_if *buf, uint32_t len) buf->loc.file=NULL; buf->loc.line=0; buf->size=0; - buf->len=len; + buf->alloclen=len; buf->start=NULL; buf->base=safe_malloc(len,"buffer_new"); } +void buffer_readonly_view(struct buffer_if *buf, const void *data, int32_t len) +{ + buf->free=False; + buf->owner="READONLY"; + buf->flags=0; + buf->loc.file=NULL; + buf->loc.line=0; + buf->size=buf->alloclen=len; + buf->base=buf->start=(uint8_t*)data; +} + +void buffer_readonly_clone(struct buffer_if *out, const struct buffer_if *in) +{ + buffer_readonly_view(out,in->start,in->size); +} + +void buffer_copy(struct buffer_if *dst, const struct buffer_if *src) +{ + if (dst->alloclen < src->alloclen) { + dst->base=realloc(dst->base,src->alloclen); + if (!dst->base) fatal_perror("buffer_copy"); + dst->alloclen = src->alloclen; + } + dst->start = dst->base + (src->start - src->base); + dst->size = src->size; + memcpy(dst->start, src->start, dst->size); +} + static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context, list_t *args) { @@ -515,19 +396,13 @@ static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context, item_t *item; dict_t *dict; bool_t lockdown=False; + uint32_t len=DEFAULT_BUFFER_SIZE; - st=safe_malloc(sizeof(*st),"buffer_apply"); + NEW(st); st->cl.description="buffer"; st->cl.type=CL_BUFFER; st->cl.apply=NULL; st->cl.interface=&st->ops; - st->ops.free=True; - st->ops.owner=NULL; - st->ops.flags=0; - st->ops.loc=loc; - st->ops.size=0; - st->ops.len=DEFAULT_BUFFER_SIZE; - st->ops.start=NULL; /* First argument, if present, is buffer length */ item=list_elem(args,0); @@ -536,11 +411,11 @@ static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context, cfgfatal(st->ops.loc,"buffer","first parameter must be a " "number (buffer size)\n"); } - st->ops.len=item->data.number; - if (st->ops.lendata.number; + if (lenops.loc,"buffer","ludicrously small buffer size\n"); } - if (st->ops.len>MAX_BUFFER_SIZE) { + if (len>MAX_BUFFER_SIZE) { cfgfatal(st->ops.loc,"buffer","ludicrously large buffer size\n"); } } @@ -556,17 +431,285 @@ static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context, False); } - st->ops.base=safe_malloc(st->ops.len,"buffer"); + buffer_new(&st->ops,len); if (lockdown) { - Message(M_WARNING,"buffer: XXX lockdown\n"); + /* XXX mlock the buffer if possible */ } return new_closure(&st->cl); } -init_module util_module; +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) +{ + buffer_init(buf,calculate_max_start_pad()); + buf_append_uint32(buf,their_index); + buf_append_uint32(buf,our_index); + buf_append_uint32(buf,LABEL_NAK); + if (logwhy) + Message(M_INFO,"%s: %08"PRIx32"<-%08"PRIx32": %08"PRIx32":" + " %s; sending NAK\n", + comm_addr_to_string(dest), + our_index, their_index, msgtype, logwhy); + dest->comm->sendmsg(dest->comm->st, buf, dest); +} + +int consttime_memeq(const void *s1in, const void *s2in, size_t n) +{ + const uint8_t *s1=s1in, *s2=s2in; + register volatile uint8_t accumulator=0; + + while (n-- > 0) { + accumulator |= (*s1++ ^ *s2++); + } + accumulator |= accumulator >> 4; /* constant-time */ + accumulator |= accumulator >> 2; /* boolean canonicalisation */ + accumulator |= accumulator >> 1; + accumulator &= 1; + accumulator ^= 1; + return accumulator; +} + void util_module(dict_t *dict) { - add_closure(dict,"logfile",logfile_apply); add_closure(dict,"sysbuffer",buffer_apply); } + +void update_max_start_pad(int32_t *our_module_global, int32_t our_instance) +{ + if (*our_module_global < our_instance) + *our_module_global=our_instance; +} + +int32_t transform_max_start_pad, comm_max_start_pad; + +int32_t calculate_max_start_pad(void) +{ + return + site_max_start_pad + + transform_max_start_pad + + comm_max_start_pad; +} + +void vslilog_part(struct log_if *lf, int priority, const char *message, va_list ap) +{ + char *buff=lf->buff; + size_t bp; + char *nlp; + + bp=strlen(buff); + assert(bp < LOG_MESSAGE_BUFLEN); + vsnprintf(buff+bp,LOG_MESSAGE_BUFLEN-bp,message,ap); + buff[LOG_MESSAGE_BUFLEN-1] = '\n'; + buff[LOG_MESSAGE_BUFLEN] = '\0'; + /* Each line is sent separately */ + while ((nlp=strchr(buff,'\n'))) { + *nlp=0; + slilog(lf,priority,"%s",buff); + memmove(buff,nlp+1,strlen(nlp+1)+1); + } +} + +extern void slilog_part(struct log_if *lf, int priority, const char *message, ...) +{ + va_list ap; + va_start(ap,message); + vslilog_part(lf,priority,message,ap); + va_end(ap); +} + +void string_item_to_iaddr(const item_t *item, uint16_t port, union iaddr *ia, + const char *desc) +{ +#ifndef CONFIG_IPV6 + + ia->sin.sin_family=AF_INET; + ia->sin.sin_addr.s_addr=string_item_to_ipaddr(item,desc); + ia->sin.sin_port=htons(port); + +#else /* CONFIG_IPV6 => we have adns_text2addr */ + + if (item->type!=t_string) + cfgfatal(item->loc,desc,"expecting a string IP (v4 or v6) address\n"); + socklen_t salen=sizeof(*ia); + int r=adns_text2addr(item->data.string, port, + adns_qf_addrlit_ipv4_quadonly, + &ia->sa, &salen); + assert(r!=ENOSPC); + if (r) cfgfatal(item->loc,desc,"invalid IP (v4 or v6) address: %s\n", + strerror(r)); + +#endif /* CONFIG_IPV6 */ +} + +#define IADDR_NBUFS 8 + +const char *iaddr_to_string(const union iaddr *ia) +{ +#ifndef CONFIG_IPV6 + + SBUF_DEFINE(IADDR_NBUFS, 100); + + assert(ia->sa.sa_family == AF_INET); + + snprintf(SBUF, sizeof(SBUF), "[%s]:%d", + inet_ntoa(ia->sin.sin_addr), + ntohs(ia->sin.sin_port)); + +#else /* CONFIG_IPV6 => we have adns_addr2text */ + + SBUF_DEFINE(IADDR_NBUFS, 1+ADNS_ADDR2TEXT_BUFLEN+20); + + int port; + + char *addrbuf = SBUF; + *addrbuf++ = '['; + int addrbuflen = ADNS_ADDR2TEXT_BUFLEN; + + int r = adns_addr2text(&ia->sa, 0, addrbuf, &addrbuflen, &port); + if (r) { + const char fmt[]= "scoped IPv6 addr, error: %.*s"; + sprintf(addrbuf, fmt, + (int)(ADNS_ADDR2TEXT_BUFLEN - sizeof(fmt)) /* underestimate */, + strerror(r)); + } + + char *portbuf = addrbuf; + int addrl = strlen(addrbuf); + portbuf += addrl; + + snprintf(portbuf, sizeof(SBUF)-addrl, "]:%d", port); + +#endif /* CONFIG_IPV6 */ + + return SBUF; +} + +bool_t iaddr_equal(const union iaddr *ia, const union iaddr *ib, + bool_t ignoreport) +{ + if (ia->sa.sa_family != ib->sa.sa_family) + return 0; + switch (ia->sa.sa_family) { + case AF_INET: + return ia->sin.sin_addr.s_addr == ib->sin.sin_addr.s_addr + && (ignoreport || + ia->sin.sin_port == ib->sin.sin_port); +#ifdef CONFIG_IPV6 + case AF_INET6: + return !memcmp(&ia->sin6.sin6_addr, &ib->sin6.sin6_addr, 16) + && ia->sin6.sin6_scope_id == ib->sin6.sin6_scope_id + && (ignoreport || + ia->sin6.sin6_port == ib->sin6.sin6_port) + /* we ignore the flowinfo field */; +#endif /* CONFIG_IPV6 */ + default: + abort(); + } +} + +int iaddr_socklen(const union iaddr *ia) +{ + switch (ia->sa.sa_family) { + case AF_INET: return sizeof(ia->sin); +#ifdef CONFIG_IPV6 + case AF_INET6: return sizeof(ia->sin6); +#endif /* CONFIG_IPV6 */ + default: abort(); + } +} + +const char *pollbadbit(int revents) +{ +#define BADBIT(b) \ + if ((revents & b)) return #b + BADBIT(POLLERR); + BADBIT(POLLHUP); + /* POLLNVAL is handled by the event loop - see afterpoll_fn comment */ +#undef BADBIT + return 0; +} + +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) + + const char *badbit=pollbadbit(revents); + if (badbit) BAD(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 +}