X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?p=secnet.git;a=blobdiff_plain;f=util.c;h=b91497edc8b3bc8606054008898d8bc98a6da230;hp=1b46bc0df7422fe0bc6fdc2c3a91c0da51dba673;hb=c6a3b1f54ccc754be82f0a2ea5b4d60746053a2b;hpb=8534d6023d74efac11d7e2b5d1903638f3c1eca3 diff --git a/util.c b/util.c index 1b46bc0..b91497e 100644 --- a/util.c +++ b/util.c @@ -36,9 +36,11 @@ #include #include #include +#include #include "util.h" #include "unaligned.h" #include "magic.h" +#include "ipaddr.h" #define MIN_BUFFER_SIZE 64 #define DEFAULT_BUFFER_SIZE 4096 @@ -61,7 +63,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; } @@ -71,7 +73,7 @@ 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; } @@ -162,6 +164,21 @@ int32_t write_mpbin(MP_INT *a, uint8_t *buffer, int32_t buflen) return i; } +void setcloexec(int fd) { + int r=fcntl(fd, F_GETFD); + if (r<0) fatal_perror("fcntl(,F_GETFD) failed"); + r |= FD_CLOEXEC; + r=fcntl(fd, F_SETFD, r|FD_CLOEXEC); + if (r<0) fatal_perror("fcntl(,F_SETFD,|FD_CLOEXEC) failed"); +} + +void pipe_cloexec(int fd[2]) { + int r=pipe(fd); + if (r) fatal_perror("pipe"); + setcloexec(fd[0]); + setcloexec(fd[1]); +} + static const char *phases[NR_PHASES]={ "PHASE_INIT", "PHASE_GETOPTS", @@ -208,7 +225,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, ...) @@ -247,13 +264,14 @@ void buffer_assert_used(struct buffer_if *buffer, cstring_t file, 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, int32_t amount) { void *p; - assert(buf->size <= buf->len - amount); + assert(amount <= buf_remaining_space(buf)); p=buf->start + buf->size; buf->size+=amount; return p; @@ -299,7 +317,7 @@ void buffer_new(struct buffer_if *buf, int32_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"); } @@ -311,7 +329,7 @@ void buffer_readonly_view(struct buffer_if *buf, const void *data, int32_t len) buf->flags=0; buf->loc.file=NULL; buf->loc.line=0; - buf->size=buf->len=len; + buf->size=buf->alloclen=len; buf->base=buf->start=(uint8_t*)data; } @@ -322,10 +340,10 @@ void buffer_readonly_clone(struct buffer_if *out, const struct buffer_if *in) 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->alloclen < src->alloclen) { + dst->base=realloc(dst->base,src->alloclen); if (!dst->base) fatal_perror("buffer_copy"); - dst->len = src->len; + dst->alloclen = src->alloclen; } dst->start = dst->base + (src->start - src->base); dst->size = src->size; @@ -386,14 +404,14 @@ 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,dest->comm->min_start_pad); + 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", - dest->comm->addr_to_string(dest->comm->st,dest), + comm_addr_to_string(dest), our_index, their_index, msgtype, logwhy); dest->comm->sendmsg(dest->comm->st, buf, dest); } @@ -418,3 +436,149 @@ 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); +} + +void text2iaddr(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); + +#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_SHIFT 3 +#define IADDR_NBUFS (1 << IADDR_NBUFS_SHIFT) + +const char *iaddr_to_string(const union iaddr *ia) +{ + static int b; + + b++; + b &= IADDR_NBUFS-1; + +#ifndef CONFIG_IPV6 + + static char bufs[IADDR_NBUFS][100]; + + assert(ia->sa.sa_family == AF_INET); + + snprintf(bufs[b], sizeof(bufs[b]), "[%s]:%d", + inet_ntoa(ia->sin.sin_addr), + ntohs(ia->sin.sin_port)); + +#else /* CONFIG_IPV6 => we have adns_addr2text */ + + static char bufs[IADDR_NBUFS][1+ADNS_ADDR2TEXT_BUFLEN+20]; + + int port; + + char *addrbuf = bufs[b]; + *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, + ADNS_ADDR2TEXT_BUFLEN - sizeof(fmt) /* underestimate */, + strerror(r)); + } + + char *portbuf = addrbuf; + int addrl = strlen(addrbuf); + portbuf += addrl; + + snprintf(portbuf, sizeof(bufs[b])-addrl, "]:%d", port); + +#endif /* CONFIG_IPV6 */ + + return bufs[b]; +} + +bool_t iaddr_equal(const union iaddr *ia, const union iaddr *ib) +{ + 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 + && 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 + && 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(); + } +}