Browse Source

[multiple] rename r to rc rv rd wr to be different

variable rename
personal/stbuehler/ci-build
Glenn Strauss 2 years ago
parent
commit
0ff60d8218
  1. 12
      src/buffer.c
  2. 38
      src/connections.c
  3. 10
      src/fdevent_libev.c
  4. 14
      src/gw_backend.c
  5. 38
      src/log.c
  6. 76
      src/mod_cgi.c
  7. 7
      src/mod_compress.c
  8. 39
      src/mod_openssl.c
  9. 86
      src/network_write.c
  10. 6
      src/request.c
  11. 34
      src/response.c
  12. 20
      src/sock_addr.c

12
src/buffer.c

@ -281,28 +281,28 @@ void buffer_copy_int(buffer *b, intmax_t val) {
}
void buffer_append_strftime(buffer *b, const char *format, const struct tm *tm) {
size_t r;
size_t rv;
char* buf;
force_assert(NULL != b);
force_assert(NULL != format);
force_assert(NULL != tm);
buf = buffer_string_prepare_append(b, 255);
r = strftime(buf, buffer_string_space(b), format, tm);
rv = strftime(buf, buffer_string_space(b), format, tm);
/* 0 (in some apis buffer_string_space(b)) signals the string may have
* been too small; but the format could also just have lead to an empty
* string
*/
if (0 == r || r >= buffer_string_space(b)) {
if (0 == rv || rv >= buffer_string_space(b)) {
/* give it a second try with a larger string */
buf = buffer_string_prepare_append(b, 4095);
r = strftime(buf, buffer_string_space(b), format, tm);
rv = strftime(buf, buffer_string_space(b), format, tm);
}
if (r >= buffer_string_space(b)) r = 0;
if (rv >= buffer_string_space(b)) rv = 0;
buffer_commit(b, r);
buffer_commit(b, rv);
}

38
src/connections.c

@ -498,8 +498,8 @@ static void connection_handle_write_state(connection *con) {
}
if (con->mode != DIRECT && !con->file_finished) {
int r = plugins_call_handle_subrequest(con);
switch(r) {
int rc = plugins_call_handle_subrequest(con);
switch(rc) {
case HANDLER_WAIT_FOR_EVENT:
case HANDLER_FINISHED:
case HANDLER_GO_ON:
@ -511,7 +511,7 @@ static void connection_handle_write_state(connection *con) {
default:
log_error(con->conf.errh, __FILE__, __LINE__,
"unexpected subrequest handler ret-value: %d %d",
con->fd, r);
con->fd, rc);
/* fall through */
case HANDLER_ERROR:
connection_set_state(con, CON_STATE_ERROR);
@ -1135,8 +1135,8 @@ connection *connection_accepted(server *srv, server_socket *srv_socket, sock_add
static int connection_handle_request(connection *con) {
int r = http_response_prepare(con);
switch (r) {
int rc = http_response_prepare(con);
switch (rc) {
case HANDLER_WAIT_FOR_EVENT:
if (!con->file_finished && (!con->file_started || 0 == con->conf.stream_response_body)) {
break; /* come back here */
@ -1234,7 +1234,7 @@ static int connection_handle_request(connection *con) {
connection_set_state(con, CON_STATE_ERROR);
break;
default:
log_error(con->conf.errh, __FILE__, __LINE__, "unknown ret-value: %d %d", con->fd, r);
log_error(con->conf.errh, __FILE__, __LINE__, "unknown ret-value: %d %d", con->fd, rc);
break;
}
@ -1244,7 +1244,7 @@ static int connection_handle_request(connection *con) {
int connection_state_machine(connection *con) {
connection_state_t ostate;
int r;
int rc;
const int log_state_handling = con->srv->srvconf.log_state_handling;
if (log_state_handling) {
@ -1326,10 +1326,10 @@ int connection_state_machine(connection *con) {
"state at exit: %d %s", con->fd, connection_get_state(con->state));
}
r = 0;
rc = 0;
switch(con->state) {
case CON_STATE_READ:
r = FDEVENT_IN | FDEVENT_RDHUP;
rc = FDEVENT_IN | FDEVENT_RDHUP;
break;
case CON_STATE_WRITE:
/* request write-fdevent only if we really need it
@ -1339,16 +1339,16 @@ int connection_state_machine(connection *con) {
if (!chunkqueue_is_empty(con->write_queue) &&
(con->is_writable == 0) &&
(con->traffic_limit_reached == 0)) {
r |= FDEVENT_OUT;
rc |= FDEVENT_OUT;
}
/* fall through */
case CON_STATE_READ_POST:
if (con->conf.stream_request_body & FDEVENT_STREAM_REQUEST_POLLIN) {
r |= FDEVENT_IN | FDEVENT_RDHUP;
rc |= FDEVENT_IN | FDEVENT_RDHUP;
}
break;
case CON_STATE_CLOSE:
r = FDEVENT_IN;
rc = FDEVENT_IN;
break;
default:
break;
@ -1357,24 +1357,24 @@ int connection_state_machine(connection *con) {
const int events = fdevent_fdnode_interest(con->fdn);
if (con->is_readable < 0) {
con->is_readable = 0;
r |= FDEVENT_IN;
rc |= FDEVENT_IN;
}
if (con->is_writable < 0) {
con->is_writable = 0;
r |= FDEVENT_OUT;
rc |= FDEVENT_OUT;
}
if (events & FDEVENT_RDHUP) {
r |= FDEVENT_RDHUP;
rc |= FDEVENT_RDHUP;
}
if (r != events) {
if (rc != events) {
/* update timestamps when enabling interest in events */
if ((r & FDEVENT_IN) && !(events & FDEVENT_IN)) {
if ((rc & FDEVENT_IN) && !(events & FDEVENT_IN)) {
con->read_idle_ts = log_epoch_secs;
}
if ((r & FDEVENT_OUT) && !(events & FDEVENT_OUT)) {
if ((rc & FDEVENT_OUT) && !(events & FDEVENT_OUT)) {
con->write_request_ts = log_epoch_secs;
}
fdevent_fdnode_event_set(con->srv->ev, con->fdn, r);
fdevent_fdnode_event_set(con->srv->ev, con->fdn, rc);
}
}

10
src/fdevent_libev.c

@ -13,15 +13,15 @@
static void io_watcher_cb(struct ev_loop *loop, ev_io *w, int revents) {
fdevents *ev = w->data;
fdnode *fdn = ev->fdarray[w->fd];
int r = 0;
int rv = 0;
UNUSED(loop);
if (revents & EV_READ) r |= FDEVENT_IN;
if (revents & EV_WRITE) r |= FDEVENT_OUT;
if (revents & EV_ERROR) r |= FDEVENT_ERR;
if (revents & EV_READ) rv |= FDEVENT_IN;
if (revents & EV_WRITE) rv |= FDEVENT_OUT;
if (revents & EV_ERROR) rv |= FDEVENT_ERR;
if (0 == ((uintptr_t)fdn & 0x3)) {
(*fdn->handler)(ev->srv, fdn->ctx, r);
(*fdn->handler)(ev->srv, fdn->ctx, rv);
}
}

14
src/gw_backend.c

@ -2043,31 +2043,31 @@ handler_t gw_handle_subrequest(connection *con, void *p_d) {
if (0 != hctx->wb->bytes_in) return HANDLER_WAIT_FOR_EVENT;
}
else {
handler_t r = connection_handle_read_post_state(con);
handler_t rc = connection_handle_read_post_state(con);
chunkqueue *req_cq = con->request_content_queue;
#if 0 /*(not reached since we send 411 Length Required below)*/
if (hctx->wb_reqlen < -1 && con->request.content_length >= 0) {
/* (completed receiving Transfer-Encoding: chunked) */
hctx->wb_reqlen= -hctx->wb_reqlen + con->request.content_length;
if (hctx->stdin_append) {
handler_t rc = hctx->stdin_append(hctx);
if (HANDLER_GO_ON != rc) return rc;
handler_t rca = hctx->stdin_append(hctx);
if (HANDLER_GO_ON != rca) return rca;
}
}
#endif
if ((0 != hctx->wb->bytes_in || -1 == hctx->wb_reqlen)
&& !chunkqueue_is_empty(req_cq)) {
if (hctx->stdin_append) {
handler_t rc = hctx->stdin_append(hctx);
if (HANDLER_GO_ON != rc) return rc;
handler_t rca = hctx->stdin_append(hctx);
if (HANDLER_GO_ON != rca) return rca;
}
else
chunkqueue_append_chunkqueue(hctx->wb, req_cq);
if (fdevent_fdnode_interest(hctx->fdn) & FDEVENT_OUT) {
return (r == HANDLER_GO_ON) ? HANDLER_WAIT_FOR_EVENT : r;
return (rc == HANDLER_GO_ON) ? HANDLER_WAIT_FOR_EVENT : rc;
}
}
if (r != HANDLER_GO_ON) return r;
if (rc != HANDLER_GO_ON) return rc;
/* XXX: create configurable flag */

38
src/log.c

@ -44,33 +44,19 @@ int log_clock_gettime_realtime (struct timespec *ts) {
}
/* retry write on EINTR or when not all data was written */
ssize_t write_all(int fd, const void* buf, size_t count) {
ssize_t written = 0;
while (count > 0) {
ssize_t r = write(fd, buf, count);
if (r < 0) {
switch (errno) {
case EINTR:
/* try again */
break;
default:
/* fail - repeating probably won't help */
return -1;
}
} else if (0 == r) {
/* really shouldn't happen... */
errno = EIO;
return -1;
} else {
force_assert(r <= (ssize_t) count);
written += r;
buf = r + (char const*) buf;
count -= r;
}
}
ssize_t write_all(int fd, const void * const buf, size_t count) {
ssize_t written = 0;
for (ssize_t wr; count > 0; count -= wr, written += wr) {
wr = write(fd, (const char *)buf + written, count);
if (wr > 0) continue;
if (wr < 0 && errno == EINTR) { wr = 0; continue; } /* try again */
if (0 == wr) errno = EIO; /* really shouldn't happen... */
return -1; /* fail - repeating probably won't help */
}
return written;
return written;
}
static int log_buffer_prepare(const log_error_st *errh, const char *filename, unsigned int line, buffer *b) {

76
src/mod_cgi.c

@ -135,8 +135,8 @@ INIT_FUNC(mod_cgi_init) {
FREE_FUNC(mod_cgi_free) {
plugin_data *p = p_d;
buffer_pid_t *r = &(p->cgi_pid);
if (r->ptr) free(r->ptr);
buffer_pid_t *bp = &(p->cgi_pid);
if (bp->ptr) free(bp->ptr);
free(p->env.ptr);
free(p->env.offsets);
free(p->env.eptr);
@ -259,24 +259,24 @@ SETDEFAULTS_FUNC(mod_cgi_set_defaults) {
static void cgi_pid_add(plugin_data *p, pid_t pid, void *ctx) {
buffer_pid_t *r = &(p->cgi_pid);
buffer_pid_t *bp = &(p->cgi_pid);
if (r->used == r->size) {
r->size += 16;
r->ptr = realloc(r->ptr, sizeof(*r->ptr) * r->size);
force_assert(r->ptr);
}
if (bp->used == bp->size) {
bp->size += 16;
bp->ptr = realloc(bp->ptr, sizeof(*bp->ptr) * bp->size);
force_assert(bp->ptr);
}
r->ptr[r->used].pid = pid;
r->ptr[r->used].ctx = ctx;
++r->used;
bp->ptr[bp->used].pid = pid;
bp->ptr[bp->used].ctx = ctx;
++bp->used;
}
static void cgi_pid_kill(plugin_data *p, pid_t pid) {
buffer_pid_t *r = &(p->cgi_pid);
for (size_t i = 0; i < r->used; ++i) {
if (r->ptr[i].pid == pid) {
r->ptr[i].ctx = NULL;
buffer_pid_t *bp = &(p->cgi_pid);
for (size_t i = 0; i < bp->used; ++i) {
if (bp->ptr[i].pid == pid) {
bp->ptr[i].ctx = NULL;
kill(pid, SIGTERM);
return;
}
@ -284,12 +284,12 @@ static void cgi_pid_kill(plugin_data *p, pid_t pid) {
}
static void cgi_pid_del(plugin_data *p, size_t i) {
buffer_pid_t *r = &(p->cgi_pid);
buffer_pid_t *bp = &(p->cgi_pid);
if (i != r->used - 1) {
r->ptr[i] = r->ptr[r->used - 1];
}
r->used--;
if (i != bp->used - 1)
bp->ptr[i] = bp->ptr[bp->used - 1];
--bp->used;
}
@ -544,7 +544,7 @@ static off_t mmap_align_offset(off_t start) {
static ssize_t cgi_write_file_chunk_mmap(connection *con, int fd, chunkqueue *cq) {
chunk* const c = cq->first;
off_t offset, toSend, file_end;
ssize_t r;
ssize_t wr;
size_t mmap_offset, mmap_avail;
char *data = NULL;
@ -614,11 +614,11 @@ static ssize_t cgi_write_file_chunk_mmap(connection *con, int fd, chunkqueue *cq
data = c->file.mmap.start + mmap_offset;
}
r = write(fd, data, toSend);
wr = write(fd, data, toSend);
if (MAP_FAILED == c->file.mmap.start) free(data);
if (r < 0) {
if (wr < 0) {
switch (errno) {
case EAGAIN:
case EINTR:
@ -633,8 +633,8 @@ static ssize_t cgi_write_file_chunk_mmap(connection *con, int fd, chunkqueue *cq
}
}
chunkqueue_mark_written(cq, r);
return r;
chunkqueue_mark_written(cq, wr);
return wr;
}
static int cgi_write_request(handler_ctx *hctx, int fd) {
@ -648,41 +648,41 @@ static int cgi_write_request(handler_ctx *hctx, int fd) {
*/
for (c = cq->first; c; c = cq->first) {
ssize_t r = -1;
ssize_t wr = -1;
switch(c->type) {
case FILE_CHUNK:
r = cgi_write_file_chunk_mmap(con, fd, cq);
wr = cgi_write_file_chunk_mmap(con, fd, cq);
break;
case MEM_CHUNK:
if ((r = write(fd, c->mem->ptr + c->offset, buffer_string_length(c->mem) - c->offset)) < 0) {
if ((wr = write(fd, c->mem->ptr + c->offset, buffer_string_length(c->mem) - c->offset)) < 0) {
switch(errno) {
case EAGAIN:
case EINTR:
/* ignore and try again */
r = 0;
wr = 0;
break;
case EPIPE:
case ECONNRESET:
/* connection closed */
r = -2;
wr = -2;
break;
default:
/* fatal error */
log_perror(con->conf.errh, __FILE__, __LINE__, "write() failed");
r = -1;
wr = -1;
break;
}
} else if (r > 0) {
chunkqueue_mark_written(cq, r);
} else if (wr > 0) {
chunkqueue_mark_written(cq, wr);
}
break;
}
if (0 == r) break; /*(might block)*/
if (0 == wr) break; /*(might block)*/
switch (r) {
switch (wr) {
case -1:
/* fatal error */
return -1;
@ -954,13 +954,13 @@ SUBREQUEST_FUNC(mod_cgi_handle_subrequest) {
con->conf.stream_request_body &= ~FDEVENT_STREAM_REQUEST_POLLIN;
if (-1 != hctx->fd) return HANDLER_WAIT_FOR_EVENT;
} else {
handler_t r = connection_handle_read_post_state(con);
handler_t rc = connection_handle_read_post_state(con);
if (!chunkqueue_is_empty(cq)) {
if (fdevent_fdnode_interest(hctx->fdntocgi) & FDEVENT_OUT) {
return (r == HANDLER_GO_ON) ? HANDLER_WAIT_FOR_EVENT : r;
return (rc == HANDLER_GO_ON) ? HANDLER_WAIT_FOR_EVENT : rc;
}
}
if (r != HANDLER_GO_ON) return r;
if (rc != HANDLER_GO_ON) return rc;
/* CGI environment requires that Content-Length be set.
* Send 411 Length Required if Content-Length missing.

7
src/mod_compress.c

@ -481,7 +481,6 @@ static int deflate_file_to_file(connection *con, plugin_data *p, int ifd, buffer
#endif
void *start;
stat_cache_entry *sce_ofn;
ssize_t r;
/* overflow */
if ((off_t)(sce->st.st_size * 1.1) < sce->st.st_size) return -1;
@ -622,12 +621,12 @@ static int deflate_file_to_file(connection *con, plugin_data *p, int ifd, buffer
}
if (ret == 0) {
r = write(ofd, CONST_BUF_LEN(p->b));
if (-1 == r) {
ssize_t wr = write(ofd, CONST_BUF_LEN(p->b));
if (-1 == wr) {
log_perror(con->conf.errh, __FILE__, __LINE__,
"writing cachefile %s failed", p->ofn->ptr);
ret = -1;
} else if ((size_t)r != buffer_string_length(p->b)) {
} else if ((size_t)wr != buffer_string_length(p->b)) {
log_error(con->conf.errh, __FILE__, __LINE__,
"writing cachefile %s failed: not enough bytes written",
p->ofn->ptr);

39
src/mod_openssl.c

@ -1789,7 +1789,7 @@ connection_write_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
while (max_bytes > 0 && NULL != cq->first) {
const char *data;
size_t data_len;
int r;
int wr;
if (0 != load_next_chunk(con,cq,max_bytes,&data,&data_len)) return -1;
@ -1803,7 +1803,7 @@ connection_write_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
*/
ERR_clear_error();
r = SSL_write(ssl, data, data_len);
wr = SSL_write(ssl, data, data_len);
if (hctx->renegotiations > 1
&& hctx->conf.ssl_disable_client_renegotiation) {
@ -1812,11 +1812,11 @@ connection_write_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
return -1;
}
if (r <= 0) {
if (wr <= 0) {
int ssl_r;
unsigned long err;
switch ((ssl_r = SSL_get_error(ssl, r))) {
switch ((ssl_r = SSL_get_error(ssl, wr))) {
case SSL_ERROR_WANT_READ:
con->is_readable = -1;
return 0; /* try again later */
@ -1828,9 +1828,9 @@ connection_write_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
if (0 != (err = ERR_get_error())) {
do {
log_error(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %d %s",ssl_r,r,ERR_error_string(err,NULL));
"SSL: %d %d %s",ssl_r,wr,ERR_error_string(err,NULL));
} while((err = ERR_get_error()));
} else if (r == -1) {
} else if (wr == -1) {
/* no, but we have errno */
switch(errno) {
case EPIPE:
@ -1838,36 +1838,36 @@ connection_write_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
return -2;
default:
log_perror(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %d", ssl_r, r);
"SSL: %d %d", ssl_r, wr);
break;
}
} else {
/* neither error-queue nor errno ? */
log_perror(con->conf.errh, __FILE__, __LINE__,
"SSL (error): %d %d", ssl_r, r);
"SSL (error): %d %d", ssl_r, wr);
}
break;
case SSL_ERROR_ZERO_RETURN:
/* clean shutdown on the remote side */
if (r == 0) return -2;
if (wr == 0) return -2;
/* fall through */
default:
while((err = ERR_get_error())) {
log_error(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %d %s", ssl_r, r, ERR_error_string(err, NULL));
"SSL: %d %d %s", ssl_r, wr, ERR_error_string(err, NULL));
}
break;
}
return -1;
}
chunkqueue_mark_written(cq, r);
max_bytes -= r;
chunkqueue_mark_written(cq, wr);
max_bytes -= wr;
if ((size_t) r < data_len) break; /* try again later */
if ((size_t) wr < data_len) break; /* try again later */
}
return 0;
@ -1878,7 +1878,7 @@ static int
connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
{
handler_ctx *hctx = con->plugin_ctx[plugin_data_singleton->id];
int r, ssl_err, len;
int len;
char *mem = NULL;
size_t mem_len = 0;
@ -1929,7 +1929,8 @@ connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
if (len < 0) {
int oerrno = errno;
switch ((r = SSL_get_error(hctx->ssl, len))) {
int rc, ssl_err;
switch ((rc = SSL_get_error(hctx->ssl, len))) {
case SSL_ERROR_WANT_WRITE:
con->is_writable = -1;
/* fall through */
@ -1959,7 +1960,7 @@ connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
while((ssl_err = ERR_get_error())) {
/* get all errors from the error-queue */
log_error(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %s", r, ERR_error_string(ssl_err, NULL));
"SSL: %d %s", rc, ERR_error_string(ssl_err, NULL));
}
switch(oerrno) {
@ -1973,7 +1974,7 @@ connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
break;
log_error(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %d %d %s", len, r, oerrno, strerror(oerrno));
"SSL: %d %d %d %s", len, rc, oerrno, strerror(oerrno));
break;
}
@ -1981,7 +1982,7 @@ connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
case SSL_ERROR_ZERO_RETURN:
/* clean shutdown on the remote side */
if (r == 0) {
if (rc == 0) {
/* FIXME: later */
}
@ -2006,7 +2007,7 @@ connection_read_cq_ssl (connection *con, chunkqueue *cq, off_t max_bytes)
}
/* get all errors from the error-queue */
log_error(con->conf.errh, __FILE__, __LINE__,
"SSL: %d %s", r, ERR_error_string(ssl_err, NULL));
"SSL: %d %s", rc, ERR_error_string(ssl_err, NULL));
}
break;
}

86
src/network_write.c

@ -217,7 +217,7 @@ static void sigbus_handler(int sig) {
static int network_write_file_chunk_mmap(int fd, chunkqueue *cq, off_t *p_max_bytes, log_error_st *errh) {
chunk* const c = cq->first;
off_t offset, toSend, file_end;
ssize_t r;
ssize_t wr;
size_t mmap_offset, mmap_avail;
const char *data;
@ -309,7 +309,7 @@ static int network_write_file_chunk_mmap(int fd, chunkqueue *cq, off_t *p_max_by
signal(SIGBUS, sigbus_handler);
sigbus_jmp_valid = 1;
r = network_write_data_len(fd, data, toSend);
wr = network_write_data_len(fd, data, toSend);
sigbus_jmp_valid = 0;
} else {
sigbus_jmp_valid = 0;
@ -322,10 +322,10 @@ static int network_write_file_chunk_mmap(int fd, chunkqueue *cq, off_t *p_max_by
return -1;
}
if (r >= 0) {
*p_max_bytes -= r;
chunkqueue_mark_written(cq, r);
return (r > 0 && r == toSend) ? 0 : -3;
if (wr >= 0) {
*p_max_bytes -= wr;
chunkqueue_mark_written(cq, wr);
return (wr > 0 && wr == toSend) ? 0 : -3;
} else {
return network_write_error(fd, errh);
}
@ -371,7 +371,7 @@ static int network_writev_mem_chunks(int fd, chunkqueue *cq, off_t *p_max_bytes,
size_t num_chunks = 0;
off_t max_bytes = *p_max_bytes;
off_t toSend = 0;
ssize_t r;
ssize_t wr;
for (const chunk *c = cq->first;
NULL != c && MEM_CHUNK == c->type
@ -395,9 +395,9 @@ static int network_writev_mem_chunks(int fd, chunkqueue *cq, off_t *p_max_bytes,
return 0;
}
r = writev(fd, chunks, num_chunks);
wr = writev(fd, chunks, num_chunks);
if (r < 0) switch (errno) {
if (wr < 0) switch (errno) {
case EAGAIN:
case EINTR:
break;
@ -409,12 +409,12 @@ static int network_writev_mem_chunks(int fd, chunkqueue *cq, off_t *p_max_bytes,
return -1;
}
if (r >= 0) {
*p_max_bytes -= r;
chunkqueue_mark_written(cq, r);
if (wr >= 0) {
*p_max_bytes -= wr;
chunkqueue_mark_written(cq, wr);
}
return (r > 0 && r == toSend) ? 0 : -3;
return (wr > 0 && wr == toSend) ? 0 : -3;
}
#endif /* NETWORK_WRITE_USE_WRITEV */
@ -436,7 +436,7 @@ static int network_writev_mem_chunks(int fd, chunkqueue *cq, off_t *p_max_bytes,
static int network_write_file_chunk_sendfile(int fd, chunkqueue *cq, off_t *p_max_bytes, log_error_st *errh) {
chunk * const c = cq->first;
ssize_t r;
ssize_t wr;
off_t offset;
off_t toSend;
off_t written = 0;
@ -459,18 +459,18 @@ static int network_write_file_chunk_sendfile(int fd, chunkqueue *cq, off_t *p_ma
#if defined(NETWORK_WRITE_USE_LINUX_SENDFILE)
r = sendfile(fd, c->file.fd, &offset, toSend);
if (r > 0) written = (off_t)r;
wr = sendfile(fd, c->file.fd, &offset, toSend);
if (wr > 0) written = (off_t)wr;
#elif defined(NETWORK_WRITE_USE_DARWIN_SENDFILE)
written = toSend;
r = sendfile(c->file.fd, fd, offset, &written, NULL, 0);
wr = sendfile(c->file.fd, fd, offset, &written, NULL, 0);
/* (for EAGAIN/EINTR written still contains the sent bytes) */
#elif defined(NETWORK_WRITE_USE_FREEBSD_SENDFILE)
r = sendfile(c->file.fd, fd, offset, toSend, NULL, &written, 0);
wr = sendfile(c->file.fd, fd, offset, toSend, NULL, &written, 0);
/* (for EAGAIN/EINTR written still contains the sent bytes) */
#elif defined(NETWORK_WRITE_USE_SOLARIS_SENDFILEV)
@ -482,17 +482,17 @@ static int network_write_file_chunk_sendfile(int fd, chunkqueue *cq, off_t *p_ma
fvec.sfv_len = toSend;
/* Solaris sendfilev() */
r = sendfilev(fd, &fvec, 1, (size_t *)&written);
wr = sendfilev(fd, &fvec, 1, (size_t *)&written);
/* (for EAGAIN/EINTR written still contains the sent bytes) */
}
#else
r = -1;
wr = -1;
errno = ENOSYS;
#endif
if (-1 == r) {
if (-1 == wr) {
switch(errno) {
case EAGAIN:
case EINTR:
@ -531,7 +531,7 @@ static int network_write_file_chunk_sendfile(int fd, chunkqueue *cq, off_t *p_ma
*p_max_bytes -= written;
}
return (r >= 0 && written == toSend) ? 0 : -3;
return (wr >= 0 && written == toSend) ? 0 : -3;
}
#endif
@ -547,23 +547,23 @@ static int network_write_file_chunk_sendfile(int fd, chunkqueue *cq, off_t *p_ma
static int network_write_chunkqueue_write(int fd, chunkqueue *cq, off_t max_bytes, log_error_st *errh) {
while (max_bytes > 0 && NULL != cq->first) {
int r = -1;
int rc = -1;
switch (cq->first->type) {
case MEM_CHUNK:
r = network_write_mem_chunk(fd, cq, &max_bytes, errh);
rc = network_write_mem_chunk(fd, cq, &max_bytes, errh);
break;
case FILE_CHUNK:
#ifdef NETWORK_WRITE_USE_MMAP
r = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
#else
r = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
#endif
break;
}
if (-3 == r) return 0;
if (0 != r) return r;
if (-3 == rc) return 0;
if (0 != rc) return rc;
}
return 0;
@ -572,27 +572,27 @@ static int network_write_chunkqueue_write(int fd, chunkqueue *cq, off_t max_byte
#if defined(NETWORK_WRITE_USE_WRITEV)
static int network_write_chunkqueue_writev(int fd, chunkqueue *cq, off_t max_bytes, log_error_st *errh) {
while (max_bytes > 0 && NULL != cq->first) {
int r = -1;
int rc = -1;
switch (cq->first->type) {
case MEM_CHUNK:
#if defined(NETWORK_WRITE_USE_WRITEV)
r = network_writev_mem_chunks(fd, cq, &max_bytes, errh);
rc = network_writev_mem_chunks(fd, cq, &max_bytes, errh);
#else
r = network_write_mem_chunk(fd, cq, &max_bytes, errh);
rc = network_write_mem_chunk(fd, cq, &max_bytes, errh);
#endif
break;
case FILE_CHUNK:
#ifdef NETWORK_WRITE_USE_MMAP
r = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
#else
r = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
#endif
break;
}
if (-3 == r) return 0;
if (0 != r) return r;
if (-3 == rc) return 0;
if (0 != rc) return rc;
}
return 0;
@ -602,29 +602,29 @@ static int network_write_chunkqueue_writev(int fd, chunkqueue *cq, off_t max_byt
#if defined(NETWORK_WRITE_USE_SENDFILE)
static int network_write_chunkqueue_sendfile(int fd, chunkqueue *cq, off_t max_bytes, log_error_st *errh) {
while (max_bytes > 0 && NULL != cq->first) {
int r = -1;
int rc = -1;
switch (cq->first->type) {
case MEM_CHUNK:
#if defined(NETWORK_WRITE_USE_WRITEV)
r = network_writev_mem_chunks(fd, cq, &max_bytes, errh);
rc = network_writev_mem_chunks(fd, cq, &max_bytes, errh);
#else
r = network_write_mem_chunk(fd, cq, &max_bytes, errh);
rc = network_write_mem_chunk(fd, cq, &max_bytes, errh);
#endif
break;
case FILE_CHUNK:
#if defined(NETWORK_WRITE_USE_SENDFILE)
r = network_write_file_chunk_sendfile(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_sendfile(fd, cq, &max_bytes, errh);
#elif defined(NETWORK_WRITE_USE_MMAP)
r = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_mmap(fd, cq, &max_bytes, errh);
#else
r = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
rc = network_write_file_chunk_no_mmap(fd, cq, &max_bytes, errh);
#endif
break;
}
if (-3 == r) return 0;
if (0 != r) return r;
if (-3 == rc) return 0;
if (0 != rc) return rc;
}
return 0;

6
src/request.c

@ -436,9 +436,9 @@ static int http_request_parse_single_header(connection * const con, const enum h
if (!(con->request.htags & HTTP_HEADER_CONTENT_LENGTH)) {
/*(trailing whitespace was removed from vlen)*/
char *err;
off_t r = strtoll(v, &err, 10);
if (r >= 0 && err == v+vlen) {
con->request.content_length = r;
off_t clen = strtoll(v, &err, 10);
if (clen >= 0 && err == v+vlen) {
con->request.content_length = clen;
}
else {
return http_request_header_line_invalid(con, 400, "invalid Content-Length header -> 400");

34
src/response.c

@ -284,7 +284,7 @@ static handler_t http_response_physical_path_check(connection *con) {
}
handler_t http_response_prepare(connection *con) {
handler_t r;
handler_t rc;
/* looks like someone has already done a decision */
if (con->mode == DIRECT &&
@ -494,8 +494,8 @@ handler_t http_response_prepare(connection *con) {
*
*/
r = plugins_call_handle_uri_raw(con);
if (HANDLER_GO_ON != r) return r;
rc = plugins_call_handle_uri_raw(con);
if (HANDLER_GO_ON != rc) return rc;
/**
*
@ -505,8 +505,8 @@ handler_t http_response_prepare(connection *con) {
*
*/
r = plugins_call_handle_uri_clean(con);
if (HANDLER_GO_ON != r) return r;
rc = plugins_call_handle_uri_clean(con);
if (HANDLER_GO_ON != rc) return rc;
if (con->request.http_method == HTTP_METHOD_OPTIONS &&
con->uri.path->ptr[0] == '*' && con->uri.path->ptr[1] == '\0') {
@ -603,8 +603,8 @@ handler_t http_response_prepare(connection *con) {
/* the docroot plugin should set the doc_root and might also set the physical.path
* for us (all vhost-plugins are supposed to set the doc_root)
* */
r = plugins_call_handle_docroot(con);
if (HANDLER_GO_ON != r) return r;
rc = plugins_call_handle_docroot(con);
if (HANDLER_GO_ON != rc) return rc;
/* MacOS X and Windows can't distiguish between upper and lower-case
*
@ -647,8 +647,8 @@ handler_t http_response_prepare(connection *con) {
* is filled in above to avoid repeating work next time
* http_response_prepare() is called while processing request) */
} else {
r = plugins_call_handle_physical(con);
if (HANDLER_GO_ON != r) return r;
rc = plugins_call_handle_physical(con);
if (HANDLER_GO_ON != rc) return rc;
if (con->conf.log_request_handling) {
log_error(con->conf.errh, __FILE__, __LINE__,
@ -679,8 +679,8 @@ handler_t http_response_prepare(connection *con) {
"Path : %s", con->physical.path->ptr);
}
r = http_response_physical_path_check(con);
if (HANDLER_GO_ON != r) return r;
rc = http_response_physical_path_check(con);
if (HANDLER_GO_ON != rc) return rc;
if (con->conf.log_request_handling) {
log_error(con->conf.errh, __FILE__, __LINE__,
@ -694,13 +694,13 @@ handler_t http_response_prepare(connection *con) {
}
/* call the handlers */
r = plugins_call_handle_subrequest_start(con);
if (HANDLER_GO_ON != r) {
rc = plugins_call_handle_subrequest_start(con);
if (HANDLER_GO_ON != rc) {
if (con->conf.log_request_handling) {
log_error(con->conf.errh, __FILE__, __LINE__,
"-- subrequest finished");
}
return r;
return rc;
}
/* if we are still here, no one wanted the file, status 403 is ok I think */
@ -711,7 +711,7 @@ handler_t http_response_prepare(connection *con) {
}
r = plugins_call_handle_subrequest(con);
if (HANDLER_GO_ON == r) r = HANDLER_FINISHED; /* request was not handled, looks like we are done */
return r;
rc = plugins_call_handle_subrequest(con);
if (HANDLER_GO_ON == rc) rc = HANDLER_FINISHED; /* request was not handled, looks like we are done */
return rc;
}

20
src/sock_addr.c

@ -395,15 +395,15 @@ int sock_addr_from_str_hints(sock_addr *saddr, socklen_t *len, const char *str,
#ifdef HAVE_IPV6
else {
struct addrinfo hints, *res;
int r;
int rc;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (0 != (r = getaddrinfo(str, NULL, &hints, &res))) {
if (0 != (rc = getaddrinfo(str, NULL, &hints, &res))) {
log_error(errh, __FILE__, __LINE__,
"getaddrinfo failed: %s '%s'", gai_strerror(r), str);
"getaddrinfo failed: %s '%s'", gai_strerror(rc), str);
return 0;
}
@ -434,7 +434,7 @@ int sock_addr_from_str_hints(sock_addr *saddr, socklen_t *len, const char *str,
}
else {
struct addrinfo hints, *res;
int r;
int rc;
memset(&hints, 0, sizeof(hints));
@ -442,11 +442,11 @@ int sock_addr_from_str_hints(sock_addr *saddr, socklen_t *len, const char *str,
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (0 != (r = getaddrinfo(str, NULL, &hints, &res))) {
if (0 != (rc = getaddrinfo(str, NULL, &hints, &res))) {
hints.ai_family = AF_INET;
if (
#ifdef EAI_ADDRFAMILY
EAI_ADDRFAMILY == r &&
EAI_ADDRFAMILY == rc &&
#endif
0 == getaddrinfo(str, NULL, &hints, &res)) {
memcpy(saddr, res->ai_addr, res->ai_addrlen);
@ -459,7 +459,7 @@ int sock_addr_from_str_hints(sock_addr *saddr, socklen_t *len, const char *str,
}
log_error(errh, __FILE__, __LINE__,
"getaddrinfo failed: %s '%s'", gai_strerror(r), str);
"getaddrinfo failed: %s '%s'", gai_strerror(rc), str);
return 0;
}
@ -484,15 +484,15 @@ int sock_addr_from_str_hints(sock_addr *saddr, socklen_t *len, const char *str,
#ifdef HAVE_INET_PTON
/*(reuse HAVE_INET_PTON for presence of getaddrinfo())*/
struct addrinfo hints, *res;
int r;
int rc;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (0 != (r = getaddrinfo(str, NULL, &hints, &res))) {
if (0 != (rc = getaddrinfo(str, NULL, &hints, &res))) {
log_error(errh, __FILE__, __LINE__,
"getaddrinfo failed: %s '%s'", gai_strerror(r), str);
"getaddrinfo failed: %s '%s'", gai_strerror(rc), str);
return 0;
}

Loading…
Cancel
Save