Limit amount of bytes we send in one go; fixes stalling in one connection and timeouts on slow systems.
git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2801 152afb58-edef-0310-8abb-c4023f1b3aa9svn/tags/lighttpd-1.4.30
parent
59ebf3c818
commit
f434d514ad
|
@ -647,11 +647,9 @@ typedef struct server {
|
|||
|
||||
fdevent_handler_t event_handler;
|
||||
|
||||
int (* network_backend_write)(struct server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int (* network_backend_read)(struct server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int (* network_backend_write)(struct server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
#ifdef USE_OPENSSL
|
||||
int (* network_ssl_backend_write)(struct server *srv, connection *con, SSL *ssl, chunkqueue *cq);
|
||||
int (* network_ssl_backend_read)(struct server *srv, connection *con, SSL *ssl, chunkqueue *cq);
|
||||
int (* network_ssl_backend_write)(struct server *srv, connection *con, SSL *ssl, chunkqueue *cq, off_t max_bytes);
|
||||
#endif
|
||||
|
||||
uid_t uid;
|
||||
|
|
|
@ -617,8 +617,9 @@ static int connection_handle_write_prepare(server *srv, connection *con) {
|
|||
}
|
||||
|
||||
static int connection_handle_write(server *srv, connection *con) {
|
||||
switch(network_write_chunkqueue(srv, con, con->write_queue)) {
|
||||
switch(network_write_chunkqueue(srv, con, con->write_queue, MAX_WRITE_LIMIT)) {
|
||||
case 0:
|
||||
con->write_request_ts = srv->cur_ts;
|
||||
if (con->file_finished) {
|
||||
connection_set_state(srv, con, CON_STATE_RESPONSE_END);
|
||||
joblist_append(srv, con);
|
||||
|
@ -635,6 +636,7 @@ static int connection_handle_write(server *srv, connection *con) {
|
|||
joblist_append(srv, con);
|
||||
break;
|
||||
case 1:
|
||||
con->write_request_ts = srv->cur_ts;
|
||||
con->is_writable = 0;
|
||||
|
||||
/* not finished yet -> WRITE */
|
||||
|
@ -1251,8 +1253,6 @@ static handler_t connection_handle_fdevent(server *srv, void *context, int reven
|
|||
log_error_write(srv, __FILE__, __LINE__, "ds",
|
||||
con->fd,
|
||||
"handle write failed.");
|
||||
} else if (con->state == CON_STATE_WRITE) {
|
||||
con->write_request_ts = srv->cur_ts;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1667,8 +1667,6 @@ int connection_state_machine(server *srv, connection *con) {
|
|||
con->fd,
|
||||
"handle write failed.");
|
||||
connection_set_state(srv, con, CON_STATE_ERROR);
|
||||
} else if (con->state == CON_STATE_WRITE) {
|
||||
con->write_request_ts = srv->cur_ts;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -3075,7 +3075,7 @@ static handler_t fcgi_write_request(server *srv, handler_ctx *hctx) {
|
|||
fcgi_set_state(srv, hctx, FCGI_STATE_WRITE);
|
||||
/* fall through */
|
||||
case FCGI_STATE_WRITE:
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb);
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
|
||||
|
||||
chunkqueue_remove_finished_chunks(hctx->wb);
|
||||
|
||||
|
|
|
@ -825,7 +825,7 @@ static handler_t proxy_write_request(server *srv, handler_ctx *hctx) {
|
|||
|
||||
/* fall through */
|
||||
case PROXY_STATE_WRITE:;
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb);
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
|
||||
|
||||
chunkqueue_remove_finished_chunks(hctx->wb);
|
||||
|
||||
|
|
|
@ -2296,7 +2296,7 @@ static handler_t scgi_write_request(server *srv, handler_ctx *hctx) {
|
|||
|
||||
/* fall through */
|
||||
case FCGI_STATE_WRITE:
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb);
|
||||
ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
|
||||
|
||||
chunkqueue_remove_finished_chunks(hctx->wb);
|
||||
|
||||
|
|
|
@ -847,7 +847,7 @@ int network_register_fdevents(server *srv) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int network_write_chunkqueue(server *srv, connection *con, chunkqueue *cq) {
|
||||
int network_write_chunkqueue(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
|
||||
int ret = -1;
|
||||
off_t written = 0;
|
||||
#ifdef TCP_CORK
|
||||
|
@ -855,14 +855,32 @@ int network_write_chunkqueue(server *srv, connection *con, chunkqueue *cq) {
|
|||
#endif
|
||||
server_socket *srv_socket = con->srv_socket;
|
||||
|
||||
if (con->conf.global_kbytes_per_second &&
|
||||
*(con->conf.global_bytes_per_second_cnt_ptr) > con->conf.global_kbytes_per_second * 1024) {
|
||||
/* we reached the global traffic limit */
|
||||
if (con->conf.global_kbytes_per_second) {
|
||||
off_t limit = con->conf.global_kbytes_per_second * 1024 - *(con->conf.global_bytes_per_second_cnt_ptr);
|
||||
if (limit <= 0) {
|
||||
/* we reached the global traffic limit */
|
||||
|
||||
con->traffic_limit_reached = 1;
|
||||
joblist_append(srv, con);
|
||||
con->traffic_limit_reached = 1;
|
||||
joblist_append(srv, con);
|
||||
|
||||
return 1;
|
||||
return 1;
|
||||
} else {
|
||||
if (max_bytes > limit) max_bytes = limit;
|
||||
}
|
||||
}
|
||||
|
||||
if (con->conf.kbytes_per_second) {
|
||||
off_t limit = con->conf.kbytes_per_second * 1024 - con->bytes_written_cur_second;
|
||||
if (limit <= 0) {
|
||||
/* we reached the traffic limit */
|
||||
|
||||
con->traffic_limit_reached = 1;
|
||||
joblist_append(srv, con);
|
||||
|
||||
return 1;
|
||||
} else {
|
||||
if (max_bytes > limit) max_bytes = limit;
|
||||
}
|
||||
}
|
||||
|
||||
written = cq->bytes_out;
|
||||
|
@ -879,10 +897,10 @@ int network_write_chunkqueue(server *srv, connection *con, chunkqueue *cq) {
|
|||
|
||||
if (srv_socket->is_ssl) {
|
||||
#ifdef USE_OPENSSL
|
||||
ret = srv->network_ssl_backend_write(srv, con, con->ssl, cq);
|
||||
ret = srv->network_ssl_backend_write(srv, con, con->ssl, cq, max_bytes);
|
||||
#endif
|
||||
} else {
|
||||
ret = srv->network_backend_write(srv, con, con->fd, cq);
|
||||
ret = srv->network_backend_write(srv, con, con->fd, cq, max_bytes);
|
||||
}
|
||||
|
||||
if (ret >= 0) {
|
||||
|
@ -903,12 +921,5 @@ int network_write_chunkqueue(server *srv, connection *con, chunkqueue *cq) {
|
|||
|
||||
*(con->conf.global_bytes_per_second_cnt_ptr) += written;
|
||||
|
||||
if (con->conf.kbytes_per_second &&
|
||||
(con->bytes_written_cur_second > con->conf.kbytes_per_second * 1024)) {
|
||||
/* we reached the traffic limit */
|
||||
|
||||
con->traffic_limit_reached = 1;
|
||||
joblist_append(srv, con);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
#include "server.h"
|
||||
|
||||
int network_write_chunkqueue(server *srv, connection *con, chunkqueue *c);
|
||||
int network_write_chunkqueue(server *srv, connection *con, chunkqueue *c, off_t max_bytes);
|
||||
|
||||
int network_init(server *srv);
|
||||
int network_close(server *srv);
|
||||
|
|
|
@ -47,18 +47,18 @@
|
|||
#include "base.h"
|
||||
|
||||
/* return values:
|
||||
* >= 0 : chunks completed
|
||||
* >= 0 : no error
|
||||
* -1 : error (on our side)
|
||||
* -2 : remote close
|
||||
*/
|
||||
|
||||
int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int fd, chunkqueue *cq);
|
||||
int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes);
|
||||
#ifdef USE_OPENSSL
|
||||
int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chunkqueue *cq);
|
||||
int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chunkqueue *cq, off_t max_bytes);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
@ -31,17 +31,16 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int fd, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
for(c = cq->first; c; c = c->next, chunks_written++) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
size_t num_chunks, i;
|
||||
|
@ -49,12 +48,10 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
chunk *tc;
|
||||
size_t num_bytes = 0;
|
||||
|
||||
/* we can't send more then SSIZE_MAX bytes in one chunk */
|
||||
|
||||
/* build writev list
|
||||
*
|
||||
* 1. limit: num_chunks < UIO_MAXIOV
|
||||
* 2. limit: num_bytes < SSIZE_MAX
|
||||
* 2. limit: num_bytes < max_bytes
|
||||
*/
|
||||
for(num_chunks = 0, tc = c; tc && tc->type == MEM_CHUNK && num_chunks < UIO_MAXIOV; num_chunks++, tc = tc->next);
|
||||
|
||||
|
@ -69,9 +66,9 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
chunks[i].iov_base = offset;
|
||||
|
||||
/* protect the return value of writev() */
|
||||
if (toSend > SSIZE_MAX ||
|
||||
num_bytes + toSend > SSIZE_MAX) {
|
||||
chunks[i].iov_len = SSIZE_MAX - num_bytes;
|
||||
if (toSend > max_bytes ||
|
||||
(off_t) num_bytes + toSend > max_bytes) {
|
||||
chunks[i].iov_len = max_bytes - num_bytes;
|
||||
|
||||
num_chunks = i + 1;
|
||||
break;
|
||||
|
@ -105,6 +102,7 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
|
||||
/* check which chunks have been written */
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
|
||||
if (r >= (ssize_t)chunks[i].iov_len) {
|
||||
|
@ -114,11 +112,10 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
|
||||
if (chunk_finished) {
|
||||
/* skip the chunks from further touches */
|
||||
chunks_written++;
|
||||
c = c->next;
|
||||
} else {
|
||||
/* chunks_written + c = c->next is done in the for()*/
|
||||
chunk_finished++;
|
||||
chunk_finished = 1;
|
||||
}
|
||||
} else {
|
||||
/* partially written */
|
||||
|
@ -134,7 +131,7 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
}
|
||||
case FILE_CHUNK: {
|
||||
off_t offset, r;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
stat_cache_entry *sce = NULL;
|
||||
|
||||
if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
|
||||
|
@ -144,9 +141,8 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
}
|
||||
|
||||
offset = c->file.start + c->offset;
|
||||
/* limit the toSend to 2^31-1 bytes in a chunk */
|
||||
toSend = c->file.length - c->offset > ((1 << 30) - 1) ?
|
||||
((1 << 30) - 1) : c->file.length - c->offset;
|
||||
toSend = c->file.length - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
if (-1 == c->file.fd) {
|
||||
if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
|
||||
|
@ -197,6 +193,7 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
chunk_finished = 1;
|
||||
|
@ -218,7 +215,7 @@ int network_write_chunkqueue_freebsdsendfile(server *srv, connection *con, int f
|
|||
}
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -27,17 +27,16 @@
|
|||
/* on linux 2.4.29 + debian/ubuntu we have crashes if this is enabled */
|
||||
#undef HAVE_POSIX_FADVISE
|
||||
|
||||
int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
for(c = cq->first; c; c = c->next, chunks_written++) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
size_t num_chunks, i;
|
||||
|
@ -45,12 +44,10 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
chunk *tc;
|
||||
size_t num_bytes = 0;
|
||||
|
||||
/* we can't send more then SSIZE_MAX bytes in one chunk */
|
||||
|
||||
/* build writev list
|
||||
*
|
||||
* 1. limit: num_chunks < UIO_MAXIOV
|
||||
* 2. limit: num_bytes < SSIZE_MAX
|
||||
* 2. limit: num_bytes < max_bytes
|
||||
*/
|
||||
for (num_chunks = 0, tc = c;
|
||||
tc && tc->type == MEM_CHUNK && num_chunks < UIO_MAXIOV;
|
||||
|
@ -67,9 +64,9 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
chunks[i].iov_base = offset;
|
||||
|
||||
/* protect the return value of writev() */
|
||||
if (toSend > SSIZE_MAX ||
|
||||
num_bytes + toSend > SSIZE_MAX) {
|
||||
chunks[i].iov_len = SSIZE_MAX - num_bytes;
|
||||
if (toSend > max_bytes ||
|
||||
(off_t) num_bytes + toSend > max_bytes) {
|
||||
chunks[i].iov_len = max_bytes - num_bytes;
|
||||
|
||||
num_chunks = i + 1;
|
||||
break;
|
||||
|
@ -100,6 +97,7 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
|
||||
/* check which chunks have been written */
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
|
||||
if (r >= (ssize_t)chunks[i].iov_len) {
|
||||
|
@ -109,11 +107,10 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
|
||||
if (chunk_finished) {
|
||||
/* skip the chunks from further touches */
|
||||
chunks_written++;
|
||||
c = c->next;
|
||||
} else {
|
||||
/* chunks_written + c = c->next is done in the for()*/
|
||||
chunk_finished++;
|
||||
chunk_finished = 1;
|
||||
}
|
||||
} else {
|
||||
/* partially written */
|
||||
|
@ -130,13 +127,12 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
case FILE_CHUNK: {
|
||||
ssize_t r;
|
||||
off_t offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
stat_cache_entry *sce = NULL;
|
||||
|
||||
offset = c->file.start + c->offset;
|
||||
/* limit the toSend to 2^31-1 bytes in a chunk */
|
||||
toSend = c->file.length - c->offset > ((1 << 30) - 1) ?
|
||||
((1 << 30) - 1) : c->file.length - c->offset;
|
||||
toSend = c->file.length - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
/* open file if not already opened */
|
||||
if (-1 == c->file.fd) {
|
||||
|
@ -215,6 +211,7 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
chunk_finished = 1;
|
||||
|
@ -243,7 +240,7 @@ int network_write_chunkqueue_linuxsendfile(server *srv, connection *con, int fd,
|
|||
}
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -27,10 +27,9 @@
|
|||
# include <openssl/ssl.h>
|
||||
# include <openssl/err.h>
|
||||
|
||||
int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chunkqueue *cq, off_t max_bytes) {
|
||||
int ssl_r;
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
/* this is a 64k sendbuffer
|
||||
*
|
||||
|
@ -59,13 +58,13 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN);
|
||||
}
|
||||
|
||||
for(c = cq->first; c; c = c->next) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
if (c->mem->used == 0 || c->mem->used == 1) {
|
||||
|
@ -75,6 +74,7 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
|
||||
offset = c->mem->ptr + c->offset;
|
||||
toSend = c->mem->used - 1 - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
/**
|
||||
* SSL_write man-page
|
||||
|
@ -139,6 +139,7 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
} else {
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
}
|
||||
|
||||
if (c->offset == (off_t)c->mem->used - 1) {
|
||||
|
@ -168,6 +169,7 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
do {
|
||||
off_t offset = c->file.start + c->offset;
|
||||
off_t toSend = c->file.length - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
if (toSend > LOCAL_SEND_BUFSIZE) toSend = LOCAL_SEND_BUFSIZE;
|
||||
|
||||
|
@ -243,6 +245,7 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
} else {
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
}
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
|
@ -263,11 +266,9 @@ int network_write_chunkqueue_openssl(server *srv, connection *con, SSL *ssl, chu
|
|||
|
||||
break;
|
||||
}
|
||||
|
||||
chunks_written++;
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
@ -38,17 +38,16 @@
|
|||
*/
|
||||
|
||||
|
||||
int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int fd, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
for(c = cq->first; c; c = c->next, chunks_written++) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
size_t num_chunks, i;
|
||||
|
@ -77,9 +76,9 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
chunks[i].iov_base = offset;
|
||||
|
||||
/* protect the return value of writev() */
|
||||
if (toSend > SSIZE_MAX ||
|
||||
num_bytes + toSend > SSIZE_MAX) {
|
||||
chunks[i].iov_len = SSIZE_MAX - num_bytes;
|
||||
if (toSend > max_bytes ||
|
||||
(off_t) num_bytes + toSend > max_bytes) {
|
||||
chunks[i].iov_len = max_bytes - num_bytes;
|
||||
|
||||
num_chunks = i + 1;
|
||||
break;
|
||||
|
@ -119,11 +118,10 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
|
||||
if (chunk_finished) {
|
||||
/* skip the chunks from further touches */
|
||||
chunks_written++;
|
||||
c = c->next;
|
||||
} else {
|
||||
/* chunks_written + c = c->next is done in the for()*/
|
||||
chunk_finished++;
|
||||
chunk_finished = 1;
|
||||
}
|
||||
} else {
|
||||
/* partially written */
|
||||
|
@ -139,8 +137,8 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
}
|
||||
case FILE_CHUNK: {
|
||||
ssize_t r;
|
||||
off_t offset;
|
||||
size_t toSend, written;
|
||||
off_t offset, toSend;
|
||||
size_t written;
|
||||
sendfilevec_t fvec;
|
||||
stat_cache_entry *sce = NULL;
|
||||
int ifd;
|
||||
|
@ -153,6 +151,7 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
|
||||
offset = c->file.start + c->offset;
|
||||
toSend = c->file.length - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
if (offset > sce->st.st_size) {
|
||||
log_error_write(srv, __FILE__, __LINE__, "sb", "file was shrinked:", c->file.name);
|
||||
|
@ -186,6 +185,7 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
close(ifd);
|
||||
c->offset += written;
|
||||
cq->bytes_out += written;
|
||||
max_bytes -= written;
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
chunk_finished = 1;
|
||||
|
@ -207,7 +207,7 @@ int network_write_chunkqueue_solarissendfilev(server *srv, connection *con, int
|
|||
}
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -24,17 +24,16 @@
|
|||
# include <sys/resource.h>
|
||||
#endif
|
||||
|
||||
int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
for(c = cq->first; c; c = c->next) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
if (c->mem->used == 0) {
|
||||
|
@ -44,6 +43,8 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
|
||||
offset = c->mem->ptr + c->offset;
|
||||
toSend = c->mem->used - 1 - c->offset;
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
#ifdef __WIN32
|
||||
if ((r = send(fd, offset, toSend, 0)) < 0) {
|
||||
/* no error handling for windows... */
|
||||
|
@ -72,6 +73,7 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
if (c->offset == (off_t)c->mem->used - 1) {
|
||||
chunk_finished = 1;
|
||||
|
@ -85,7 +87,7 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
#endif
|
||||
ssize_t r;
|
||||
off_t offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
stat_cache_entry *sce = NULL;
|
||||
int ifd;
|
||||
|
||||
|
@ -98,6 +100,8 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
offset = c->file.start + c->offset;
|
||||
toSend = c->file.length - c->offset;
|
||||
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
if (offset > sce->st.st_size) {
|
||||
log_error_write(srv, __FILE__, __LINE__, "sb", "file was shrinked:", c->file.name);
|
||||
|
||||
|
@ -181,6 +185,7 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
chunk_finished = 1;
|
||||
|
@ -200,11 +205,9 @@ int network_write_chunkqueue_write(server *srv, connection *con, int fd, chunkqu
|
|||
|
||||
break;
|
||||
}
|
||||
|
||||
chunks_written++;
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
|
|
@ -30,17 +30,16 @@
|
|||
#define LOCAL_BUFFERING 1
|
||||
#endif
|
||||
|
||||
int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq) {
|
||||
int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
|
||||
chunk *c;
|
||||
size_t chunks_written = 0;
|
||||
|
||||
for(c = cq->first; c; c = c->next) {
|
||||
for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
|
||||
int chunk_finished = 0;
|
||||
|
||||
switch(c->type) {
|
||||
case MEM_CHUNK: {
|
||||
char * offset;
|
||||
size_t toSend;
|
||||
off_t toSend;
|
||||
ssize_t r;
|
||||
|
||||
size_t num_chunks, i;
|
||||
|
@ -65,12 +64,10 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
#error "sysconf() doesnt return _SC_IOV_MAX ..., check the output of 'man writev' for the EINVAL error and send the output to jan@kneschke.de"
|
||||
#endif
|
||||
|
||||
/* we can't send more then SSIZE_MAX bytes in one chunk */
|
||||
|
||||
/* build writev list
|
||||
*
|
||||
* 1. limit: num_chunks < max_chunks
|
||||
* 2. limit: num_bytes < SSIZE_MAX
|
||||
* 2. limit: num_bytes < max_bytes
|
||||
*/
|
||||
for (num_chunks = 0, tc = c; tc && tc->type == MEM_CHUNK && num_chunks < max_chunks; num_chunks++, tc = tc->next);
|
||||
|
||||
|
@ -87,9 +84,9 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
chunks[i].iov_base = offset;
|
||||
|
||||
/* protect the return value of writev() */
|
||||
if (toSend > SSIZE_MAX ||
|
||||
num_bytes + toSend > SSIZE_MAX) {
|
||||
chunks[i].iov_len = SSIZE_MAX - num_bytes;
|
||||
if (toSend > max_bytes ||
|
||||
(off_t) num_bytes + toSend > max_bytes) {
|
||||
chunks[i].iov_len = max_bytes - num_bytes;
|
||||
|
||||
num_chunks = i + 1;
|
||||
break;
|
||||
|
@ -121,6 +118,7 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
}
|
||||
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
/* check which chunks have been written */
|
||||
|
||||
|
@ -132,11 +130,10 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
|
||||
if (chunk_finished) {
|
||||
/* skip the chunks from further touches */
|
||||
chunks_written++;
|
||||
c = c->next;
|
||||
} else {
|
||||
/* chunks_written + c = c->next is done in the for()*/
|
||||
chunk_finished++;
|
||||
chunk_finished = 1;
|
||||
}
|
||||
} else {
|
||||
/* partially written */
|
||||
|
@ -284,6 +281,8 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
assert(toSend < 0);
|
||||
}
|
||||
|
||||
if (toSend > max_bytes) toSend = max_bytes;
|
||||
|
||||
#ifdef LOCAL_BUFFERING
|
||||
start = c->mem->ptr;
|
||||
#else
|
||||
|
@ -309,6 +308,7 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
|
||||
c->offset += r;
|
||||
cq->bytes_out += r;
|
||||
max_bytes -= r;
|
||||
|
||||
if (c->offset == c->file.length) {
|
||||
chunk_finished = 1;
|
||||
|
@ -334,11 +334,9 @@ int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkq
|
|||
|
||||
break;
|
||||
}
|
||||
|
||||
chunks_written++;
|
||||
}
|
||||
|
||||
return chunks_written;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -21,7 +21,10 @@
|
|||
* 64kB (no real reason, just a guess)
|
||||
*/
|
||||
#define BUFFER_MAX_REUSE_SIZE (4 * 1024)
|
||||
#define MAX_READ_LIMIT (4*1024*1024)
|
||||
|
||||
/* both should be way smaller than SSIZE_MAX :) */
|
||||
#define MAX_READ_LIMIT (256*1024)
|
||||
#define MAX_WRITE_LIMIT (256*1024)
|
||||
|
||||
/**
|
||||
* max size of the HTTP request header
|
||||
|
|
Loading…
Reference in New Issue