X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Futcp.c;h=fa45e9c625b4b4e1d28c07ea49d881dad40e2107;hb=32ab3f06ce82167e2670bd9c7c58a0c21a2550c2;hp=20dd0aba049757ca30833779ec772c63ba685310;hpb=d1b43b5060795728b95b4ed3311b3398771cf34e;p=meshlink diff --git a/src/utcp.c b/src/utcp.c index 20dd0aba..fa45e9c6 100644 --- a/src/utcp.c +++ b/src/utcp.c @@ -196,6 +196,16 @@ static bool buffer_wraps(struct buffer *buf) { } static bool buffer_resize(struct buffer *buf, uint32_t newsize) { + assert(!buf->external); + + if(!newsize) { + free(buf->data); + buf->data = NULL; + buf->size = 0; + buf->offset = 0; + return true; + } + char *newdata = realloc(buf->data, newsize); if(!newdata) { @@ -395,8 +405,99 @@ static bool buffer_set_size(struct buffer *buf, uint32_t minsize, uint32_t maxsi return buf->size >= minsize || buffer_resize(buf, minsize); } +static void buffer_transfer(struct buffer *buf, char *newdata, size_t newsize) { + if(buffer_wraps(buf)) { + // Old situation: + // [345......012] + // New situation: + // [012345......] + uint32_t tailsize = buf->size - buf->offset; + memcpy(newdata, buf->data + buf->offset, tailsize); + memcpy(newdata + tailsize, buf->data, buf->used - tailsize); + } else { + // Old situation: + // [....012345..] + // New situation: + // [012345......] + memcpy(newdata, buf->data + buf->offset, buf->used); + } + + buf->offset = 0; + buf->size = newsize; +} + +static void set_buffer_storage(struct buffer *buf, char *data, size_t size) { + if(size > UINT32_MAX) { + size = UINT32_MAX; + } + + buf->maxsize = size; + + if(data) { + if(buf->external) { + // Don't allow resizing an external buffer + abort(); + } + + if(size < buf->used) { + // Ignore requests for an external buffer if we are already using more than it can store + return; + } + + // Transition from internal to external buffer + buffer_transfer(buf, data, size); + free(buf->data); + buf->data = data; + buf->external = true; + } else if(buf->external) { + // Transition from external to internal buf + size_t minsize = buf->used <= DEFAULT_SNDBUFSIZE ? DEFAULT_SNDBUFSIZE : buf->used; + + if(minsize) { + data = malloc(minsize); + + if(!data) { + // Cannot handle this + abort(); + } + + buffer_transfer(buf, data, minsize); + buf->data = data; + } else { + buf->data = NULL; + buf->size = 0; + } + + buf->external = false; + } else { + // Don't do anything if the buffer wraps + if(buffer_wraps(buf)) { + return; + } + + // Realloc internal storage + size_t minsize = max(DEFAULT_SNDBUFSIZE, buf->offset + buf->used); + + if(minsize) { + data = realloc(buf->data, minsize); + + if(data) { + buf->data = data; + buf->size = minsize; + } + } else { + free(buf->data); + buf->data = NULL; + buf->size = 0; + } + } +} + static void buffer_exit(struct buffer *buf) { - free(buf->data); + if(!buf->external) { + free(buf->data); + } + memset(buf, 0, sizeof(*buf)); } @@ -1499,6 +1600,8 @@ synack: // The peer has aborted our connection. set_state(c, CLOSED); errno = ECONNRESET; + buffer_clear(&c->sndbuf); + buffer_clear(&c->rcvbuf); if(c->recv) { c->recv(c, NULL, 0); @@ -1971,6 +2074,9 @@ static bool reset_connection(struct utcp_connection *c) { return false; } + buffer_clear(&c->sndbuf); + buffer_clear(&c->rcvbuf); + c->recv = NULL; c->poll = NULL; @@ -2005,12 +2111,22 @@ static bool reset_connection(struct utcp_connection *c) { hdr.ack = c->rcv.nxt; hdr.wnd = 0; hdr.ctl = RST; + hdr.aux = 0; print_packet(c, "send", &hdr, sizeof(hdr)); c->utcp->send(c->utcp, &hdr, sizeof(hdr)); return true; } +static void set_reapable(struct utcp_connection *c) { + set_buffer_storage(&c->sndbuf, NULL, min(c->sndbuf.maxsize, DEFAULT_MAXSNDBUFSIZE)); + set_buffer_storage(&c->rcvbuf, NULL, min(c->rcvbuf.maxsize, DEFAULT_MAXRCVBUFSIZE)); + + c->recv = NULL; + c->poll = NULL; + c->reapable = true; +} + // Closes all the opened connections void utcp_abort_all_connections(struct utcp *utcp) { if(!utcp) { @@ -2028,7 +2144,7 @@ void utcp_abort_all_connections(struct utcp *utcp) { utcp_recv_t old_recv = c->recv; utcp_poll_t old_poll = c->poll; - reset_connection(c); + utcp_abort(c); if(old_recv) { errno = 0; @@ -2049,9 +2165,7 @@ int utcp_close(struct utcp_connection *c) { return -1; } - c->recv = NULL; - c->poll = NULL; - c->reapable = true; + set_reapable(c); return 0; } @@ -2060,7 +2174,7 @@ int utcp_abort(struct utcp_connection *c) { return -1; } - c->reapable = true; + set_reapable(c); return 0; } @@ -2096,6 +2210,8 @@ struct timespec utcp_timeout(struct utcp *utcp) { if(timespec_isset(&c->conn_timeout) && timespec_lt(&c->conn_timeout, &now)) { errno = ETIMEDOUT; c->state = CLOSED; + buffer_clear(&c->sndbuf); + buffer_clear(&c->rcvbuf); if(c->recv) { c->recv(c, NULL, 0); @@ -2198,6 +2314,9 @@ void utcp_exit(struct utcp *utcp) { struct utcp_connection *c = utcp->connections[i]; if(!c->reapable) { + buffer_clear(&c->sndbuf); + buffer_clear(&c->rcvbuf); + if(c->recv) { c->recv(c, NULL, 0); } @@ -2315,16 +2434,12 @@ size_t utcp_get_sndbuf_free(struct utcp_connection *c) { } } -void utcp_set_sndbuf(struct utcp_connection *c, size_t size) { +void utcp_set_sndbuf(struct utcp_connection *c, void *data, size_t size) { if(!c) { return; } - c->sndbuf.maxsize = size; - - if(c->sndbuf.maxsize != size) { - c->sndbuf.maxsize = -1; - } + set_buffer_storage(&c->sndbuf, data, size); c->do_poll = is_reliable(c) && buffer_free(&c->sndbuf); } @@ -2341,16 +2456,12 @@ size_t utcp_get_rcvbuf_free(struct utcp_connection *c) { } } -void utcp_set_rcvbuf(struct utcp_connection *c, size_t size) { +void utcp_set_rcvbuf(struct utcp_connection *c, void *data, size_t size) { if(!c) { return; } - c->rcvbuf.maxsize = size; - - if(c->rcvbuf.maxsize != size) { - c->rcvbuf.maxsize = -1; - } + set_buffer_storage(&c->rcvbuf, data, size); } size_t utcp_get_sendq(struct utcp_connection *c) { @@ -2428,6 +2539,11 @@ void utcp_expect_data(struct utcp_connection *c, bool expect) { } } +void utcp_set_flags(struct utcp_connection *c, uint32_t flags) { + c->flags &= ~UTCP_CHANGEABLE_FLAGS; + c->flags |= flags & UTCP_CHANGEABLE_FLAGS; +} + void utcp_offline(struct utcp *utcp, bool offline) { struct timespec now; clock_gettime(UTCP_CLOCK, &now);