webserver: comparison src/server/util/io.c

-:21274e5950af
+:a1f4cb076d2f
 HttpStream *st = pool_malloc(pool, sizeof(HttpStream));
 st->st = http_io_funcs;
 st->fd = fd;
 st->max_read = 0;
 st->read = 0;
+st->read_total = 0;
+st->readbuf = NULL;
+st->bufsize = 0;
+st->buflen = NULL;
+st->bufpos = NULL;
+st->chunk_buf_pos = 0;
 st->chunked_enc = WS_FALSE;
-st->buffered = WS_FALSE;
+st->read_eof = WS_TRUE;
+st->write_eof = WS_FALSE;
 return (IOStream*)st;
 }
+int httpstream_enable_chunked_read(IOStream *st, char *buffer, size_t bufsize, int *cursize, int *pos) {
+if(st->read != (io_read_f)net_http_read) {
+log_ereport(LOG_FAILURE, "%s", "httpstream_enable_chunked_read: IOStream is not an HttpStream");
+return 1;
+}
+st->read = (io_read_f)net_http_read_chunked;
+HttpStream *http = (HttpStream*)st;
+http->max_read = 0;
+http->read = 0;
+http->readbuf = buffer;
+http->bufsize = bufsize;
+http->buflen = cursize;
+http->bufpos = pos;
+http->chunk_buf_pos = 0;
+http->read_eof = WS_FALSE;
+return 0;
+}
+int httpstream_enable_chunked_write(IOStream *st) {
+if(st->write != (io_write_f)net_http_write) {
+log_ereport(LOG_FAILURE, "%s", "httpstream_enable_chunked_write: IOStream is not an HttpStream");
+return 1;
+}
+HttpStream *http = (HttpStream*)st;
+http->chunked_enc = WS_TRUE;
+return 0;
+}
+int httpstream_set_max_read(IOStream *st, int64_t maxread) {
+if(st->write != (io_write_f)net_http_write) {
+log_ereport(LOG_FAILURE, "%s", "httpstream_set_max_read: IOStream is not an HttpStream");
+return 1;
+}
+HttpStream *http = (HttpStream*)st;
+http->max_read = maxread;
+return 0;
+}
+WSBool httpstream_eof(IOStream *st) {
+HttpStream *http = (HttpStream*)st;
+return http->read_eof;
+}
 ssize_t net_http_write(HttpStream *st, void *buf, size_t nbytes) {
+if(st->write_eof) return 0;
 IOStream *fd = st->fd;
 if(st->chunked_enc) {
 // TODO: on some plattforms iov_len is smaller than size_t
 struct iovec io[3];
 char chunk_len[16];
 io[0].iov_len = snprintf(chunk_len, 16, "%zx\r\n", nbytes);
 io[1].iov_base = buf;
 io[1].iov_len = nbytes;
 io[2].iov_base = "\r\n";
 io[2].iov_len = 2;
+// TODO: FIXME: if r < sum of iov_len, everything would explode
+// we need to store the chunk state and remaining bytes
 ssize_t r = fd->writev(fd, io, 3);
-return r - io[0].iov_len;
+return r - io[0].iov_len - io[2].iov_len;
 } else {
 return fd->write(fd, buf, nbytes);
 }
 }
 ssize_t net_http_writev(HttpStream *st, struct iovec *iovec, int iovcnt) {
+if(st->write_eof) return 0;
 IOStream *fd = st->fd;
 if(st->chunked_enc) {
 struct iovec *io = calloc(iovcnt + 1, sizeof(struct iovec));
+if(!io) {
+return 0;
+}
 char chunk_len[16];
 io[0].iov_base = chunk_len;
 size_t len = 0;
 for(int i=0;i<iovcnt;i++) {
 len += iovec[i].iov_len;
 }
 io[0].iov_len = snprintf(chunk_len, 16, "\r\n%zx\r\n", len);
 memcpy(io + 1, iovec, iovcnt * sizeof(struct iovec));
 ssize_t r = fd->writev(fd, io, iovcnt + 1);
-return r - io[0].iov_len;
+ssize_t ret = r - io[0].iov_len;
+free(io);
+return ret;
 } else {
 return fd->writev(fd, iovec, iovcnt);
 }
 }
 ssize_t net_http_read(HttpStream *st, void *buf, size_t nbytes) {
-if(st->max_read != 0 && st->read >= st->max_read) {
+if(st->read >= st->max_read) {
+st->read_eof = WS_TRUE;
 return 0;
 }
 ssize_t r = st->fd->read(st->fd, buf, nbytes);
+if(r < 0) {
+st->st.io_errno = st->fd->io_errno;
+}
 st->read += r;
 return r;
 }
-ssize_t net_http_sendfile(HttpStream *st, sendfiledata *sfd) {
+#define BUF_UNNEEDED_DIFF 64
+/*
+* read from st->chunk_buf first, read from st->fd if perform_io is true
+*/
+static ssize_t net_http_read_buffered(HttpStream *st, char *buf, size_t nbytes, WSBool read_data, WSBool *perform_io) {
+ssize_t r = 0;
+//memset(buf, 'x', nbytes);
+//char *orig_buf = buf;
+// copy available data from st->readbuf to buf
+int pos = *st->bufpos;
+size_t buf_available = *st->buflen - pos;
+if(buf_available) {
+size_t cplen = buf_available > nbytes ? nbytes : buf_available;
+if(read_data) {
+// if we read data (and not a chunk header), we limit the
+// amount of bytes we copy
+size_t chunk_available = st->max_read - st->read;
+cplen = cplen > chunk_available ? chunk_available : cplen;
+st->read += cplen;
+}
+memcpy(buf, st->readbuf + pos, cplen);
+*st->bufpos += cplen;
+r += cplen;
+buf += cplen;
+nbytes -= cplen;
+}
+// maybe perform IO and refill the read buffer
+// if we read data (read_data == true), make sure not to perform IO,
+// when a chunk is completed
+//
+// if we read a chunk header (read_data == false) it is very important
+// to not perform IO, if we have previously copied data from readbuf
+// this ensures we never override non-chunk-header data
+if(*perform_io && ((read_data && nbytes > 0 && st->max_read - st->read) || (!read_data && r == 0))) {
+if(*st->buflen - *st->bufpos > 0) {
+printf("todo: fix, should not happen, remove later\n");
+}
+// fill buffer again
+ssize_t rlen = st->fd->read(st->fd, st->readbuf, st->bufsize);
+*st->buflen = rlen;
+*st->bufpos = 0;
+*perform_io = WS_FALSE;
+if(rlen < 0) {
+st->st.io_errno = st->fd->io_errno;
+}
+if(rlen > 0) {
+// call func again to get data from buffer (no IO will be performed)
+r += net_http_read_buffered(st, buf, nbytes, read_data, perform_io);
+}
+}
+return r;
+}
+/*
+* parses a chunk header
+* the chunk length is stored in chunklen
+* return:  0 if the data is incomplete
+*         -1 if an error occured
+*         >0 chunk header length
+*/
+static int parse_chunk_header(char *str, int len, WSBool first, int64_t *chunklen) {
+char *hdr_start = NULL;
+char *hdr_end = NULL;
+int i = 0;
+if(first) {
+hdr_start = str;
+} else {
+if(len < 3) {
+return 0;
+}
+if(str[0] == '\r' && str[1] == '\n') {
+hdr_start = str+2;
+i = 2;
+} else if(str[0] == '\n') {
+hdr_start = str+1;
+i = 1;
+} else {
+return -1;
+}
+}
+for(;i<len;i++) {
+char c = str[i];
+if(c == '\r' || c == '\n') {
+hdr_end = str+i;
+break;
+}
+}
+if(!hdr_end || i == len) {
+return 0; // incomplete
+}
+if(*hdr_end == '\r') {
+// we also need '\n'
+if(hdr_end[1] != '\n') {
+return -1;
+}
+i++; // '\n' found
+}
+// parse
+char save_c = *hdr_end;
+*hdr_end = '\0';
+char *end;
+int64_t clen;
+errno = 0;
+clen = strtoll(hdr_start, &end, 16);
+*hdr_end = save_c;
+if(errno) {
+return -1;
+}
+i++;
+if(clen == 0) {
+// chunk length of 0 indicates the end
+// an additional \r\n is required (we also accept \n)
+if(i >= len) {
+return 0;
+}
+if(str[i] == '\n') {
+i++;
+} else if(str[i] == '\r') {
+if(++i >= len) {
+return 0;
+}
+if(str[i] == '\n') {
+i++;
+} else {
+return -1;
+}
+} else {
+return -1;
+}
+}
+*chunklen = clen;
+return i;
+}
+ssize_t net_http_read_chunked(HttpStream *st, void *buf, size_t nbytes) {
+if(st->read_eof) {
+return 0;
+}
+char *rbuf = buf; // buffer pos
+size_t rd = 0; // number of bytes read
+size_t rbuflen = nbytes; // number of bytes until end of buf
+WSBool perform_io = WS_TRUE; // we do only 1 read before we abort
+while(rd < nbytes && (perform_io || (st->max_read - st->read) > 0)) {
+// how many bytes are available in the current chunk
+size_t chunk_available = st->max_read - st->read;
+if(chunk_available > 0) {
+ssize_t r = net_http_read_buffered(st, rbuf, rbuflen, TRUE, &perform_io);
+if(r == 0) {
+break;
+}
+rd += r;
+st->read_total += r;
+rbuf += r;
+rbuflen -= r;
+} else {
+int chunkbuf_avail = HTTP_STREAM_CBUF_SIZE - st->chunk_buf_pos;
+if(chunkbuf_avail == 0) {
+// for some reason HTTP_STREAM_CBUF_SIZE is not enough
+// to store the chunk header
+// this indicates that something has gone wrong (or this is an attack)
+st->read_eof = WS_TRUE;
+return -1;
+}
+// fill st->chunk_buf
+ssize_t r = net_http_read_buffered(st, &st->chunk_buf[st->chunk_buf_pos], chunkbuf_avail, FALSE, &perform_io);
+if(r == 0) {
+break;
+}
+int chunkbuf_len = st->chunk_buf_pos + r;
+int64_t chunklen;
+int ret = parse_chunk_header(st->chunk_buf, chunkbuf_len, st->read_total > 0 ? FALSE : TRUE, &chunklen);
+if(ret == 0) {
+// incomplete chunk header
+st->chunk_buf_pos = chunkbuf_len;
+} else if(ret < 0) {
+// error
+st->read_eof = WS_TRUE;
+return -1;
+} else if(ret > 0) {
+st->max_read = chunklen;
+st->read = 0;
+int remaining_len = chunkbuf_len - ret;
+if(remaining_len > 0) {
+// we have read more into chunk_buf than the chunk_header
+// it is save to just move bufpos back
+*st->bufpos -= remaining_len;
+}
+//st->remaining_len = chunkbuf_len - ret;
+st->chunk_buf_pos = 0;
+if(chunklen == 0) {
+st->read_eof = WS_TRUE;
+break;
+}
+}
+}
+if(!perform_io && rd == 0) {
+perform_io = WS_TRUE;
+}
+}
+return rd;
+}
+ssize_t net_http_sendfile(HttpStream *st, sendfiledata *sfd) {
+if(st->write_eof) return 0;
 ssize_t ret = 0;
 // TODO: support chunked transfer encoding
 if(st->fd->sendfile) {
 ret = st->fd->sendfile(st->fd, sfd);
 } else {
 void net_http_close(HttpStream *st) {
 st->fd->close(st->fd);
 }
 void net_http_finish(HttpStream *st) {
-if(st->chunked_enc) {
+if(st->chunked_enc && !st->write_eof) {
 st->fd->write(st->fd, "0\r\n\r\n", 5);
 }
+st->write_eof = WS_TRUE;
 }
 void net_http_setmode(HttpStream *st, int mode) {
 st->fd->setmode(st->fd, mode);
 }
 ssize_t net_printf(SYS_NETFD fd, char *format, ...) {
 va_list arg;
 va_start(arg, format);
 sstr_t buf = ucx_vasprintf(ucx_default_allocator(), format, arg);
-ssize_t r = net_write(fd, buf.ptr, buf.length);
+ssize_t r = buf.length > 0 ? net_write(fd, buf.ptr, buf.length) : 0;
 free(buf.ptr);
 va_end(arg);
 if(r < 0) {
 ((IOStream*)fd)->io_errno = errno;
 }

Mercurial > hg > webserver / file comparison

comparison: src/server/util/io.c

src/server/util/io.c