X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?p=secnet.git;a=blobdiff_plain;f=util.c;h=3bfa6bb81afbca72ef26aed0741f62e10b8eeaee;hp=997979ac93b4e99b498602077f72519755eb68c6;hb=1a448682f9a56b3e33e24fc07767a07e40feaec7;hpb=59938e0ed0c8ac267c3715a25a0a3ed27f7a7e47 diff --git a/util.c b/util.c index 997979a..3bfa6bb 100644 --- a/util.c +++ b/util.c @@ -38,6 +38,7 @@ #include #include "util.h" #include "unaligned.h" +#include "magic.h" #define MIN_BUFFER_SIZE 64 #define DEFAULT_BUFFER_SIZE 4096 @@ -60,7 +61,7 @@ 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; } @@ -70,10 +71,16 @@ void *safe_malloc(size_t size, const char *message) void *r; r=malloc(size); if (!r) { - fatal_perror(message); + fatal_perror("%s",message); } return r; } +void *safe_malloc_ary(size_t size, size_t count, const char *message) { + if (count >= INT_MAX/size) { + fatal("array allocation overflow: %s", message); + } + return safe_malloc(size*count, message); +} /* Convert a buffer into its MP_INT representation */ void read_mpbin(MP_INT *a, uint8_t *bin, int binsize) @@ -133,7 +140,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; @@ -160,6 +167,7 @@ static const char *phases[NR_PHASES]={ "PHASE_GETOPTS", "PHASE_READCONFIG", "PHASE_SETUP", + "PHASE_DAEMONIZE", "PHASE_GETRESOURCES", "PHASE_DROPPRIV", "PHASE_RUN", @@ -200,7 +208,7 @@ bool_t remove_hook(uint32_t phase, hook_fn *fn, void *state) void vslilog(struct log_if *lf, int priority, const char *message, va_list ap) { - lf->vlog(lf->st,priority,message,ap); + lf->vlogfn(lf->st,priority,message,ap); } void slilog(struct log_if *lf, int priority, const char *message, ...) @@ -218,48 +226,54 @@ struct buffer { }; void buffer_assert_free(struct buffer_if *buffer, cstring_t file, - uint32_t line) + int line) { if (!buffer->free) { - fatal("BUF_ASSERT_FREE, %s line %d, owned by %s", - 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, cstring_t file, - uint32_t line) + int line) { if (buffer->free) { - fatal("BUF_ASSERT_USED, %s line %d, last owned by %s", - 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->len); buffer->start=buffer->base+max_start_pad; buffer->size=0; } -void *buf_append(struct buffer_if *buf, uint32_t amount) { +void *buf_append(struct buffer_if *buf, int32_t amount) { void *p; + assert(buf->size <= buf->len - amount); 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; @@ -270,14 +284,15 @@ void *buf_unprepend(struct buffer_if *buf, uint32_t amount) { network byte order. */ void buf_append_string(struct buffer_if *buf, cstring_t s) { - uint16_t len; + size_t len; len=strlen(s); + /* fixme: if string is longer than 65535, result is a corrupted packet */ buf_append_uint16(buf,len); memcpy(buf_append(buf,len),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; @@ -290,6 +305,34 @@ void buffer_new(struct buffer_if *buf, uint32_t len) 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->len=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->len < src->len) { + dst->base=realloc(dst->base,src->len); + if (!dst->base) fatal_perror("buffer_copy"); + dst->len = src->len; + } + 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) { @@ -340,7 +383,82 @@ static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context, return new_closure(&st->cl); } +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,"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); +}