diff --git a/cget/main.c b/cget/main.c index ba361970c..dba4e539d 100644 --- a/cget/main.c +++ b/cget/main.c @@ -177,7 +177,8 @@ do_download__has_headers (cherokee_downloader_t *downloader, void *param) /* Check the response */ if (quiet == false) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_init (&tmp); cherokee_http_code_copy (HDR_RESPONSE(hdr), &tmp); print_tuple_str ("Response", tmp.buf); @@ -226,7 +227,7 @@ do_download__read_body (cherokee_downloader_t *downloader, void *param) { ret_t ret; ssize_t len; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; UNUSED(param); @@ -240,6 +241,7 @@ do_download__read_body (cherokee_downloader_t *downloader, void *param) /* Print info */ + cherokee_buffer_init (&tmp); cherokee_buffer_add_fsize (&tmp, downloader->content_length); cherokee_buffer_add_str (&tmp, " of "); cherokee_buffer_add_fsize (&tmp, downloader->info.body_recv); @@ -348,7 +350,7 @@ main (int argc, char **argv) cint_t param_num; cint_t long_index; cherokee_downloader_t *downloader; - cherokee_buffer_t proxy = CHEROKEE_BUF_INIT; + cherokee_buffer_t proxy; cuint_t proxy_port; struct option long_options[] = { @@ -419,49 +421,70 @@ main (int argc, char **argv) return EXIT_OK; } + /* Initialise the buffers + */ + cherokee_buffer_init (&proxy); + /* Tracing and proxy discovering.. */ cherokee_init(); cget_find_proxy (&proxy, &proxy_port); for (val=optind; vallist_subnets); diff --git a/cherokee/admin_server.c b/cherokee/admin_server.c index fa5d35c25..f7263e487 100644 --- a/cherokee/admin_server.c +++ b/cherokee/admin_server.c @@ -212,7 +212,7 @@ cherokee_admin_server_reply_close_conn (cherokee_handler_t *hdl, ret_t ret; char *begin; cherokee_server_t *server = HANDLER_SRV(hdl); - cherokee_buffer_t match = CHEROKEE_BUF_INIT; + cherokee_buffer_t match; cherokee_buffer_fake_str (&match, "del server.connection "); @@ -265,7 +265,7 @@ cherokee_admin_server_reply_set_trace (cherokee_handler_t *hdl, cherokee_buffer_t *question) { ret_t ret; - cherokee_buffer_t match = CHEROKEE_BUF_INIT; + cherokee_buffer_t match; UNUSED (hdl); @@ -421,7 +421,7 @@ cherokee_admin_server_reply_kill_source (cherokee_handler_t *hdl, char id[10]; cherokee_source_t *source = NULL; cherokee_server_t *srv = HANDLER_SRV(hdl); - cherokee_buffer_t match = CHEROKEE_BUF_INIT; + cherokee_buffer_t match; cherokee_buffer_fake_str (&match, "kill server.source "); diff --git a/cherokee/balancer_failover.c b/cherokee/balancer_failover.c index 7b4b853b4..e316b3929 100644 --- a/cherokee/balancer_failover.c +++ b/cherokee/balancer_failover.c @@ -87,7 +87,7 @@ reactivate_entry (cherokee_balancer_failover_t *balancer, /* balancer->mutex is LOCKED */ ret_t ret; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Reactivate */ @@ -95,6 +95,7 @@ reactivate_entry (cherokee_balancer_failover_t *balancer, /* Notify */ + cherokee_buffer_init (&tmp); cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_FAILOVER_REACTIVE, tmp.buf); cherokee_buffer_mrproper (&tmp); @@ -124,10 +125,12 @@ report_fail (cherokee_balancer_failover_t *balancer, ret_t ret; cherokee_list_t *i; cherokee_balancer_entry_t *entry; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; UNUSED(conn); + cherokee_buffer_init (&tmp); + CHEROKEE_MUTEX_LOCK (&balancer->mutex); list_for_each (i, &BAL(balancer)->entries) { @@ -152,9 +155,9 @@ report_fail (cherokee_balancer_failover_t *balancer, */ cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_FAILOVER_DISABLE, tmp.buf); - cherokee_buffer_mrproper (&tmp); CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret_ok; } @@ -163,6 +166,7 @@ report_fail (cherokee_balancer_failover_t *balancer, out: CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret; } diff --git a/cherokee/balancer_ip_hash.c b/cherokee/balancer_ip_hash.c index 8b7ca33bd..d23407cf4 100644 --- a/cherokee/balancer_ip_hash.c +++ b/cherokee/balancer_ip_hash.c @@ -82,7 +82,7 @@ reactivate_entry (cherokee_balancer_ip_hash_t *balancer, { /* balancer->mutex is LOCKED */ - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Disable */ @@ -94,6 +94,7 @@ reactivate_entry (cherokee_balancer_ip_hash_t *balancer, /* Notify */ + cherokee_buffer_init (&tmp); cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_IP_REACTIVE, tmp.buf, balancer->n_active); cherokee_buffer_mrproper (&tmp); @@ -110,10 +111,12 @@ report_fail (cherokee_balancer_ip_hash_t *balancer, ret_t ret; cherokee_list_t *i; cherokee_balancer_entry_t *entry; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; UNUSED(conn); + cherokee_buffer_init (&tmp); + CHEROKEE_MUTEX_LOCK (&balancer->mutex); list_for_each (i, &BAL(balancer)->entries) { @@ -140,9 +143,9 @@ report_fail (cherokee_balancer_ip_hash_t *balancer, */ cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_IP_DISABLE, tmp.buf, balancer->n_active); - cherokee_buffer_mrproper (&tmp); CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret_ok; } @@ -151,6 +154,7 @@ report_fail (cherokee_balancer_ip_hash_t *balancer, out: CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret; } diff --git a/cherokee/balancer_round_robin.c b/cherokee/balancer_round_robin.c index 79b5043b6..431e87cc3 100644 --- a/cherokee/balancer_round_robin.c +++ b/cherokee/balancer_round_robin.c @@ -67,7 +67,7 @@ reactivate_entry (cherokee_balancer_entry_t *entry) { /* balancer->mutex is LOCKED */ - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Disable */ @@ -78,6 +78,7 @@ reactivate_entry (cherokee_balancer_entry_t *entry) /* Notify */ + cherokee_buffer_init (&tmp); cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_ONLINE_SOURCE, tmp.buf); cherokee_buffer_mrproper (&tmp); @@ -141,9 +142,12 @@ report_fail (cherokee_balancer_round_robin_t *balancer, ret_t ret; cherokee_list_t *i; cherokee_balancer_entry_t *entry; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; UNUSED(conn); + + cherokee_buffer_init (&tmp); + CHEROKEE_MUTEX_LOCK (&balancer->mutex); list_for_each (i, &BAL(balancer)->entries) { @@ -168,9 +172,9 @@ report_fail (cherokee_balancer_round_robin_t *balancer, */ cherokee_source_copy_name (entry->source, &tmp); LOG_WARNING (CHEROKEE_ERROR_BALANCER_OFFLINE_SOURCE, tmp.buf); - cherokee_buffer_mrproper (&tmp); CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret_ok; } @@ -179,6 +183,7 @@ report_fail (cherokee_balancer_round_robin_t *balancer, out: CHEROKEE_MUTEX_UNLOCK (&balancer->mutex); + cherokee_buffer_mrproper (&tmp); return ret; } diff --git a/cherokee/bogotime.c b/cherokee/bogotime.c index 3b88b8be7..e95f7144c 100644 --- a/cherokee/bogotime.c +++ b/cherokee/bogotime.c @@ -89,10 +89,17 @@ init_timezone (void) ret_t cherokee_bogotime_init (void) { + ret_t ret; + if (inited) { return ret_ok; } + /* Initialise the buffers */ + cherokee_buffer_init (&cherokee_bogonow_strgmt); + ret = cherokee_buffer_ensure_size (&cherokee_bogonow_strgmt, DTM_SIZE_GMTTM_STR+2); + if (unlikely (ret != ret_ok)) return ret; + /* RW-lock mutex */ CHEROKEE_RWLOCK_INIT (&lock, NULL); @@ -101,9 +108,6 @@ cherokee_bogotime_init (void) INIT_LIST_HEAD (&_callbacks); - cherokee_buffer_init (&cherokee_bogonow_strgmt); - cherokee_buffer_ensure_size (&cherokee_bogonow_strgmt, DTM_SIZE_GMTTM_STR+2); - /* Init time zone */ init_timezone(); diff --git a/cherokee/buffer.c b/cherokee/buffer.c index 41f9621fb..82c56e0b7 100644 --- a/cherokee/buffer.c +++ b/cherokee/buffer.c @@ -54,24 +54,6 @@ CHEROKEE_ADD_FUNC_NEW (buffer); CHEROKEE_ADD_FUNC_FREE (buffer); -ret_t -cherokee_buffer_init (cherokee_buffer_t *buf) -{ - buf->buf = NULL; - buf->len = 0; - buf->size = 0; - - return ret_ok; -} - -void -cherokee_buffer_fake (cherokee_buffer_t *buf, const char *str, cuint_t len) -{ - buf->buf = (char *)str; - buf->len = len; - buf->size = len + 1; -} - ret_t cherokee_buffer_mrproper (cherokee_buffer_t *buf) @@ -87,15 +69,17 @@ cherokee_buffer_mrproper (cherokee_buffer_t *buf) return ret_ok; } -void +ret_t cherokee_buffer_clean (cherokee_buffer_t *buf) { if (buf->buf != NULL) buf->buf[0] = '\0'; buf->len = 0; + + return ret_ok; } -void +ret_t cherokee_buffer_swap_buffers (cherokee_buffer_t *buf, cherokee_buffer_t *second) { char *tmp_buf; @@ -113,6 +97,8 @@ cherokee_buffer_swap_buffers (cherokee_buffer_t *buf, cherokee_buffer_t *second) second->buf = tmp_buf; second->len = tmp_len; second->size = tmp_size; + + return ret_ok; } ret_t @@ -136,7 +122,7 @@ cherokee_buffer_dup (cherokee_buffer_t *buf, cherokee_buffer_t **dup) } -static ret_t +static ret_t must_check realloc_inc_bufsize (cherokee_buffer_t *buf, size_t incsize) { char *pbuf; @@ -154,7 +140,7 @@ realloc_inc_bufsize (cherokee_buffer_t *buf, size_t incsize) } -static ret_t +static ret_t must_check realloc_new_bufsize (cherokee_buffer_t *buf, size_t newsize) { char *pbuf; @@ -654,7 +640,10 @@ cherokee_buffer_add_va_list (cherokee_buffer_t *buf, const char *format, va_list LOG_ERROR (CHEROKEE_ERROR_BUFFER_AVAIL_SIZE, estimation, len, size, format); - cherokee_buffer_ensure_size (buf, buf->len + len + 2); + ret = cherokee_buffer_ensure_size (buf, buf->len + len + 2); + if (unlikely (ret != ret_ok)) + return ret; + size = buf->size - buf->len; len = vsnprintf (buf->buf + buf->len, size, format, args2); @@ -678,6 +667,9 @@ cherokee_buffer_add_va (cherokee_buffer_t *buf, const char *format, ...) va_start (ap, format); ret = cherokee_buffer_add_va_list (buf, format, ap); + if (unlikely (ret != ret_ok)) + return ret; + va_end (ap); return ret; @@ -796,7 +788,7 @@ cherokee_buffer_move_to_begin (cherokee_buffer_t *buf, cuint_t pos) ret_t cherokee_buffer_ensure_addlen (cherokee_buffer_t *buf, size_t addlen) { - if (buf->len + addlen < buf->size) + if ((buf->len + addlen) < buf->size) return ret_ok; return cherokee_buffer_ensure_size (buf, ((size_t)buf->len + addlen + 1)); @@ -1075,7 +1067,8 @@ cherokee_buffer_read_file (cherokee_buffer_t *buf, char *filename) ret_t cherokee_buffer_read_from_fd (cherokee_buffer_t *buf, int fd, size_t size, size_t *ret_size) { - int len; + ret_t ret; + int len; if (fd < 0) return ret_error; @@ -1084,7 +1077,9 @@ cherokee_buffer_read_from_fd (cherokee_buffer_t *buf, int fd, size_t size, size_ * NOTE: usually the caller should have already allocated * enough space for the buffer, so this is a security measure */ - cherokee_buffer_ensure_addlen(buf, size); + ret = cherokee_buffer_ensure_addlen(buf, size); + if (unlikely (ret != ret_ok)) + return ret; /* Read data at the end of the buffer */ @@ -1132,13 +1127,18 @@ cherokee_buffer_read_from_fd (cherokee_buffer_t *buf, int fd, size_t size, size_ ret_t cherokee_buffer_multiply (cherokee_buffer_t *buf, int num) { + ret_t ret; int i, initial_size; initial_size = buf->len; - cherokee_buffer_ensure_size (buf, buf->len * num + 1); + ret = cherokee_buffer_ensure_size (buf, buf->len * num + 1); + if (unlikely (ret != ret_ok)) + return ret; for (i = 1; i < num; i++) { - cherokee_buffer_add (buf, buf->buf, initial_size); + ret = cherokee_buffer_add (buf, buf->buf, initial_size); + if (unlikely (ret != ret_ok)) + return ret; } return ret_ok; @@ -1336,6 +1336,7 @@ escape_with_table (cherokee_buffer_t *buffer, cherokee_buffer_t *src, uint32_t *is_char_escaped) { + ret_t ret; char *t; const char *s,*s_next; char *end; @@ -1369,7 +1370,9 @@ escape_with_table (cherokee_buffer_t *buffer, /* Get the memory */ - cherokee_buffer_ensure_addlen (buffer, src->len + (n_escape * 3)); + ret = cherokee_buffer_ensure_addlen (buffer, src->len + (n_escape * 3)); + if (unlikely (ret != ret_ok)) + return ret; /* Convert it */ @@ -1750,6 +1753,7 @@ cherokee_buffer_encode_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encode ret_t cherokee_buffer_encode_md5_digest (cherokee_buffer_t *buf) { + ret_t ret; int i; struct MD5Context context; unsigned char digest[16]; @@ -1758,7 +1762,9 @@ cherokee_buffer_encode_md5_digest (cherokee_buffer_t *buf) MD5Update (&context, (md5byte *)buf->buf, buf->len); MD5Final (digest, &context); - cherokee_buffer_ensure_size (buf, 34); + ret = cherokee_buffer_ensure_size (buf, 34); + if (unlikely (ret != ret_ok)) + return ret; for (i = 0; i < 16; ++i) { int tmp; @@ -1779,9 +1785,12 @@ cherokee_buffer_encode_md5_digest (cherokee_buffer_t *buf) ret_t cherokee_buffer_encode_md5 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { + ret_t ret; struct MD5Context context; - cherokee_buffer_ensure_size (encoded, 17); + ret = cherokee_buffer_ensure_size (encoded, 17); + if (unlikely (ret != ret_ok)) + return ret; MD5Init (&context); MD5Update (&context, (md5byte *)buf->buf, buf->len); @@ -1801,12 +1810,16 @@ cherokee_buffer_encode_md5 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) ret_t cherokee_buffer_encode_sha1 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { + ret_t ret; SHA_INFO sha1; sha_init (&sha1); sha_update (&sha1, (unsigned char*) buf->buf, buf->len); - cherokee_buffer_ensure_size (encoded, SHA1_DIGEST_SIZE + 1); + ret = cherokee_buffer_ensure_size (encoded, SHA1_DIGEST_SIZE + 1); + if (unlikely (ret != ret_ok)) + return ret; + sha_final (&sha1, (unsigned char *) encoded->buf); encoded->len = SHA1_DIGEST_SIZE; @@ -1819,6 +1832,7 @@ cherokee_buffer_encode_sha1 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) ret_t cherokee_buffer_encode_sha1_digest (cherokee_buffer_t *buf) { + ret_t ret; int i; unsigned char digest[SHA1_DIGEST_SIZE]; SHA_INFO sha1; @@ -1827,7 +1841,9 @@ cherokee_buffer_encode_sha1_digest (cherokee_buffer_t *buf) sha_update (&sha1, (unsigned char*) buf->buf, buf->len); sha_final (&sha1, digest); - cherokee_buffer_ensure_size (buf, (2 * SHA1_DIGEST_SIZE)+1); + ret = cherokee_buffer_ensure_size (buf, (2 * SHA1_DIGEST_SIZE)+1); + if (unlikely (ret != ret_ok)) + return ret; for (i = 0; i < SHA1_DIGEST_SIZE; ++i) { int tmp; @@ -1852,20 +1868,32 @@ cherokee_buffer_encode_sha1_digest (cherokee_buffer_t *buf) ret_t cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { + ret_t ret; + /* Prepare destination buffer */ - cherokee_buffer_ensure_size (encoded, (SHA1_DIGEST_SIZE * 2) + 1); + ret = cherokee_buffer_ensure_size (encoded, (SHA1_DIGEST_SIZE * 2) + 1); + if (unlikely (ret != ret_ok)) + return ret; + cherokee_buffer_clean (encoded); /* Encode sha1 + base64 */ - cherokee_buffer_encode_sha1 (buf, encoded); - cherokee_buffer_encode_base64 (encoded, buf); + ret = cherokee_buffer_encode_sha1 (buf, encoded); + if (unlikely (ret != ret_ok)) + return ret; + + ret = cherokee_buffer_encode_base64 (encoded, buf); + if (unlikely (ret != ret_ok)) + return ret; /* Copy result to destination buffer */ cherokee_buffer_clean (encoded); - cherokee_buffer_add_buffer (encoded, buf); + ret = cherokee_buffer_add_buffer (encoded, buf); + if (unlikely (ret != ret_ok)) + return ret; return ret_ok; } @@ -1874,12 +1902,16 @@ cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *e ret_t cherokee_buffer_encode_sha512 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { + ret_t ret; SHA512_CTX sha512; SHA512_Init (&sha512); SHA512_Update (&sha512, (unsigned char*) buf->buf, buf->len); - cherokee_buffer_ensure_size (encoded, SHA512_DIGEST_LENGTH + 1); + ret = cherokee_buffer_ensure_size (encoded, SHA512_DIGEST_LENGTH + 1); + if (unlikely (ret != ret_ok)) + return ret; + SHA512_Final (&sha512, (unsigned char *) encoded->buf); encoded->len = SHA512_DIGEST_LENGTH; @@ -1892,6 +1924,7 @@ cherokee_buffer_encode_sha512 (cherokee_buffer_t *buf, cherokee_buffer_t *encode ret_t cherokee_buffer_encode_sha512_digest (cherokee_buffer_t *buf) { + ret_t ret; int i; unsigned char digest[SHA512_DIGEST_LENGTH]; SHA512_CTX sha512; @@ -1900,7 +1933,9 @@ cherokee_buffer_encode_sha512_digest (cherokee_buffer_t *buf) SHA512_Update (&sha512, (unsigned char*) buf->buf, buf->len); SHA512_Final (&sha512, digest); - cherokee_buffer_ensure_size (buf, (2 * SHA512_DIGEST_LENGTH)+1); + ret = cherokee_buffer_ensure_size (buf, (2 * SHA512_DIGEST_LENGTH)+1); + if (unlikely (ret != ret_ok)) + return ret; for (i = 0; i < SHA512_DIGEST_LENGTH; ++i) { int tmp; @@ -1922,20 +1957,32 @@ cherokee_buffer_encode_sha512_digest (cherokee_buffer_t *buf) ret_t cherokee_buffer_encode_sha512_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { + ret_t ret; + /* Prepare destination buffer */ - cherokee_buffer_ensure_size (encoded, (SHA512_DIGEST_LENGTH * 2) + 1); + ret = cherokee_buffer_ensure_size (encoded, (SHA512_DIGEST_LENGTH * 2) + 1); + if (unlikely (ret != ret_ok)) + return ret; + cherokee_buffer_clean (encoded); /* Encode sha1 + base64 */ - cherokee_buffer_encode_sha512 (buf, encoded); - cherokee_buffer_encode_base64 (encoded, buf); + ret = cherokee_buffer_encode_sha512 (buf, encoded); + if (unlikely (ret != ret_ok)) + return ret; + + ret = cherokee_buffer_encode_base64 (encoded, buf); + if (unlikely (ret != ret_ok)) + return ret; /* Copy result to destination buffer */ cherokee_buffer_clean (encoded); - cherokee_buffer_add_buffer (encoded, buf); + ret = cherokee_buffer_add_buffer (encoded, buf); + if (unlikely (ret != ret_ok)) + return ret; return ret_ok; } @@ -1948,15 +1995,19 @@ cherokee_buffer_encode_sha512_base64 (cherokee_buffer_t *buf, cherokee_buffer_t ret_t cherokee_buffer_encode_hex (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) { - cuchar_t *in; - cuchar_t *out; + ret_t ret; + cuchar_t *in; + cuchar_t *out; cuint_t j; cuint_t i; cuint_t inlen = buf->len; /* Prepare destination buffer */ - cherokee_buffer_ensure_size (encoded, (inlen * 2 + 1)); + ret = cherokee_buffer_ensure_size (encoded, (inlen * 2 + 1)); + if (unlikely (ret != ret_ok)) + return ret; + cherokee_buffer_clean (encoded); /* Encode source to destination @@ -2191,6 +2242,8 @@ cherokee_buffer_substitute_string (cherokee_buffer_t *bufsrc, /* Preset size of destination buffer. */ ret = cherokee_buffer_ensure_size(bufdst, result_length + 2); + if (unlikely (ret != ret_ok)) + return ret; /* Build the new string */ @@ -2224,6 +2277,7 @@ cherokee_buffer_substitute_string (cherokee_buffer_t *bufsrc, ret_t cherokee_buffer_add_comma_marks (cherokee_buffer_t *buf) { + ret_t ret; cuint_t off, num, i; char *p; @@ -2233,7 +2287,9 @@ cherokee_buffer_add_comma_marks (cherokee_buffer_t *buf) num = buf->len / 3; off = buf->len % 3; - cherokee_buffer_ensure_size (buf, buf->len + num + 2); + ret = cherokee_buffer_ensure_size (buf, buf->len + num + 2); + if (unlikely (ret != ret_ok)) + return ret; if (off == 0) { p = buf->buf + 3; @@ -2312,7 +2368,9 @@ cherokee_buffer_insert (cherokee_buffer_t *buf, size_t txt_len, size_t pos) { - cherokee_buffer_ensure_size (buf, buf->len + txt_len + 1); + ret_t ret = cherokee_buffer_ensure_size (buf, buf->len + txt_len + 1); + if (unlikely (ret != ret_ok)) + return ret; /* Make room */ memmove (buf->buf + pos + txt_len, @@ -2383,10 +2441,15 @@ cherokee_buffer_split_lines (cherokee_buffer_t *buf, /* Line just split */ if (indent) { + ret_t ret; int offset = p - buf->buf; - cherokee_buffer_insert (buf, (char *)indent, indent_len, - (latest_newline - buf->buf)+1); + ret = cherokee_buffer_insert (buf, (char *)indent, indent_len, + (latest_newline - buf->buf)+1); + + if (unlikely (ret != ret_ok)) { + return ret; + } since_prev += indent_len; p = buf->buf + offset + indent_len; diff --git a/cherokee/buffer.h b/cherokee/buffer.h index c468901a0..a2cb9c493 100644 --- a/cherokee/buffer.h +++ b/cherokee/buffer.h @@ -38,6 +38,8 @@ CHEROKEE_BEGIN_DECLS +#define dont_check +#define should_chk typedef struct { char *buf; /**< Memory chunk */ @@ -45,8 +47,30 @@ typedef struct { cuint_t len; /**< Length of the string */ } cherokee_buffer_t; +/* Placing the functions here allows the compiler to inline + * the code without the use of link-time optimisation #1081 + */ +static inline ret_t dont_check +cherokee_buffer_init (cherokee_buffer_t *buf) +{ + buf->buf = NULL; + buf->len = 0; + buf->size = 0; + + return ret_ok; +} + +static inline ret_t dont_check +cherokee_buffer_fake (cherokee_buffer_t *buf, const char *str, cuint_t len) +{ + buf->buf = (char *)str; + buf->len = len; + buf->size = len + 1; + + return ret_ok; +} + #define BUF(x) ((cherokee_buffer_t *)(x)) -#define CHEROKEE_BUF_INIT {NULL, 0, 0} #define CHEROKEE_BUF_SLIDE_NONE INT_MIN #define cherokee_buffer_is_empty(b) (BUF(b)->len == 0) @@ -57,88 +81,87 @@ typedef struct { #define cherokee_buffer_case_cmp_str(b,s) cherokee_buffer_case_cmp (b, (char *)(s), sizeof(s)-1) #define cherokee_buffer_fake_str(b,s) cherokee_buffer_fake (b, s, sizeof(s)-1) -ret_t cherokee_buffer_new (cherokee_buffer_t **buf); -ret_t cherokee_buffer_free (cherokee_buffer_t *buf); -ret_t cherokee_buffer_init (cherokee_buffer_t *buf); -ret_t cherokee_buffer_mrproper (cherokee_buffer_t *buf); -void cherokee_buffer_fake (cherokee_buffer_t *buf, const char *str, cuint_t len); - -void cherokee_buffer_clean (cherokee_buffer_t *buf); -ret_t cherokee_buffer_dup (cherokee_buffer_t *buf, cherokee_buffer_t **dup); -void cherokee_buffer_swap_buffers (cherokee_buffer_t *buf, cherokee_buffer_t *second); - -ret_t cherokee_buffer_add (cherokee_buffer_t *buf, const char *txt, size_t size); -ret_t cherokee_buffer_add_long10 (cherokee_buffer_t *buf, clong_t lNum); -ret_t cherokee_buffer_add_llong10 (cherokee_buffer_t *buf, cllong_t lNum); -ret_t cherokee_buffer_add_ulong10 (cherokee_buffer_t *buf, culong_t ulNum); -ret_t cherokee_buffer_add_ullong10 (cherokee_buffer_t *buf, cullong_t ulNum); -ret_t cherokee_buffer_add_ulong16 (cherokee_buffer_t *buf, culong_t ulNum); -ret_t cherokee_buffer_add_ullong16 (cherokee_buffer_t *buf, cullong_t ulNum); -ret_t cherokee_buffer_add_va (cherokee_buffer_t *buf, const char *format, ...); -ret_t cherokee_buffer_add_va_fixed (cherokee_buffer_t *buf, const char *format, ...); -ret_t cherokee_buffer_add_va_list (cherokee_buffer_t *buf, const char *format, va_list args); -ret_t cherokee_buffer_add_char (cherokee_buffer_t *buf, char c); -ret_t cherokee_buffer_add_char_n (cherokee_buffer_t *buf, char c, int n); -ret_t cherokee_buffer_add_buffer (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); -ret_t cherokee_buffer_add_buffer_slice (cherokee_buffer_t *buf, cherokee_buffer_t *buf2, ssize_t begin, ssize_t end); -ret_t cherokee_buffer_add_fsize (cherokee_buffer_t *buf, CST_OFFSET size); -ret_t cherokee_buffer_prepend (cherokee_buffer_t *buf, const char *txt, size_t size); - -cint_t cherokee_buffer_cmp (cherokee_buffer_t *buf, char *txt, cuint_t txt_len); -cint_t cherokee_buffer_cmp_buf (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); -cint_t cherokee_buffer_case_cmp (cherokee_buffer_t *buf, char *txt, cuint_t txt_len); -cint_t cherokee_buffer_case_cmp_buf (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); - -ret_t cherokee_buffer_read_file (cherokee_buffer_t *buf, char *filename); -ret_t cherokee_buffer_read_from_fd (cherokee_buffer_t *buf, int fd, size_t size, size_t *ret_size); - -ret_t cherokee_buffer_move_to_begin (cherokee_buffer_t *buf, cuint_t pos); -ret_t cherokee_buffer_drop_ending (cherokee_buffer_t *buf, cuint_t num_chars); -ret_t cherokee_buffer_multiply (cherokee_buffer_t *buf, int num); -ret_t cherokee_buffer_swap_chars (cherokee_buffer_t *buf, char a, char b); -ret_t cherokee_buffer_remove_dups (cherokee_buffer_t *buf, char c); -ret_t cherokee_buffer_remove_string (cherokee_buffer_t *buf, char *string, int string_len); -ret_t cherokee_buffer_remove_chunk (cherokee_buffer_t *buf, cuint_t from, cuint_t len); -ret_t cherokee_buffer_replace_string (cherokee_buffer_t *buf, const char *subs, int subs_len, const char *repl, int repl_len); -ret_t cherokee_buffer_substitute_string (cherokee_buffer_t *bufsrc, cherokee_buffer_t *bufdst, char *subs, int subs_len, char *repl, int repl_len); -ret_t cherokee_buffer_trim (cherokee_buffer_t *buf); -ret_t cherokee_buffer_insert (cherokee_buffer_t *buf, char *txt, size_t txt_len, size_t pos); -ret_t cherokee_buffer_insert_buffer (cherokee_buffer_t *buf, cherokee_buffer_t *src, size_t pos); - -ret_t cherokee_buffer_get_utf8_len (cherokee_buffer_t *buf, cuint_t *len); -ret_t cherokee_buffer_ensure_addlen (cherokee_buffer_t *buf, size_t alen); -ret_t cherokee_buffer_ensure_size (cherokee_buffer_t *buf, size_t size); - -int cherokee_buffer_is_ending (cherokee_buffer_t *buf, char c); -char cherokee_buffer_end_char (cherokee_buffer_t *buf); -size_t cherokee_buffer_cnt_spn (cherokee_buffer_t *buf, cuint_t offset, const char *str); -size_t cherokee_buffer_cnt_cspn (cherokee_buffer_t *buf, cuint_t offset, const char *str); - -crc_t cherokee_buffer_crc32 (cherokee_buffer_t *buf); -ret_t cherokee_buffer_encode_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_decode_base64 (cherokee_buffer_t *buf); -ret_t cherokee_buffer_encode_md5 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_encode_md5_digest (cherokee_buffer_t *buf); -ret_t cherokee_buffer_encode_sha1 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_encode_sha1_digest (cherokee_buffer_t *buf); -ret_t cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_encode_sha512 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_encode_sha512_digest (cherokee_buffer_t *buf); -ret_t cherokee_buffer_encode_sha512_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_encode_hex (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); -ret_t cherokee_buffer_decode_hex (cherokee_buffer_t *buf); -ret_t cherokee_buffer_unescape_uri (cherokee_buffer_t *buf); -ret_t cherokee_buffer_escape_uri (cherokee_buffer_t *buf, cherokee_buffer_t *src); -ret_t cherokee_buffer_escape_uri_delims (cherokee_buffer_t *buf, cherokee_buffer_t *src); -ret_t cherokee_buffer_escape_arg (cherokee_buffer_t *buf, cherokee_buffer_t *src); -ret_t cherokee_buffer_add_escape_html (cherokee_buffer_t *buf, cherokee_buffer_t *src); -ret_t cherokee_buffer_escape_html (cherokee_buffer_t *buf, cherokee_buffer_t *src); -ret_t cherokee_buffer_add_comma_marks (cherokee_buffer_t *buf); - -ret_t cherokee_buffer_to_lowcase (cherokee_buffer_t *buf); -ret_t cherokee_buffer_split_lines (cherokee_buffer_t *buf, int columns, const char *indent); - -ret_t cherokee_buffer_print_debug (cherokee_buffer_t *buf, int length); +ret_t must_check cherokee_buffer_new (cherokee_buffer_t **buf); +ret_t dont_check cherokee_buffer_free (cherokee_buffer_t *buf); +ret_t dont_check cherokee_buffer_init (cherokee_buffer_t *buf); +ret_t dont_check cherokee_buffer_mrproper (cherokee_buffer_t *buf); + +ret_t dont_check cherokee_buffer_clean (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_dup (cherokee_buffer_t *buf, cherokee_buffer_t **dup); +ret_t dont_check cherokee_buffer_swap_buffers (cherokee_buffer_t *buf, cherokee_buffer_t *second); + +ret_t should_chk cherokee_buffer_add (cherokee_buffer_t *buf, const char *txt, size_t size); +ret_t should_chk cherokee_buffer_add_long10 (cherokee_buffer_t *buf, clong_t lNum); +ret_t should_chk cherokee_buffer_add_llong10 (cherokee_buffer_t *buf, cllong_t lNum); +ret_t should_chk cherokee_buffer_add_ulong10 (cherokee_buffer_t *buf, culong_t ulNum); +ret_t should_chk cherokee_buffer_add_ullong10 (cherokee_buffer_t *buf, cullong_t ulNum); +ret_t must_check cherokee_buffer_add_ulong16 (cherokee_buffer_t *buf, culong_t ulNum); +ret_t should_chk cherokee_buffer_add_ullong16 (cherokee_buffer_t *buf, cullong_t ulNum); +ret_t should_chk cherokee_buffer_add_va (cherokee_buffer_t *buf, const char *format, ...); +ret_t must_check cherokee_buffer_add_va_fixed (cherokee_buffer_t *buf, const char *format, ...); +ret_t should_chk cherokee_buffer_add_va_list (cherokee_buffer_t *buf, const char *format, va_list args); +ret_t should_chk cherokee_buffer_add_char (cherokee_buffer_t *buf, char c); +ret_t must_check cherokee_buffer_add_char_n (cherokee_buffer_t *buf, char c, int n); +ret_t should_chk cherokee_buffer_add_buffer (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); +ret_t must_check cherokee_buffer_add_buffer_slice (cherokee_buffer_t *buf, cherokee_buffer_t *buf2, ssize_t begin, ssize_t end); +ret_t should_chk cherokee_buffer_add_fsize (cherokee_buffer_t *buf, CST_OFFSET size); +ret_t must_check cherokee_buffer_prepend (cherokee_buffer_t *buf, const char *txt, size_t size); + +cint_t must_check cherokee_buffer_cmp (cherokee_buffer_t *buf, char *txt, cuint_t txt_len); +cint_t must_check cherokee_buffer_cmp_buf (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); +cint_t must_check cherokee_buffer_case_cmp (cherokee_buffer_t *buf, char *txt, cuint_t txt_len); +cint_t must_check cherokee_buffer_case_cmp_buf (cherokee_buffer_t *buf, cherokee_buffer_t *buf2); + +ret_t must_check cherokee_buffer_read_file (cherokee_buffer_t *buf, char *filename); +ret_t must_check cherokee_buffer_read_from_fd (cherokee_buffer_t *buf, int fd, size_t size, size_t *ret_size); + +ret_t dont_check cherokee_buffer_move_to_begin (cherokee_buffer_t *buf, cuint_t pos); +ret_t dont_check cherokee_buffer_drop_ending (cherokee_buffer_t *buf, cuint_t num_chars); +ret_t must_check cherokee_buffer_multiply (cherokee_buffer_t *buf, int num); +ret_t dont_check cherokee_buffer_swap_chars (cherokee_buffer_t *buf, char a, char b); +ret_t dont_check cherokee_buffer_remove_dups (cherokee_buffer_t *buf, char c); +ret_t dont_check cherokee_buffer_remove_string (cherokee_buffer_t *buf, char *string, int string_len); +ret_t dont_check cherokee_buffer_remove_chunk (cherokee_buffer_t *buf, cuint_t from, cuint_t len); +ret_t must_check cherokee_buffer_replace_string (cherokee_buffer_t *buf, const char *subs, int subs_len, const char *repl, int repl_len); +ret_t must_check cherokee_buffer_substitute_string (cherokee_buffer_t *bufsrc, cherokee_buffer_t *bufdst, char *subs, int subs_len, char *repl, int repl_len); +ret_t dont_check cherokee_buffer_trim (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_insert (cherokee_buffer_t *buf, char *txt, size_t txt_len, size_t pos); +ret_t must_check cherokee_buffer_insert_buffer (cherokee_buffer_t *buf, cherokee_buffer_t *src, size_t pos); + +ret_t dont_check cherokee_buffer_get_utf8_len (cherokee_buffer_t *buf, cuint_t *len); +ret_t must_check cherokee_buffer_ensure_addlen (cherokee_buffer_t *buf, size_t alen); +ret_t must_check cherokee_buffer_ensure_size (cherokee_buffer_t *buf, size_t size); + +int must_check cherokee_buffer_is_ending (cherokee_buffer_t *buf, char c); +char must_check cherokee_buffer_end_char (cherokee_buffer_t *buf); +size_t must_check cherokee_buffer_cnt_spn (cherokee_buffer_t *buf, cuint_t offset, const char *str); +size_t must_check cherokee_buffer_cnt_cspn (cherokee_buffer_t *buf, cuint_t offset, const char *str); + +crc_t must_check cherokee_buffer_crc32 (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_encode_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t dont_check cherokee_buffer_decode_base64 (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_encode_md5 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t must_check cherokee_buffer_encode_md5_digest (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_encode_sha1 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t must_check cherokee_buffer_encode_sha1_digest (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t must_check cherokee_buffer_encode_sha512 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t must_check cherokee_buffer_encode_sha512_digest (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_encode_sha512_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t must_check cherokee_buffer_encode_hex (cherokee_buffer_t *buf, cherokee_buffer_t *encoded); +ret_t dont_check cherokee_buffer_decode_hex (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_unescape_uri (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_escape_uri (cherokee_buffer_t *buf, cherokee_buffer_t *src); +ret_t must_check cherokee_buffer_escape_uri_delims (cherokee_buffer_t *buf, cherokee_buffer_t *src); +ret_t must_check cherokee_buffer_escape_arg (cherokee_buffer_t *buf, cherokee_buffer_t *src); +ret_t must_check cherokee_buffer_add_escape_html (cherokee_buffer_t *buf, cherokee_buffer_t *src); +ret_t must_check cherokee_buffer_escape_html (cherokee_buffer_t *buf, cherokee_buffer_t *src); +ret_t must_check cherokee_buffer_add_comma_marks (cherokee_buffer_t *buf); + +ret_t dont_check cherokee_buffer_to_lowcase (cherokee_buffer_t *buf); +ret_t must_check cherokee_buffer_split_lines (cherokee_buffer_t *buf, int columns, const char *indent); + +ret_t dont_check cherokee_buffer_print_debug (cherokee_buffer_t *buf, int length); CHEROKEE_END_DECLS diff --git a/cherokee/cache.c b/cherokee/cache.c index 417995871..109aa6647 100644 --- a/cherokee/cache.c +++ b/cherokee/cache.c @@ -571,8 +571,9 @@ cherokee_cache_get (cherokee_cache_t *cache, #ifdef TRACE_ENABLED if (cache->count % 100 == 0) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_init (&tmp); cherokee_cache_get_stats (cache, &tmp); TRACE(ENTRIES, "Cache stats:\n%s", tmp.buf); cherokee_buffer_mrproper (&tmp); diff --git a/cherokee/collector_rrd.c b/cherokee/collector_rrd.c index 50071ea1a..4ab5e7093 100644 --- a/cherokee/collector_rrd.c +++ b/cherokee/collector_rrd.c @@ -222,7 +222,8 @@ vsrv_init (cherokee_collector_vsrv_rrd_t *rrd, cherokee_buffer_add_str (&rrd->path_database, "/vserver_"); cherokee_buffer_add_buffer (&rrd->path_database, &vsrv->name); cherokee_buffer_add_str (&rrd->path_database, ".rrd"); - cherokee_buffer_replace_string (&rrd->path_database, " ", 1, "_", 1); + ret = cherokee_buffer_replace_string (&rrd->path_database, " ", 1, "_", 1); + if (unlikely (ret != ret_ok)) return ret; /* Check whether the DB exists */ diff --git a/cherokee/config_node.c b/cherokee/config_node.c index 392bb96d7..b9b311c75 100644 --- a/cherokee/config_node.c +++ b/cherokee/config_node.c @@ -102,12 +102,17 @@ add_new_child (cherokee_config_node_t *entry, cherokee_buffer_t *key) ret_t cherokee_config_node_add (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t *val) { + ret_t ret; char *sep; cherokee_config_node_t *child; cherokee_config_node_t *current = conf; const char *begin = key; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; cherokee_boolean_t final = false; + cherokee_buffer_t tmp; + + /* Initialise buffers + */ + cherokee_buffer_init (&tmp); /* 'include' is a special case */ @@ -133,7 +138,10 @@ cherokee_config_node_add (cherokee_config_node_t *conf, const char *key, cheroke child = search_child (current, &tmp); if (child == NULL) { child = add_new_child (current, &tmp); - if (child == NULL) return ret_error; + if (child == NULL) { + cherokee_buffer_mrproper (&tmp); + return ret_error; + } } if (final) { @@ -169,8 +177,10 @@ cherokee_config_node_get (cherokee_config_node_t *conf, const char *key, cheroke cherokee_config_node_t *child; cherokee_config_node_t *current = conf; const char *begin = key; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; cherokee_boolean_t final = false; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); do { /* Extract current child @@ -408,7 +418,11 @@ cherokee_config_node_read_list (cherokee_config_node_t *conf, static ret_t convert_to_list_step (char *entry, void *data) { - CHEROKEE_NEW(buf, buffer); + ret_t ret; + cherokee_buffer_t *buf; + + ret = cherokee_buffer_new (&buf); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add (buf, entry, strlen(entry)); return cherokee_list_add_tail_content (LIST(data), buf); diff --git a/cherokee/config_reader.c b/cherokee/config_reader.c index d8b35a964..15641f458 100644 --- a/cherokee/config_reader.c +++ b/cherokee/config_reader.c @@ -37,7 +37,9 @@ static ret_t do_parse_file (cherokee_config_node_t *conf, const char *file) { ret_t ret; - cherokee_buffer_t buf = CHEROKEE_BUF_INIT; + cherokee_buffer_t buf; + + cherokee_buffer_init (&buf); ret = cherokee_buffer_read_file (&buf, (char *)file); if (ret != ret_ok) goto error; @@ -79,7 +81,7 @@ do_include (cherokee_config_node_t *conf, cherokee_buffer_t *path) while ((entry = readdir(dir)) != NULL) { ret_t ret; - cherokee_buffer_t full_new = CHEROKEE_BUF_INIT; + cherokee_buffer_t full_new; /* Ignore backup files */ @@ -95,6 +97,7 @@ do_include (cherokee_config_node_t *conf, cherokee_buffer_t *path) continue; } + cherokee_buffer_init (&full_new); ret = cherokee_buffer_add_va (&full_new, "%s/%s", path->buf, entry->d_name); if (unlikely (ret != ret_ok)) { cherokee_buffer_mrproper (&full_new); @@ -208,8 +211,13 @@ cherokee_config_reader_parse_string (cherokee_config_node_t *conf, cherokee_buff char *equal; char *tmp; char *eof; - cherokee_buffer_t key = CHEROKEE_BUF_INIT; - cherokee_buffer_t val = CHEROKEE_BUF_INIT; + cherokee_buffer_t key; + cherokee_buffer_t val; + + /* Initialise buffers + */ + cherokee_buffer_init (&key); + cherokee_buffer_init (&val); eof = buf->buf + buf->len; diff --git a/cherokee/connection-protected.h b/cherokee/connection-protected.h index 855c1322b..8f3aa9f3e 100644 --- a/cherokee/connection-protected.h +++ b/cherokee/connection-protected.h @@ -225,6 +225,7 @@ struct cherokee_connection { cherokee_boolean_t chunked_encoding; cherokee_boolean_t chunked_last_package; cherokee_buffer_t chunked_len; + char chunked_len_buf[13]; size_t chunked_sent; struct iovec chunks[3]; uint16_t chunksn; @@ -299,7 +300,7 @@ ret_t cherokee_connection_step (cherokee_connection_t *conn); /* Headers */ ret_t cherokee_connection_read_post (cherokee_connection_t *conn); -ret_t cherokee_connection_build_header (cherokee_connection_t *conn); +ret_t must_check cherokee_connection_build_header (cherokee_connection_t *conn); ret_t cherokee_connection_get_request (cherokee_connection_t *conn); ret_t cherokee_connection_parse_range (cherokee_connection_t *conn); int cherokee_connection_is_userdir (cherokee_connection_t *conn); diff --git a/cherokee/connection.c b/cherokee/connection.c index bd05b08ed..58cb86cba 100644 --- a/cherokee/connection.c +++ b/cherokee/connection.c @@ -422,7 +422,6 @@ ret_t cherokee_connection_setup_error_handler (cherokee_connection_t *conn) { ret_t ret; - cherokee_server_t *srv; cherokee_virtual_server_t *vsrv; cherokee_config_entry_t *entry; @@ -431,7 +430,6 @@ cherokee_connection_setup_error_handler (cherokee_connection_t *conn) * call continue (becase conn->error_code might have changed). */ - srv = CONN_SRV(conn); vsrv = CONN_VSRV(conn); entry = vsrv->error_handler; @@ -615,7 +613,7 @@ cherokee_connection_setup_hsts_handler (cherokee_connection_t *conn) } -static void +static ret_t must_check build_response_header_authentication (cherokee_connection_t *conn, cherokee_buffer_t *buffer) { ret_t ret; @@ -651,6 +649,7 @@ build_response_header_authentication (cherokee_connection_t *conn, cherokee_buff if ((conn->validator != NULL) && (! cherokee_buffer_is_empty (&conn->validator->nonce))) { + /* can be found or not */ ret = cherokee_nonce_table_check (CONN_SRV(conn)->nonces, &conn->validator->nonce); } @@ -658,7 +657,8 @@ build_response_header_authentication (cherokee_connection_t *conn, cherokee_buff cherokee_buffer_add_str (buffer, "nonce=\""); if (ret != ret_ok) { cherokee_buffer_clean (new_nonce); - cherokee_nonce_table_generate (CONN_SRV(conn)->nonces, conn, new_nonce); + ret = cherokee_nonce_table_generate (CONN_SRV(conn)->nonces, conn, new_nonce); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add_buffer (buffer, new_nonce); } else { cherokee_buffer_add_buffer (buffer, &conn->validator->nonce); @@ -671,6 +671,8 @@ build_response_header_authentication (cherokee_connection_t *conn, cherokee_buff */ cherokee_buffer_add_str (buffer, "qop=\"auth\", algorithm=\"MD5\""CRLF); } + + return ret_ok; } @@ -789,10 +791,11 @@ cherokee_connection_add_expiration_header (cherokee_connection_t *conn, } -static void +static ret_t must_check build_response_header (cherokee_connection_t *conn, cherokee_buffer_t *buffer) { + ret_t ret; cherokee_buffer_t *tmp1 = THREAD_TMP_BUF1(CONN_THREAD(conn)); /* Build the response header. @@ -848,7 +851,7 @@ build_response_header (cherokee_connection_t *conn, */ if ((conn->handler != NULL) && (HANDLER_SUPPORTS (conn->handler, hsupport_full_headers))) - return; + return ret_ok; /* Date */ @@ -868,7 +871,8 @@ build_response_header (cherokee_connection_t *conn, if ((conn->error_code == http_unauthorized) || (conn->error_internal_code == http_unauthorized)) { - build_response_header_authentication (conn, buffer); + ret = build_response_header_authentication (conn, buffer); + if (unlikely (ret != ret_ok)) return ret; } } @@ -911,6 +915,8 @@ build_response_header (cherokee_connection_t *conn, cherokee_buffer_add_str (buffer, CRLF); } + + return ret_ok; } @@ -1020,7 +1026,8 @@ cherokee_connection_build_header (cherokee_connection_t *conn) out: /* Add the server headers (phase 1) */ - build_response_header (conn, &conn->buffer); + ret = build_response_header (conn, &conn->buffer); + if (unlikely (ret != ret_ok)) return ret; /* Add handler headers */ @@ -1289,11 +1296,15 @@ cherokee_connection_send (cherokee_connection_t *conn) (conn->socket.is_tls == TLS)) { if (! (conn->options & conn_op_chunked_formatted)) { - cherokee_buffer_prepend_buf (&conn->buffer, &conn->chunked_len); - cherokee_buffer_add_str (&conn->buffer, CRLF); + ret = cherokee_buffer_prepend_buf (&conn->buffer, &conn->chunked_len); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add_str (&conn->buffer, CRLF); + if (unlikely (ret != ret_ok)) return ret; if (conn->chunked_last_package) { - cherokee_buffer_add_str (&conn->buffer, "0" CRLF CRLF); + ret = cherokee_buffer_add_str (&conn->buffer, "0" CRLF CRLF); + if (unlikely (ret != ret_ok)) return ret; } BIT_SET (conn->options, conn_op_chunked_formatted); @@ -1682,9 +1693,14 @@ cherokee_connection_step (cherokee_connection_t *conn) * len(str(hex(4294967295))+"\r\n\0") = 13 */ cherokee_buffer_clean (&conn->chunked_len); - cherokee_buffer_ensure_size (&conn->chunked_len, 13); - cherokee_buffer_add_ulong16 (&conn->chunked_len, conn->buffer.len); - cherokee_buffer_add_str (&conn->chunked_len, CRLF); + ret = cherokee_buffer_ensure_size (&conn->chunked_len, 13); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add_ulong16 (&conn->chunked_len, conn->buffer.len); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add_str (&conn->chunked_len, CRLF); + if (unlikely (ret != ret_ok)) return ret; conn->chunked_sent = 0; } @@ -2664,6 +2680,8 @@ cherokee_connection_parse_args (cherokee_connection_t *conn) ret_t cherokee_connection_open_request (cherokee_connection_t *conn) { + ret_t ret; + TRACE (ENTRIES, "web_directory='%s' request='%s' local_directory='%s'\n", conn->web_directory.buf, conn->request.buf, @@ -2671,8 +2689,11 @@ cherokee_connection_open_request (cherokee_connection_t *conn) /* Ensure the space for headers and I/O buffer */ - cherokee_buffer_ensure_size (&conn->header_buffer, 384); - cherokee_buffer_ensure_size (&conn->buffer, DEFAULT_READ_SIZE+1); + ret = cherokee_buffer_ensure_size (&conn->header_buffer, 384); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_ensure_size (&conn->buffer, DEFAULT_READ_SIZE+1); + if (unlikely (ret != ret_ok)) return ret; /* Init the connection handler object */ @@ -2722,6 +2743,8 @@ cherokee_connection_update_vhost_traffic (cherokee_connection_t *conn) ret_t cherokee_connection_clean_for_respin (cherokee_connection_t *conn) { + ret_t ret; + TRACE(ENTRIES, "Clean for respin: conn=%p\n", conn); conn->respins += 1; @@ -2732,7 +2755,9 @@ cherokee_connection_clean_for_respin (cherokee_connection_t *conn) } if (cherokee_connection_use_webdir(conn)) { - cherokee_buffer_prepend_buf (&conn->request, &conn->web_directory); + ret = cherokee_buffer_prepend_buf (&conn->request, &conn->web_directory); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_clean (&conn->local_directory); BIT_UNSET (conn->options, conn_op_document_root); } @@ -2919,6 +2944,7 @@ cherokee_connection_get_phase_str (cherokee_connection_t *conn) ret_t cherokee_connection_set_redirect (cherokee_connection_t *conn, cherokee_buffer_t *address) { + ret_t ret; cuint_t len; /* Build the redirection address @@ -2932,7 +2958,8 @@ cherokee_connection_set_redirect (cherokee_connection_t *conn, cherokee_buffer_t sizeof(":65535") + sizeof("https://") + 4; - cherokee_buffer_ensure_size (&conn->redirect, len); + ret = cherokee_buffer_ensure_size (&conn->redirect, len); + if (unlikely (ret != ret_ok)) return ret; if (! cherokee_buffer_is_empty (&conn->host)) { if (conn->socket.is_tls == TLS) diff --git a/cherokee/connection_info.c b/cherokee/connection_info.c index aaeafba5c..b7dacab89 100644 --- a/cherokee/connection_info.c +++ b/cherokee/connection_info.c @@ -94,7 +94,9 @@ info_fill_up (cherokee_connection_info_t *info, /* From */ if (conn->socket.socket >= 0) { - cherokee_buffer_ensure_size (&info->ip, CHE_INET_ADDRSTRLEN + 1); + ret = cherokee_buffer_ensure_size (&info->ip, CHE_INET_ADDRSTRLEN + 1); + if (unlikely (ret != ret_ok)) return ret; + memset (info->ip.buf, 0, info->ip.size); cherokee_socket_ntop (&conn->socket, info->ip.buf, info->ip.size - 1); info->ip.len = strlen(info->ip.buf); @@ -151,8 +153,9 @@ info_fill_up (cherokee_connection_info_t *info, { char *tmp; cherokee_buffer_t *icon; - cherokee_buffer_t name = CHEROKEE_BUF_INIT; + cherokee_buffer_t name; + cherokee_buffer_init (&name); cherokee_buffer_add_buffer (&name, &info->request); tmp = strchr (name.buf, '?'); @@ -210,6 +213,7 @@ cherokee_connection_info_list_thread (cherokee_list_t *list, if (unlikely (ret != ret_ok)) goto out; info_fill_up (n, CONN(i)); + if (unlikely (ret != ret_ok)) goto out; cherokee_list_add (LIST(n), list); } @@ -220,6 +224,7 @@ cherokee_connection_info_list_thread (cherokee_list_t *list, if (unlikely (ret != ret_ok)) goto out; info_fill_up (n, CONN(i)); + if (unlikely (ret != ret_ok)) goto out; cherokee_list_add (LIST(n), list); } diff --git a/cherokee/cryptor_libssl.c b/cherokee/cryptor_libssl.c index 9d14d72f0..b50910b91 100644 --- a/cherokee/cryptor_libssl.c +++ b/cherokee/cryptor_libssl.c @@ -113,8 +113,9 @@ try_read_dh_param(cherokee_config_node_t *conf, ret_t ret; cherokee_buffer_t *buf; FILE *paramfile = NULL; - cherokee_buffer_t confentry = CHEROKEE_BUF_INIT; + cherokee_buffer_t confentry; + cherokee_buffer_init (&confentry); cherokee_buffer_add_va (&confentry, "dh_param%d", bitsize); /* Read the configuration parameter @@ -632,7 +633,7 @@ socket_initialize (cherokee_cryptor_socket_libssl_t *cryp, cherokee_cryptor_vserver_libssl_t *vsrv_crytor = CRYPTOR_VSRV_SSL(vserver->cryptor); #ifdef OPENSSL_NO_TLSEXT - cherokee_buffer_t servername = CHEROKEE_BUF_INIT; + cherokee_buffer_t servername; #endif /* Set the virtual server object reference @@ -679,6 +680,7 @@ socket_initialize (cherokee_cryptor_socket_libssl_t *cryp, #else /* Attempt to determine the vserver without SNI. */ + cherokee_buffer_init (&servername); cherokee_buffer_ensure_size(&servername, 40); cherokee_socket_ntop (&conn->socket, servername.buf, servername.size); cherokee_cryptor_libssl_find_vserver (cryp->session, CONN_SRV(conn), &servername, conn); diff --git a/cherokee/downloader.c b/cherokee/downloader.c index 36c67338f..f4c3b758b 100644 --- a/cherokee/downloader.c +++ b/cherokee/downloader.c @@ -56,14 +56,11 @@ cherokee_downloader_init (cherokee_downloader_t *n) ret = cherokee_request_header_init (&n->request); if (unlikely(ret != ret_ok)) return ret; - ret = cherokee_buffer_init (&n->request_header); - if (unlikely(ret != ret_ok)) return ret; + cherokee_buffer_init (&n->request_header); - ret = cherokee_buffer_init (&n->reply_header); - if (unlikely(ret != ret_ok)) return ret; + cherokee_buffer_init (&n->reply_header); - ret = cherokee_buffer_init (&n->body); - if (unlikely(ret != ret_ok)) return ret; + cherokee_buffer_init (&n->body); ret = cherokee_socket_init (&n->socket); if (unlikely(ret != ret_ok)) return ret; @@ -488,14 +485,14 @@ cherokee_downloader_step (cherokee_downloader_t *downloader, /* Build the request header */ ret = cherokee_request_header_build_string (req, &downloader->request_header, tmp1, tmp2); - if (unlikely(ret < ret_ok)) + if (unlikely(ret != ret_ok)) return ret; /* Deal with the connection */ if (! is_connected (downloader)) { ret = cherokee_downloader_connect (downloader); - if (ret < ret_ok) return ret; + if (ret != ret_ok) return ret; } /* Everything is ok, go ahead! diff --git a/cherokee/dwriter.c b/cherokee/dwriter.c index 8815cfc95..e85db72bb 100644 --- a/cherokee/dwriter.c +++ b/cherokee/dwriter.c @@ -132,10 +132,12 @@ escape_string (cherokee_buffer_t *buffer, const char *s, cuint_t len) { + ret_t ret; char c; cuint_t i, j; - cherokee_buffer_ensure_size (buffer, len*2); + ret = cherokee_buffer_ensure_size (buffer, len*2); + if (unlikely (ret != ret_ok)) return ret; for (i=0,j=0; idescription, ap_tmp); - cherokee_buffer_add_escape_html (output, &tmp); + ret = cherokee_buffer_add_escape_html (output, &tmp); + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_add_str (output, "\", "); /* ARGS: Skip 'description' */ @@ -194,7 +199,8 @@ render_python_error (cherokee_error_type_t type, cherokee_buffer_clean (&tmp); cherokee_buffer_add_str (output, "'debug': \""); cherokee_buffer_add_va_list (&tmp, error->debug, ap_tmp); - cherokee_buffer_add_escape_html (output, &tmp); + ret = cherokee_buffer_add_escape_html (output, &tmp); + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_add_str (output, "\", "); /* ARGS: Skip 'debug' */ @@ -213,7 +219,8 @@ render_python_error (cherokee_error_type_t type, cherokee_buffer_add_str (output, "'configure_args': \""); cherokee_buffer_clean (&tmp); cherokee_buffer_add_str (&tmp, CHEROKEE_CONFIG_ARGS); - cherokee_buffer_add_escape_html (output, &tmp); + ret = cherokee_buffer_add_escape_html (output, &tmp); + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_add_buffer (output, &tmp); cherokee_buffer_add_str (output, "\", "); @@ -223,7 +230,8 @@ render_python_error (cherokee_error_type_t type, #ifdef BACKTRACES_ENABLED cherokee_buffer_clean (&tmp); cherokee_buf_add_backtrace (&tmp, 2, "\\n", ""); - cherokee_buffer_add_escape_html (output, &tmp); + ret = cherokee_buffer_add_escape_html (output, &tmp); + if (unlikely (ret != ret_ok)) goto out; #endif cherokee_buffer_add_str (output, "\", "); } @@ -234,8 +242,13 @@ render_python_error (cherokee_error_type_t type, } cherokee_buffer_add_str (output, "}\n"); + ret = ret_ok; + +out: /* Clean up */ cherokee_buffer_mrproper (&tmp); + + return ret; } @@ -313,6 +326,7 @@ render (cherokee_error_type_t type, va_list ap, cherokee_buffer_t *error_str) { + ret_t ret; const cherokee_error_t *error; cherokee_boolean_t readable; @@ -335,10 +349,12 @@ render (cherokee_error_type_t type, */ if (readable) { render_human_error (type, filename, line, error_num, error, error_str, ap); - cherokee_buffer_split_lines (error_str, TERMINAL_WIDTH, " "); + ret = cherokee_buffer_split_lines (error_str, TERMINAL_WIDTH, " "); + if (unlikely (ret != ret_ok)) return ret; render_human_backtrace (error, error_str); } else { - render_python_error (type, filename, line, error_num, error, error_str, ap); + ret = render_python_error (type, filename, line, error_num, error, error_str, ap); + if (unlikely (ret != ret_ok)) return ret; } return ret_ok; @@ -352,7 +368,11 @@ cherokee_error_log (cherokee_error_type_t type, int error_num, ...) { va_list ap; - cherokee_buffer_t error_str = CHEROKEE_BUF_INIT; + cherokee_buffer_t error_str; + + /* Initialise the buffers + */ + cherokee_buffer_init (&error_str); /* Render the error message */ @@ -377,10 +397,15 @@ cherokee_error_errno_log (int errnumber, int line, int error_num, ...) { + ret_t ret; va_list ap; const char *errstr; char err_tmp[ERROR_MAX_BUFSIZE]; - cherokee_buffer_t error_str = CHEROKEE_BUF_INIT; + cherokee_buffer_t error_str; + + /* Initialise the buffers + */ + cherokee_buffer_init (&error_str); /* Render the error message */ @@ -395,8 +420,10 @@ cherokee_error_errno_log (int errnumber, errstr = "unknwon error (?)"; } - cherokee_buffer_replace_string (&error_str, (char *)"${errno}", 8, - (char *) errstr, strlen(errstr)); + ret = cherokee_buffer_replace_string (&error_str, (char *)"${errno}", 8, + (char *) errstr, strlen(errstr)); + + if (unlikely (ret != ret_ok)) return ret; /* Report it */ diff --git a/cherokee/flcache.c b/cherokee/flcache.c index 7e5a93028..b8b56ae49 100644 --- a/cherokee/flcache.c +++ b/cherokee/flcache.c @@ -144,8 +144,9 @@ cherokee_flcache_configure (cherokee_flcache_t *flcache, ret = mkdir_flcache_directory (flcache, vserver, CHEROKEE_FLCACHE); if (ret != ret_ok) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_init (&tmp); cherokee_buffer_add_buffer (&tmp, &cherokee_tmp_dir); cherokee_buffer_add_str (&tmp, "/flcache"); @@ -363,7 +364,7 @@ cherokee_flcache_req_set_store (cherokee_flcache_t *flcache, } -static ret_t +static ret_t must_check inspect_header (cherokee_flcache_conn_t *flcache_conn, cherokee_buffer_t *header, cherokee_connection_t *conn) @@ -540,7 +541,8 @@ inspect_header (cherokee_flcache_conn_t *flcache_conn, cherokee_buffer_add_str (tmp, " (Cherokee/"PACKAGE_VERSION")"); /* Insert at the end */ - cherokee_buffer_insert_buffer (header, tmp, end - header->buf); + ret = cherokee_buffer_insert_buffer (header, tmp, end - header->buf); + if (unlikely (ret != ret_ok)) return ret; /* The buffer might have been relocated */ begin = header->buf + pos1; @@ -599,9 +601,13 @@ create_flconn_file (cherokee_flcache_t *flcache, cherokee_connection_t *conn) { ret_t ret; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; cherokee_avl_flcache_node_t *entry = conn->flcache.avl_node_ref; + /* Initialise buffers + */ + cherokee_buffer_init (&tmp); + conn->flcache.fd = cherokee_open (entry->file.buf, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, S_IRUSR|S_IWUSR); if (conn->flcache.fd == -1) { char *p; @@ -669,6 +675,8 @@ cherokee_flcache_conn_commit_header (cherokee_flcache_conn_t *flcache_conn, cherokee_flcache_del_entry (CONN_VSRV(conn)->flcache, entry); return ret_ok; + } else if (unlikely (ret != ret_ok)) { + return ret; } /* Create the cache file diff --git a/cherokee/handler_admin.c b/cherokee/handler_admin.c index 6402d90da..537db3f30 100644 --- a/cherokee/handler_admin.c +++ b/cherokee/handler_admin.c @@ -205,8 +205,8 @@ cherokee_handler_admin_read_post (cherokee_handler_admin_t *hdl) int re; ret_t ret; char *tmp; - cherokee_buffer_t post = CHEROKEE_BUF_INIT; - cherokee_buffer_t line = CHEROKEE_BUF_INIT; + cherokee_buffer_t post; + cherokee_buffer_t line; cherokee_connection_t *conn = HANDLER_CONN(hdl); /* Check for the post info @@ -216,6 +216,11 @@ cherokee_handler_admin_read_post (cherokee_handler_admin_t *hdl) return ret_error; } + /* Initialise the buffers + */ + cherokee_buffer_init (&post); + cherokee_buffer_init (&line); + /* Process line per line */ ret = cherokee_post_read (&conn->post, &conn->socket, &post); @@ -225,7 +230,7 @@ cherokee_handler_admin_read_post (cherokee_handler_admin_t *hdl) break; default: conn->error_code = http_bad_request; - return ret_error; + goto exit2; } /* Parse diff --git a/cherokee/handler_cgi.c b/cherokee/handler_cgi.c index d1d2e132f..c6d893b5c 100644 --- a/cherokee/handler_cgi.c +++ b/cherokee/handler_cgi.c @@ -291,8 +291,6 @@ cherokee_handler_cgi_props_free (cherokee_handler_cgi_props_t *props) ret_t cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { - cherokee_handler_cgi_props_t *props; - /* Instance a new property object */ if (*_props == NULL) { @@ -303,15 +301,13 @@ cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *_props = MODULE_PROPS(n); } - props = PROP_CGI(*_props); - /* Parse local options */ return cherokee_handler_cgi_base_configure (conf, srv, _props); } -void +ret_t cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi_base, const char *name, int name_len, const char *content, int content_len) @@ -327,11 +323,11 @@ cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi_base, /* Build the new envp entry */ if (name == NULL) - return; + return ret_error; entry = (char *) malloc (name_len + content_len + 2); if (entry == NULL) - return; + return ret_nomem; memcpy (entry, name, name_len); entry[name_len] = '='; @@ -351,6 +347,7 @@ cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi_base, SHOULDNT_HAPPEN; } #endif + return ret_ok; } static ret_t @@ -362,15 +359,15 @@ add_environment (cherokee_handler_cgi_t *cgi, cherokee_buffer_t *tmp = THREAD_TMP_BUF2(CONN_THREAD(conn)); ret = cherokee_handler_cgi_base_build_envp (HDL_CGI_BASE(cgi), conn); - if (unlikely (ret != ret_ok)) - return ret; + if (unlikely (ret != ret_ok)) return ret; /* CONTENT_LENGTH */ if (conn->post.has_info) { cherokee_buffer_clean (tmp); cherokee_buffer_add_ullong10 (tmp, conn->post.len); - set_env (cgi_base, "CONTENT_LENGTH", tmp->buf, tmp->len); + ret = set_env (cgi_base, "CONTENT_LENGTH", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; } /* SCRIPT_FILENAME @@ -378,10 +375,12 @@ add_environment (cherokee_handler_cgi_t *cgi, if (cgi_base->executable.len <= 0) return ret_error; - set_env (cgi_base, "SCRIPT_FILENAME", + ret = set_env (cgi_base, "SCRIPT_FILENAME", cgi_base->executable.buf, cgi_base->executable.len); + if (unlikely (ret != ret_ok)) return ret; + return ret_ok; } @@ -740,8 +739,8 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) PROCESS_INFORMATION pi; STARTUPINFO si; char *cmd; - cherokee_buffer_t cmd_line = CHEROKEE_BUF_INIT; - cherokee_buffer_t exec_dir = CHEROKEE_BUF_INIT; + cherokee_buffer_t cmd_line; + cherokee_buffer_t exec_dir; cherokee_connection_t *conn = HANDLER_CONN(cgi); SECURITY_ATTRIBUTES saSecAtr; @@ -751,6 +750,11 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) HANDLE hChildStdoutRd = INVALID_HANDLE_VALUE; HANDLE hChildStdoutWr = INVALID_HANDLE_VALUE; + /* Initialise the buffers + */ + cherokee_buffer_init (&cmd_line); + cherokee_buffer_init (&exec_dir); + /* Create the environment for the process */ add_environment (cgi, conn); @@ -786,10 +790,10 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) hProc = GetCurrentProcess(); re = CreatePipe (&hChildStdoutRd, &hChildStdoutWr, &saSecAtr, 0); - if (!re) return ret_error; + if (!re) goto error; re = CreatePipe (&hChildStdinRd, &hChildStdinWr, &saSecAtr, 0); - if (!re) return ret_error; + if (!re) goto error; /* Make them inheritable */ @@ -797,13 +801,13 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) hProc, &hChildStdoutRd, 0, TRUE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS); - if (!re) return ret_error; + if (!re) goto error; re = DuplicateHandle (hProc, hChildStdinWr, hProc, &hChildStdinWr, 0, TRUE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS); - if (!re) return ret_error; + if (!re) goto error; /* Starting information @@ -840,7 +844,7 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) CloseHandle (pi.hThread); conn->error_code = http_internal_error; - return ret_error; + goto error; } cherokee_buffer_mrproper (&cmd_line); @@ -866,6 +870,12 @@ fork_and_execute_cgi_win32 (cherokee_handler_cgi_t *cgi) TRACE (ENTRIES, "In fd %d, Out fd %d\n", cgi->pipeInput, cgi->pipeOutput); return ret_ok; + +error: + cherokee_buffer_mrproper (&cmd_line); + cherokee_buffer_mrproper (&exec_dir); + + return ret_error; } #endif diff --git a/cherokee/handler_cgi.h b/cherokee/handler_cgi.h index 352ef8eef..c4fc23553 100644 --- a/cherokee/handler_cgi.h +++ b/cherokee/handler_cgi.h @@ -85,7 +85,7 @@ ret_t cherokee_handler_cgi_step (cherokee_handler_cgi_t *hdl, cherokee_bu /* This handler export these extra functions to allow phpcgi * set enviroment variables, work with pathinfo, etc.. */ -void cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi, +ret_t must_check cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi, const char *name, int name_len, const char *content, int content_len); diff --git a/cherokee/handler_cgi_base.c b/cherokee/handler_cgi_base.c index 47f6b05ac..f018095d5 100644 --- a/cherokee/handler_cgi_base.c +++ b/cherokee/handler_cgi_base.c @@ -35,8 +35,8 @@ #define ENTRIES "cgibase" -#define set_env(cgi,key,val,len) \ - set_env_pair (cgi, key, sizeof(key)-1, val, len) +#define set_env(cgi,key,val,len) \ + set_env_pair (cgi, key, sizeof(key)-1, val, len); \ static cherokee_handler_file_props_t handler_file_props; @@ -48,6 +48,8 @@ cherokee_handler_cgi_base_init (cherokee_handler_cgi_base_t *cgi, cherokee_handler_cgi_base_add_env_pair_t add_env_pair, cherokee_handler_cgi_base_read_from_cgi_t read_from_cgi) { + ret_t ret; + /* Init the base class object */ cherokee_handler_init_base (HANDLER(cgi), conn, props, info); @@ -63,7 +65,8 @@ cherokee_handler_cgi_base_init (cherokee_handler_cgi_base_t *cgi, cherokee_buffer_init (&cgi->executable); cherokee_buffer_init (&cgi->data); - cherokee_buffer_ensure_size (&cgi->data, 2*1024); + ret = cherokee_buffer_ensure_size (&cgi->data, 2*1024); + if (unlikely (ret != ret_ok)) return ret; /* Virtual methods */ @@ -245,7 +248,7 @@ cherokee_handler_cgi_base_free (cherokee_handler_cgi_base_t *cgi) #ifdef _WIN32 -static void +static ret_t add_win32_systemroot_env (cherokee_handler_cgi_base_t *cgi, cherokee_handler_cgi_base_add_env_pair_t set_env_pair) { @@ -253,9 +256,9 @@ add_win32_systemroot_env (cherokee_handler_cgi_base_t *cgi, root = getenv("SYSTEMROOT"); if (!root) - return; + return ret_ok; - set_env (cgi, "SYSTEMROOT", root, strlen(root)); + return set_env (cgi, "SYSTEMROOT", root, strlen(root)); } #endif @@ -282,12 +285,16 @@ cherokee_handler_cgi_base_build_basic_env ( /* Set the basic variables */ - set_env (cgi, "SERVER_SOFTWARE", - bind->server_string.buf, - bind->server_string.len); + ret = set_env (cgi, "SERVER_SOFTWARE", + bind->server_string.buf, + bind->server_string.len); + if (unlikely (ret != ret_ok)) return ret; - set_env (cgi, "SERVER_SIGNATURE", "
Cherokee Web Server
", 38); - set_env (cgi, "GATEWAY_INTERFACE", "CGI/1.1", 7); + ret = set_env (cgi, "SERVER_SIGNATURE", "
Cherokee Web Server
", 38); + if (unlikely (ret != ret_ok)) return ret; + + ret = set_env (cgi, "GATEWAY_INTERFACE", "CGI/1.1", 7); + if (unlikely (ret != ret_ok)) return ret; /* $PATH */ @@ -300,13 +307,15 @@ cherokee_handler_cgi_base_build_basic_env ( env_PATH_len = strlen (env_PATH); } - set_env (cgi, "PATH", env_PATH, env_PATH_len); + ret = set_env (cgi, "PATH", env_PATH, env_PATH_len); + if (unlikely (ret != ret_ok)) return ret; /* Document Root: */ - set_env (cgi, "DOCUMENT_ROOT", + ret = set_env (cgi, "DOCUMENT_ROOT", conn->local_directory.buf, conn->local_directory.len); + if (unlikely (ret != ret_ok)) return ret; /* REMOTE_(ADDR/PORT): X-Real-IP */ @@ -362,10 +371,13 @@ cherokee_handler_cgi_base_build_basic_env ( port_end++; } - set_env (cgi, "REMOTE_ADDR", p, colon - p); - set_env (cgi, "REMOTE_PORT", colon+1, port_end - (colon+1)); + ret = set_env (cgi, "REMOTE_ADDR", p, colon - p); + if (unlikely (ret != ret_ok)) return ret; + ret = set_env (cgi, "REMOTE_PORT", colon+1, port_end - (colon+1)); + if (unlikely (ret != ret_ok)) return ret; } else { - set_env (cgi, "REMOTE_ADDR", p, end - p); + ret = set_env (cgi, "REMOTE_ADDR", p, end - p); + if (unlikely (ret != ret_ok)) return ret; } remote_addr_set = true; @@ -379,12 +391,14 @@ cherokee_handler_cgi_base_build_basic_env ( /* REMOTE_ADDR */ memset (remote_ip, 0, sizeof(remote_ip)); cherokee_socket_ntop (&conn->socket, remote_ip, sizeof(remote_ip)-1); - set_env (cgi, "REMOTE_ADDR", remote_ip, strlen(remote_ip)); + ret = set_env (cgi, "REMOTE_ADDR", remote_ip, strlen(remote_ip)); + if (unlikely (ret != ret_ok)) return ret; /* REMOTE_PORT */ re = snprintf (temp, temp_size, "%d", SOCKET_SIN_PORT(&conn->socket)); if (re > 0) { - set_env (cgi, "REMOTE_PORT", temp, re); + ret = set_env (cgi, "REMOTE_PORT", temp, re); + if (unlikely (ret != ret_ok)) return ret; } } @@ -394,18 +408,22 @@ cherokee_handler_cgi_base_build_basic_env ( */ cherokee_header_copy_known (&conn->header, header_host, tmp); if (! cherokee_buffer_is_empty(tmp)) { - set_env (cgi, "HTTP_HOST", tmp->buf, tmp->len); + ret = set_env (cgi, "HTTP_HOST", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; p = strchr (tmp->buf, ':'); if (p != NULL) { - set_env (cgi, "SERVER_NAME", tmp->buf, p - tmp->buf); + ret = set_env (cgi, "SERVER_NAME", tmp->buf, p - tmp->buf); + if (unlikely (ret != ret_ok)) return ret; } else { - set_env (cgi, "SERVER_NAME", tmp->buf, tmp->len); + ret = set_env (cgi, "SERVER_NAME", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; } } else { ret = cherokee_gethostname (tmp); if (ret == ret_ok) { - set_env (cgi, "SERVER_NAME", tmp->buf, tmp->len); + ret = set_env (cgi, "SERVER_NAME", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; } else { LOG_WARNING_S (CHEROKEE_ERROR_HANDLER_CGI_GET_HOSTNAME); } @@ -416,47 +434,60 @@ cherokee_handler_cgi_base_build_basic_env ( cherokee_buffer_clean (tmp); ret = cherokee_header_copy_known (&conn->header, header_content_type, tmp); if (ret == ret_ok) { - set_env (cgi, "CONTENT_TYPE", tmp->buf, tmp->len); + ret = set_env (cgi, "CONTENT_TYPE", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; } /* SYSTEMROOT environment for Win32 */ #ifdef _WIN32 add_win32_systemroot_env (cgi, set_env_pair); + if (unlikely (ret != ret_ok)) return ret; #endif /* Query string */ - if (conn->query_string.len > 0) - set_env (cgi, "QUERY_STRING", conn->query_string.buf, conn->query_string.len); - else - set_env (cgi, "QUERY_STRING", "", 0); + if (conn->query_string.len > 0) { + ret = set_env (cgi, "QUERY_STRING", conn->query_string.buf, conn->query_string.len); + if (unlikely (ret != ret_ok)) return ret; + } else { + ret = set_env (cgi, "QUERY_STRING", "", 0); + if (unlikely (ret != ret_ok)) return ret; + } /* HTTP protocol version */ ret = cherokee_http_version_to_string (conn->header.version, (const char **) &p, &p_len); - if (ret >= ret_ok) - set_env (cgi, "SERVER_PROTOCOL", p, p_len); + if (ret >= ret_ok) { + ret = set_env (cgi, "SERVER_PROTOCOL", p, p_len); + if (unlikely (ret != ret_ok)) return ret; + } /* Set the method */ ret = cherokee_http_method_to_string (conn->header.method, (const char **) &p, &p_len); - if (ret >= ret_ok) - set_env (cgi, "REQUEST_METHOD", p, p_len); + if (ret >= ret_ok) { + ret = set_env (cgi, "REQUEST_METHOD", p, p_len); + if (unlikely (ret != ret_ok)) return ret; + } /* Remote user */ if (conn->validator && !cherokee_buffer_is_empty (&conn->validator->user)) { /* Only set when user authenticated (bug #467) */ - set_env (cgi, "REMOTE_USER", conn->validator->user.buf, conn->validator->user.len); + ret = set_env (cgi, "REMOTE_USER", conn->validator->user.buf, conn->validator->user.len); + if (unlikely (ret != ret_ok)) return ret; } /* Set PATH_INFO */ - if (! cherokee_buffer_is_empty (&conn->pathinfo)) - set_env (cgi, "PATH_INFO", conn->pathinfo.buf, conn->pathinfo.len); - else - set_env (cgi, "PATH_INFO", "", 0); + if (! cherokee_buffer_is_empty (&conn->pathinfo)) { + ret = set_env (cgi, "PATH_INFO", conn->pathinfo.buf, conn->pathinfo.len); + if (unlikely (ret != ret_ok)) return ret; + } else { + ret = set_env (cgi, "PATH_INFO", "", 0); + if (unlikely (ret != ret_ok)) return ret; + } /* Set REQUEST_URI: * @@ -466,7 +497,8 @@ cherokee_handler_cgi_base_build_basic_env ( cherokee_buffer_clean (tmp); if (conn->options & conn_op_root_index) { - cherokee_header_copy_request_w_args (&conn->header, tmp); + ret = cherokee_header_copy_request_w_args (&conn->header, tmp); + if (unlikely (ret != ret_ok)) return ret; } else { if (! cherokee_buffer_is_empty (&conn->userdir)) { @@ -489,7 +521,8 @@ cherokee_handler_cgi_base_build_basic_env ( } } } - set_env (cgi, "REQUEST_URI", tmp->buf, tmp->len); + ret = set_env (cgi, "REQUEST_URI", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; /* Set SCRIPT_URL */ @@ -498,22 +531,27 @@ cherokee_handler_cgi_base_build_basic_env ( cherokee_buffer_add_str (tmp, "/~"); cherokee_buffer_add_buffer (tmp, &conn->userdir); cherokee_buffer_add_buffer (tmp, &conn->request); - set_env (cgi, "SCRIPT_URL", tmp->buf, tmp->len); + ret = set_env (cgi, "SCRIPT_URL", tmp->buf, tmp->len); + if (unlikely (ret != ret_ok)) return ret; } else { - set_env (cgi, "SCRIPT_URL", conn->request.buf, conn->request.len); + ret = set_env (cgi, "SCRIPT_URL", conn->request.buf, conn->request.len); + if (unlikely (ret != ret_ok)) return ret; } /* Set HTTPS and SERVER_PORT */ if (conn->socket.is_tls) { - set_env (cgi, "HTTPS", "on", 2); + ret = set_env (cgi, "HTTPS", "on", 2); + if (unlikely (ret != ret_ok)) return ret; } else { - set_env (cgi, "HTTPS", "off", 3); + ret = set_env (cgi, "HTTPS", "off", 3); + if (unlikely (ret != ret_ok)) return ret; } - set_env (cgi, "SERVER_PORT", - bind->server_port.buf, - bind->server_port.len); + ret = set_env (cgi, "SERVER_PORT", + bind->server_port.buf, + bind->server_port.len); + if (unlikely (ret != ret_ok)) return ret; /* Set SERVER_ADDR */ @@ -531,26 +569,30 @@ cherokee_handler_cgi_base_build_basic_env ( (struct sockaddr *) &my_address, ip_str, sizeof(ip_str)-1); - set_env (cgi, "SERVER_ADDR", - ip_str, strlen(ip_str)); + ret = set_env (cgi, "SERVER_ADDR", + ip_str, strlen(ip_str)); + if (unlikely (ret != ret_ok)) return ret; } } else { - set_env (cgi, "SERVER_ADDR", - bind->server_address.buf, - bind->server_address.len); + ret = set_env (cgi, "SERVER_ADDR", + bind->server_address.buf, + bind->server_address.len); + if (unlikely (ret != ret_ok)) return ret; } /* Internal error redirection: * It is okay if the QS is empty. */ if (! cherokee_buffer_is_empty (&conn->error_internal_url)) { - set_env (cgi, "REDIRECT_URL", - conn->error_internal_url.buf, - conn->error_internal_url.len); - - set_env (cgi, "REDIRECT_QUERY_STRING", - conn->error_internal_qs.buf, - conn->error_internal_qs.len); + ret = set_env (cgi, "REDIRECT_URL", + conn->error_internal_url.buf, + conn->error_internal_url.len); + if (unlikely (ret != ret_ok)) return ret; + + ret = set_env (cgi, "REDIRECT_QUERY_STRING", + conn->error_internal_qs.buf, + conn->error_internal_qs.len); + if (unlikely (ret != ret_ok)) return ret; } /* Authentication @@ -559,10 +601,12 @@ cherokee_handler_cgi_base_build_basic_env ( case http_auth_nothing: break; case http_auth_basic: - set_env (cgi, "AUTH_TYPE", "Basic", 5); + ret = set_env (cgi, "AUTH_TYPE", "Basic", 5); + if (unlikely (ret != ret_ok)) return ret; break; case http_auth_digest: - set_env (cgi, "AUTH_TYPE", "Digest", 6); + ret = set_env (cgi, "AUTH_TYPE", "Digest", 6); + if (unlikely (ret != ret_ok)) return ret; break; } @@ -570,82 +614,98 @@ cherokee_handler_cgi_base_build_basic_env ( */ ret = cherokee_header_get_known (&conn->header, header_accept, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_ACCEPT", p, p_len); + ret = set_env (cgi, "HTTP_ACCEPT", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_accept_charset, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_ACCEPT_CHARSET", p, p_len); + ret = set_env (cgi, "HTTP_ACCEPT_CHARSET", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_accept_encoding, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_ACCEPT_ENCODING", p, p_len); + ret = set_env (cgi, "HTTP_ACCEPT_ENCODING", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_accept_language, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_ACCEPT_LANGUAGE", p, p_len); + ret = set_env (cgi, "HTTP_ACCEPT_LANGUAGE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_authorization, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_AUTHORIZATION", p, p_len); + ret = set_env (cgi, "HTTP_AUTHORIZATION", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_connection, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_CONNECTION", p, p_len); + ret = set_env (cgi, "HTTP_CONNECTION", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_cookie, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_COOKIE", p, p_len); + ret = set_env (cgi, "HTTP_COOKIE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_if_modified_since, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_IF_MODIFIED_SINCE", p, p_len); + ret = set_env (cgi, "HTTP_IF_MODIFIED_SINCE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_if_none_match, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_IF_NONE_MATCH", p, p_len); + ret = set_env (cgi, "HTTP_IF_NONE_MATCH", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_if_range, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_IF_RANGE", p, p_len); + ret = set_env (cgi, "HTTP_IF_RANGE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_keepalive, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_KEEP_ALIVE", p, p_len); + ret = set_env (cgi, "HTTP_KEEP_ALIVE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_range, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_RANGE", p, p_len); + ret = set_env (cgi, "HTTP_RANGE", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_referer, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_REFERER", p, p_len); + ret = set_env (cgi, "HTTP_REFERER", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_user_agent, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_USER_AGENT", p, p_len); + ret = set_env (cgi, "HTTP_USER_AGENT", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_x_forwarded_for, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_X_FORWARDED_FOR", p, p_len); + ret = set_env (cgi, "HTTP_X_FORWARDED_FOR", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_header_get_known (&conn->header, header_x_forwarded_host, &p, &p_len); if (ret == ret_ok) { - set_env (cgi, "HTTP_X_FORWARDED_HOST", p, p_len); + ret = set_env (cgi, "HTTP_X_FORWARDED_HOST", p, p_len); + if (unlikely (ret != ret_ok)) return ret; } /* TODO: Fill the others CGI environment variables @@ -658,11 +718,12 @@ cherokee_handler_cgi_base_build_basic_env ( } -static ret_t +static ret_t must_check foreach_header_add_unknown_variable (cherokee_buffer_t *header, cherokee_buffer_t *content, void *data) { + ret_t ret; cuint_t i; cherokee_handler_cgi_base_t *cgi = HDL_CGI_BASE(data); @@ -679,14 +740,16 @@ foreach_header_add_unknown_variable (cherokee_buffer_t *header, } } - cherokee_buffer_prepend_str (header, "HTTP_"); + ret = cherokee_buffer_prepend_str (header, "HTTP_"); + if (unlikely (ret != ret_ok)) return ret; /* Add it to the *CGI environment */ - cgi->add_env_pair (cgi, - header->buf, header->len, - content->buf, content->len); - return ret_ok; + ret = cgi->add_env_pair (cgi, + header->buf, header->len, + content->buf, content->len); + + return ret; } @@ -698,17 +761,22 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee cherokee_buffer_t *name; cuint_t len = 0; const char *p = ""; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; cherokee_handler_cgi_base_props_t *cgi_props = HANDLER_CGI_BASE_PROPS(cgi); + cherokee_buffer_t tmp; + + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); /* Add user defined variables at the beginning, * these have precedence.. */ list_for_each (i, &cgi_props->system_env) { env_item_t *env = (env_item_t *)i; - cgi->add_env_pair (cgi, - env->env.buf, env->env.len, - env->val.buf, env->val.len); + ret = cgi->add_env_pair (cgi, + env->env.buf, env->env.len, + env->val.buf, env->val.len); + if (unlikely (ret != ret_ok)) goto out; } /* Pass request headers. @@ -722,7 +790,7 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee /* Add the basic enviroment variables */ ret = cherokee_handler_cgi_base_build_basic_env (cgi, cgi->add_env_pair, conn, &tmp); - if (unlikely (ret != ret_ok)) return ret; + if (unlikely (ret != ret_ok)) goto out; /* SCRIPT_NAME: */ @@ -733,11 +801,13 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee * - Otherwise, it is the web_directory. */ if (conn->web_directory.len > 1) { - cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, - conn->web_directory.buf, - conn->web_directory.len); + ret = cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, + conn->web_directory.buf, + conn->web_directory.len); + if (unlikely (ret != ret_ok)) goto out; } else { - cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, "", 0); + ret = cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, "", 0); + if (unlikely (ret != ret_ok)) goto out; } } else { @@ -771,7 +841,8 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee if (len > 0) cherokee_buffer_add (&tmp, p, len); - cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, tmp.buf, tmp.len); + ret = cgi->add_env_pair (cgi, "SCRIPT_NAME", 11, tmp.buf, tmp.len); + if (unlikely (ret != ret_ok)) goto out; } /* Set PATH_TRANSLATED; only if PATH_INFO is set @@ -780,9 +851,11 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee cherokee_buffer_add_buffer (&conn->local_directory, &conn->pathinfo); - cgi->add_env_pair (cgi, "PATH_TRANSLATED", 15, - conn->local_directory.buf, - conn->local_directory.len); + ret = cgi->add_env_pair (cgi, "PATH_TRANSLATED", 15, + conn->local_directory.buf, + conn->local_directory.len); + + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_drop_ending (&conn->local_directory, conn->pathinfo.len); @@ -792,8 +865,11 @@ cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee * It depends on the type of CGI (CGI, SCGI o FastCGI): * http://php.net/reserved.variables */ + ret = ret_ok; + +out: cherokee_buffer_mrproper (&tmp); - return ret_ok; + return ret; } @@ -1192,7 +1268,9 @@ cherokee_handler_cgi_base_add_headers (cherokee_handler_cgi_base_t *cgi, */ len = content - inbuf->buf; - cherokee_buffer_ensure_size (outbuf, len+6); + ret = cherokee_buffer_ensure_size (outbuf, len+6); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add (outbuf, inbuf->buf, len); cherokee_buffer_add_str (outbuf, CRLF_CRLF); @@ -1209,15 +1287,13 @@ cherokee_handler_cgi_base_add_headers (cherokee_handler_cgi_base_t *cgi, /* Parse the header.. it is likely we will have something to do with it. */ ret = parse_header (cgi, outbuf); - if (unlikely (ret != ret_ok)) { - return ret; - } + if (unlikely (ret != ret_ok)) return ret; /* Handle X-Sendfile */ if (! cherokee_buffer_is_empty (&cgi->xsendfile)) { - cherokee_buffer_t cgi_header = CHEROKEE_BUF_INIT; + cherokee_buffer_t cgi_header; /* Instance the 'file' sub-handler */ @@ -1233,6 +1309,7 @@ cherokee_handler_cgi_base_add_headers (cherokee_handler_cgi_base_t *cgi, /* Work out the header */ + cherokee_buffer_init (&cgi_header); cherokee_buffer_add_buffer (&cgi_header, outbuf); cherokee_buffer_clean (outbuf); diff --git a/cherokee/handler_cgi_base.h b/cherokee/handler_cgi_base.h index 95595ad59..f0554a426 100644 --- a/cherokee/handler_cgi_base.h +++ b/cherokee/handler_cgi_base.h @@ -53,7 +53,7 @@ */ typedef struct cherokee_handler_cgi_base cherokee_handler_cgi_base_t; -typedef void (* cherokee_handler_cgi_base_add_env_pair_t) (cherokee_handler_cgi_base_t *cgi, +typedef ret_t must_check (* cherokee_handler_cgi_base_add_env_pair_t) (cherokee_handler_cgi_base_t *cgi, const char *name, int name_len, const char *content, int content_len); diff --git a/cherokee/handler_dbslayer.c b/cherokee/handler_dbslayer.c index 6ce84703c..fda2e46e7 100644 --- a/cherokee/handler_dbslayer.c +++ b/cherokee/handler_dbslayer.c @@ -72,6 +72,7 @@ connect_to_database (cherokee_handler_dbslayer_t *hdl) static ret_t send_query (cherokee_handler_dbslayer_t *hdl) { + ret_t ret; int re; cuint_t len; cherokee_connection_t *conn = HANDLER_CONN(hdl); @@ -92,7 +93,8 @@ send_query (cherokee_handler_dbslayer_t *hdl) conn->request.buf + len, conn->request.len - len); - cherokee_buffer_unescape_uri (tmp); + ret = cherokee_buffer_unescape_uri (tmp); + if (unlikely (ret != ret_ok)) return ret; /* Send the query */ diff --git a/cherokee/handler_dirlist.c b/cherokee/handler_dirlist.c index bc82af663..db97b65d9 100644 --- a/cherokee/handler_dirlist.c +++ b/cherokee/handler_dirlist.c @@ -142,13 +142,16 @@ file_entry_free (file_entry_t *file) static ret_t load_theme_load_file (cherokee_buffer_t *theme_path, const char *file, cherokee_buffer_t *output) { - cherokee_buffer_t path = CHEROKEE_BUF_INIT; + ret_t ret; + cherokee_buffer_t path; + cherokee_buffer_init (&path); cherokee_buffer_add_buffer (&path, theme_path); cherokee_buffer_add (&path, file, strlen(file)); cherokee_buffer_clean (output); - cherokee_buffer_read_file (output, path.buf); + ret = cherokee_buffer_read_file (output, path.buf); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_mrproper (&path); return ret_ok; @@ -160,8 +163,9 @@ parse_if (cherokee_buffer_t *buf, const char *if_entry, size_t len_entry, cherok { char *begin; char *end; - cherokee_buffer_t token = CHEROKEE_BUF_INIT; + cherokee_buffer_t token; + cherokee_buffer_init (&token); cherokee_buffer_add_str (&token, "%if "); cherokee_buffer_add (&token, if_entry, len_entry); cherokee_buffer_add_str (&token, "%"); @@ -289,7 +293,7 @@ cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_list_t *i; cherokee_handler_dirlist_props_t *props; const char *theme = NULL; - cherokee_buffer_t theme_path = CHEROKEE_BUF_INIT; + cherokee_buffer_t theme_path; UNUSED(srv); @@ -387,6 +391,7 @@ cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, if (theme == NULL) theme = "default"; + cherokee_buffer_init (&theme_path); cherokee_buffer_add_buffer (&theme_path, &srv->themes_dir); cherokee_buffer_add_va (&theme_path, "/%s/", theme); @@ -425,13 +430,15 @@ is_file_in_list (cherokee_list_t *list, char *filename, cuint_t len) } -static ret_t +static ret_t must_check realpath_buf (cherokee_buffer_t *in, cherokee_buffer_t *resolved) { + ret_t ret; char *re; - cherokee_buffer_ensure_size (resolved, PATH_MAX); + ret = cherokee_buffer_ensure_size (resolved, PATH_MAX); + if (unlikely (ret != ret_ok)) return ret; re = realpath (in->buf, resolved->buf); if (re == NULL) { @@ -794,7 +801,7 @@ build_file_list (cherokee_handler_dirlist_t *dhdl) int is_dir; int is_link; cherokee_connection_t *conn = HANDLER_CONN(dhdl); - cherokee_buffer_t local_realpath = CHEROKEE_BUF_INIT; + cherokee_buffer_t local_realpath; /* Build the local directory path */ @@ -806,6 +813,10 @@ build_file_list (cherokee_handler_dirlist_t *dhdl) return ret_error; } + /* Initialise the buffers + */ + cherokee_buffer_init (&local_realpath); + /* Read the files */ for (;;) { @@ -1081,7 +1092,8 @@ render_file (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer, file_e /* File */ cherokee_buffer_clean (tmp); - cherokee_buffer_add_escape_html (tmp, &name_buf); + ret = cherokee_buffer_add_escape_html (tmp, &name_buf); + if (unlikely (ret != ret_ok)) return ret; VTMP_SUBSTITUTE_TOKEN ("%file_name%", tmp->buf); if ((is_link) && (props->redir_symlinks)) { @@ -1090,17 +1102,20 @@ render_file (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer, file_e } cherokee_buffer_clean (tmp); - cherokee_buffer_escape_uri_delims (tmp, &file->realpath); + ret = cherokee_buffer_escape_uri_delims (tmp, &file->realpath); + if (unlikely (ret != ret_ok)) return ret; VTMP_SUBSTITUTE_TOKEN ("%file_link%", tmp->buf); } else if (! is_dir) { cherokee_buffer_clean (tmp); - cherokee_buffer_escape_uri_delims (tmp, &name_buf); + ret = cherokee_buffer_escape_uri_delims (tmp, &name_buf); + if (unlikely (ret != ret_ok)) return ret; VTMP_SUBSTITUTE_TOKEN ("%file_link%", tmp->buf); } else { cherokee_buffer_clean (tmp); - cherokee_buffer_escape_uri_delims (tmp, &name_buf); + ret = cherokee_buffer_escape_uri_delims (tmp, &name_buf); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add_str (tmp, "/"); VTMP_SUBSTITUTE_TOKEN ("%file_link%", tmp->buf); } @@ -1112,7 +1127,8 @@ render_file (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer, file_e struct tm ltime_buf; cherokee_buffer_clean (tmp); - cherokee_buffer_ensure_size (tmp, 33); + ret = cherokee_buffer_ensure_size (tmp, 33); + if (unlikely (ret != ret_ok)) return ret; ltime = cherokee_localtime (&file->stat.st_mtime, <ime_buf); if (ltime != NULL) { @@ -1135,7 +1151,9 @@ render_file (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer, file_e char *unit; cherokee_buffer_clean (tmp); - cherokee_buffer_ensure_size (tmp, 8); + ret = cherokee_buffer_ensure_size (tmp, 8); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add_fsize (tmp, file->stat.st_size); unit = tmp->buf; diff --git a/cherokee/handler_error.c b/cherokee/handler_error.c index 1301ba1df..d3bfd2ba0 100644 --- a/cherokee/handler_error.c +++ b/cherokee/handler_error.c @@ -68,9 +68,7 @@ cherokee_handler_error_new (cherokee_handler_t **hdl, cherokee_connection_t *cnt /* Init */ - ret = cherokee_buffer_init (&n->content); - if (unlikely(ret < ret_ok)) - return ret; + cherokee_buffer_init (&n->content); /* Return the object */ @@ -90,9 +88,12 @@ cherokee_handler_error_free (cherokee_handler_error_t *hdl) static ret_t build_hardcoded_response_page (cherokee_connection_t *conn, cherokee_buffer_t *buffer) { + ret_t ret; + /* Avoid too many reallocations. */ - cherokee_buffer_ensure_addlen (buffer, 1000); + ret = cherokee_buffer_ensure_addlen (buffer, 1000); + if (unlikely (ret != ret_ok)) return ret; /* Add document header */ @@ -118,13 +119,15 @@ build_hardcoded_response_page (cherokee_connection_t *conn, cherokee_buffer_t *b case http_gone: cherokee_buffer_add_str (buffer, "The requested URL "); if (! cherokee_buffer_is_empty (&conn->request_original)) { - cherokee_buffer_add_escape_html (buffer, &conn->request_original); + ret = cherokee_buffer_add_escape_html (buffer, &conn->request_original); + if (unlikely (ret != ret_ok)) return ret; } else if (! cherokee_buffer_is_empty (&conn->request)) { if (cherokee_connection_use_webdir (conn)) { cherokee_buffer_add_buffer (buffer, &conn->web_directory); } - cherokee_buffer_add_escape_html (buffer, &conn->request); + ret = cherokee_buffer_add_escape_html (buffer, &conn->request); + if (unlikely (ret != ret_ok)) return ret; } if (conn->error_code == http_not_found) { @@ -140,7 +143,8 @@ build_hardcoded_response_page (cherokee_connection_t *conn, cherokee_buffer_t *b cherokee_buffer_add_str (buffer, "Your browser sent a request that this server could not understand."); cherokee_buffer_add_str (buffer, "

");
-		cherokee_buffer_add_escape_html (buffer, conn->header.input_buffer);
+		ret = cherokee_buffer_add_escape_html (buffer, conn->header.input_buffer);
+		if (unlikely (ret != ret_ok)) return ret;
 		cherokee_buffer_add_str   (buffer, "
"); break; @@ -167,7 +171,8 @@ build_hardcoded_response_page (cherokee_connection_t *conn, cherokee_buffer_t *b case http_moved_permanently: case http_moved_temporarily: cherokee_buffer_add_str (buffer, "The document has moved redirect); + ret = cherokee_buffer_add_escape_html (buffer, &conn->redirect); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add_str (buffer, "\">here."); break; diff --git a/cherokee/handler_error_nn.c b/cherokee/handler_error_nn.c index c0726d30f..bc3a1cf3d 100644 --- a/cherokee/handler_error_nn.c +++ b/cherokee/handler_error_nn.c @@ -134,8 +134,7 @@ get_nearest_name (cherokee_connection_t *conn, /* Prepend the rest of the old request to the new filename */ - cherokee_buffer_prepend (output, request->buf, rest - request->buf); - return ret_ok; + return cherokee_buffer_prepend (output, request->buf, rest - request->buf); } diff --git a/cherokee/handler_fcgi.c b/cherokee/handler_fcgi.c index e28b48f09..20500b47c 100644 --- a/cherokee/handler_fcgi.c +++ b/cherokee/handler_fcgi.c @@ -45,9 +45,9 @@ set_env_pair (cgi, key, sizeof(key)-1, val, len) -static void set_env_pair (cherokee_handler_cgi_base_t *cgi_base, - const char *key, int key_len, - const char *val, int val_len); +static ret_t must_check set_env_pair (cherokee_handler_cgi_base_t *cgi_base, + const char *key, int key_len, + const char *val, int val_len); /* Plug-in initialization */ @@ -63,7 +63,7 @@ process_package (cherokee_handler_fcgi_t *hdl, cherokee_buffer_t *inbuf, cheroke cuint_t len; char *data; cuint_t type; - cuint_t id; +/* cuint_t id; */ cuint_t padding; /* Is there enough information? @@ -93,7 +93,7 @@ process_package (cherokee_handler_fcgi_t *hdl, cherokee_buffer_t *inbuf, cheroke */ type = header->type; padding = header->paddingLength; - id = (header->requestIdB0 | (header->requestIdB1 << 8)); +/* id = (header->requestIdB0 | (header->requestIdB1 << 8)); */ len = (header->contentLengthB0 | (header->contentLengthB1 << 8)); data = inbuf->buf + FCGI_HEADER_LEN; @@ -265,6 +265,7 @@ cherokee_handler_fcgi_configure (cherokee_config_node_t *conf, ret_t cherokee_handler_fcgi_new (cherokee_handler_t **hdl, void *cnt, cherokee_module_props_t *props) { + ret_t ret; CHEROKEE_NEW_STRUCT (n, handler_fcgi); /* Init the base class @@ -290,7 +291,8 @@ cherokee_handler_fcgi_new (cherokee_handler_t **hdl, void *cnt, cherokee_module_ cherokee_socket_init (&n->socket); cherokee_buffer_init (&n->write_buffer); - cherokee_buffer_ensure_size (&n->write_buffer, 512); + ret = cherokee_buffer_ensure_size (&n->write_buffer, 512); + if (unlikely (ret != ret_ok)) return ret; /* Return the object */ @@ -339,11 +341,12 @@ fcgi_build_request_body (FCGI_BeginRequestRecord *request) request->body.reserved[4] = 0; } -static void +static ret_t set_env_pair (cherokee_handler_cgi_base_t *cgi_base, const char *key, int key_len, const char *val, int val_len) { + ret_t ret; int len; FCGI_BeginRequestRecord request; cherokee_handler_fcgi_t *hdl = HDL_FCGI(cgi_base); @@ -367,7 +370,9 @@ set_env_pair (cherokee_handler_cgi_base_t *cgi_base, fcgi_build_header (&request.header, FCGI_PARAMS, 1, len, 0); - cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len); + ret = cherokee_buffer_ensure_size (buf, buf->len + sizeof(FCGI_Header) + key_len + val_len); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header)); if (key_len <= 127) { @@ -390,27 +395,37 @@ set_env_pair (cherokee_handler_cgi_base_t *cgi_base, cherokee_buffer_add (buf, key, key_len); cherokee_buffer_add (buf, val, val_len); + + return ret_ok; } static ret_t add_extra_fcgi_env (cherokee_handler_fcgi_t *hdl, cuint_t *last_header_offset) { + ret_t ret; cherokee_handler_cgi_base_t *cgi_base = HDL_CGI_BASE(hdl); - cherokee_buffer_t buffer = CHEROKEE_BUF_INIT; cherokee_connection_t *conn = HANDLER_CONN(hdl); cherokee_handler_cgi_base_props_t *props = HANDLER_CGI_BASE_PROPS(hdl); + cherokee_buffer_t buffer; + + /* Initialise the buffers + */ + cherokee_buffer_init (&buffer); /* POST management */ if (conn->post.has_info) { if (conn->post.encoding == post_enc_regular) { cherokee_buffer_add_ullong10 (&buffer, conn->post.len); - set_env (cgi_base, "CONTENT_LENGTH", buffer.buf, buffer.len); + ret = set_env (cgi_base, "CONTENT_LENGTH", buffer.buf, buffer.len); + if (unlikely (ret != ret_ok)) return ret; } else if (conn->post.encoding == post_enc_chunked) { TRACE (ENTRIES",post", "Setting Chunked Post: %s flag\n", "retransmit"); - set_env (cgi_base, "CONTENT_TRANSFER_ENCODING", "chunked", 7); + ret = set_env (cgi_base, "CONTENT_TRANSFER_ENCODING", "chunked", 7); + if (unlikely (ret != ret_ok)) return ret; + conn->post.chunked.retransmit = true; } } @@ -429,9 +444,10 @@ add_extra_fcgi_env (cherokee_handler_fcgi_t *hdl, cuint_t *last_header_offset) * SCRIPT_FILENAME = /docroot/script.php */ if (cgi_base->executable.len > 0) { - set_env (cgi_base, "SCRIPT_FILENAME", - cgi_base->executable.buf, - cgi_base->executable.len); + ret = set_env (cgi_base, "SCRIPT_FILENAME", + cgi_base->executable.buf, + cgi_base->executable.len); + if (unlikely (ret != ret_ok)) return ret; } else { cherokee_buffer_clean (&buffer); @@ -442,7 +458,8 @@ add_extra_fcgi_env (cherokee_handler_fcgi_t *hdl, cuint_t *last_header_offset) cherokee_buffer_add_buffer (&buffer, &conn->request); } - set_env (cgi_base, "SCRIPT_FILENAME", buffer.buf, buffer.len); + ret = set_env (cgi_base, "SCRIPT_FILENAME", buffer.buf, buffer.len); + if (unlikely (ret != ret_ok)) return ret; } cherokee_buffer_mrproper (&buffer); @@ -450,27 +467,32 @@ add_extra_fcgi_env (cherokee_handler_fcgi_t *hdl, cuint_t *last_header_offset) } -static void +static ret_t must_check fixup_padding (cherokee_buffer_t *buf, cuint_t last_header_offset) { + ret_t ret; cuint_t rest; cuint_t pad; static char padding[8] = {0, 0, 0, 0, 0, 0, 0, 0}; FCGI_Header *last_header; if (buf->len <= 0) - return; + return ret_ok; last_header = (FCGI_Header *) (buf->buf + last_header_offset); rest = buf->len % 8; pad = 8 - rest; if (rest == 0) - return; + return ret_ok; last_header->paddingLength = pad; - cherokee_buffer_ensure_size (buf, buf->len + pad); + ret = cherokee_buffer_ensure_size (buf, buf->len + pad); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add (buf, padding, pad); + + return ret_ok; } static void @@ -488,6 +510,7 @@ add_empty_packet (cherokee_handler_fcgi_t *hdl, cuint_t type) static ret_t build_header (cherokee_handler_fcgi_t *hdl, cherokee_buffer_t *buffer) { + ret_t ret; FCGI_BeginRequestRecord request; cuint_t last_header_offset; cherokee_connection_t *conn = HANDLER_CONN(hdl); @@ -507,7 +530,8 @@ build_header (cherokee_handler_fcgi_t *hdl, cherokee_buffer_t *buffer) cherokee_handler_cgi_base_build_envp (HDL_CGI_BASE(hdl), conn); add_extra_fcgi_env (hdl, &last_header_offset); - fixup_padding (buffer, last_header_offset); + ret = fixup_padding (buffer, last_header_offset); + if (unlikely (ret != ret_ok)) return ret; /* There are no more parameters */ diff --git a/cherokee/handler_file.c b/cherokee/handler_file.c index 11704dcf0..c4dd1d2b0 100644 --- a/cherokee/handler_file.c +++ b/cherokee/handler_file.c @@ -791,6 +791,7 @@ cherokee_handler_file_add_headers (cherokee_handler_file_t *fhdl, ret_t cherokee_handler_file_step (cherokee_handler_file_t *fhdl, cherokee_buffer_t *buffer) { + ret_t ret; off_t total; size_t size; cherokee_connection_t *conn = HANDLER_CONN(fhdl); @@ -859,7 +860,8 @@ cherokee_handler_file_step (cherokee_handler_file_t *fhdl, cherokee_buffer_t *bu /* Ensure there's enough memory */ - cherokee_buffer_ensure_size (buffer, size + 1); + ret = cherokee_buffer_ensure_size (buffer, size + 1); + if (unlikely (ret != ret_ok)) return ret; /* Read */ diff --git a/cherokee/handler_post_report.c b/cherokee/handler_post_report.c index 656e63b51..5295f0762 100644 --- a/cherokee/handler_post_report.c +++ b/cherokee/handler_post_report.c @@ -102,10 +102,7 @@ cherokee_handler_post_report_new (cherokee_handler_t **hdl, /* Init */ - ret = cherokee_buffer_init (&n->buffer); - if (unlikely(ret != ret_ok)) { - return ret; - } + cherokee_buffer_init (&n->buffer); ret = cherokee_dwriter_init (&n->writer, &CONN_THREAD(cnt)->tmp_buf1); if (unlikely(ret != ret_ok)) { diff --git a/cherokee/handler_proxy.c b/cherokee/handler_proxy.c index dbaeaf2ae..9ab8f1d66 100644 --- a/cherokee/handler_proxy.c +++ b/cherokee/handler_proxy.c @@ -563,7 +563,9 @@ build_request (cherokee_handler_proxy_t *hdl, /* X-Forwarded-For */ - cherokee_buffer_ensure_size (tmp, CHE_INET_ADDRSTRLEN+1); + ret = cherokee_buffer_ensure_size (tmp, CHE_INET_ADDRSTRLEN+1); + if (unlikely (ret != ret_ok)) goto error; + cherokee_socket_ntop (&conn->socket, tmp->buf, tmp->size-1); cherokee_buffer_add_str (buf, "X-Forwarded-For: "); @@ -1192,7 +1194,6 @@ cherokee_handler_proxy_init (cherokee_handler_proxy_t *hdl) static void xsendfile_header_clean_up (cherokee_buffer_t *header) { - char *p; char *begin; char *end; char chr_end; @@ -1200,7 +1201,6 @@ xsendfile_header_clean_up (cherokee_buffer_t *header) end = header->buf + header->len; begin = header->buf; - p = begin; while (begin < end) { end = cherokee_header_get_next_line (begin); if (end == NULL) @@ -1252,7 +1252,7 @@ parse_server_header (cherokee_handler_proxy_t *hdl, char *colon; char *header_end; cherokee_list_t *i; - cherokee_http_version_t version; + // cherokee_http_version_t version; cint_t xsendfile_len; char *xsendfile = NULL; cherokee_boolean_t added_server = false; @@ -1270,14 +1270,14 @@ parse_server_header (cherokee_handler_proxy_t *hdl, p+= 5; if (strncmp (p, "1.1", 3) == 0) { - version = http_version_11; + // version = http_version_11; } else if (strncmp (p, "1.0", 3) == 0) { - version = http_version_10; + // version = http_version_10; hdl->pconn->keepalive_in = false; } else if (strncmp (p, "0.9", 3) == 0) { - version = http_version_09; + // version = http_version_09; hdl->pconn->keepalive_in = false; } else goto error; diff --git a/cherokee/handler_redir.c b/cherokee/handler_redir.c index 1829aeaff..0c2e5df56 100644 --- a/cherokee/handler_redir.c +++ b/cherokee/handler_redir.c @@ -42,7 +42,7 @@ PLUGIN_INFO_HANDLER_EASIEST_INIT (redir, http_all_methods); /* Methods implementation */ -static ret_t +static ret_t must_check substitute (cherokee_handler_redir_t *hdl, cherokee_buffer_t *regex, cherokee_buffer_t *source, @@ -80,19 +80,23 @@ substitute (cherokee_handler_redir_t *hdl, if (token != NULL) { offset = token - target->buf; if (! cherokee_buffer_is_empty (&conn->host)) { - cherokee_buffer_insert_buffer (target, &conn->host, offset); + ret = cherokee_buffer_insert_buffer (target, &conn->host, offset); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_remove_chunk (target, offset + conn->host.len, 7); } else if (! cherokee_buffer_is_empty (&conn->bind->ip)) { - cherokee_buffer_insert_buffer (target, &conn->bind->ip, offset); + ret = cherokee_buffer_insert_buffer (target, &conn->bind->ip, offset); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_remove_chunk (target, offset + conn->bind->ip.len, 7); } else { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_init (&tmp); ret = cherokee_copy_local_address (&conn->socket, &tmp); if (ret == ret_ok) { - cherokee_buffer_insert_buffer (target, &tmp, offset); + ret = cherokee_buffer_insert_buffer (target, &tmp, offset); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_remove_chunk (target, offset + tmp.len, 7); } @@ -104,7 +108,7 @@ substitute (cherokee_handler_redir_t *hdl, } -static ret_t +static ret_t must_check match_and_substitute (cherokee_handler_redir_t *hdl) { cherokee_list_t *i; @@ -117,7 +121,8 @@ match_and_substitute (cherokee_handler_redir_t *hdl) if ((conn->web_directory.len > 1) && (conn->options & conn_op_document_root)) { - cherokee_buffer_prepend_buf (&conn->request, &conn->web_directory); + ret = cherokee_buffer_prepend_buf (&conn->request, &conn->web_directory); + if (unlikely (ret != ret_ok)) return ret; } if (! cherokee_buffer_is_empty (&conn->query_string)) { @@ -205,12 +210,15 @@ match_and_substitute (cherokee_handler_redir_t *hdl) cherokee_buffer_clean (&conn->web_directory); cherokee_buffer_clean (&conn->local_directory); - cherokee_buffer_ensure_size (&conn->request, conn->request.len + subject_len); - substitute (hdl, - &list->subs, /* regex str */ - tmp, /* source */ - &conn->request, /* target */ - ovector, rc); /* ovector */ + ret = cherokee_buffer_ensure_size (&conn->request, conn->request.len + subject_len); + if (unlikely (ret != ret_ok)) return ret; + + ret = substitute (hdl, + &list->subs, /* regex str */ + tmp, /* source */ + &conn->request, /* target */ + ovector, rc); /* ovector */ + if (unlikely (ret != ret_ok)) return ret; /* Arguments */ @@ -223,7 +231,8 @@ match_and_substitute (cherokee_handler_redir_t *hdl) /* Non-global redirection */ if (conn->request.buf[0] != '/') { - cherokee_buffer_prepend_str (&conn->request, "/"); + ret = cherokee_buffer_prepend_str (&conn->request, "/"); + if (unlikely (ret != ret_ok)) return ret; } TRACE (ENTRIES, "Hidden redirect to: request=\"%s\" query_string=\"%s\"\n", @@ -234,13 +243,15 @@ match_and_substitute (cherokee_handler_redir_t *hdl) /* External redirect */ - cherokee_buffer_ensure_size (&conn->redirect, conn->request.len + subject_len); + ret = cherokee_buffer_ensure_size (&conn->redirect, conn->request.len + subject_len); + if (unlikely (ret != ret_ok)) return ret; - substitute (hdl, - &list->subs, /* regex str */ - tmp, /* source */ - &conn->redirect, /* target */ - ovector, rc); /* ovector */ + ret = substitute (hdl, + &list->subs, /* regex str */ + tmp, /* source */ + &conn->redirect, /* target */ + ovector, rc); /* ovector */ + if (unlikely (ret != ret_ok)) return ret; TRACE (ENTRIES, "Redirect %s -> %s\n", conn->request_original.buf, conn->redirect.buf); @@ -248,8 +259,6 @@ match_and_substitute (cherokee_handler_redir_t *hdl) goto out; } - ret = ret_ok; - out: if (! cherokee_buffer_is_empty (&conn->query_string)) { cherokee_buffer_drop_ending (&conn->request, conn->query_string.len + 1); @@ -261,7 +270,7 @@ match_and_substitute (cherokee_handler_redir_t *hdl) cherokee_buffer_move_to_begin (&conn->request, conn->web_directory.len); } - return ret; + return ret_ok; } @@ -298,6 +307,8 @@ cherokee_handler_redir_new (cherokee_handler_t **hdl, void *cnt, cherokee_module if (ret == ret_eagain) { cherokee_handler_free (HANDLER(n)); return ret_eagain; + } else if (unlikely (ret != ret_ok)) { + return ret; } } } @@ -321,6 +332,7 @@ cherokee_handler_redir_free (cherokee_handler_redir_t *rehdl) ret_t cherokee_handler_redir_init (cherokee_handler_redir_t *n) { + ret_t ret; int request_end; char *request_ending; cherokee_connection_t *conn = HANDLER_CONN(n); @@ -345,7 +357,9 @@ cherokee_handler_redir_init (cherokee_handler_redir_t *n) request_end = (conn->request.len - conn->web_directory.len); request_ending = conn->request.buf + conn->web_directory.len; - cherokee_buffer_ensure_size (&conn->redirect, request_end + HDL_REDIR_PROPS(n)->url.len +1); + ret = cherokee_buffer_ensure_size (&conn->redirect, request_end + HDL_REDIR_PROPS(n)->url.len +1); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add_buffer (&conn->redirect, &HDL_REDIR_PROPS(n)->url); cherokee_buffer_add (&conn->redirect, request_ending, request_end); diff --git a/cherokee/handler_render_rrd.c b/cherokee/handler_render_rrd.c index 4ba10ae9c..2c1d4b0f8 100644 --- a/cherokee/handler_render_rrd.c +++ b/cherokee/handler_render_rrd.c @@ -60,13 +60,17 @@ static cherokee_boolean_t check_image_freshness (cherokee_buffer_t *buf, cherokee_collector_rrd_interval_t *interval) { + ret_t ret; int re; struct stat info; /* cache_img_dir + "/" + buf + "_" + interval + ".png" */ - cherokee_buffer_prepend_str (buf, "/"); - cherokee_buffer_prepend_buf (buf, &rrd_connection->path_img_cache); + ret = cherokee_buffer_prepend_str (buf, "/"); + if (unlikely (ret != ret_ok)) return false; + + ret = cherokee_buffer_prepend_buf (buf, &rrd_connection->path_img_cache); + if (unlikely (ret != ret_ok)) return false; cherokee_buffer_add_char (buf, '_'); cherokee_buffer_add (buf, interval->interval, strlen(interval->interval)); @@ -304,7 +308,7 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) cherokee_collector_rrd_interval_t *interval; cherokee_boolean_t fresh; cherokee_connection_t *conn = HANDLER_CONN(hdl); - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* The handler might be disabled */ @@ -338,6 +342,10 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) return ret_error; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + /* Launch the task */ if (! strncmp (begin, "/server_accepts_", 16)) { @@ -434,7 +442,7 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) } else if (! strncmp (begin, "/vserver_traffic_", 17)) { const char *vserver_name; int vserver_len; - cherokee_buffer_t vserver_buf = CHEROKEE_BUF_INIT; + cherokee_buffer_t vserver_buf; /* Virtual server name */ @@ -447,8 +455,10 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) return ret_error; } + cherokee_buffer_init (&vserver_buf); cherokee_buffer_add (&vserver_buf, vserver_name, vserver_len); - cherokee_buffer_replace_string (&vserver_buf, " ", 1, "_", 1); + ret = cherokee_buffer_replace_string (&vserver_buf, " ", 1, "_", 1); + if (unlikely (ret != ret_ok)) return ret; /* Is it fresh enough? */ @@ -462,6 +472,7 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) unlocked = CHEROKEE_MUTEX_TRY_LOCK (&rrd_connection->mutex); if (unlocked) { cherokee_connection_sleep (conn, 200); + cherokee_buffer_mrproper (&vserver_buf); return ret_eagain; } @@ -504,7 +515,8 @@ cherokee_handler_render_rrd_init (cherokee_handler_render_rrd_t *hdl) cherokee_buffer_add_buffer (&conn->request_original, &conn->request); } - cherokee_buffer_replace_string (&conn->request, " ", 1, "_", 1); + ret = cherokee_buffer_replace_string (&conn->request, " ", 1, "_", 1); + if (unlikely (ret != ret_ok)) return ret; /* Handler file init */ diff --git a/cherokee/handler_scgi.c b/cherokee/handler_scgi.c index 975492cd3..d316fe4de 100644 --- a/cherokee/handler_scgi.c +++ b/cherokee/handler_scgi.c @@ -105,11 +105,12 @@ cherokee_handler_scgi_configure (cherokee_config_node_t *conf, cherokee_server_t } -static void +static ret_t add_env_pair (cherokee_handler_cgi_base_t *cgi_base, const char *key, int key_len, const char *val, int val_len) { + ret_t ret; static char zero = '\0'; cherokee_handler_scgi_t *scgi = HDL_SCGI(cgi_base); @@ -125,12 +126,15 @@ add_env_pair (cherokee_handler_cgi_base_t *cgi_base, TRACE (ENTRIES, "%s", tmp->buf); #endif - cherokee_buffer_ensure_size (&scgi->header, scgi->header.len + key_len + val_len + 3); + ret = cherokee_buffer_ensure_size (&scgi->header, scgi->header.len + key_len + val_len + 3); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add (&scgi->header, key, key_len); cherokee_buffer_add (&scgi->header, &zero, 1); cherokee_buffer_add (&scgi->header, val, val_len); cherokee_buffer_add (&scgi->header, &zero, 1); + + return ret_ok; } @@ -225,9 +229,10 @@ cherokee_handler_scgi_free (cherokee_handler_scgi_t *hdl) } -static ret_t +static ret_t must_check netstringer (cherokee_buffer_t *buf) { + ret_t ret; cint_t len; CHEROKEE_TEMP(num,16); @@ -235,9 +240,14 @@ netstringer (cherokee_buffer_t *buf) if (len < 0) return ret_error; - cherokee_buffer_ensure_size (buf, buf->len + len + 2); - cherokee_buffer_prepend (buf, num, len); - cherokee_buffer_add (buf, ",", 1); + ret = cherokee_buffer_ensure_size (buf, buf->len + len + 2); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_prepend (buf, num, len); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add (buf, ",", 1); + if (unlikely (ret != ret_ok)) return ret; #if 0 cherokee_buffer_print_debug (buf, -1); @@ -250,14 +260,18 @@ netstringer (cherokee_buffer_t *buf) static ret_t build_header (cherokee_handler_scgi_t *hdl) { + ret_t ret; cuint_t len; char tmp[64]; cherokee_connection_t *conn = HANDLER_CONN(hdl); len = snprintf (tmp, sizeof(tmp), FMT_OFFSET, (CST_OFFSET)conn->post.len); - set_env (HDL_CGI_BASE(hdl), "CONTENT_LENGTH", tmp, len); - set_env (HDL_CGI_BASE(hdl), "SCGI", "1", 1); + ret = set_env (HDL_CGI_BASE(hdl), "CONTENT_LENGTH", tmp, len); + if (unlikely (ret != ret_ok)) return ret; + + ret = set_env (HDL_CGI_BASE(hdl), "SCGI", "1", 1); + if (unlikely (ret != ret_ok)) return ret; cherokee_handler_cgi_base_build_envp (HDL_CGI_BASE(hdl), conn); diff --git a/cherokee/handler_secdownload.c b/cherokee/handler_secdownload.c index 929dd2ca8..8f7d3d29b 100644 --- a/cherokee/handler_secdownload.c +++ b/cherokee/handler_secdownload.c @@ -128,7 +128,7 @@ cherokee_handler_secdownload_new (cherokee_handler_t **hdl, cuint_t path_len; time_t time_url; char *time_s; - cherokee_buffer_t md5 = CHEROKEE_BUF_INIT; + cherokee_buffer_t md5; cherokee_connection_t *conn = CONN(cnt); TRACE(ENTRIES, "Analyzing request '%s'\n", conn->request.buf); @@ -184,18 +184,21 @@ cherokee_handler_secdownload_new (cherokee_handler_t **hdl, */ path_len = (conn->request.buf + conn->request.len) - p; + cherokee_buffer_init (&md5); cherokee_buffer_add_buffer (&md5, &PROP_SECDOWN(props)->secret); cherokee_buffer_add (&md5, p, path_len); cherokee_buffer_add (&md5, time_s, 8); - cherokee_buffer_encode_md5_digest (&md5); + ret = cherokee_buffer_encode_md5_digest (&md5); + if (unlikely (ret != ret_ok)) return ret; re = strncasecmp (md5.buf, &conn->request.buf[1], 32); if (re != 0) { #ifdef TRACE_ENABLED if (cherokee_trace_is_tracing()) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_init (&tmp); cherokee_buffer_add_str (&tmp, "secret='"); cherokee_buffer_add_buffer (&tmp, &PROP_SECDOWN(props)->secret); cherokee_buffer_add_str (&tmp, "', path='"); diff --git a/cherokee/handler_server_info.c b/cherokee/handler_server_info.c index 9795b8ee0..7f0578b53 100644 --- a/cherokee/handler_server_info.c +++ b/cherokee/handler_server_info.c @@ -307,8 +307,11 @@ add_uptime (cherokee_dwriter_t *writer, cherokee_server_t *srv) cuint_t days; cuint_t hours; cuint_t mins; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; cuint_t lapse = cherokee_bogonow_now - srv->start_time; + cherokee_buffer_t tmp; + + /* Initialise the buffers */ + cherokee_buffer_init (&tmp); cherokee_dwriter_dict_open (writer); @@ -349,7 +352,11 @@ static void add_traffic (cherokee_dwriter_t *writer, cherokee_server_t *srv) { cherokee_list_t *i; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); /* Global statistics */ @@ -611,18 +618,22 @@ server_info_build_logo (cherokee_handler_server_info_t *hdl, cherokee_buffer_t * static ret_t server_info_build_html (cherokee_handler_server_info_t *hdl, cherokee_buffer_t *buffer) { - cherokee_buffer_t ver = CHEROKEE_BUF_INIT; + ret_t ret; + cherokee_buffer_t ver; cherokee_buffer_add_str (buffer, PAGE_HEADER); cherokee_buffer_add_str (buffer, AJAX_JS); + cherokee_buffer_init (&ver); cherokee_version_add (&ver, HANDLER_SRV(hdl)->server_token); - cherokee_buffer_replace_string (buffer, "{cherokee_name}", 15, ver.buf, ver.len); + ret = cherokee_buffer_replace_string (buffer, "{cherokee_name}", 15, ver.buf, ver.len); cherokee_buffer_mrproper (&ver); + if (unlikely (ret != ret_ok)) return ret; - cherokee_buffer_replace_string (buffer, "{request}", 9, - HANDLER_CONN(hdl)->request.buf, - HANDLER_CONN(hdl)->request.len); + ret = cherokee_buffer_replace_string (buffer, "{request}", 9, + HANDLER_CONN(hdl)->request.buf, + HANDLER_CONN(hdl)->request.len); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add_str (buffer, PAGE_FOOT); return ret_ok; @@ -653,7 +664,7 @@ add_iocache (cherokee_dwriter_t *writer, cherokee_server_t *srv) { float percent; size_t mmaped = 0; - cherokee_buffer_t tmp_buf = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp_buf; cherokee_iocache_t *iocache = srv->iocache; if (iocache == NULL) { @@ -661,6 +672,9 @@ add_iocache (cherokee_dwriter_t *writer, cherokee_server_t *srv) return; } + /* Initialise the buffers */ + cherokee_buffer_init (&tmp_buf); + cherokee_dwriter_dict_open (writer); /* General parameters */ @@ -725,7 +739,9 @@ static void add_detailed_connections (cherokee_dwriter_t *writer, cherokee_list_t *infos) { cherokee_list_t *i, *j; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); cherokee_dwriter_list_open (writer); @@ -793,12 +809,13 @@ server_info_build_info (cherokee_handler_server_info_t *hdl) ret_t ret; cherokee_dwriter_t *writer = &hdl->writer; cherokee_server_t *srv = HANDLER_SRV(hdl); - cherokee_buffer_t ver = CHEROKEE_BUF_INIT; + cherokee_buffer_t ver; cherokee_dwriter_dict_open (writer); /* Version */ + cherokee_buffer_init (&ver); cherokee_version_add (&ver, HANDLER_SRV(hdl)->server_token); cherokee_dwriter_cstring (writer, "version"); cherokee_dwriter_bstring (writer, &ver); @@ -872,9 +889,7 @@ cherokee_handler_server_info_new (cherokee_handler_t **hdl, /* Init */ - ret = cherokee_buffer_init (&n->buffer); - if (unlikely(ret != ret_ok)) - goto error; + cherokee_buffer_init (&n->buffer); ret = cherokee_buffer_ensure_size (&n->buffer, 4*1024); if (unlikely(ret != ret_ok)) diff --git a/cherokee/handler_ssi.c b/cherokee/handler_ssi.c index be37aa3c5..e47c88fd6 100644 --- a/cherokee/handler_ssi.c +++ b/cherokee/handler_ssi.c @@ -177,10 +177,15 @@ parse (cherokee_handler_ssi_t *hdl, path_type_t path; struct stat info; cherokee_boolean_t ignore; - cherokee_buffer_t key = CHEROKEE_BUF_INIT; - cherokee_buffer_t val = CHEROKEE_BUF_INIT; - cherokee_buffer_t pair = CHEROKEE_BUF_INIT; - cherokee_buffer_t fpath = CHEROKEE_BUF_INIT; + cherokee_buffer_t key; + cherokee_buffer_t val; + cherokee_buffer_t pair; + cherokee_buffer_t fpath; + + cherokee_buffer_init (&key); + cherokee_buffer_init (&val); + cherokee_buffer_init (&pair); + cherokee_buffer_init (&fpath); q = in->buf; @@ -317,7 +322,9 @@ parse (cherokee_handler_ssi_t *hdl, if (! ignore) { switch (op) { case op_include: { - cherokee_buffer_t file_content = CHEROKEE_BUF_INIT; + cherokee_buffer_t file_content; + + cherokee_buffer_init (&file_content); ret = cherokee_buffer_read_file (&file_content, fpath.buf); if (unlikely (ret != ret_ok)) { diff --git a/cherokee/handler_uwsgi.c b/cherokee/handler_uwsgi.c index 382723d5b..cd9f8ef4d 100644 --- a/cherokee/handler_uwsgi.c +++ b/cherokee/handler_uwsgi.c @@ -129,17 +129,19 @@ cherokee_handler_uwsgi_configure (cherokee_config_node_t *conf, cherokee_server_ } -static void +static ret_t must_check add_env_pair (cherokee_handler_cgi_base_t *cgi_base, const char *key, int key_len, const char *val, int val_len) { + ret_t ret; uint16_t u_key_len = (uint16_t) key_len ; uint16_t u_val_len = (uint16_t) val_len ; cherokee_handler_uwsgi_t *uwsgi = HDL_UWSGI(cgi_base); /* 2 bytes for every string (16 bit le) */ - cherokee_buffer_ensure_size (&uwsgi->header, uwsgi->header.len + key_len + val_len + 4); + ret = cherokee_buffer_ensure_size (&uwsgi->header, uwsgi->header.len + key_len + val_len + 4); + if (unlikely (ret != ret_ok)) return ret; /* force to le if cherokee is big-endian */ #if BYTE_ORDER == BIG_ENDIAN @@ -158,6 +160,8 @@ add_env_pair (cherokee_handler_cgi_base_t *cgi_base, u_val_len = uwsgi_swap16(u_val_len); #endif cherokee_buffer_add (&uwsgi->header, val, val_len); + + return ret_ok; } @@ -253,12 +257,12 @@ cherokee_handler_uwsgi_free (cherokee_handler_uwsgi_t *hdl) } -static ret_t +static ret_t must_check uwsgi_fix_packet (cherokee_buffer_t *buf, uint8_t modifier1, uint8_t modifier2) { - + ret_t ret; uwsgi_header uh; uh.modifier1 = modifier1 ; @@ -269,16 +273,17 @@ uwsgi_fix_packet (cherokee_buffer_t *buf, uh.env_size = (uint16_t) buf->len ; #endif - cherokee_buffer_ensure_size (buf, buf->len + 4); - cherokee_buffer_prepend (buf, (const char * )&uh, 4); + ret = cherokee_buffer_ensure_size (buf, buf->len + 4); + if (unlikely (ret != ret_ok)) return ret; - return ret_ok; + return cherokee_buffer_prepend (buf, (const char * )&uh, 4); } static ret_t build_header (cherokee_handler_uwsgi_t *hdl) { + ret_t ret; cuint_t len; char tmp[64]; cherokee_connection_t *conn = HANDLER_CONN(hdl); @@ -286,7 +291,8 @@ build_header (cherokee_handler_uwsgi_t *hdl) if (props->pass_request_body == true && props->pass_wsgi_vars == true) { len = snprintf (tmp, sizeof(tmp), FMT_OFFSET, (CST_OFFSET)conn->post.len); - add_env_pair(HDL_CGI_BASE(hdl), "CONTENT_LENGTH", 14, tmp, len); + ret = add_env_pair(HDL_CGI_BASE(hdl), "CONTENT_LENGTH", 14, tmp, len); + if (unlikely (ret != ret_ok)) return ret; } if (props->pass_wsgi_vars == true) { diff --git a/cherokee/header.c b/cherokee/header.c index 141e4e06d..b1633a8a8 100644 --- a/cherokee/header.c +++ b/cherokee/header.c @@ -1186,8 +1186,11 @@ ret_t cherokee_header_foreach_unknown (cherokee_header_t *hdr, cherokee_header_foreach_func_t func, void *data) { int i; - cherokee_buffer_t tmp_hdr = CHEROKEE_BUF_INIT; - cherokee_buffer_t tmp_val = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp_hdr; + cherokee_buffer_t tmp_val; + + cherokee_buffer_init (&tmp_hdr); + cherokee_buffer_init (&tmp_val); HEADER_INTERNAL_CHECK(hdr); diff --git a/cherokee/header.h b/cherokee/header.h index 44dedf98e..d7b51f496 100644 --- a/cherokee/header.h +++ b/cherokee/header.h @@ -97,7 +97,7 @@ ret_t cherokee_header_foreach_unknown (cherokee_header_t *hdr, cherokee_head ret_t cherokee_header_copy_request (cherokee_header_t *hdr, cherokee_buffer_t *request); ret_t cherokee_header_copy_query_string (cherokee_header_t *hdr, cherokee_buffer_t *query_string); -ret_t cherokee_header_copy_request_w_args (cherokee_header_t *hdr, cherokee_buffer_t *request); +ret_t must_check cherokee_header_copy_request_w_args (cherokee_header_t *hdr, cherokee_buffer_t *request); ret_t cherokee_header_get_request_w_args (cherokee_header_t *hdr, char **req, int *req_len); ret_t cherokee_header_has_known (cherokee_header_t *hdr, cherokee_common_header_t header); diff --git a/cherokee/info.c b/cherokee/info.c index bd0f86ddf..8e4a304f1 100644 --- a/cherokee/info.c +++ b/cherokee/info.c @@ -30,7 +30,7 @@ void cherokee_info_build_print (cherokee_server_t *srv) { - cherokee_buffer_t builtin = CHEROKEE_BUF_INIT; + cherokee_buffer_t builtin; /* Basic info */ @@ -53,6 +53,7 @@ cherokee_info_build_print (cherokee_server_t *srv) /* Print plug-ins information */ + cherokee_buffer_init (&builtin); printf ("Plug-ins\n"); cherokee_plugin_loader_get_mods_info (&srv->loader, &builtin); printf (" Built-in: %s\n", builtin.buf ? builtin.buf : ""); diff --git a/cherokee/logger_custom.c b/cherokee/logger_custom.c index dac859fc8..7a5df0c09 100644 --- a/cherokee/logger_custom.c +++ b/cherokee/logger_custom.c @@ -52,6 +52,7 @@ add_ip_remote (cherokee_template_t *template, cherokee_buffer_t *output, void *param) { + ret_t ret; cuint_t prev_len; cherokee_connection_t *conn = CONN(param); @@ -69,7 +70,9 @@ add_ip_remote (cherokee_template_t *template, */ prev_len = output->len; - cherokee_buffer_ensure_addlen (output, CHE_INET_ADDRSTRLEN); + ret = cherokee_buffer_ensure_addlen (output, CHE_INET_ADDRSTRLEN); + if (unlikely (ret != ret_ok)) return ret; + cherokee_socket_ntop (&conn->socket, (output->buf + output->len), (output->size - output->len) -1); diff --git a/cherokee/logger_ncsa.c b/cherokee/logger_ncsa.c index e4744ef58..332ceaff7 100644 --- a/cherokee/logger_ncsa.c +++ b/cherokee/logger_ncsa.c @@ -135,9 +135,15 @@ cherokee_logger_ncsa_init_base (cherokee_logger_ncsa_t *logger, cherokee_buffer_init (&logger->now_dtm); cherokee_buffer_init (&logger->referer); cherokee_buffer_init (&logger->useragent); - cherokee_buffer_ensure_size (&logger->now_dtm, 64); - cherokee_buffer_ensure_size (&logger->referer, 1024); - cherokee_buffer_ensure_size (&logger->useragent, 512); + + ret = cherokee_buffer_ensure_size (&logger->now_dtm, 64); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_ensure_size (&logger->referer, 1024); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_ensure_size (&logger->useragent, 512); + if (unlikely (ret != ret_ok)) return ret; /* Init the logger writer */ @@ -300,7 +306,9 @@ build_log_string (cherokee_logger_ncsa_t *logger, cherokee_header_copy_known (&cnt->header, header_referer, referer); cherokee_header_copy_known (&cnt->header, header_user_agent, useragent); - cherokee_buffer_ensure_addlen (buf, 8 + referer->len + referer->len); + + ret = cherokee_buffer_ensure_addlen (buf, 8 + referer->len + referer->len); + if (unlikely (ret != ret_ok)) return ret; if (referer->len > 0) { cherokee_buffer_add_str (buf, " \""); diff --git a/cherokee/logger_writer.c b/cherokee/logger_writer.c index 0a91507af..c197e3eff 100644 --- a/cherokee/logger_writer.c +++ b/cherokee/logger_writer.c @@ -48,6 +48,8 @@ typedef struct { ret_t cherokee_logger_writer_new (cherokee_logger_writer_t **writer) { + ret_t ret; + CHEROKEE_NEW_STRUCT(n,logger_writer); INIT_LIST_HEAD (&n->listed); @@ -60,7 +62,8 @@ cherokee_logger_writer_new (cherokee_logger_writer_t **writer) cherokee_buffer_init (&n->filename); cherokee_buffer_init (&n->buffer); - cherokee_buffer_ensure_size (&n->buffer, n->max_bufsize); + ret = cherokee_buffer_ensure_size (&n->buffer, n->max_bufsize); + if (unlikely (ret != ret_ok)) return ret; n->priv = malloc (sizeof(priv_t)); if (n->priv == NULL) { diff --git a/cherokee/macros.h b/cherokee/macros.h index 9aaddf2f7..5f8b8a5e0 100644 --- a/cherokee/macros.h +++ b/cherokee/macros.h @@ -404,7 +404,8 @@ cherokee_ ## klass ## _free (cherokee_ ## klass ## _t *obj) { \ #define CHEROKEE_PRINT_BACKTRACE \ do { \ - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; \ + cherokee_buffer_t tmp; \ + cherokee_buffer_init (&tmp); \ cherokee_buf_add_backtrace (&tmp, 0, "\n", ""); \ PRINT_MSG ("%s", tmp.buf); \ cherokee_buffer_mrproper (&tmp); \ diff --git a/cherokee/main_admin.c b/cherokee/main_admin.c index 04215e5ac..f0d7bc3fb 100644 --- a/cherokee/main_admin.c +++ b/cherokee/main_admin.c @@ -75,7 +75,7 @@ static int iocache = 1; static int scgi_port = 4000; static int thread_num = -1; static cherokee_server_t *srv = NULL; -static cherokee_buffer_t password = CHEROKEE_BUF_INIT; +static cherokee_buffer_t password; static ret_t @@ -84,8 +84,9 @@ find_empty_port (int starting, int *port) ret_t ret; cherokee_socket_t s; int p = starting; - cherokee_buffer_t bind_ = CHEROKEE_BUF_INIT; + cherokee_buffer_t bind_; + cherokee_buffer_init (&bind_); cherokee_buffer_add_str (&bind_, "127.0.0.1"); cherokee_socket_init (&s); @@ -187,10 +188,16 @@ config_server (cherokee_server_t *srv) ret_t ret; cherokee_config_node_t conf; cuint_t nthreads; - cherokee_buffer_t buf = CHEROKEE_BUF_INIT; - cherokee_buffer_t rrd_dir = CHEROKEE_BUF_INIT; - cherokee_buffer_t rrd_bin = CHEROKEE_BUF_INIT; cherokee_buffer_t fake; + cherokee_buffer_t buf; + cherokee_buffer_t rrd_dir; + cherokee_buffer_t rrd_bin; + + /* Initialise the buffers + */ + cherokee_buffer_init (&buf); + cherokee_buffer_init (&rrd_dir); + cherokee_buffer_init (&rrd_bin); /* Generate the password */ @@ -426,16 +433,19 @@ config_server (cherokee_server_t *srv) ret = cherokee_server_read_config_string (srv, &buf); if (ret != ret_ok) { PRINT_ERROR_S ("Could not initialize the server\n"); - return ret; + goto out; } + ret = ret_ok; + +out: cherokee_config_node_mrproper (&conf); cherokee_buffer_mrproper (&rrd_bin); cherokee_buffer_mrproper (&rrd_dir); cherokee_buffer_mrproper (&buf); - return ret_ok; + return ret; } @@ -584,11 +594,14 @@ signals_handler (int sig, siginfo_t *si, void *context) ret_t ret; int retcode; - UNUSED(context); + UNUSED (context); switch (sig) { case SIGCHLD: ret = cherokee_wait_pid (si->si_pid, &retcode); + if (ret == ret_ok) { + UNUSED (retcode); + } break; case SIGINT: @@ -617,6 +630,8 @@ main (int argc, char **argv) config_file = strdup (DEFAULT_CONFIG_FILE); bind_to = strdup (DEFAULT_BIND); + cherokee_buffer_init (&password); + if ((!bind_to) || (!config_file) || (!document_root)) { PRINT_MSG ("ERROR: Couldn't allocate memory.\n"); exit (EXIT_ERROR); diff --git a/cherokee/main_worker.c b/cherokee/main_worker.c index ad7e6c807..f5eaa7c5b 100644 --- a/cherokee/main_worker.c +++ b/cherokee/main_worker.c @@ -199,8 +199,8 @@ common_server_initialization (cherokee_server_t *srv) #endif if (document_root != NULL) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; - cherokee_buffer_t droot = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_t droot; /* Sanity check */ @@ -209,6 +209,11 @@ common_server_initialization (cherokee_server_t *srv) return ret_error; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + cherokee_buffer_init (&droot); + /* Build the configuration string */ cherokee_buffer_add (&droot, document_root, strlen(document_root)); diff --git a/cherokee/md5crypt.c b/cherokee/md5crypt.c index 9cafb2a72..c9349f57f 100644 --- a/cherokee/md5crypt.c +++ b/cherokee/md5crypt.c @@ -63,7 +63,7 @@ to64 (char *tmp, unsigned long v, int n) char * md5_crypt(const char *pw, const char *salt, const char *magic, char passwd[MD5CRYPT_PASSWD_LEN]) { - char salt_copy[9], *p; + char salt_copy[9]; const char *sp, *ep; unsigned char final[16]; int sl, pl, i, j; @@ -165,8 +165,6 @@ md5_crypt(const char *pw, const char *salt, const char *magic, char passwd[MD5CR MD5Final(final, &ctx1); } - p = passwd + strlen(passwd); - l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; strlcat (passwd, to64(to64_buf, l, 4), MD5CRYPT_PASSWD_LEN); l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; diff --git a/cherokee/nonce.c b/cherokee/nonce.c index ed880680e..af95f9b57 100644 --- a/cherokee/nonce.c +++ b/cherokee/nonce.c @@ -146,17 +146,24 @@ cherokee_nonce_table_generate (cherokee_nonce_table_t *nonces, cherokee_connection_t *conn, cherokee_buffer_t *nonce) { + ret_t ret; entry_t *entry; /* Generate nonce string */ - cherokee_buffer_add_ullong16(nonce, (cullong_t) cherokee_bogonow_now); - cherokee_buffer_add_ulong16 (nonce, (culong_t) rand()); - cherokee_buffer_add_ulong16 (nonce, (culong_t) POINTER_TO_INT(conn)); + ret = cherokee_buffer_add_ullong16(nonce, (cullong_t) cherokee_bogonow_now); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add_ulong16 (nonce, (culong_t) rand()); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_add_ulong16 (nonce, (culong_t) POINTER_TO_INT(conn)); + if (unlikely (ret != ret_ok)) return ret; /* Compute MD5 and overwrite buffer content without reallocating it ! */ - cherokee_buffer_encode_md5_digest (nonce); + ret = cherokee_buffer_encode_md5_digest (nonce); + if (unlikely (ret != ret_ok)) return ret; /* Copy the nonce and add to the table */ @@ -164,7 +171,8 @@ cherokee_nonce_table_generate (cherokee_nonce_table_t *nonces, if (unlikely (entry == NULL)) return ret_nomem; - cherokee_buffer_add_buffer (&entry->nonce, nonce); + ret = cherokee_buffer_add_buffer (&entry->nonce, nonce); + if (unlikely (ret != ret_ok)) return ret; CHEROKEE_MUTEX_LOCK (&nonces->access); cherokee_avl_add (&nonces->table, nonce, entry); diff --git a/cherokee/nonce.h b/cherokee/nonce.h index d8341c37a..c7247eb0b 100644 --- a/cherokee/nonce.h +++ b/cherokee/nonce.h @@ -41,9 +41,9 @@ ret_t cherokee_nonce_table_new (cherokee_nonce_table_t **nonces); ret_t cherokee_nonce_table_free (cherokee_nonce_table_t *nonces); ret_t cherokee_nonce_table_cleanup (cherokee_nonce_table_t *nonces); -ret_t cherokee_nonce_table_check (cherokee_nonce_table_t *nonces, cherokee_buffer_t *nonce); -ret_t cherokee_nonce_table_remove (cherokee_nonce_table_t *nonces, cherokee_buffer_t *nonce); -ret_t cherokee_nonce_table_generate (cherokee_nonce_table_t *nonces, cherokee_connection_t *conn, cherokee_buffer_t *nonce); +ret_t dont_check cherokee_nonce_table_check (cherokee_nonce_table_t *nonces, cherokee_buffer_t *nonce); +ret_t dont_check cherokee_nonce_table_remove (cherokee_nonce_table_t *nonces, cherokee_buffer_t *nonce); +ret_t must_check cherokee_nonce_table_generate (cherokee_nonce_table_t *nonces, cherokee_connection_t *conn, cherokee_buffer_t *nonce); CHEROKEE_END_DECLS diff --git a/cherokee/plugin_loader.c b/cherokee/plugin_loader.c index c12394be8..7bf67ad0b 100644 --- a/cherokee/plugin_loader.c +++ b/cherokee/plugin_loader.c @@ -115,17 +115,13 @@ cherokee_plugin_loader_init (cherokee_plugin_loader_t *loader) /* Plug-in dir */ - ret = cherokee_buffer_init (&loader->module_dir); - if (unlikely(ret < ret_ok)) - return ret; + cherokee_buffer_init (&loader->module_dir); cherokee_buffer_add_str (&loader->module_dir, CHEROKEE_PLUGINDIR); /* Plug-in dependencies dir */ - ret = cherokee_buffer_init (&loader->deps_dir); - if (unlikely(ret < ret_ok)) - return ret; + cherokee_buffer_init (&loader->deps_dir); cherokee_buffer_add_str (&loader->deps_dir, CHEROKEE_DEPSDIR); @@ -180,7 +176,9 @@ dylib_open (cherokee_plugin_loader_t *loader, ret_t ret; void *lib; int flags; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); flags = RTLD_BASE | extra_flags; @@ -219,10 +217,11 @@ execute_init_func (cherokee_plugin_loader_t *loader, { ret_t ret; void (*init_func) (cherokee_plugin_loader_t *); - cherokee_buffer_t init_name = CHEROKEE_BUF_INIT; + cherokee_buffer_t init_name; /* Build the init function name */ + cherokee_buffer_init (&init_name); ret = cherokee_buffer_add_va (&init_name, "cherokee_plugin_%s_init", module); if (unlikely(ret < ret_ok)) { cherokee_buffer_mrproper (&init_name); @@ -265,10 +264,11 @@ get_info (cherokee_plugin_loader_t *loader, void **dl_handler) { ret_t ret; - cherokee_buffer_t info_name = CHEROKEE_BUF_INIT; + cherokee_buffer_t info_name; /* Build the info struct string */ + cherokee_buffer_init (&info_name); cherokee_buffer_add_va (&info_name, "cherokee_%s_info", module); /* Open it @@ -298,8 +298,9 @@ check_deps_file (cherokee_plugin_loader_t *loader, { FILE *file; char temp[128]; - cherokee_buffer_t filename = CHEROKEE_BUF_INIT; + cherokee_buffer_t filename; + cherokee_buffer_init (&filename); cherokee_buffer_add_va (&filename, "%s/%s.deps", loader->deps_dir.buf, modname); file = fopen (filename.buf, "r"); if (file == NULL) diff --git a/cherokee/post_track.c b/cherokee/post_track.c index 77fee5f05..9064fbd38 100644 --- a/cherokee/post_track.c +++ b/cherokee/post_track.c @@ -162,7 +162,7 @@ _register (cherokee_post_track_t *track, { ret_t ret; cherokee_post_track_entry_t *entry = NULL; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; TRACE (ENTRIES, "Register conn ID: %d\n", conn->id); @@ -172,10 +172,15 @@ _register (cherokee_post_track_t *track, return ret_ok; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + /* Look for X-Progress-ID */ ret = _figure_x_progress_id (conn, &tmp); if (ret != ret_ok) { + cherokee_buffer_mrproper (&tmp); return ret_ok; } diff --git a/cherokee/proxy_hosts.c b/cherokee/proxy_hosts.c index df772a5bc..72dcdf555 100644 --- a/cherokee/proxy_hosts.c +++ b/cherokee/proxy_hosts.c @@ -254,6 +254,7 @@ poll_release (cherokee_handler_proxy_poll_t *poll, ret_t cherokee_handler_proxy_conn_new (cherokee_handler_proxy_conn_t **pconn) { + ret_t ret; CHEROKEE_NEW_STRUCT (n, handler_proxy_conn); /* Socket stuff @@ -265,7 +266,8 @@ cherokee_handler_proxy_conn_new (cherokee_handler_proxy_conn_t **pconn) cherokee_buffer_init (&n->post.buf_temp); cherokee_buffer_init (&n->header_in_raw); - cherokee_buffer_ensure_size (&n->header_in_raw, 512); + ret = cherokee_buffer_ensure_size (&n->header_in_raw, 512); + if (unlikely (ret != ret_ok)) return ret; n->poll_ref = NULL; n->keepalive_in = false; diff --git a/cherokee/request.c b/cherokee/request.c index 15babca7b..fed7e4720 100644 --- a/cherokee/request.c +++ b/cherokee/request.c @@ -106,7 +106,8 @@ cherokee_request_header_build_string (cherokee_request_header_t *request, cherok /* 200 bytes should be enough for a small header */ - cherokee_buffer_ensure_size (buf, 200); + ret = cherokee_buffer_ensure_size (buf, 200); + if (unlikely (ret != ret_ok)) return ret; /* Add main request line: * GET /dir/object HTTP/1.1 @@ -177,7 +178,8 @@ cherokee_request_header_build_string (cherokee_request_header_t *request, cherok cherokee_buffer_add_char (tmp1, ':'); cherokee_buffer_add_buffer (tmp1, &request->password); - cherokee_buffer_encode_base64 (tmp1, tmp2); + ret = cherokee_buffer_encode_base64 (tmp1, tmp2); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add_str (buf, "Authorization: Basic "); cherokee_buffer_add_buffer (buf, tmp2); @@ -218,7 +220,11 @@ cherokee_request_header_set_auth (cherokee_request_header_t *request, ret_t cherokee_request_header_add_header (cherokee_request_header_t *request, char *ptr, cuint_t len) { - cherokee_buffer_ensure_addlen (&request->extra_headers, len + CSZLEN(CRLF)); + ret_t ret; + + ret = cherokee_buffer_ensure_addlen (&request->extra_headers, len + CSZLEN(CRLF)); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add (&request->extra_headers, ptr, len); cherokee_buffer_add_str (&request->extra_headers, CRLF); diff --git a/cherokee/request.h b/cherokee/request.h index ecfc1c49e..8cf18df79 100644 --- a/cherokee/request.h +++ b/cherokee/request.h @@ -64,7 +64,7 @@ ret_t cherokee_request_header_clean (cherokee_request_header_t *request); ret_t cherokee_request_header_mrproper (cherokee_request_header_t *request); ret_t cherokee_request_header_parse_string (cherokee_request_header_t *request, cherokee_buffer_t *url_string); -ret_t cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2); +ret_t must_check cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2); ret_t cherokee_request_header_uses_proxy (cherokee_request_header_t *request, cherokee_boolean_t proxy); ret_t cherokee_request_header_add_header (cherokee_request_header_t *request, char *ptr, cuint_t len); diff --git a/cherokee/rrd_tools.c b/cherokee/rrd_tools.c index 1abf1b0ff..6a87cee45 100644 --- a/cherokee/rrd_tools.c +++ b/cherokee/rrd_tools.c @@ -412,8 +412,8 @@ cherokee_rrd_connection_create_srv_db (cherokee_rrd_connection_t *rrd_conn) { ret_t ret; cherokee_boolean_t exist; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; - cherokee_buffer_t dbname = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + cherokee_buffer_t dbname; /* Ensure directories are accessible */ @@ -432,6 +432,11 @@ cherokee_rrd_connection_create_srv_db (cherokee_rrd_connection_t *rrd_conn) return ret_error; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + cherokee_buffer_init (&dbname); + /* Check the Server database */ cherokee_buffer_add_buffer (&dbname, &rrd_conn->path_databases); @@ -439,7 +444,8 @@ cherokee_rrd_connection_create_srv_db (cherokee_rrd_connection_t *rrd_conn) exist = ensure_db_exists (&dbname); if (exist) { - return ret_ok; + ret = ret_ok; + goto out; } cherokee_buffer_add_str (&tmp, "create "); @@ -477,14 +483,17 @@ cherokee_rrd_connection_create_srv_db (cherokee_rrd_connection_t *rrd_conn) ret = cherokee_rrd_connection_spawn (rrd_conn); if (unlikely (ret != ret_ok)) { - return ret_error; + ret = ret_error; + goto out; } ret = cherokee_rrd_connection_execute (rrd_conn, &tmp); if (unlikely (ret != ret_ok)) { - return ret_error; + ret = ret_error; + goto out; } +out: cherokee_buffer_mrproper (&dbname); cherokee_buffer_mrproper (&tmp); return ret_ok; @@ -497,7 +506,7 @@ cherokee_rrd_connection_create_vsrv_db (cherokee_rrd_connection_t *rrd_conn, { ret_t ret; cherokee_boolean_t exist; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Ensure directories are accessible */ @@ -523,6 +532,10 @@ cherokee_rrd_connection_create_vsrv_db (cherokee_rrd_connection_t *rrd_conn, return ret_ok; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + cherokee_buffer_add_str (&tmp, "create "); cherokee_buffer_add_buffer (&tmp, dbpath); cherokee_buffer_add_str (&tmp, " --step "); @@ -555,14 +568,17 @@ cherokee_rrd_connection_create_vsrv_db (cherokee_rrd_connection_t *rrd_conn, ret = cherokee_rrd_connection_spawn (rrd_conn); if (unlikely (ret != ret_ok)) { - return ret_error; + ret = ret_error; + goto out; } ret = cherokee_rrd_connection_execute (rrd_conn, &tmp); if (unlikely (ret != ret_ok)) { - return ret_error; + ret = ret_error; + goto out; } +out: cherokee_buffer_mrproper (&tmp); - return ret_ok; + return ret; } diff --git a/cherokee/rule_exists.c b/cherokee/rule_exists.c index e4b04113e..5f22040b0 100644 --- a/cherokee/rule_exists.c +++ b/cherokee/rule_exists.c @@ -46,7 +46,9 @@ parse_value (cherokee_buffer_t *value, { char *val; char *tmpp; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); TRACE(ENTRIES, "Adding exists: '%s'\n", value->buf); cherokee_buffer_add_buffer (&tmp, value); @@ -58,8 +60,10 @@ parse_value (cherokee_buffer_t *value, TRACE(ENTRIES, "Adding exists: '%s'\n", val); entry = (entry_t *)malloc (sizeof(entry_t)); - if (unlikely (entry == NULL)) + if (unlikely (entry == NULL)) { + cherokee_buffer_mrproper (&tmp); return ret_nomem; + } cherokee_buffer_init (&entry->file); cherokee_buffer_add (&entry->file, val, strlen(val)); diff --git a/cherokee/rule_extensions.c b/cherokee/rule_extensions.c index 6ea09b8fd..fa3f216d9 100644 --- a/cherokee/rule_extensions.c +++ b/cherokee/rule_extensions.c @@ -41,7 +41,9 @@ parse_value (cherokee_buffer_t *value, cherokee_avl_t *extensions) { char *val; char *tmpp; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); TRACE(ENTRIES, "Adding extensions: '%s'\n", value->buf); cherokee_buffer_add_buffer (&tmp, value); diff --git a/cherokee/rule_geoip.c b/cherokee/rule_geoip.c index f5951aeb7..9a99bf176 100644 --- a/cherokee/rule_geoip.c +++ b/cherokee/rule_geoip.c @@ -123,7 +123,9 @@ parse_contry_list (cherokee_buffer_t *value, cherokee_avl_t *countries) { char *val; char *tmpp; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); TRACE(ENTRIES, "Adding geoip countries: '%s'\n", value->buf); cherokee_buffer_add_buffer (&tmp, value); diff --git a/cherokee/server.c b/cherokee/server.c index e5f86a8bc..aa97ff315 100644 --- a/cherokee/server.c +++ b/cherokee/server.c @@ -416,7 +416,11 @@ print_banner (cherokee_server_t *srv) cherokee_list_t *i; size_t b = 0; size_t len = 0; - cherokee_buffer_t n = CHEROKEE_BUF_INIT; + cherokee_buffer_t n; + + /* Initialise the buffers + */ + cherokee_buffer_init (&n); /* First line */ @@ -532,13 +536,18 @@ print_banner (cherokee_server_t *srv) /* Print it to stdout */ - cherokee_buffer_split_lines (&n, TERMINAL_WIDTH, NULL); + ret = cherokee_buffer_split_lines (&n, TERMINAL_WIDTH, NULL); + if (unlikely (ret != ret_ok)) goto out; + fprintf (stdout, "%s\n", n.buf); fflush (stdout); + ret = ret_ok; + +out: cherokee_buffer_mrproper (&n); - return ret_ok; + return ret; } @@ -1750,7 +1759,9 @@ ret_t cherokee_server_read_config_file (cherokee_server_t *srv, const char *fullpath) { ret_t ret; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); cherokee_buffer_add (&tmp, fullpath, strlen(fullpath)); @@ -1909,7 +1920,7 @@ NORETURN void cherokee_server_handle_panic (cherokee_server_t *srv) { int re; - cherokee_buffer_t cmd = CHEROKEE_BUF_INIT; + cherokee_buffer_t cmd; PRINT_MSG_S ("Cherokee feels panic!\n"); @@ -1917,6 +1928,8 @@ cherokee_server_handle_panic (cherokee_server_t *srv) goto fin; } + cherokee_buffer_init (&cmd); + cherokee_buffer_add_va (&cmd, "%s %d", srv->panic_action.buf, getpid()); re = system (cmd.buf); @@ -2102,7 +2115,11 @@ cherokee_server_get_log_writer (cherokee_server_t *srv, cherokee_logger_writer_t **writer) { ret_t ret; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); /* Build the index name */ diff --git a/cherokee/source_interpreter.c b/cherokee/source_interpreter.c index 74c252496..95b4542c1 100644 --- a/cherokee/source_interpreter.c +++ b/cherokee/source_interpreter.c @@ -153,9 +153,10 @@ check_interpreter_full (cherokee_buffer_t *fullpath, cherokee_buffer_t *chroot_d char *p; char tmp; const char *end; - cherokee_buffer_t completepath = CHEROKEE_BUF_INIT; + cherokee_buffer_t completepath; + + cherokee_buffer_init (&completepath); - cherokee_buffer_clean(&completepath); if (chroot_dir->len > 0) { /* Chroot and relative path, it doesn't make sense */ if (fullpath->len == 0 || fullpath->buf[0] != '/') @@ -210,7 +211,7 @@ check_interpreter_path (cherokee_buffer_t *partial_path, cherokee_buffer_t *chro char *p; char *colon; char *path; - cherokee_buffer_t fullpath = CHEROKEE_BUF_INIT; + cherokee_buffer_t fullpath; p = getenv("PATH"); if (p == NULL) @@ -220,6 +221,8 @@ check_interpreter_path (cherokee_buffer_t *partial_path, cherokee_buffer_t *chro if (path == NULL) return ret_error; + cherokee_buffer_init (&fullpath); + p = path; do { colon = strchr(p, ':'); @@ -286,10 +289,13 @@ check_interpreter (cherokee_source_interpreter_t *src) static ret_t replace_environment_variables (cherokee_buffer_t *buf) { + ret_t ret; char *dollar; char *p; char *val; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); do { /* Find $ @@ -320,16 +326,19 @@ replace_environment_variables (cherokee_buffer_t *buf) /* Replacement */ if (val != NULL) { - cherokee_buffer_replace_string (buf, tmp.buf, tmp.len, val, strlen(val)); + ret = cherokee_buffer_replace_string (buf, tmp.buf, tmp.len, val, strlen(val)); + if (unlikely (ret != ret_ok)) goto out; } else { cherokee_buffer_remove_string (buf, tmp.buf, tmp.len); } } while (true); + ret = ret_ok; + out: cherokee_buffer_mrproper (&tmp); - return ret_ok; + return ret; } @@ -343,13 +352,11 @@ add_env (cherokee_source_interpreter_t *src, cherokee_buffer_t *env, cherokee_bu /* Replace $ENVs */ - cherokee_buffer_dup (val_orig, &val); + ret = cherokee_buffer_dup (val_orig, &val); + if (unlikely (ret != ret_ok)) goto error; ret = replace_environment_variables (val); - if (ret != ret_ok) { - ret = ret_error; - goto error; - } + if (unlikely (ret != ret_ok)) goto error; /* Build the env entry */ @@ -561,7 +568,11 @@ _spawn_local (cherokee_source_interpreter_t *src, const char *argv[] = {"sh", "-c", NULL, NULL}; int child = -1; char *empty_envp[] = {NULL}; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); /* If there is a previous instance running, kill it */ diff --git a/cherokee/spawner.c b/cherokee/spawner.c index 36a2b2774..1cba779cd 100644 --- a/cherokee/spawner.c +++ b/cherokee/spawner.c @@ -54,7 +54,7 @@ cherokee_spawner_init (void) { #ifdef HAVE_SYSV_SEMAPHORES ret_t ret; - cherokee_buffer_t name = CHEROKEE_BUF_INIT; + cherokee_buffer_t name; if (! _active) { return ret_ok; @@ -63,6 +63,9 @@ cherokee_spawner_init (void) /* Monitor mutex */ CHEROKEE_MUTEX_INIT (&spawning_mutex, CHEROKEE_MUTEX_FAST); + /* Initialise the buffers */ + cherokee_buffer_init (&name); + /* Shared memory */ cherokee_buffer_add_va (&name, TMPDIR "/cherokee-spawner-%d", getppid()); @@ -194,13 +197,14 @@ cherokee_spawner_spawn (cherokee_buffer_t *binary, pid_t *pid_ret) { #ifdef HAVE_SYSV_SEMAPHORES + ret_t ret; char **n; int *pid_shm; int pid_prev; int k; int phase; int envs = 0; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; #define ALIGN4(buf) \ while (buf.len & 0x3) { \ @@ -224,10 +228,15 @@ cherokee_spawner_spawn (cherokee_buffer_t *binary, return ret_eagain; } + /* Initialise the buffers + */ + cherokee_buffer_init (&tmp); + /* Build the string * The first character of each block is a mark. */ - cherokee_buffer_ensure_size (&tmp, SPAWN_SHARED_LEN); + ret = cherokee_buffer_ensure_size (&tmp, SPAWN_SHARED_LEN); + if (unlikely (ret != ret_ok)) return ret; /* 1.- Executable */ phase = 0xF0; diff --git a/cherokee/template.c b/cherokee/template.c index 840c69ec2..602eb6365 100644 --- a/cherokee/template.c +++ b/cherokee/template.c @@ -179,7 +179,9 @@ cherokee_template_parse (cherokee_template_t *tem, ret_t ret = ret_ok; char *p = incoming->buf; char *end = incoming->buf + incoming->len; - cherokee_buffer_t token = CHEROKEE_BUF_INIT; + cherokee_buffer_t token; + + cherokee_buffer_init (&token); while (p < end) { cherokee_template_replacement_t *repl; @@ -293,12 +295,14 @@ cherokee_template_parse_file (cherokee_template_t *tem, const char *file) { ret_t ret; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; ret = cherokee_buffer_read_file (&tmp, (char *)file); if (ret != ret_ok) return ret; + cherokee_buffer_init (&tmp); + ret = cherokee_template_parse (tem, &tmp); if (ret != ret_ok) { ret = ret_error; @@ -339,7 +343,9 @@ cherokee_template_render (cherokee_template_t *tem, if ((repl->slice.begin != CHEROKEE_BUF_SLIDE_NONE) || (repl->slice.end != CHEROKEE_BUF_SLIDE_NONE)) { - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; + + cherokee_buffer_init (&tmp); ret = repl->token->func (tem, repl->token, &tmp, param); if (unlikely (ret != ret_ok)) { diff --git a/cherokee/thread.c b/cherokee/thread.c index a045adf0f..36a93def6 100644 --- a/cherokee/thread.c +++ b/cherokee/thread.c @@ -205,8 +205,11 @@ cherokee_thread_new (cherokee_thread_t **thd, */ cherokee_buffer_init (&n->tmp_buf1); cherokee_buffer_init (&n->tmp_buf2); - cherokee_buffer_ensure_size (&n->tmp_buf1, 4096); - cherokee_buffer_ensure_size (&n->tmp_buf2, 4096); + ret = cherokee_buffer_ensure_size (&n->tmp_buf1, 4096); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_ensure_size (&n->tmp_buf2, 4096); + if (unlikely (ret != ret_ok)) return ret; /* Traffic shaping */ diff --git a/cherokee/trace.c b/cherokee/trace.c index 00d33a15a..fde421017 100644 --- a/cherokee/trace.c +++ b/cherokee/trace.c @@ -45,7 +45,7 @@ typedef struct { static cherokee_trace_t trace = { - CHEROKEE_BUF_INIT, + {NULL, 0, 0}, /* cherokee_buffer_init */ false, false, false, @@ -64,7 +64,7 @@ ret_t cherokee_trace_init (void) { const char *env; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Read the environment variable */ @@ -87,7 +87,6 @@ cherokee_trace_set_modules (cherokee_buffer_t *modules) ret_t ret; char *p; char *end; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; /* Store a copy of the modules */ @@ -120,24 +119,22 @@ cherokee_trace_set_modules (cherokee_buffer_t *modules) } if (end > p) { + cherokee_buffer_t tmp; ret = cherokee_access_new (&trace.from_filter); if (ret != ret_ok) return ret_error; + cherokee_buffer_init (&tmp); cherokee_buffer_add (&tmp, p, end-p); ret = cherokee_access_add (trace.from_filter, tmp.buf); + cherokee_buffer_mrproper (&tmp); if (ret != ret_ok) { - ret = ret_error; - goto out; + return ret_error; } } } - ret = ret_ok; - -out: - cherokee_buffer_mrproper (&tmp); - return ret; + return ret_ok; } @@ -152,7 +149,7 @@ cherokee_trace_do_trace (const char *entry, const char *file, int line, const ch cherokee_connection_t *conn; cherokee_buffer_t *trace_modules = &trace.modules; cherokee_boolean_t do_log = false; - cherokee_buffer_t entries = CHEROKEE_BUF_INIT; + cherokee_buffer_t entries; /* Prevents loops */ @@ -162,6 +159,10 @@ cherokee_trace_do_trace (const char *entry, const char *file, int line, const ch disabled = true; + /* Initialise the buffers + */ + cherokee_buffer_init (&entries); + /* Return ASAP if nothing is being traced */ if (cherokee_buffer_is_empty (&trace.modules)) { @@ -238,7 +239,8 @@ cherokee_trace_do_trace (const char *entry, const char *file, int line, const ch longest_len = MAX (longest_len, len); cherokee_buffer_add_str (&entries, "{0x"); - cherokee_buffer_add_char_n (&entries, '0', longest_len - len); + ret = cherokee_buffer_add_char_n (&entries, '0', longest_len - len); + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_add (&entries, tmp, len); cherokee_buffer_add_str (&entries, "} "); } diff --git a/cherokee/url.c b/cherokee/url.c index 9d4463cf7..bccb87b2b 100644 --- a/cherokee/url.c +++ b/cherokee/url.c @@ -39,11 +39,8 @@ cherokee_url_init (cherokee_url_t *url) /* New buffer objects */ - ret = cherokee_buffer_init (&url->host); - if (unlikely(ret < ret_ok)) return ret; - - ret = cherokee_buffer_init (&url->request); - if (unlikely(ret < ret_ok)) return ret; + cherokee_buffer_init (&url->host); + cherokee_buffer_init (&url->request); /* Set default values */ diff --git a/cherokee/util.c b/cherokee/util.c index ca3849de1..99875aca9 100644 --- a/cherokee/util.c +++ b/cherokee/util.c @@ -625,7 +625,6 @@ cherokee_estimate_va_length (const char *fmt, va_list ap) cherokee_boolean_t lflag; cherokee_boolean_t llflag; cuint_t width; - char padc; cuint_t len = 0; #define LEN_NUM(var,base) \ @@ -637,7 +636,6 @@ cherokee_estimate_va_length (const char *fmt, va_list ap) for (;;) { width = 0; - padc = ' '; while ((ch = *fmt++) != '%') { if (ch == '\0') @@ -675,7 +673,7 @@ cherokee_estimate_va_length (const char *fmt, va_list ap) LEN_NUM(ul,10); break; case '0': - padc = '0'; + len++; goto reswitch; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': @@ -1074,8 +1072,11 @@ cherokee_path_arg_eval (cherokee_buffer_t *path) if (path->buf[0] != '/') { d = getcwd (tmp, sizeof(tmp)); - cherokee_buffer_prepend (path, (char *)"/", 1); - cherokee_buffer_prepend (path, d, strlen(d)); + ret = cherokee_buffer_prepend (path, (char *)"/", 1); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_prepend (path, d, strlen(d)); + if (unlikely (ret != ret_ok)) return ret; } ret = cherokee_path_short (path); @@ -1900,7 +1901,7 @@ cherokee_rm_rf (cherokee_buffer_t *path, struct dirent *entry; char entry_buf[512]; struct stat info; - cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; + cherokee_buffer_t tmp; /* Remove the directory contents */ @@ -1909,6 +1910,10 @@ cherokee_rm_rf (cherokee_buffer_t *path, return ret_ok; } + /* Initialise buffer + */ + cherokee_buffer_init (&tmp); + while (true) { re = cherokee_readdir (d, (struct dirent *)entry_buf, &entry); if ((re != 0) || (entry == NULL)) diff --git a/cherokee/validator.c b/cherokee/validator.c index 8b02b6989..8abcb073a 100644 --- a/cherokee/validator.c +++ b/cherokee/validator.c @@ -123,10 +123,11 @@ ret_t cherokee_validator_parse_basic (cherokee_validator_t *validator, char *str, cuint_t str_len) { char *colon; - cherokee_buffer_t auth = CHEROKEE_BUF_INIT; + cherokee_buffer_t auth; /* Decode base64 */ + cherokee_buffer_init (&auth); cherokee_buffer_add (&auth, str, str_len); cherokee_buffer_decode_base64 (&auth); @@ -163,11 +164,12 @@ cherokee_validator_parse_digest (cherokee_validator_t *validator, char *entry; char *comma; char *equal; - cherokee_buffer_t auth = CHEROKEE_BUF_INIT; + cherokee_buffer_t auth; cherokee_buffer_t *entry_buf; /* Copy authentication string */ + cherokee_buffer_init (&auth); cherokee_buffer_add (&auth, str, str_len); entry = auth.buf; @@ -263,7 +265,7 @@ cherokee_validator_parse_digest (cherokee_validator_t *validator, } -static ret_t +static ret_t must_check digest_HA2 (cherokee_validator_t *validator, cherokee_buffer_t *buf, cherokee_connection_t *conn) { ret_t ret; @@ -276,18 +278,16 @@ digest_HA2 (cherokee_validator_t *validator, cherokee_buffer_t *buf, cherokee_co return ret_deny; ret = cherokee_http_method_to_string (conn->header.method, &method, &method_len); - if (unlikely (ret != ret_ok)) - return ret; + if (unlikely (ret != ret_ok)) return ret; - cherokee_buffer_ensure_size (buf, method_len + 1 + validator->uri.len); + ret = cherokee_buffer_ensure_size (buf, method_len + 1 + validator->uri.len); + if (unlikely (ret != ret_ok)) return ret; cherokee_buffer_add (buf, method, method_len); cherokee_buffer_add_str (buf, ":"); cherokee_buffer_add_buffer (buf, &validator->uri); - cherokee_buffer_encode_md5_digest (buf); - - return ret_ok; + return cherokee_buffer_encode_md5_digest (buf); } @@ -298,7 +298,7 @@ cherokee_validator_digest_response (cherokee_validator_t *validator, cherokee_connection_t *conn) { ret_t ret; - cherokee_buffer_t a2 = CHEROKEE_BUF_INIT; + cherokee_buffer_t a2; /* A1 has to be in string of length 32: * MD5_digest(user":"realm":"passwd) @@ -312,15 +312,19 @@ cherokee_validator_digest_response (cherokee_validator_t *validator, if (cherokee_buffer_is_empty (&validator->nonce)) return ret_deny; + /* Initialise the buffers + */ + cherokee_buffer_init (&a2); + /* Build A2 */ ret = digest_HA2 (validator, &a2, conn); - if (ret != ret_ok) - goto error; + if (unlikely (ret != ret_ok)) goto out; /* Build the final string */ - cherokee_buffer_ensure_size (buf, 32 + a2.len + validator->nonce.len + 4); + ret = cherokee_buffer_ensure_size (buf, 32 + a2.len + validator->nonce.len + 4); + if (unlikely (ret != ret_ok)) goto out; cherokee_buffer_add (buf, A1, 32); cherokee_buffer_add_str (buf, ":"); @@ -339,24 +343,21 @@ cherokee_validator_digest_response (cherokee_validator_t *validator, } cherokee_buffer_add_buffer (buf, &a2); - cherokee_buffer_encode_md5_digest (buf); - cherokee_buffer_mrproper (&a2); - - return ret_ok; + ret = cherokee_buffer_encode_md5_digest (buf); -error: +out: cherokee_buffer_mrproper (&a2); return ret; } -ret_t +ret_t must_check cherokee_validator_digest_check (cherokee_validator_t *validator, cherokee_buffer_t *passwd, cherokee_connection_t *conn) { ret_t ret; + cherokee_buffer_t a1; + cherokee_buffer_t buf; int re = -1; - cherokee_buffer_t a1 = CHEROKEE_BUF_INIT; - cherokee_buffer_t buf = CHEROKEE_BUF_INIT; /* Sanity check */ @@ -364,12 +365,19 @@ cherokee_validator_digest_check (cherokee_validator_t *validator, cherokee_buffe cherokee_buffer_is_empty (&validator->realm)) return ret_deny; + /* Initialise the buffers + */ + cherokee_buffer_init (&a1); + cherokee_buffer_init (&buf); + /* Build A1 */ - cherokee_buffer_ensure_size (&a1, - validator->user.len + 1 + - validator->realm.len + 1 + - passwd->len); + ret = cherokee_buffer_ensure_size (&a1, + validator->user.len + 1 + + validator->realm.len + 1 + + passwd->len); + + if (unlikely (ret != ret_ok)) goto go_out; cherokee_buffer_add_buffer (&a1, &validator->user); cherokee_buffer_add_str (&a1, ":"); @@ -377,23 +385,25 @@ cherokee_validator_digest_check (cherokee_validator_t *validator, cherokee_buffe cherokee_buffer_add_str (&a1, ":"); cherokee_buffer_add_buffer (&a1, passwd); - cherokee_buffer_encode_md5_digest (&a1); + ret = cherokee_buffer_encode_md5_digest (&a1); + if (unlikely (ret != ret_ok)) goto go_out; /* Build a possible response */ ret = cherokee_validator_digest_response (validator, a1.buf, &buf, conn); - if (unlikely(ret != ret_ok)) - goto go_out; + if (unlikely(ret != ret_ok)) goto go_out; /* Compare and return */ re = cherokee_buffer_cmp_buf (&conn->validator->response, &buf); + ret = (re == 0) ? ret_ok : ret_deny; + go_out: cherokee_buffer_mrproper (&a1); cherokee_buffer_mrproper (&buf); - return (re == 0) ? ret_ok : ret_deny; + return ret; } @@ -461,7 +471,8 @@ cherokee_validator_configure (cherokee_config_node_t *conf, void *config_entry) /* Sanity checks */ if (entry->auth_realm == NULL) { - cherokee_buffer_new (&entry->auth_realm); + ret = cherokee_buffer_new (&entry->auth_realm); + if (unlikely (ret != ret_ok)) return ret; } if (cherokee_buffer_is_empty (entry->auth_realm)) { diff --git a/cherokee/validator.h b/cherokee/validator.h index d0c755b90..7eef0c2e7 100644 --- a/cherokee/validator.h +++ b/cherokee/validator.h @@ -116,7 +116,7 @@ ret_t cherokee_validator_free_base (cherokee_validator_t *validator); /* Validator virtual methods */ -ret_t cherokee_validator_configure (cherokee_config_node_t *conf, void *config_entry); +ret_t must_check cherokee_validator_configure (cherokee_config_node_t *conf, void *config_entry); ret_t cherokee_validator_free (cherokee_validator_t *validator); ret_t cherokee_validator_check (cherokee_validator_t *validator, void *conn); ret_t cherokee_validator_add_headers (cherokee_validator_t *validator, void *conn, cherokee_buffer_t *buf); @@ -125,7 +125,7 @@ ret_t cherokee_validator_add_headers (cherokee_validator_t *validator, void */ ret_t cherokee_validator_parse_basic (cherokee_validator_t *validator, char *str, cuint_t str_len); ret_t cherokee_validator_parse_digest (cherokee_validator_t *validator, char *str, cuint_t str_len); -ret_t cherokee_validator_digest_response (cherokee_validator_t *validator, char *A1, cherokee_buffer_t *buf, cherokee_connection_t *conn); +ret_t must_check cherokee_validator_digest_response (cherokee_validator_t *validator, char *A1, cherokee_buffer_t *buf, cherokee_connection_t *conn); ret_t cherokee_validator_digest_check (cherokee_validator_t *validator, cherokee_buffer_t *passwd, cherokee_connection_t *conn); /* Validator properties methods diff --git a/cherokee/validator_htdigest.c b/cherokee/validator_htdigest.c index 5851d9e2b..21463f636 100644 --- a/cherokee/validator_htdigest.c +++ b/cherokee/validator_htdigest.c @@ -43,9 +43,7 @@ props_free (cherokee_validator_htdigest_props_t *props) ret_t cherokee_validator_htdigest_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { - cherokee_validator_htdigest_props_t *props; - - UNUSED(srv); + UNUSED (srv); if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, validator_htdigest_props); @@ -55,8 +53,6 @@ cherokee_validator_htdigest_configure (cherokee_config_node_t *conf, cherokee_se *_props = MODULE_PROPS(n); } - props = PROP_HTDIGEST(*_props); - /* Call the file based validator configure */ return cherokee_validator_file_configure (conf, srv, _props); @@ -94,12 +90,11 @@ cherokee_validator_htdigest_free (cherokee_validator_htdigest_t *htdigest) } -static ret_t +static ret_t must_check build_HA1 (cherokee_connection_t *conn, cherokee_buffer_t *buf) { cherokee_buffer_add_va (buf, "%s:%s:%s", conn->validator->user.buf, conn->config_entry.auth_realm->buf, conn->validator->passwd.buf); - cherokee_buffer_encode_md5_digest (buf); - return ret_ok; + return cherokee_buffer_encode_md5_digest (buf); } @@ -156,7 +151,7 @@ extract_user_entry (cherokee_buffer_t *file, char *user_, char **user, char **re } -static ret_t +static ret_t must_check validate_basic (cherokee_validator_htdigest_t *htdigest, cherokee_connection_t *conn, cherokee_buffer_t *file) { ret_t ret; @@ -164,10 +159,14 @@ validate_basic (cherokee_validator_htdigest_t *htdigest, cherokee_connection_t * char *user = NULL; char *realm = NULL; char *passwd = NULL; - cherokee_buffer_t ha1 = CHEROKEE_BUF_INIT; + cherokee_buffer_t ha1; UNUSED(htdigest); + /* Initialise the buffers + */ + cherokee_buffer_init (&ha1); + /* Extact the right entry information */ ret = extract_user_entry (file, conn->validator->user.buf, &user, &realm, &passwd); @@ -176,7 +175,8 @@ validate_basic (cherokee_validator_htdigest_t *htdigest, cherokee_connection_t * /* Build the hash */ - build_HA1 (conn, &ha1); + ret = build_HA1 (conn, &ha1); + if (unlikely (ret != ret_ok)) return ret; /* Compare it with the stored hash, clean, and return */ @@ -195,7 +195,11 @@ validate_digest (cherokee_validator_htdigest_t *htdigest, cherokee_connection_t char *user = NULL; char *realm = NULL; char *passwd = NULL; - cherokee_buffer_t buf = CHEROKEE_BUF_INIT; + cherokee_buffer_t buf; + + /* Initialise the buffers + */ + cherokee_buffer_init (&buf); /* Sanity check */ @@ -231,7 +235,11 @@ cherokee_validator_htdigest_check (cherokee_validator_htdigest_t *htdigest, { ret_t ret; cherokee_buffer_t *fpass; - cherokee_buffer_t file = CHEROKEE_BUF_INIT; + cherokee_buffer_t file; + + /* Initialise the buffers + */ + cherokee_buffer_init (&file); /* Ensure that we have all what we need */ diff --git a/cherokee/validator_htpasswd.c b/cherokee/validator_htpasswd.c index 4130c68f6..52acd151c 100644 --- a/cherokee/validator_htpasswd.c +++ b/cherokee/validator_htpasswd.c @@ -57,9 +57,7 @@ cherokee_validator_htpasswd_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { - cherokee_validator_htpasswd_props_t *props; - - UNUSED(srv); + UNUSED (srv); if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, validator_htpasswd_props); @@ -68,8 +66,6 @@ cherokee_validator_htpasswd_configure (cherokee_config_node_t *conf, *_props = MODULE_PROPS(n); } - props = PROP_HTPASSWD(*_props); - /* Call the file based validator configure */ return cherokee_validator_file_configure (conf, srv, _props); @@ -202,9 +198,10 @@ validate_md5 (cherokee_connection_t *conn, const char *magic, char *crypted) } -static ret_t +static ret_t must_check validate_non_salted_sha (cherokee_connection_t *conn, char *crypted) { + ret_t ret; cuint_t c_len = strlen (crypted); cherokee_thread_t *thread = CONN_THREAD(conn); cherokee_buffer_t *sha1_buf1 = THREAD_TMP_BUF1(thread); @@ -221,7 +218,8 @@ validate_non_salted_sha (cherokee_connection_t *conn, char *crypted) cherokee_buffer_clean (sha1_buf1); cherokee_buffer_clean (sha1_buf2); cherokee_buffer_add_buffer (sha1_buf1, &conn->validator->passwd); - cherokee_buffer_encode_sha1_base64 (sha1_buf1, sha1_buf2); + ret = cherokee_buffer_encode_sha1_base64 (sha1_buf1, sha1_buf2); + if (unlikely (ret != ret_ok)) return ret; if (strcmp (sha1_buf2->buf, crypted) == 0) { return ret_ok; diff --git a/cherokee/validator_ldap.c b/cherokee/validator_ldap.c index f007f6a4d..239d3b6ba 100644 --- a/cherokee/validator_ldap.c +++ b/cherokee/validator_ldap.c @@ -300,19 +300,24 @@ validate_dn (cherokee_validator_ldap_props_t *props, char *dn, char *password) } -static ret_t +static ret_t must_check init_filter (cherokee_validator_ldap_t *ldap, cherokee_validator_ldap_props_t *props, cherokee_connection_t *conn) { + ret_t ret; + if (cherokee_buffer_is_empty (&props->filter)) { TRACE (ENTRIES, "Empty filter: %s\n", "Ignoring it"); return ret_ok; } - cherokee_buffer_ensure_size (&ldap->filter, props->filter.len + conn->validator->user.len); + ret = cherokee_buffer_ensure_size (&ldap->filter, props->filter.len + conn->validator->user.len); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add_buffer (&ldap->filter, &props->filter); - cherokee_buffer_replace_string (&ldap->filter, "${user}", 7, conn->validator->user.buf, conn->validator->user.len); + ret = cherokee_buffer_replace_string (&ldap->filter, "${user}", 7, conn->validator->user.buf, conn->validator->user.len); + if (unlikely (ret != ret_ok)) return ret; TRACE (ENTRIES, "filter %s\n", ldap->filter.buf); return ret_ok; diff --git a/cherokee/validator_mysql.c b/cherokee/validator_mysql.c index a4e25120b..d2b053541 100644 --- a/cherokee/validator_mysql.c +++ b/cherokee/validator_mysql.c @@ -230,13 +230,18 @@ cherokee_validator_mysql_check (cherokee_validator_mysql_t *mysql, cherokee_conn int re; ret_t ret; MYSQL_ROW row; - MYSQL_RES *result; + MYSQL_RES *result = NULL; unsigned long *lengths; - cherokee_buffer_t db_passwd = CHEROKEE_BUF_INIT; - cherokee_buffer_t user_passwd = CHEROKEE_BUF_INIT; - cherokee_buffer_t query = CHEROKEE_BUF_INIT; + cherokee_buffer_t db_passwd; + cherokee_buffer_t user_passwd; + cherokee_buffer_t query; cherokee_validator_mysql_props_t *props = VAL_MYSQL_PROP(mysql); + /* Initialise the buffers */ + cherokee_buffer_init (&db_passwd); + cherokee_buffer_init (&user_passwd); + cherokee_buffer_init (&query); + /* Sanity checks */ if (unlikely ((conn->validator == NULL) || @@ -259,8 +264,11 @@ cherokee_validator_mysql_check (cherokee_validator_mysql_t *mysql, cherokee_conn /* Build query */ cherokee_buffer_add_buffer (&query, &props->query); - cherokee_buffer_replace_string (&query, "${user}", 7, conn->validator->user.buf, conn->validator->user.len); - cherokee_buffer_replace_string (&query, "${passwd}", 9, conn->validator->passwd.buf, conn->validator->passwd.len); + ret = cherokee_buffer_replace_string (&query, "${user}", 7, conn->validator->user.buf, conn->validator->user.len); + if (unlikely (ret != ret_ok)) return ret; + + ret = cherokee_buffer_replace_string (&query, "${passwd}", 9, conn->validator->passwd.buf, conn->validator->passwd.len); + if (unlikely (ret != ret_ok)) return ret; TRACE (ENTRIES, "Query: %s\n", query.buf); @@ -302,11 +310,16 @@ cherokee_validator_mysql_check (cherokee_validator_mysql_t *mysql, cherokee_conn /* Hashes */ if (props->hash_type == cherokee_mysql_hash_md5) { - cherokee_buffer_encode_md5_digest (&user_passwd); + ret = cherokee_buffer_encode_md5_digest (&user_passwd); + if (unlikely (ret != ret_ok)) return ret; + } else if (props->hash_type == cherokee_mysql_hash_sha1) { - cherokee_buffer_encode_sha1_digest (&user_passwd); + ret = cherokee_buffer_encode_sha1_digest (&user_passwd); + if (unlikely (ret != ret_ok)) return ret; + } else if (props->hash_type == cherokee_mysql_hash_sha512) { - cherokee_buffer_encode_sha512_digest (&user_passwd); + ret = cherokee_buffer_encode_sha512_digest (&user_passwd); + if (unlikely (ret != ret_ok)) return ret; } /* Compare passwords */ @@ -332,6 +345,7 @@ cherokee_validator_mysql_check (cherokee_validator_mysql_t *mysql, cherokee_conn TRACE (ENTRIES, "Access to user %s has been granted\n", conn->validator->user.buf); +error: /* Clean-up */ cherokee_buffer_mrproper (&query); @@ -339,12 +353,6 @@ cherokee_validator_mysql_check (cherokee_validator_mysql_t *mysql, cherokee_conn cherokee_buffer_mrproper (&user_passwd); mysql_free_result (result); - return ret_ok; - -error: - cherokee_buffer_mrproper (&query); - cherokee_buffer_mrproper (&db_passwd); - cherokee_buffer_mrproper (&user_passwd); return ret; } diff --git a/cherokee/validator_plain.c b/cherokee/validator_plain.c index 9d1222d12..4521d8abc 100644 --- a/cherokee/validator_plain.c +++ b/cherokee/validator_plain.c @@ -48,8 +48,6 @@ cherokee_validator_plain_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { - cherokee_validator_plain_props_t *props; - UNUSED(srv); if (*_props == NULL) { @@ -59,8 +57,6 @@ cherokee_validator_plain_configure (cherokee_config_node_t *conf, *_props = MODULE_PROPS(n); } - props = PROP_PLAIN(*_props); - /* Call the file based validator configure */ return cherokee_validator_file_configure (conf, srv, _props); @@ -108,9 +104,14 @@ cherokee_validator_plain_check (cherokee_validator_plain_t *plain, const char *p; const char *end; cherokee_buffer_t *fpass; - cherokee_buffer_t file = CHEROKEE_BUF_INIT; - cherokee_buffer_t buser = CHEROKEE_BUF_INIT; - cherokee_buffer_t bpass = CHEROKEE_BUF_INIT; + cherokee_buffer_t file; + cherokee_buffer_t buser; + cherokee_buffer_t bpass; + + /* Initialise the buffers */ + cherokee_buffer_init (&file); + cherokee_buffer_init (&buser); + cherokee_buffer_init (&bpass); /* Sanity check */ if (unlikely ((conn->validator == NULL) || diff --git a/cherokee/version.c b/cherokee/version.c index e713955f3..5617d4659 100644 --- a/cherokee/version.c +++ b/cherokee/version.c @@ -112,5 +112,5 @@ cherokee_version_add_simple (cherokee_buffer_t *buf, cherokee_server_token_t lev ret = ret_error; } - return ret_ok; + return ret; } diff --git a/cherokee/virtual_server.c b/cherokee/virtual_server.c index a5ed4acb7..f2f29754b 100644 --- a/cherokee/virtual_server.c +++ b/cherokee/virtual_server.c @@ -93,17 +93,9 @@ cherokee_virtual_server_new (cherokee_virtual_server_t **vserver, void *server) cherokee_buffer_init (&n->ciphers); cherokee_buffer_add_str (&n->ciphers, CHEROKEE_CIPHERS_DEFAULT); - ret = cherokee_buffer_init (&n->root); - if (unlikely(ret < ret_ok)) - return ret; - - ret = cherokee_buffer_init (&n->name); - if (unlikely(ret < ret_ok)) - return ret; - - ret = cherokee_buffer_init (&n->userdir); - if (unlikely(ret < ret_ok)) - return ret; + cherokee_buffer_init (&n->root); + cherokee_buffer_init (&n->name); + cherokee_buffer_init (&n->userdir); /* Return the object */ @@ -221,12 +213,15 @@ cherokee_virtual_server_init_tls (cherokee_virtual_server_t *vsrv) static ret_t add_directory_index (char *index, void *data) { + ret_t ret; cherokee_buffer_t *new_buf; cherokee_virtual_server_t *vserver = VSERVER(data); TRACE(ENTRIES, "Adding directory index '%s'\n", index); - cherokee_buffer_new (&new_buf); + ret = cherokee_buffer_new (&new_buf); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add (new_buf, index, strlen(index)); cherokee_list_add_tail_content (&vserver->index_list, new_buf); @@ -363,10 +358,12 @@ init_entry_property (cherokee_config_node_t *conf, void *data) return ret_error; } - if (entry->document_root == NULL) - cherokee_buffer_new (&entry->document_root); - else + if (entry->document_root == NULL) { + ret = cherokee_buffer_new (&entry->document_root); + if (unlikely (ret != ret_ok)) return ret; + } else { cherokee_buffer_clean (entry->document_root); + } cherokee_buffer_add_buffer (entry->document_root, tmp); cherokee_fix_dirpath (entry->document_root); @@ -506,13 +503,12 @@ init_entry_property (cherokee_config_node_t *conf, void *data) subconf2 = NULL; ret = cherokee_config_node_get (subconf, "do_cache", &subconf2); if ((ret == ret_ok) && (subconf2 != NULL)) { - cherokee_list_t *i; - cherokee_config_node_t *child; + cherokee_list_t *i; cherokee_config_node_foreach (i, subconf2) { - child = CONFIG_NODE(i); + cherokee_config_node_t *child = CONFIG_NODE(i); - ret = add_flcache_cookies_do_cache (entry, CONFIG_NODE(i), srv); + ret = add_flcache_cookies_do_cache (entry, child, srv); if (ret != ret_ok) return ret; } @@ -604,7 +600,9 @@ init_entry_property (cherokee_config_node_t *conf, void *data) if (entry->timeout_header != NULL) { cherokee_buffer_free (entry->timeout_header); } - cherokee_buffer_new (&entry->timeout_header); + ret = cherokee_buffer_new (&entry->timeout_header); + if (unlikely (ret != ret_ok)) return ret; + cherokee_buffer_add_va (entry->timeout_header, "Keep-Alive: timeout=%d"CRLF, entry->timeout_lapse); } else if (equal_buf_str (&conf->key, "match")) {