From 6b1aed0962db94cde10da8a769be7db6b461cdc6 Mon Sep 17 00:00:00 2001 From: bel2125 Date: Sun, 19 Nov 2023 13:51:06 +0100 Subject: [PATCH] Format code --- src/civetweb.c | 204 +++++++++++++++++++++++++++----------------- src/mod_mbedtls.inl | 8 +- 2 files changed, 130 insertions(+), 82 deletions(-) diff --git a/src/civetweb.c b/src/civetweb.c index 7e869887..c8df640a 100644 --- a/src/civetweb.c +++ b/src/civetweb.c @@ -1921,8 +1921,9 @@ struct socket { unsigned char is_ssl; /* Is port SSL-ed */ unsigned char ssl_redir; /* Is port supposed to redirect everything to SSL * port */ - unsigned char is_optional; /* Shouldn't cause us to exit if we can't bind to it */ - unsigned char in_use; /* 0: invalid, 1: valid, 2: free */ + unsigned char + is_optional; /* Shouldn't cause us to exit if we can't bind to it */ + unsigned char in_use; /* 0: invalid, 1: valid, 2: free */ }; @@ -2399,17 +2400,18 @@ struct mg_context { stop_flag_t stop_flag; /* Should we stop event loop */ pthread_mutex_t thread_mutex; /* Protects client_socks or queue */ - pthread_t masterthreadid; /* The master thread ID */ - unsigned int - cfg_max_worker_threads; /* How many worker-threads we are allowed to create, total */ + pthread_t masterthreadid; /* The master thread ID */ + unsigned int cfg_max_worker_threads; /* How many worker-threads we are + allowed to create, total */ + unsigned int spawned_worker_threads; /* How many worker-threads currently + exist (modified by master thread) */ unsigned int - spawned_worker_threads; /* How many worker-threads currently exist (modified by master thread) */ - unsigned int - idle_worker_thread_count; /* How many worker-threads are currently sitting around with nothing to do */ - /* Access to this value MUST be synchronized by thread_mutex */ + idle_worker_thread_count; /* How many worker-threads are currently + sitting around with nothing to do */ + /* Access to this value MUST be synchronized by thread_mutex */ - pthread_t *worker_threadids; /* The worker thread IDs */ + pthread_t *worker_threadids; /* The worker thread IDs */ unsigned long starter_thread_idx; /* thread index which called mg_start */ /* Connection to thread dispatching */ @@ -4205,7 +4207,8 @@ send_cors_header(struct mg_connection *conn) conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_CREDENTIALS]; if (cors_cred_cfg && *cors_cred_cfg && origin_hdr && *origin_hdr) { /* Cross-origin resource sharing (CORS), see - * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials */ + * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials + */ mg_response_header_add(conn, "Access-Control-Allow-Credentials", cors_cred_cfg, @@ -4215,30 +4218,29 @@ send_cors_header(struct mg_connection *conn) const char *cors_hdr_cfg = conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_HEADERS]; if (cors_hdr_cfg && *cors_hdr_cfg) { - mg_response_header_add(conn, - "Access-Control-Allow-Headers", - cors_hdr_cfg, - -1); + mg_response_header_add(conn, + "Access-Control-Allow-Headers", + cors_hdr_cfg, + -1); } const char *cors_exphdr_cfg = - conn->dom_ctx->config[ACCESS_CONTROL_EXPOSE_HEADERS]; + conn->dom_ctx->config[ACCESS_CONTROL_EXPOSE_HEADERS]; if (cors_exphdr_cfg && *cors_exphdr_cfg) { - mg_response_header_add(conn, - "Access-Control-Expose-Headers", - cors_exphdr_cfg, - -1); + mg_response_header_add(conn, + "Access-Control-Expose-Headers", + cors_exphdr_cfg, + -1); } const char *cors_meth_cfg = - conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_METHODS]; + conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_METHODS]; if (cors_meth_cfg && *cors_meth_cfg) { - mg_response_header_add(conn, - "Access-Control-Allow-Methods", - cors_meth_cfg, - -1); + mg_response_header_add(conn, + "Access-Control-Allow-Methods", + cors_meth_cfg, + -1); } - } @@ -15038,19 +15040,19 @@ handle_request(struct mg_connection *conn) suggest_connection_header(conn)); const char *cors_cred_cfg = - conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_CREDENTIALS]; + conn->dom_ctx->config[ACCESS_CONTROL_ALLOW_CREDENTIALS]; if (cors_cred_cfg && *cors_cred_cfg) { - mg_printf(conn, - "Access-Control-Allow-Credentials: %s\r\n", - cors_cred_cfg); + mg_printf(conn, + "Access-Control-Allow-Credentials: %s\r\n", + cors_cred_cfg); } const char *cors_exphdr_cfg = - conn->dom_ctx->config[ACCESS_CONTROL_EXPOSE_HEADERS]; + conn->dom_ctx->config[ACCESS_CONTROL_EXPOSE_HEADERS]; if (cors_exphdr_cfg && *cors_exphdr_cfg) { - mg_printf(conn, - "Access-Control-Expose-Headers: %s\r\n", - cors_exphdr_cfg); + mg_printf(conn, + "Access-Control-Expose-Headers: %s\r\n", + cors_exphdr_cfg); } if (cors_acrh || (cors_cred_cfg && *cors_cred_cfg)) { @@ -15844,31 +15846,37 @@ parse_port_string(const struct vec *vec, struct socket *so, int *ip_version) } /* sscanf and the option splitting code ensure the following condition - * Make sure the port is valid and vector ends with the port, 'o', 's', or 'r' */ + * Make sure the port is valid and vector ends with the port, 'o', 's', or + * 'r' */ if ((len > 0) && (is_valid_port(port))) { int bad_suffix = 0; /* Parse any suffix character(s) after the port number */ - for (size_t i=len; ilen; i++) - { - unsigned char * opt = NULL; - switch(vec->ptr[i]) - { - case 'o': opt = &so->is_optional; break; - case 'r': opt = &so->ssl_redir; break; - case 's': opt = &so->is_ssl; break; - default: /* empty */ break; + for (size_t i = len; i < vec->len; i++) { + unsigned char *opt = NULL; + switch (vec->ptr[i]) { + case 'o': + opt = &so->is_optional; + break; + case 'r': + opt = &so->ssl_redir; + break; + case 's': + opt = &so->is_ssl; + break; + default: /* empty */ + break; } - if ((opt)&&(*opt == 0)) *opt = 1; - else - { + if ((opt) && (*opt == 0)) + *opt = 1; + else { bad_suffix = 1; break; } } - if ((bad_suffix == 0)&&((so->is_ssl == 0)||(so->ssl_redir == 0))) { + if ((bad_suffix == 0) && ((so->is_ssl == 0) || (so->ssl_redir == 0))) { return 1; } } @@ -15924,8 +15932,11 @@ is_ssl_port_used(const char *ports) for (i = 0; i < portslen; i++) { if (prevIsNumber) { - int suffixCharIdx = (ports[i] == 'o') ? (i+1) : i; /* allow "os" and "or" suffixes */ - if (ports[suffixCharIdx] == 's' || ports[suffixCharIdx] == 'r') { + int suffixCharIdx = (ports[i] == 'o') + ? (i + 1) + : i; /* allow "os" and "or" suffixes */ + if (ports[suffixCharIdx] == 's' + || ports[suffixCharIdx] == 'r') { return 1; } } @@ -16111,7 +16122,8 @@ set_ports_option(struct mg_context *phys_ctx) closesocket(so.sock); so.sock = INVALID_SOCKET; if (so.is_optional) { - portsOk++; /* it's okay if we couldn't bind, this port is optional anyway */ + portsOk++; /* it's okay if we couldn't bind, this port is + optional anyway */ } continue; } @@ -16130,7 +16142,8 @@ set_ports_option(struct mg_context *phys_ctx) closesocket(so.sock); so.sock = INVALID_SOCKET; if (so.is_optional) { - portsOk++; /* it's okay if we couldn't bind, this port is optional anyway */ + portsOk++; /* it's okay if we couldn't bind, this port is + optional anyway */ } continue; } @@ -16149,7 +16162,8 @@ set_ports_option(struct mg_context *phys_ctx) closesocket(so.sock); so.sock = INVALID_SOCKET; if (so.is_optional) { - portsOk++; /* it's okay if we couldn't bind, this port is optional anyway */ + portsOk++; /* it's okay if we couldn't bind, this port is + optional anyway */ } continue; } @@ -18847,7 +18861,8 @@ get_message(struct mg_connection *conn, char *ebuf, size_t ebuf_len, int *err) ebuf, ebuf_len, "%s", - conn->request_len == -3 ? "Request timeout" : "Malformed message"); + conn->request_len == -3 ? "Request timeout" + : "Malformed message"); *err = 400; } else { /* Server did not recv anything -> just close the connection */ @@ -19779,7 +19794,9 @@ process_new_connection(struct mg_connection *conn) #endif } -static int mg_start_worker_thread(struct mg_context *ctx, int only_if_no_idle_threads); /* forward declaration */ +static int +mg_start_worker_thread(struct mg_context *ctx, + int only_if_no_idle_threads); /* forward declaration */ #if defined(ALTERNATIVE_QUEUE) @@ -19788,7 +19805,9 @@ produce_socket(struct mg_context *ctx, const struct socket *sp) { unsigned int i; - (void)mg_start_worker_thread(ctx, 1); /* will start a worker-thread only if there aren't currently any idle worker-threads */ + (void)mg_start_worker_thread( + ctx, 1); /* will start a worker-thread only if there aren't currently + any idle worker-threads */ while (!ctx->stop_flag) { for (i = 0; i < ctx->spawned_worker_threads; i++) { @@ -19816,11 +19835,16 @@ produce_socket(struct mg_context *ctx, const struct socket *sp) static int -consume_socket(struct mg_context *ctx, struct socket *sp, int thread_index, int counter_was_preincremented) +consume_socket(struct mg_context *ctx, + struct socket *sp, + int thread_index, + int counter_was_preincremented) { DEBUG_TRACE("%s", "going idle"); (void)pthread_mutex_lock(&ctx->thread_mutex); - if (counter_was_preincremented == 0) { /* first call only: the master-thread pre-incremented this before he spawned us */ + if (counter_was_preincremented + == 0) { /* first call only: the master-thread pre-incremented this + before he spawned us */ ctx->idle_worker_thread_count++; } ctx->client_socks[thread_index].in_use = 2; @@ -19854,13 +19878,18 @@ consume_socket(struct mg_context *ctx, struct socket *sp, int thread_index, int /* Worker threads take accepted socket from the queue */ static int -consume_socket(struct mg_context *ctx, struct socket *sp, int thread_index, int counter_was_preincremented) +consume_socket(struct mg_context *ctx, + struct socket *sp, + int thread_index, + int counter_was_preincremented) { (void)thread_index; DEBUG_TRACE("%s", "going idle"); (void)pthread_mutex_lock(&ctx->thread_mutex); - if (counter_was_preincremented == 0) { /* first call only: the master-thread pre-incremented this before he spawned us */ + if (counter_was_preincremented + == 0) { /* first call only: the master-thread pre-incremented this + before he spawned us */ ctx->idle_worker_thread_count++; } @@ -19935,7 +19964,9 @@ produce_socket(struct mg_context *ctx, const struct socket *sp) (void)pthread_cond_signal(&ctx->sq_full); (void)pthread_mutex_unlock(&ctx->thread_mutex); - (void)mg_start_worker_thread(ctx, 1); /* will start a worker-thread only if there aren't currently any idle worker-threads */ + (void)mg_start_worker_thread( + ctx, 1); /* will start a worker-thread only if there aren't currently + any idle worker-threads */ } #endif /* ALTERNATIVE_QUEUE */ @@ -20013,7 +20044,8 @@ worker_thread_run(struct mg_connection *conn) /* Call consume_socket() even when ctx->stop_flag > 0, to let it * signal sq_empty condvar to wake up the master waiting in * produce_socket() */ - while (consume_socket(ctx, &conn->client, thread_index, first_call_to_consume_socket)) { + while (consume_socket( + ctx, &conn->client, thread_index, first_call_to_consume_socket)) { first_call_to_consume_socket = 0; /* New connections must start with new protocol negotiation */ @@ -20791,34 +20823,43 @@ mg_socketpair(int *sockA, int *sockB) #endif } -static int mg_start_worker_thread(struct mg_context *ctx, int only_if_no_idle_threads) { +static int +mg_start_worker_thread(struct mg_context *ctx, int only_if_no_idle_threads) +{ const unsigned int i = ctx->spawned_worker_threads; if (i >= ctx->cfg_max_worker_threads) { - return -1; /* Oops, we hit our worker-thread limit! No more worker threads, ever! */ + return -1; /* Oops, we hit our worker-thread limit! No more worker + threads, ever! */ } (void)pthread_mutex_lock(&ctx->thread_mutex); #if defined(ALTERNATIVE_QUEUE) - if ((only_if_no_idle_threads)&&(ctx->idle_worker_thread_count > 0)) { + if ((only_if_no_idle_threads) && (ctx->idle_worker_thread_count > 0)) { #else - if ((only_if_no_idle_threads)&&(ctx->idle_worker_thread_count > (unsigned)(ctx->sq_head-ctx->sq_tail))) { + if ((only_if_no_idle_threads) + && (ctx->idle_worker_thread_count + > (unsigned)(ctx->sq_head - ctx->sq_tail))) { #endif (void)pthread_mutex_unlock(&ctx->thread_mutex); - return -2; /* There are idle threads available, so no need to spawn a new worker thread now */ + return -2; /* There are idle threads available, so no need to spawn a + new worker thread now */ } - ctx->idle_worker_thread_count++; /* we do this here to avoid a race condition while the thread is starting up */ + ctx->idle_worker_thread_count++; /* we do this here to avoid a race + condition while the thread is starting + up */ (void)pthread_mutex_unlock(&ctx->thread_mutex); ctx->worker_connections[i].phys_ctx = ctx; int ret = mg_start_thread_with_id(worker_thread, - &ctx->worker_connections[i], - &ctx->worker_threadids[i]); + &ctx->worker_connections[i], + &ctx->worker_threadids[i]); if (ret == 0) { - ctx->spawned_worker_threads++; /* note that we've filled another slot in the table */ + ctx->spawned_worker_threads++; /* note that we've filled another slot in + the table */ DEBUG_TRACE("Started worker_thread #%i", ctx->spawned_worker_threads); } else { (void)pthread_mutex_lock(&ctx->thread_mutex); - ctx->idle_worker_thread_count--; /* whoops, roll-back on error */ + ctx->idle_worker_thread_count--; /* whoops, roll-back on error */ (void)pthread_mutex_unlock(&ctx->thread_mutex); } return ret; @@ -21081,11 +21122,13 @@ mg_start2(struct mg_init_data *init, struct mg_error_data *error) #endif /* Worker thread count option */ - workerthreadcount = atoi(ctx->dd.config[NUM_THREADS]); + workerthreadcount = atoi(ctx->dd.config[NUM_THREADS]); prespawnthreadcount = atoi(ctx->dd.config[PRESPAWN_THREADS]); - if ((prespawnthreadcount < 0)||(prespawnthreadcount > workerthreadcount)) { - prespawnthreadcount = workerthreadcount; /* can't prespawn more than all of them! */ + if ((prespawnthreadcount < 0) + || (prespawnthreadcount > workerthreadcount)) { + prespawnthreadcount = + workerthreadcount; /* can't prespawn more than all of them! */ } if ((workerthreadcount > MAX_WORKER_THREADS) || (workerthreadcount <= 0)) { @@ -21352,9 +21395,10 @@ mg_start2(struct mg_init_data *init, struct mg_error_data *error) } ctx->cfg_max_worker_threads = ((unsigned int)(workerthreadcount)); - ctx->worker_threadids = (pthread_t *)mg_calloc_ctx(ctx->cfg_max_worker_threads, - sizeof(pthread_t), - ctx); + ctx->worker_threadids = + (pthread_t *)mg_calloc_ctx(ctx->cfg_max_worker_threads, + sizeof(pthread_t), + ctx); if (ctx->worker_threadids == NULL) { const char *err_msg = "Not enough memory for worker thread ID array"; @@ -21362,8 +21406,8 @@ mg_start2(struct mg_init_data *init, struct mg_error_data *error) if (error != NULL) { error->code = MG_ERROR_DATA_CODE_OUT_OF_MEMORY; - error->code_sub = - (unsigned)ctx->cfg_max_worker_threads * (unsigned)sizeof(pthread_t); + error->code_sub = (unsigned)ctx->cfg_max_worker_threads + * (unsigned)sizeof(pthread_t); mg_snprintf(NULL, NULL, /* No truncation check for error buffers */ error->text, diff --git a/src/mod_mbedtls.inl b/src/mod_mbedtls.inl index cada215e..c0333b21 100644 --- a/src/mod_mbedtls.inl +++ b/src/mod_mbedtls.inl @@ -189,7 +189,9 @@ mbed_ssl_accept(mbedtls_ssl_context **ssl, } #if MBEDTLS_VERSION_NUMBER >= 0x03000000 - DEBUG_TRACE("TLS connection %p accepted, state: %d", ssl, (*ssl)->MBEDTLS_PRIVATE(state)); + DEBUG_TRACE("TLS connection %p accepted, state: %d", + ssl, + (*ssl)->MBEDTLS_PRIVATE(state)); #else DEBUG_TRACE("TLS connection %p accepted, state: %d", ssl, (*ssl)->state); #endif @@ -219,7 +221,9 @@ mbed_ssl_handshake(mbedtls_ssl_context *ssl) } #if MBEDTLS_VERSION_NUMBER >= 0x03000000 - DEBUG_TRACE("TLS handshake rc: %d, state: %d", rc, ssl->MBEDTLS_PRIVATE(state)); + DEBUG_TRACE("TLS handshake rc: %d, state: %d", + rc, + ssl->MBEDTLS_PRIVATE(state)); #else DEBUG_TRACE("TLS handshake rc: %d, state: %d", rc, ssl->state); #endif -- 2.43.0