| /* |
| * libwebsockets - small server side websockets and web server implementation |
| * |
| * Copyright (C) 2010-2017 Andy Green <andy@warmcat.com> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation: |
| * version 2.1 of the License. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| * MA 02110-1301 USA |
| */ |
| |
| #include "core/private.h" |
| |
| #ifdef LWS_HAVE_SYS_TYPES_H |
| #include <sys/types.h> |
| #endif |
| |
| #ifdef LWS_WITH_IPV6 |
| #if defined(WIN32) || defined(_WIN32) |
| #include <wincrypt.h> |
| #include <iphlpapi.h> |
| #else |
| #include <net/if.h> |
| #endif |
| #endif |
| |
| int log_level = LLL_ERR | LLL_WARN | LLL_NOTICE; |
| static void (*lwsl_emit)(int level, const char *line) |
| #ifndef LWS_PLAT_OPTEE |
| = lwsl_emit_stderr |
| #endif |
| ; |
| #ifndef LWS_PLAT_OPTEE |
| static const char * const log_level_names[] = { |
| "ERR", |
| "WARN", |
| "NOTICE", |
| "INFO", |
| "DEBUG", |
| "PARSER", |
| "HEADER", |
| "EXTENSION", |
| "CLIENT", |
| "LATENCY", |
| "USER", |
| "THREAD", |
| "?", |
| "?" |
| }; |
| #endif |
| |
| #if defined (_DEBUG) |
| void lwsi_set_role(struct lws *wsi, lws_wsi_state_t role) |
| { |
| wsi->wsistate = (wsi->wsistate & (~LWSI_ROLE_MASK)) | role; |
| |
| lwsl_debug("lwsi_set_role(%p, 0x%x)\n", wsi, wsi->wsistate); |
| } |
| |
| void lwsi_set_state(struct lws *wsi, lws_wsi_state_t lrs) |
| { |
| wsi->wsistate = (wsi->wsistate & (~LRS_MASK)) | lrs; |
| |
| lwsl_debug("lwsi_set_state(%p, 0x%x)\n", wsi, wsi->wsistate); |
| } |
| #endif |
| |
| signed char char_to_hex(const char c) |
| { |
| if (c >= '0' && c <= '9') |
| return c - '0'; |
| |
| if (c >= 'a' && c <= 'f') |
| return c - 'a' + 10; |
| |
| if (c >= 'A' && c <= 'F') |
| return c - 'A' + 10; |
| |
| return -1; |
| } |
| |
| int lws_open(const char *__file, int __oflag, ...) |
| { |
| va_list ap; |
| int n; |
| |
| va_start(ap, __oflag); |
| if (((__oflag & O_CREAT) == O_CREAT) |
| #if defined(O_TMPFILE) |
| || ((__oflag & O_TMPFILE) == O_TMPFILE) |
| #endif |
| ) |
| /* last arg is really a mode_t. But windows... */ |
| n = open(__file, __oflag, va_arg(ap, uint32_t)); |
| else |
| n = open(__file, __oflag); |
| va_end(ap); |
| |
| if (n != -1 && lws_plat_apply_FD_CLOEXEC(n)) { |
| close(n); |
| |
| return -1; |
| } |
| |
| return n; |
| } |
| |
| void |
| lws_vhost_bind_wsi(struct lws_vhost *vh, struct lws *wsi) |
| { |
| if (wsi->vhost == vh) |
| return; |
| wsi->vhost = vh; |
| vh->count_bound_wsi++; |
| lwsl_info("%s: vh %s: count_bound_wsi %d\n", |
| __func__, vh->name, vh->count_bound_wsi); |
| assert(wsi->vhost->count_bound_wsi > 0); |
| } |
| |
| void |
| lws_vhost_unbind_wsi(struct lws *wsi) |
| { |
| if (!wsi->vhost) |
| return; |
| |
| lws_context_lock(wsi->context, __func__); /* ---------- context { */ |
| |
| assert(wsi->vhost->count_bound_wsi > 0); |
| wsi->vhost->count_bound_wsi--; |
| lwsl_info("%s: vh %s: count_bound_wsi %d\n", __func__, |
| wsi->vhost->name, wsi->vhost->count_bound_wsi); |
| |
| if (!wsi->vhost->count_bound_wsi && |
| wsi->vhost->being_destroyed) { |
| /* |
| * We have closed all wsi that were bound to this vhost |
| * by any pt: nothing can be servicing any wsi belonging |
| * to it any more. |
| * |
| * Finalize the vh destruction |
| */ |
| __lws_vhost_destroy2(wsi->vhost); |
| } |
| wsi->vhost = NULL; |
| |
| lws_context_unlock(wsi->context); /* } context ---------- */ |
| } |
| |
| void |
| __lws_free_wsi(struct lws *wsi) |
| { |
| if (!wsi) |
| return; |
| |
| /* |
| * Protocol user data may be allocated either internally by lws |
| * or by specified the user. We should only free what we allocated. |
| */ |
| if (wsi->protocol && wsi->protocol->per_session_data_size && |
| wsi->user_space && !wsi->user_space_externally_allocated) |
| lws_free(wsi->user_space); |
| |
| lws_buflist_destroy_all_segments(&wsi->buflist); |
| lws_buflist_destroy_all_segments(&wsi->buflist_out); |
| lws_free_set_NULL(wsi->udp); |
| |
| if (wsi->vhost && wsi->vhost->lserv_wsi == wsi) |
| wsi->vhost->lserv_wsi = NULL; |
| #if !defined(LWS_NO_CLIENT) |
| lws_dll_lws_remove(&wsi->dll_active_client_conns); |
| #endif |
| wsi->context->count_wsi_allocated--; |
| |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| __lws_header_table_detach(wsi, 0); |
| #endif |
| __lws_same_vh_protocol_remove(wsi); |
| #if !defined(LWS_NO_CLIENT) |
| lws_client_stash_destroy(wsi); |
| lws_free_set_NULL(wsi->client_hostname_copy); |
| #endif |
| |
| if (wsi->role_ops->destroy_role) |
| wsi->role_ops->destroy_role(wsi); |
| |
| #if defined(LWS_WITH_PEER_LIMITS) |
| lws_peer_track_wsi_close(wsi->context, wsi->peer); |
| wsi->peer = NULL; |
| #endif |
| |
| /* since we will destroy the wsi, make absolutely sure now */ |
| |
| #if defined(LWS_WITH_OPENSSL) |
| __lws_ssl_remove_wsi_from_buffered_list(wsi); |
| #endif |
| __lws_remove_from_timeout_list(wsi); |
| |
| if (wsi->context->event_loop_ops->destroy_wsi) |
| wsi->context->event_loop_ops->destroy_wsi(wsi); |
| |
| lws_vhost_unbind_wsi(wsi); |
| |
| lwsl_debug("%s: %p, remaining wsi %d\n", __func__, wsi, |
| wsi->context->count_wsi_allocated); |
| |
| lws_free(wsi); |
| } |
| |
| void |
| lws_dll_add_front(struct lws_dll *d, struct lws_dll *phead) |
| { |
| if (d->prev) |
| return; |
| |
| /* our next guy is current first guy */ |
| d->next = phead->next; |
| /* if there is a next guy, set his prev ptr to our next ptr */ |
| if (d->next) |
| d->next->prev = d; |
| /* our prev ptr is first ptr */ |
| d->prev = phead; |
| /* set the first guy to be us */ |
| phead->next = d; |
| } |
| |
| /* situation is: |
| * |
| * HEAD: struct lws_dll * = &entry1 |
| * |
| * Entry 1: struct lws_dll .pprev = &HEAD , .next = Entry 2 |
| * Entry 2: struct lws_dll .pprev = &entry1 , .next = &entry2 |
| * Entry 3: struct lws_dll .pprev = &entry2 , .next = NULL |
| * |
| * Delete Entry1: |
| * |
| * - HEAD = &entry2 |
| * - Entry2: .pprev = &HEAD, .next = &entry3 |
| * - Entry3: .pprev = &entry2, .next = NULL |
| * |
| * Delete Entry2: |
| * |
| * - HEAD = &entry1 |
| * - Entry1: .pprev = &HEAD, .next = &entry3 |
| * - Entry3: .pprev = &entry1, .next = NULL |
| * |
| * Delete Entry3: |
| * |
| * - HEAD = &entry1 |
| * - Entry1: .pprev = &HEAD, .next = &entry2 |
| * - Entry2: .pprev = &entry1, .next = NULL |
| * |
| */ |
| |
| void |
| lws_dll_remove(struct lws_dll *d) |
| { |
| if (!d->prev) /* ie, not part of the list */ |
| return; |
| |
| /* |
| * remove us |
| * |
| * USp <-> us <-> USn --> USp <-> USn |
| */ |
| |
| /* if we have a next guy, set his prev to our prev */ |
| if (d->next) |
| d->next->prev = d->prev; |
| |
| /* set our prev guy to our next guy instead of us */ |
| if (d->prev) |
| d->prev->next = d->next; |
| |
| /* we're out of the list, we should not point anywhere any more */ |
| d->prev = NULL; |
| d->next = NULL; |
| } |
| |
| void |
| __lws_remove_from_timeout_list(struct lws *wsi) |
| { |
| lws_dll_lws_remove(&wsi->dll_timeout); |
| } |
| |
| void |
| lws_remove_from_timeout_list(struct lws *wsi) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| |
| lws_pt_lock(pt, __func__); |
| __lws_remove_from_timeout_list(wsi); |
| lws_pt_unlock(pt); |
| } |
| |
| void |
| lws_dll_dump(struct lws_dll_lws *head, const char *title) |
| { |
| int n = 0; |
| |
| (void)n; |
| lwsl_notice("%s: %s (head.next %p)\n", __func__, title, head->next); |
| |
| lws_start_foreach_dll_safe(struct lws_dll_lws *, d, d1, head->next) { |
| struct lws *wsi = lws_container_of(d, struct lws, dll_hrtimer); |
| |
| (void)wsi; |
| |
| lwsl_notice(" %d: wsi %p: %llu\n", n++, wsi, |
| (unsigned long long)wsi->pending_timer); |
| } lws_end_foreach_dll_safe(d, d1); |
| } |
| |
| void |
| __lws_set_timer_usecs(struct lws *wsi, lws_usec_t usecs) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| struct lws_dll_lws *dd = &pt->dll_head_hrtimer; |
| struct timeval now; |
| struct lws *wsi1; |
| int bef = 0; |
| |
| lws_dll_lws_remove(&wsi->dll_hrtimer); |
| |
| if (usecs == LWS_SET_TIMER_USEC_CANCEL) |
| return; |
| |
| gettimeofday(&now, NULL); |
| wsi->pending_timer = ((now.tv_sec * 1000000ll) + now.tv_usec) + usecs; |
| |
| /* |
| * we sort the hrtimer list with the earliest timeout first |
| */ |
| |
| lws_start_foreach_dll_safe(struct lws_dll_lws *, d, d1, |
| pt->dll_head_hrtimer.next) { |
| dd = d; |
| wsi1 = lws_container_of(d, struct lws, dll_hrtimer); |
| |
| if (wsi1->pending_timer >= wsi->pending_timer) { |
| /* d, dprev's next, is >= our time */ |
| bef = 1; |
| break; |
| } |
| } lws_end_foreach_dll_safe(d, d1); |
| |
| if (bef) { |
| /* |
| * we go before dd |
| * DDp <-> DD <-> DDn --> DDp <-> us <-> DD <-> DDn |
| */ |
| /* we point forward to dd */ |
| wsi->dll_hrtimer.next = dd; |
| /* we point back to what dd used to point back to */ |
| wsi->dll_hrtimer.prev = dd->prev; |
| /* DDp points forward to us now */ |
| dd->prev->next = &wsi->dll_hrtimer; |
| /* DD points back to us now */ |
| dd->prev = &wsi->dll_hrtimer; |
| } else { |
| /* |
| * we go after dd |
| * DDp <-> DD <-> DDn --> DDp <-> DD <-> us <-> DDn |
| */ |
| /* we point forward to what dd used to point forward to */ |
| wsi->dll_hrtimer.next = dd->next; |
| /* we point back to dd */ |
| wsi->dll_hrtimer.prev = dd; |
| /* DDn points back to us */ |
| if (dd->next) |
| dd->next->prev = &wsi->dll_hrtimer; |
| /* DD points forward to us */ |
| dd->next = &wsi->dll_hrtimer; |
| } |
| |
| // lws_dll_dump(&pt->dll_head_hrtimer, "after set_timer_usec"); |
| } |
| |
| LWS_VISIBLE lws_usec_t |
| lws_now_usecs(void) |
| { |
| struct timeval now; |
| |
| gettimeofday(&now, NULL); |
| return (now.tv_sec * 1000000ll) + now.tv_usec; |
| } |
| |
| LWS_VISIBLE void |
| lws_set_timer_usecs(struct lws *wsi, lws_usec_t usecs) |
| { |
| __lws_set_timer_usecs(wsi, usecs); |
| } |
| |
| lws_usec_t |
| __lws_hrtimer_service(struct lws_context_per_thread *pt) |
| { |
| struct timeval now; |
| struct lws *wsi; |
| lws_usec_t t; |
| |
| gettimeofday(&now, NULL); |
| t = (now.tv_sec * 1000000ll) + now.tv_usec; |
| |
| lws_start_foreach_dll_safe(struct lws_dll_lws *, d, d1, |
| pt->dll_head_hrtimer.next) { |
| wsi = lws_container_of(d, struct lws, dll_hrtimer); |
| |
| /* |
| * if we met one in the future, we are done, because the list |
| * is sorted by time in the future. |
| */ |
| if (wsi->pending_timer > t) |
| break; |
| |
| lws_set_timer_usecs(wsi, LWS_SET_TIMER_USEC_CANCEL); |
| |
| /* it's time for the timer to be serviced */ |
| |
| if (wsi->protocol && |
| wsi->protocol->callback(wsi, LWS_CALLBACK_TIMER, |
| wsi->user_space, NULL, 0)) |
| __lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS, |
| "timer cb errored"); |
| } lws_end_foreach_dll_safe(d, d1); |
| |
| /* return an estimate how many us until next timer hit */ |
| |
| if (!pt->dll_head_hrtimer.next) |
| return LWS_HRTIMER_NOWAIT; |
| |
| wsi = lws_container_of(pt->dll_head_hrtimer.next, struct lws, dll_hrtimer); |
| |
| gettimeofday(&now, NULL); |
| t = (now.tv_sec * 1000000ll) + now.tv_usec; |
| |
| if (wsi->pending_timer < t) |
| return 0; |
| |
| return wsi->pending_timer - t; |
| } |
| |
| void |
| __lws_set_timeout(struct lws *wsi, enum pending_timeout reason, int secs) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| time_t now; |
| |
| time(&now); |
| |
| lwsl_debug("%s: %p: %d secs (reason %d)\n", __func__, wsi, secs, reason); |
| wsi->pending_timeout_limit = secs; |
| wsi->pending_timeout_set = now; |
| wsi->pending_timeout = reason; |
| |
| if (!reason) |
| lws_dll_lws_remove(&wsi->dll_timeout); |
| else |
| lws_dll_lws_add_front(&wsi->dll_timeout, &pt->dll_head_timeout); |
| } |
| |
| LWS_VISIBLE void |
| lws_set_timeout(struct lws *wsi, enum pending_timeout reason, int secs) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| |
| if (secs == LWS_TO_KILL_SYNC) { |
| lws_remove_from_timeout_list(wsi); |
| lwsl_debug("synchronously killing %p\n", wsi); |
| lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS, "to sync kill"); |
| return; |
| } |
| |
| if (secs == LWS_TO_KILL_ASYNC) |
| secs = 0; |
| |
| lws_pt_lock(pt, __func__); |
| __lws_set_timeout(wsi, reason, secs); |
| lws_pt_unlock(pt); |
| } |
| |
| int |
| lws_timed_callback_remove(struct lws_vhost *vh, struct lws_timed_vh_protocol *p) |
| { |
| lws_start_foreach_llp(struct lws_timed_vh_protocol **, pt, |
| vh->timed_vh_protocol_list) { |
| if (*pt == p) { |
| *pt = p->next; |
| lws_free(p); |
| |
| return 0; |
| } |
| } lws_end_foreach_llp(pt, next); |
| |
| return 1; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_timed_callback_vh_protocol(struct lws_vhost *vh, const struct lws_protocols *prot, |
| int reason, int secs) |
| { |
| struct lws_timed_vh_protocol *p = (struct lws_timed_vh_protocol *) |
| lws_malloc(sizeof(*p), "timed_vh"); |
| |
| if (!p) |
| return 1; |
| |
| p->protocol = prot; |
| p->reason = reason; |
| p->time = lws_now_secs() + secs; |
| p->next = vh->timed_vh_protocol_list; |
| |
| vh->timed_vh_protocol_list = p; |
| |
| return 0; |
| } |
| |
| void |
| lws_remove_child_from_any_parent(struct lws *wsi) |
| { |
| struct lws **pwsi; |
| int seen = 0; |
| |
| if (!wsi->parent) |
| return; |
| |
| /* detach ourselves from parent's child list */ |
| pwsi = &wsi->parent->child_list; |
| while (*pwsi) { |
| if (*pwsi == wsi) { |
| lwsl_info("%s: detach %p from parent %p\n", __func__, |
| wsi, wsi->parent); |
| |
| if (wsi->parent->protocol) |
| wsi->parent->protocol->callback(wsi, |
| LWS_CALLBACK_CHILD_CLOSING, |
| wsi->parent->user_space, wsi, 0); |
| |
| *pwsi = wsi->sibling_list; |
| seen = 1; |
| break; |
| } |
| pwsi = &(*pwsi)->sibling_list; |
| } |
| if (!seen) |
| lwsl_err("%s: failed to detach from parent\n", __func__); |
| |
| wsi->parent = NULL; |
| } |
| |
| int |
| lws_bind_protocol(struct lws *wsi, const struct lws_protocols *p, const char *reason) |
| { |
| // if (wsi->protocol == p) |
| // return 0; |
| const struct lws_protocols *vp = wsi->vhost->protocols, *vpo; |
| |
| if (wsi->protocol && wsi->protocol_bind_balance) { |
| wsi->protocol->callback(wsi, |
| wsi->role_ops->protocol_unbind_cb[!!lwsi_role_server(wsi)], |
| wsi->user_space, (void *)reason, 0); |
| wsi->protocol_bind_balance = 0; |
| } |
| if (!wsi->user_space_externally_allocated) |
| lws_free_set_NULL(wsi->user_space); |
| |
| lws_same_vh_protocol_remove(wsi); |
| |
| wsi->protocol = p; |
| if (!p) |
| return 0; |
| |
| if (lws_ensure_user_space(wsi)) |
| return 1; |
| |
| if (p > vp && p < &vp[wsi->vhost->count_protocols]) |
| lws_same_vh_protocol_insert(wsi, (int)(p - vp)); |
| else { |
| int n = wsi->vhost->count_protocols; |
| int hit = 0; |
| |
| vpo = vp; |
| |
| while (n--) { |
| if (p->name && vp->name && !strcmp(p->name, vp->name)) { |
| hit = 1; |
| lws_same_vh_protocol_insert(wsi, (int)(vp - vpo)); |
| break; |
| } |
| vp++; |
| } |
| if (!hit) |
| lwsl_err("%s: %p is not in vhost '%s' protocols list\n", |
| __func__, p, wsi->vhost->name); |
| } |
| |
| if (wsi->protocol->callback(wsi, wsi->role_ops->protocol_bind_cb[ |
| !!lwsi_role_server(wsi)], |
| wsi->user_space, NULL, 0)) |
| return 1; |
| |
| wsi->protocol_bind_balance = 1; |
| |
| return 0; |
| } |
| |
| void |
| __lws_close_free_wsi(struct lws *wsi, enum lws_close_status reason, const char *caller) |
| { |
| struct lws_context_per_thread *pt; |
| struct lws *wsi1, *wsi2; |
| struct lws_context *context; |
| int n; |
| |
| lwsl_info("%s: %p: caller: %s\n", __func__, wsi, caller); |
| |
| if (!wsi) |
| return; |
| |
| lws_access_log(wsi); |
| |
| context = wsi->context; |
| pt = &context->pt[(int)wsi->tsi]; |
| lws_stats_atomic_bump(wsi->context, pt, LWSSTATS_C_API_CLOSE, 1); |
| |
| #if !defined(LWS_NO_CLIENT) |
| |
| lws_free_set_NULL(wsi->client_hostname_copy); |
| /* we are no longer an active client connection that can piggyback */ |
| lws_dll_lws_remove(&wsi->dll_active_client_conns); |
| |
| /* |
| * if we have wsi in our transaction queue, if we are closing we |
| * must go through and close all those first |
| */ |
| if (wsi->vhost) { |
| if ((int)reason != -1) |
| lws_vhost_lock(wsi->vhost); |
| lws_start_foreach_dll_safe(struct lws_dll_lws *, d, d1, |
| wsi->dll_client_transaction_queue_head.next) { |
| struct lws *w = lws_container_of(d, struct lws, |
| dll_client_transaction_queue); |
| |
| __lws_close_free_wsi(w, -1, "trans q leader closing"); |
| } lws_end_foreach_dll_safe(d, d1); |
| |
| /* |
| * !!! If we are closing, but we have pending pipelined transaction |
| * results we already sent headers for, that's going to destroy sync |
| * for HTTP/1 and leave H2 stream with no live swsi. |
| * |
| * However this is normal if we are being closed because the transaction |
| * queue leader is closing. |
| */ |
| lws_dll_lws_remove(&wsi->dll_client_transaction_queue); |
| if ((int)reason !=-1) |
| lws_vhost_unlock(wsi->vhost); |
| } |
| #endif |
| |
| /* if we have children, close them first */ |
| if (wsi->child_list) { |
| wsi2 = wsi->child_list; |
| while (wsi2) { |
| wsi1 = wsi2->sibling_list; |
| wsi2->parent = NULL; |
| /* stop it doing shutdown processing */ |
| wsi2->socket_is_permanently_unusable = 1; |
| __lws_close_free_wsi(wsi2, reason, "general child recurse"); |
| wsi2 = wsi1; |
| } |
| wsi->child_list = NULL; |
| } |
| |
| if (wsi->role_ops == &role_ops_raw_file) { |
| lws_remove_child_from_any_parent(wsi); |
| __remove_wsi_socket_from_fds(wsi); |
| wsi->protocol->callback(wsi, wsi->role_ops->close_cb[0], |
| wsi->user_space, NULL, 0); |
| goto async_close; |
| } |
| |
| wsi->wsistate_pre_close = wsi->wsistate; |
| |
| #ifdef LWS_WITH_CGI |
| if (wsi->role_ops == &role_ops_cgi) { |
| /* we are not a network connection, but a handler for CGI io */ |
| if (wsi->parent && wsi->parent->http.cgi) { |
| |
| if (wsi->cgi_channel == LWS_STDOUT) |
| lws_cgi_remove_and_kill(wsi->parent); |
| |
| /* end the binding between us and master */ |
| wsi->parent->http.cgi->stdwsi[(int)wsi->cgi_channel] = NULL; |
| } |
| wsi->socket_is_permanently_unusable = 1; |
| |
| goto just_kill_connection; |
| } |
| |
| if (wsi->http.cgi) |
| lws_cgi_remove_and_kill(wsi); |
| #endif |
| |
| #if !defined(LWS_NO_CLIENT) |
| lws_client_stash_destroy(wsi); |
| #endif |
| |
| if (wsi->role_ops == &role_ops_raw_skt) { |
| wsi->socket_is_permanently_unusable = 1; |
| goto just_kill_connection; |
| } |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| if (lwsi_role_http(wsi) && lwsi_role_server(wsi) && |
| wsi->http.fop_fd != NULL) |
| lws_vfs_file_close(&wsi->http.fop_fd); |
| #endif |
| |
| if (lwsi_state(wsi) == LRS_DEAD_SOCKET) |
| return; |
| |
| if (wsi->socket_is_permanently_unusable || |
| reason == LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY || |
| lwsi_state(wsi) == LRS_SHUTDOWN) |
| goto just_kill_connection; |
| |
| switch (lwsi_state_PRE_CLOSE(wsi)) { |
| case LRS_DEAD_SOCKET: |
| return; |
| |
| /* we tried the polite way... */ |
| case LRS_WAITING_TO_SEND_CLOSE: |
| case LRS_AWAITING_CLOSE_ACK: |
| case LRS_RETURNED_CLOSE: |
| goto just_kill_connection; |
| |
| case LRS_FLUSHING_BEFORE_CLOSE: |
| if (lws_has_buffered_out(wsi) |
| #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) |
| || wsi->http.comp_ctx.buflist_comp || |
| wsi->http.comp_ctx.may_have_more |
| #endif |
| ) { |
| lws_callback_on_writable(wsi); |
| return; |
| } |
| lwsl_info("%p: end LRS_FLUSHING_BEFORE_CLOSE\n", wsi); |
| goto just_kill_connection; |
| default: |
| if (lws_has_buffered_out(wsi) |
| #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) |
| || wsi->http.comp_ctx.buflist_comp || |
| wsi->http.comp_ctx.may_have_more |
| #endif |
| ) { |
| lwsl_info("%p: LRS_FLUSHING_BEFORE_CLOSE\n", wsi); |
| lwsi_set_state(wsi, LRS_FLUSHING_BEFORE_CLOSE); |
| __lws_set_timeout(wsi, |
| PENDING_FLUSH_STORED_SEND_BEFORE_CLOSE, 5); |
| return; |
| } |
| break; |
| } |
| |
| if (lwsi_state(wsi) == LRS_WAITING_CONNECT || |
| lwsi_state(wsi) == LRS_H1C_ISSUE_HANDSHAKE) |
| goto just_kill_connection; |
| |
| if (!wsi->told_user_closed && wsi->user_space && wsi->protocol && |
| wsi->protocol_bind_balance) { |
| wsi->protocol->callback(wsi, |
| wsi->role_ops->protocol_unbind_cb[ |
| !!lwsi_role_server(wsi)], |
| wsi->user_space, (void *)__func__, 0); |
| wsi->protocol_bind_balance = 0; |
| } |
| |
| /* |
| * signal we are closing, lws_write will |
| * add any necessary version-specific stuff. If the write fails, |
| * no worries we are closing anyway. If we didn't initiate this |
| * close, then our state has been changed to |
| * LRS_RETURNED_CLOSE and we will skip this. |
| * |
| * Likewise if it's a second call to close this connection after we |
| * sent the close indication to the peer already, we are in state |
| * LRS_AWAITING_CLOSE_ACK and will skip doing this a second time. |
| */ |
| |
| if (wsi->role_ops->close_via_role_protocol && |
| wsi->role_ops->close_via_role_protocol(wsi, reason)) |
| return; |
| |
| just_kill_connection: |
| |
| if (wsi->role_ops->close_kill_connection) |
| wsi->role_ops->close_kill_connection(wsi, reason); |
| |
| lws_remove_child_from_any_parent(wsi); |
| n = 0; |
| |
| if (!wsi->told_user_closed && wsi->user_space && |
| wsi->protocol_bind_balance) { |
| lwsl_debug("%s: %p: DROP_PROTOCOL %s\n", __func__, wsi, |
| wsi->protocol->name); |
| wsi->protocol->callback(wsi, |
| wsi->role_ops->protocol_unbind_cb[ |
| !!lwsi_role_server(wsi)], |
| wsi->user_space, (void *)__func__, 0); |
| wsi->protocol_bind_balance = 0; |
| } |
| |
| if ((lwsi_state(wsi) == LRS_WAITING_SERVER_REPLY || |
| lwsi_state(wsi) == LRS_WAITING_CONNECT) && !wsi->already_did_cce) |
| wsi->protocol->callback(wsi, |
| LWS_CALLBACK_CLIENT_CONNECTION_ERROR, |
| wsi->user_space, NULL, 0); |
| |
| /* |
| * Testing with ab shows that we have to stage the socket close when |
| * the system is under stress... shutdown any further TX, change the |
| * state to one that won't emit anything more, and wait with a timeout |
| * for the POLLIN to show a zero-size rx before coming back and doing |
| * the actual close. |
| */ |
| if (wsi->role_ops != &role_ops_raw_skt && !lwsi_role_client(wsi) && |
| lwsi_state(wsi) != LRS_SHUTDOWN && |
| lwsi_state(wsi) != LRS_UNCONNECTED && |
| reason != LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY && |
| !wsi->socket_is_permanently_unusable) { |
| |
| #if defined(LWS_WITH_TLS) |
| if (lws_is_ssl(wsi) && wsi->tls.ssl) { |
| n = 0; |
| switch (__lws_tls_shutdown(wsi)) { |
| case LWS_SSL_CAPABLE_DONE: |
| case LWS_SSL_CAPABLE_ERROR: |
| case LWS_SSL_CAPABLE_MORE_SERVICE_READ: |
| case LWS_SSL_CAPABLE_MORE_SERVICE_WRITE: |
| case LWS_SSL_CAPABLE_MORE_SERVICE: |
| break; |
| } |
| } else |
| #endif |
| { |
| lwsl_info("%s: shutdown conn: %p (sock %d, state 0x%x)\n", |
| __func__, wsi, (int)(long)wsi->desc.sockfd, |
| lwsi_state(wsi)); |
| if (!wsi->socket_is_permanently_unusable && |
| lws_socket_is_valid(wsi->desc.sockfd)) { |
| wsi->socket_is_permanently_unusable = 1; |
| n = shutdown(wsi->desc.sockfd, SHUT_WR); |
| } |
| } |
| if (n) |
| lwsl_debug("closing: shutdown (state 0x%x) ret %d\n", |
| lwsi_state(wsi), LWS_ERRNO); |
| |
| /* |
| * This causes problems on WINCE / ESP32 with disconnection |
| * when the events are half closing connection |
| */ |
| #if !defined(_WIN32_WCE) && !defined(LWS_WITH_ESP32) |
| /* libuv: no event available to guarantee completion */ |
| if (!wsi->socket_is_permanently_unusable && |
| lws_socket_is_valid(wsi->desc.sockfd) && |
| lwsi_state(wsi) != LRS_SHUTDOWN && |
| context->event_loop_ops->periodic_events_available) { |
| __lws_change_pollfd(wsi, LWS_POLLOUT, LWS_POLLIN); |
| lwsi_set_state(wsi, LRS_SHUTDOWN); |
| __lws_set_timeout(wsi, PENDING_TIMEOUT_SHUTDOWN_FLUSH, |
| context->timeout_secs); |
| |
| return; |
| } |
| #endif |
| } |
| |
| lwsl_debug("%s: real just_kill_connection: %p (sockfd %d)\n", __func__, |
| wsi, wsi->desc.sockfd); |
| |
| #ifdef LWS_WITH_HUBBUB |
| if (wsi->http.rw) { |
| lws_rewrite_destroy(wsi->http.rw); |
| wsi->http.rw = NULL; |
| } |
| #endif |
| |
| if (wsi->http.pending_return_headers) |
| lws_free_set_NULL(wsi->http.pending_return_headers); |
| |
| /* |
| * we won't be servicing or receiving anything further from this guy |
| * delete socket from the internal poll list if still present |
| */ |
| __lws_ssl_remove_wsi_from_buffered_list(wsi); |
| __lws_remove_from_timeout_list(wsi); |
| lws_dll_lws_remove(&wsi->dll_hrtimer); |
| |
| /* don't repeat event loop stuff */ |
| if (wsi->told_event_loop_closed) |
| return; |
| |
| /* checking return redundant since we anyway close */ |
| if (wsi->desc.sockfd != LWS_SOCK_INVALID) |
| __remove_wsi_socket_from_fds(wsi); |
| else |
| __lws_same_vh_protocol_remove(wsi); |
| |
| lwsi_set_state(wsi, LRS_DEAD_SOCKET); |
| lws_buflist_destroy_all_segments(&wsi->buflist); |
| lws_dll_lws_remove(&wsi->dll_buflist); |
| |
| if (wsi->role_ops->close_role) |
| wsi->role_ops->close_role(pt, wsi); |
| |
| /* tell the user it's all over for this guy */ |
| |
| if ((lwsi_state_est_PRE_CLOSE(wsi) || |
| lwsi_state_PRE_CLOSE(wsi) == LRS_WAITING_SERVER_REPLY) && |
| !wsi->told_user_closed && |
| wsi->role_ops->close_cb[lwsi_role_server(wsi)]) { |
| const struct lws_protocols *pro = wsi->protocol; |
| |
| if (!wsi->protocol) |
| pro = &wsi->vhost->protocols[0]; |
| |
| if (!wsi->upgraded_to_http2 || !lwsi_role_client(wsi)) |
| /* |
| * The network wsi for a client h2 connection shouldn't |
| * call back for its role: the child stream connections |
| * own the role. Otherwise h2 will call back closed |
| * one too many times as the children do it and then |
| * the closing network stream. |
| */ |
| pro->callback(wsi, |
| wsi->role_ops->close_cb[lwsi_role_server(wsi)], |
| wsi->user_space, NULL, 0); |
| wsi->told_user_closed = 1; |
| } |
| |
| async_close: |
| wsi->socket_is_permanently_unusable = 1; |
| |
| if (wsi->context->event_loop_ops->wsi_logical_close) |
| if (wsi->context->event_loop_ops->wsi_logical_close(wsi)) |
| return; |
| |
| __lws_close_free_wsi_final(wsi); |
| } |
| |
| void |
| __lws_close_free_wsi_final(struct lws *wsi) |
| { |
| int n; |
| |
| if (!wsi->shadow && |
| lws_socket_is_valid(wsi->desc.sockfd) && !lws_ssl_close(wsi)) { |
| lwsl_debug("%s: wsi %p: fd %d\n", __func__, wsi, wsi->desc.sockfd); |
| n = compatible_close(wsi->desc.sockfd); |
| if (n) |
| lwsl_debug("closing: close ret %d\n", LWS_ERRNO); |
| |
| wsi->desc.sockfd = LWS_SOCK_INVALID; |
| } |
| |
| /* outermost destroy notification for wsi (user_space still intact) */ |
| if (wsi->vhost) |
| wsi->vhost->protocols[0].callback(wsi, LWS_CALLBACK_WSI_DESTROY, |
| wsi->user_space, NULL, 0); |
| |
| #ifdef LWS_WITH_CGI |
| if (wsi->http.cgi) { |
| |
| for (n = 0; n < 3; n++) { |
| if (wsi->http.cgi->pipe_fds[n][!!(n == 0)] == 0) |
| lwsl_err("ZERO FD IN CGI CLOSE"); |
| |
| if (wsi->http.cgi->pipe_fds[n][!!(n == 0)] >= 0) |
| close(wsi->http.cgi->pipe_fds[n][!!(n == 0)]); |
| } |
| |
| lws_free(wsi->http.cgi); |
| } |
| #endif |
| |
| __lws_free_wsi(wsi); |
| } |
| |
| |
| void |
| lws_close_free_wsi(struct lws *wsi, enum lws_close_status reason, const char *caller) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| |
| lws_pt_lock(pt, __func__); |
| __lws_close_free_wsi(wsi, reason, caller); |
| lws_pt_unlock(pt); |
| } |
| |
| /* lws_buflist */ |
| |
| int |
| lws_buflist_append_segment(struct lws_buflist **head, const uint8_t *buf, |
| size_t len) |
| { |
| struct lws_buflist *nbuf; |
| int first = !*head; |
| void *p = *head; |
| int sanity = 1024; |
| |
| assert(buf); |
| assert(len); |
| |
| /* append at the tail */ |
| while (*head) { |
| if (!--sanity || head == &((*head)->next)) { |
| lwsl_err("%s: corrupt list points to self\n", __func__); |
| return -1; |
| } |
| head = &((*head)->next); |
| } |
| |
| lwsl_info("%s: len %u first %d %p\n", __func__, (uint32_t)len, first, p); |
| |
| nbuf = (struct lws_buflist *) |
| lws_malloc(sizeof(**head) + len, __func__); |
| if (!nbuf) { |
| lwsl_err("%s: OOM\n", __func__); |
| return -1; |
| } |
| |
| nbuf->len = len; |
| nbuf->pos = 0; |
| nbuf->next = NULL; |
| |
| p = (void *)nbuf->buf; |
| memcpy(p, buf, len); |
| |
| *head = nbuf; |
| |
| return first; /* returns 1 if first segment just created */ |
| } |
| |
| static int |
| lws_buflist_destroy_segment(struct lws_buflist **head) |
| { |
| struct lws_buflist *old = *head; |
| |
| assert(*head); |
| *head = (*head)->next; |
| old->next = NULL; |
| lws_free(old); |
| |
| return !*head; /* returns 1 if last segment just destroyed */ |
| } |
| |
| void |
| lws_buflist_destroy_all_segments(struct lws_buflist **head) |
| { |
| struct lws_buflist *p = *head, *p1; |
| |
| while (p) { |
| p1 = p->next; |
| p->next = NULL; |
| lws_free(p); |
| p = p1; |
| } |
| |
| *head = NULL; |
| } |
| |
| size_t |
| lws_buflist_next_segment_len(struct lws_buflist **head, uint8_t **buf) |
| { |
| if (!*head) { |
| if (buf) |
| *buf = NULL; |
| |
| return 0; |
| } |
| |
| if (!(*head)->len && (*head)->next) |
| lws_buflist_destroy_segment(head); |
| |
| if (!*head) { |
| if (buf) |
| *buf = NULL; |
| |
| return 0; |
| } |
| |
| assert((*head)->pos < (*head)->len); |
| |
| if (buf) |
| *buf = (*head)->buf + (*head)->pos; |
| |
| return (*head)->len - (*head)->pos; |
| } |
| |
| int |
| lws_buflist_use_segment(struct lws_buflist **head, size_t len) |
| { |
| assert(*head); |
| assert(len); |
| assert((*head)->pos + len <= (*head)->len); |
| |
| (*head)->pos += len; |
| if ((*head)->pos == (*head)->len) |
| lws_buflist_destroy_segment(head); |
| |
| if (!*head) |
| return 0; |
| |
| return (int)((*head)->len - (*head)->pos); |
| } |
| |
| void |
| lws_buflist_describe(struct lws_buflist **head, void *id) |
| { |
| struct lws_buflist *old; |
| int n = 0; |
| |
| if (*head == NULL) |
| lwsl_notice("%p: buflist empty\n", id); |
| |
| while (*head) { |
| lwsl_notice("%p: %d: %llu / %llu (%llu left)\n", id, n, |
| (unsigned long long)(*head)->pos, |
| (unsigned long long)(*head)->len, |
| (unsigned long long)(*head)->len - (*head)->pos); |
| old = *head; |
| head = &((*head)->next); |
| if (*head == old) { |
| lwsl_err("%s: next points to self\n", __func__); |
| break; |
| } |
| n++; |
| } |
| } |
| |
| /* ... */ |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_get_urlarg_by_name(struct lws *wsi, const char *name, char *buf, int len) |
| { |
| int n = 0, sl = (int)strlen(name); |
| |
| while (lws_hdr_copy_fragment(wsi, buf, len, |
| WSI_TOKEN_HTTP_URI_ARGS, n) >= 0) { |
| |
| if (!strncmp(buf, name, sl)) |
| return buf + sl; |
| |
| n++; |
| } |
| |
| return NULL; |
| } |
| |
| #if !defined(LWS_WITH_ESP32) |
| LWS_VISIBLE int |
| interface_to_sa(struct lws_vhost *vh, const char *ifname, |
| struct sockaddr_in *addr, size_t addrlen) |
| { |
| int ipv6 = 0; |
| #ifdef LWS_WITH_IPV6 |
| ipv6 = LWS_IPV6_ENABLED(vh); |
| #endif |
| (void)vh; |
| |
| return lws_interface_to_sa(ipv6, ifname, addr, addrlen); |
| } |
| #endif |
| |
| #ifndef LWS_PLAT_OPTEE |
| static int |
| lws_get_addresses(struct lws_vhost *vh, void *ads, char *name, |
| int name_len, char *rip, int rip_len) |
| { |
| struct addrinfo ai, *res; |
| struct sockaddr_in addr4; |
| |
| rip[0] = '\0'; |
| name[0] = '\0'; |
| addr4.sin_family = AF_UNSPEC; |
| |
| #ifdef LWS_WITH_IPV6 |
| if (LWS_IPV6_ENABLED(vh)) { |
| if (!lws_plat_inet_ntop(AF_INET6, |
| &((struct sockaddr_in6 *)ads)->sin6_addr, |
| rip, rip_len)) { |
| lwsl_err("inet_ntop: %s", strerror(LWS_ERRNO)); |
| return -1; |
| } |
| |
| // Strip off the IPv4 to IPv6 header if one exists |
| if (strncmp(rip, "::ffff:", 7) == 0) |
| memmove(rip, rip + 7, strlen(rip) - 6); |
| |
| getnameinfo((struct sockaddr *)ads, sizeof(struct sockaddr_in6), |
| name, name_len, NULL, 0, 0); |
| |
| return 0; |
| } else |
| #endif |
| { |
| struct addrinfo *result; |
| |
| memset(&ai, 0, sizeof ai); |
| ai.ai_family = PF_UNSPEC; |
| ai.ai_socktype = SOCK_STREAM; |
| #if !defined(LWS_WITH_ESP32) |
| if (getnameinfo((struct sockaddr *)ads, |
| sizeof(struct sockaddr_in), |
| name, name_len, NULL, 0, 0)) |
| return -1; |
| #endif |
| |
| if (getaddrinfo(name, NULL, &ai, &result)) |
| return -1; |
| |
| res = result; |
| while (addr4.sin_family == AF_UNSPEC && res) { |
| switch (res->ai_family) { |
| case AF_INET: |
| addr4.sin_addr = |
| ((struct sockaddr_in *)res->ai_addr)->sin_addr; |
| addr4.sin_family = AF_INET; |
| break; |
| } |
| |
| res = res->ai_next; |
| } |
| freeaddrinfo(result); |
| } |
| |
| if (addr4.sin_family == AF_UNSPEC) |
| return -1; |
| |
| if (lws_plat_inet_ntop(AF_INET, &addr4.sin_addr, rip, rip_len) == NULL) |
| return -1; |
| |
| return 0; |
| } |
| |
| |
| LWS_VISIBLE const char * |
| lws_get_peer_simple(struct lws *wsi, char *name, int namelen) |
| { |
| socklen_t len, olen; |
| #ifdef LWS_WITH_IPV6 |
| struct sockaddr_in6 sin6; |
| #endif |
| struct sockaddr_in sin4; |
| int af = AF_INET; |
| void *p, *q; |
| |
| wsi = lws_get_network_wsi(wsi); |
| |
| #ifdef LWS_WITH_IPV6 |
| if (LWS_IPV6_ENABLED(wsi->vhost)) { |
| len = sizeof(sin6); |
| p = &sin6; |
| af = AF_INET6; |
| q = &sin6.sin6_addr; |
| } else |
| #endif |
| { |
| len = sizeof(sin4); |
| p = &sin4; |
| q = &sin4.sin_addr; |
| } |
| |
| olen = len; |
| if (getpeername(wsi->desc.sockfd, p, &len) < 0 || len > olen) { |
| lwsl_warn("getpeername: %s\n", strerror(LWS_ERRNO)); |
| return NULL; |
| } |
| |
| return lws_plat_inet_ntop(af, q, name, namelen); |
| } |
| #endif |
| |
| LWS_VISIBLE void |
| lws_get_peer_addresses(struct lws *wsi, lws_sockfd_type fd, char *name, |
| int name_len, char *rip, int rip_len) |
| { |
| #ifndef LWS_PLAT_OPTEE |
| socklen_t len; |
| #ifdef LWS_WITH_IPV6 |
| struct sockaddr_in6 sin6; |
| #endif |
| struct sockaddr_in sin4; |
| struct lws_context *context = wsi->context; |
| int ret = -1; |
| void *p; |
| |
| rip[0] = '\0'; |
| name[0] = '\0'; |
| |
| lws_latency_pre(context, wsi); |
| |
| #ifdef LWS_WITH_IPV6 |
| if (LWS_IPV6_ENABLED(wsi->vhost)) { |
| len = sizeof(sin6); |
| p = &sin6; |
| } else |
| #endif |
| { |
| len = sizeof(sin4); |
| p = &sin4; |
| } |
| |
| if (getpeername(fd, p, &len) < 0) { |
| lwsl_warn("getpeername: %s\n", strerror(LWS_ERRNO)); |
| goto bail; |
| } |
| |
| ret = lws_get_addresses(wsi->vhost, p, name, name_len, rip, rip_len); |
| |
| bail: |
| lws_latency(context, wsi, "lws_get_peer_addresses", ret, 1); |
| #endif |
| (void)wsi; |
| (void)fd; |
| (void)name; |
| (void)name_len; |
| (void)rip; |
| (void)rip_len; |
| |
| } |
| |
| LWS_EXTERN void * |
| lws_vhost_user(struct lws_vhost *vhost) |
| { |
| return vhost->user; |
| } |
| |
| LWS_EXTERN void * |
| lws_context_user(struct lws_context *context) |
| { |
| return context->user_space; |
| } |
| |
| LWS_VISIBLE struct lws_vhost * |
| lws_vhost_get(struct lws *wsi) |
| { |
| return wsi->vhost; |
| } |
| |
| LWS_VISIBLE struct lws_vhost * |
| lws_get_vhost(struct lws *wsi) |
| { |
| return wsi->vhost; |
| } |
| |
| LWS_VISIBLE const struct lws_protocols * |
| lws_protocol_get(struct lws *wsi) |
| { |
| return wsi->protocol; |
| } |
| |
| LWS_VISIBLE const struct lws_udp * |
| lws_get_udp(const struct lws *wsi) |
| { |
| return wsi->udp; |
| } |
| |
| LWS_VISIBLE struct lws * |
| lws_get_network_wsi(struct lws *wsi) |
| { |
| if (!wsi) |
| return NULL; |
| |
| #if defined(LWS_WITH_HTTP2) |
| if (!wsi->http2_substream && !wsi->client_h2_substream) |
| return wsi; |
| |
| while (wsi->h2.parent_wsi) |
| wsi = wsi->h2.parent_wsi; |
| #endif |
| |
| return wsi; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN const struct lws_protocols * |
| lws_vhost_name_to_protocol(struct lws_vhost *vh, const char *name) |
| { |
| int n; |
| |
| for (n = 0; n < vh->count_protocols; n++) |
| if (!strcmp(name, vh->protocols[n].name)) |
| return &vh->protocols[n]; |
| |
| return NULL; |
| } |
| |
| LWS_VISIBLE int |
| lws_callback_all_protocol(struct lws_context *context, |
| const struct lws_protocols *protocol, int reason) |
| { |
| struct lws_context_per_thread *pt = &context->pt[0]; |
| unsigned int n, m = context->count_threads; |
| struct lws *wsi; |
| |
| while (m--) { |
| for (n = 0; n < pt->fds_count; n++) { |
| wsi = wsi_from_fd(context, pt->fds[n].fd); |
| if (!wsi) |
| continue; |
| if (wsi->protocol == protocol) |
| protocol->callback(wsi, reason, wsi->user_space, |
| NULL, 0); |
| } |
| pt++; |
| } |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE int |
| lws_callback_all_protocol_vhost_args(struct lws_vhost *vh, |
| const struct lws_protocols *protocol, int reason, |
| void *argp, size_t len) |
| { |
| struct lws_context *context = vh->context; |
| struct lws_context_per_thread *pt = &context->pt[0]; |
| unsigned int n, m = context->count_threads; |
| struct lws *wsi; |
| |
| while (m--) { |
| for (n = 0; n < pt->fds_count; n++) { |
| wsi = wsi_from_fd(context, pt->fds[n].fd); |
| if (!wsi) |
| continue; |
| if (wsi->vhost == vh && (wsi->protocol == protocol || |
| !protocol)) |
| wsi->protocol->callback(wsi, reason, |
| wsi->user_space, argp, len); |
| } |
| pt++; |
| } |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE int |
| lws_callback_all_protocol_vhost(struct lws_vhost *vh, |
| const struct lws_protocols *protocol, int reason) |
| { |
| return lws_callback_all_protocol_vhost_args(vh, protocol, reason, NULL, 0); |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_callback_vhost_protocols(struct lws *wsi, int reason, void *in, int len) |
| { |
| int n; |
| |
| for (n = 0; n < wsi->vhost->count_protocols; n++) |
| if (wsi->vhost->protocols[n].callback(wsi, reason, NULL, in, len)) |
| return 1; |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_callback_vhost_protocols_vhost(struct lws_vhost *vh, int reason, void *in, |
| size_t len) |
| { |
| int n; |
| struct lws *wsi = lws_zalloc(sizeof(*wsi), "fake wsi"); |
| |
| wsi->context = vh->context; |
| lws_vhost_bind_wsi(vh, wsi); |
| |
| for (n = 0; n < wsi->vhost->count_protocols; n++) { |
| wsi->protocol = &vh->protocols[n]; |
| if (wsi->protocol->callback(wsi, reason, NULL, in, len)) { |
| lws_free(wsi); |
| return 1; |
| } |
| } |
| |
| lws_free(wsi); |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_set_fops(struct lws_context *context, const struct lws_plat_file_ops *fops) |
| { |
| context->fops = fops; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN lws_filepos_t |
| lws_vfs_tell(lws_fop_fd_t fop_fd) |
| { |
| return fop_fd->pos; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN lws_filepos_t |
| lws_vfs_get_length(lws_fop_fd_t fop_fd) |
| { |
| return fop_fd->len; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN uint32_t |
| lws_vfs_get_mod_time(lws_fop_fd_t fop_fd) |
| { |
| return fop_fd->mod_time; |
| } |
| |
| LWS_VISIBLE lws_fileofs_t |
| lws_vfs_file_seek_set(lws_fop_fd_t fop_fd, lws_fileofs_t offset) |
| { |
| lws_fileofs_t ofs; |
| |
| ofs = fop_fd->fops->LWS_FOP_SEEK_CUR(fop_fd, offset - fop_fd->pos); |
| |
| return ofs; |
| } |
| |
| |
| LWS_VISIBLE lws_fileofs_t |
| lws_vfs_file_seek_end(lws_fop_fd_t fop_fd, lws_fileofs_t offset) |
| { |
| return fop_fd->fops->LWS_FOP_SEEK_CUR(fop_fd, fop_fd->len + |
| fop_fd->pos + offset); |
| } |
| |
| |
| const struct lws_plat_file_ops * |
| lws_vfs_select_fops(const struct lws_plat_file_ops *fops, const char *vfs_path, |
| const char **vpath) |
| { |
| const struct lws_plat_file_ops *pf; |
| const char *p = vfs_path; |
| int n; |
| |
| *vpath = NULL; |
| |
| /* no non-platform fops, just use that */ |
| |
| if (!fops->next) |
| return fops; |
| |
| /* |
| * scan the vfs path looking for indications we are to be |
| * handled by a specific fops |
| */ |
| |
| while (p && *p) { |
| if (*p != '/') { |
| p++; |
| continue; |
| } |
| /* the first one is always platform fops, so skip */ |
| pf = fops->next; |
| while (pf) { |
| n = 0; |
| while (n < (int)LWS_ARRAY_SIZE(pf->fi) && pf->fi[n].sig) { |
| if (p >= vfs_path + pf->fi[n].len) |
| if (!strncmp(p - (pf->fi[n].len - 1), |
| pf->fi[n].sig, |
| pf->fi[n].len - 1)) { |
| *vpath = p + 1; |
| return pf; |
| } |
| |
| n++; |
| } |
| pf = pf->next; |
| } |
| p++; |
| } |
| |
| return fops; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN lws_fop_fd_t LWS_WARN_UNUSED_RESULT |
| lws_vfs_file_open(const struct lws_plat_file_ops *fops, const char *vfs_path, |
| lws_fop_flags_t *flags) |
| { |
| const char *vpath = ""; |
| const struct lws_plat_file_ops *selected; |
| |
| selected = lws_vfs_select_fops(fops, vfs_path, &vpath); |
| |
| return selected->LWS_FOP_OPEN(fops, vfs_path, vpath, flags); |
| } |
| |
| |
| /** |
| * lws_now_secs() - seconds since 1970-1-1 |
| * |
| */ |
| LWS_VISIBLE LWS_EXTERN unsigned long |
| lws_now_secs(void) |
| { |
| struct timeval tv; |
| |
| gettimeofday(&tv, NULL); |
| |
| return tv.tv_sec; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_compare_time_t(struct lws_context *context, time_t t1, time_t t2) |
| { |
| if (t1 < context->time_discontiguity) |
| t1 += context->time_fixup; |
| |
| if (t2 < context->time_discontiguity) |
| t2 += context->time_fixup; |
| |
| return (int)(t1 - t2); |
| } |
| |
| LWS_VISIBLE lws_sockfd_type |
| lws_get_socket_fd(struct lws *wsi) |
| { |
| if (!wsi) |
| return -1; |
| return wsi->desc.sockfd; |
| } |
| |
| #ifdef LWS_LATENCY |
| void |
| lws_latency(struct lws_context *context, struct lws *wsi, const char *action, |
| int ret, int completed) |
| { |
| unsigned long long u; |
| char buf[256]; |
| |
| u = time_in_microseconds(); |
| |
| if (!action) { |
| wsi->latency_start = u; |
| if (!wsi->action_start) |
| wsi->action_start = u; |
| return; |
| } |
| if (completed) { |
| if (wsi->action_start == wsi->latency_start) |
| sprintf(buf, |
| "Completion first try lat %lluus: %p: ret %d: %s\n", |
| u - wsi->latency_start, |
| (void *)wsi, ret, action); |
| else |
| sprintf(buf, |
| "Completion %lluus: lat %lluus: %p: ret %d: %s\n", |
| u - wsi->action_start, |
| u - wsi->latency_start, |
| (void *)wsi, ret, action); |
| wsi->action_start = 0; |
| } else |
| sprintf(buf, "lat %lluus: %p: ret %d: %s\n", |
| u - wsi->latency_start, (void *)wsi, ret, action); |
| |
| if (u - wsi->latency_start > context->worst_latency) { |
| context->worst_latency = u - wsi->latency_start; |
| strcpy(context->worst_latency_info, buf); |
| } |
| lwsl_latency("%s", buf); |
| } |
| #endif |
| |
| LWS_VISIBLE int |
| lws_rx_flow_control(struct lws *wsi, int _enable) |
| { |
| struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; |
| int en = _enable; |
| |
| // h2 ignores rx flow control atm |
| if (lwsi_role_h2(wsi) || wsi->http2_substream || |
| lwsi_role_h2_ENCAPSULATION(wsi)) |
| return 0; // !!! |
| |
| lwsl_info("%s: %p 0x%x\n", __func__, wsi, _enable); |
| |
| if (!(_enable & LWS_RXFLOW_REASON_APPLIES)) { |
| /* |
| * convert user bool style to bitmap style... in user simple |
| * bool style _enable = 0 = flow control it, = 1 = allow rx |
| */ |
| en = LWS_RXFLOW_REASON_APPLIES | LWS_RXFLOW_REASON_USER_BOOL; |
| if (_enable & 1) |
| en |= LWS_RXFLOW_REASON_APPLIES_ENABLE_BIT; |
| } |
| |
| lws_pt_lock(pt, __func__); |
| |
| /* any bit set in rxflow_bitmap DISABLEs rxflow control */ |
| if (en & LWS_RXFLOW_REASON_APPLIES_ENABLE_BIT) |
| wsi->rxflow_bitmap &= ~(en & 0xff); |
| else |
| wsi->rxflow_bitmap |= en & 0xff; |
| |
| if ((LWS_RXFLOW_PENDING_CHANGE | (!wsi->rxflow_bitmap)) == |
| wsi->rxflow_change_to) |
| goto skip; |
| |
| wsi->rxflow_change_to = LWS_RXFLOW_PENDING_CHANGE | |
| (!wsi->rxflow_bitmap); |
| |
| lwsl_info("%s: %p: bitmap 0x%x: en 0x%x, ch 0x%x\n", __func__, wsi, |
| wsi->rxflow_bitmap, en, wsi->rxflow_change_to); |
| |
| if (_enable & LWS_RXFLOW_REASON_FLAG_PROCESS_NOW || |
| !wsi->rxflow_will_be_applied) { |
| en = __lws_rx_flow_control(wsi); |
| lws_pt_unlock(pt); |
| |
| return en; |
| } |
| |
| skip: |
| lws_pt_unlock(pt); |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE void |
| lws_rx_flow_allow_all_protocol(const struct lws_context *context, |
| const struct lws_protocols *protocol) |
| { |
| const struct lws_context_per_thread *pt = &context->pt[0]; |
| struct lws *wsi; |
| unsigned int n, m = context->count_threads; |
| |
| while (m--) { |
| for (n = 0; n < pt->fds_count; n++) { |
| wsi = wsi_from_fd(context, pt->fds[n].fd); |
| if (!wsi) |
| continue; |
| if (wsi->protocol == protocol) |
| lws_rx_flow_control(wsi, LWS_RXFLOW_ALLOW); |
| } |
| pt++; |
| } |
| } |
| |
| int |
| lws_broadcast(struct lws_context *context, int reason, void *in, size_t len) |
| { |
| struct lws_vhost *v = context->vhost_list; |
| struct lws wsi; |
| int n, ret = 0; |
| |
| memset(&wsi, 0, sizeof(wsi)); |
| wsi.context = context; |
| |
| while (v) { |
| const struct lws_protocols *p = v->protocols; |
| wsi.vhost = v; /* not a real bound wsi */ |
| |
| for (n = 0; n < v->count_protocols; n++) { |
| wsi.protocol = p; |
| if (p->callback && |
| p->callback(&wsi, reason, NULL, in, len)) |
| ret |= 1; |
| p++; |
| } |
| v = v->vhost_next; |
| } |
| |
| return ret; |
| } |
| |
| LWS_VISIBLE extern const char * |
| lws_canonical_hostname(struct lws_context *context) |
| { |
| return (const char *)context->canonical_hostname; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_get_vhost_name(struct lws_vhost *vhost) |
| { |
| return vhost->name; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_get_vhost_port(struct lws_vhost *vhost) |
| { |
| return vhost->listen_port; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void * |
| lws_get_vhost_user(struct lws_vhost *vhost) |
| { |
| return vhost->user; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_get_vhost_iface(struct lws_vhost *vhost) |
| { |
| return vhost->iface; |
| } |
| |
| int user_callback_handle_rxflow(lws_callback_function callback_function, |
| struct lws *wsi, |
| enum lws_callback_reasons reason, void *user, |
| void *in, size_t len) |
| { |
| int n; |
| |
| wsi->rxflow_will_be_applied = 1; |
| n = callback_function(wsi, reason, user, in, len); |
| wsi->rxflow_will_be_applied = 0; |
| if (!n) |
| n = __lws_rx_flow_control(wsi); |
| |
| return n; |
| } |
| |
| #if !defined(LWS_WITHOUT_CLIENT) |
| LWS_VISIBLE int |
| lws_set_proxy(struct lws_vhost *vhost, const char *proxy) |
| { |
| char *p; |
| char authstring[96]; |
| |
| if (!proxy) |
| return -1; |
| |
| /* we have to deal with a possible redundant leading http:// */ |
| if (!strncmp(proxy, "http://", 7)) |
| proxy += 7; |
| |
| p = strrchr(proxy, '@'); |
| if (p) { /* auth is around */ |
| |
| if ((unsigned int)(p - proxy) > sizeof(authstring) - 1) |
| goto auth_too_long; |
| |
| lws_strncpy(authstring, proxy, p - proxy + 1); |
| // null termination not needed on input |
| if (lws_b64_encode_string(authstring, lws_ptr_diff(p, proxy), |
| vhost->proxy_basic_auth_token, |
| sizeof vhost->proxy_basic_auth_token) < 0) |
| goto auth_too_long; |
| |
| lwsl_info(" Proxy auth in use\n"); |
| |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| proxy = p + 1; |
| #endif |
| } else |
| vhost->proxy_basic_auth_token[0] = '\0'; |
| |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| lws_strncpy(vhost->http.http_proxy_address, proxy, |
| sizeof(vhost->http.http_proxy_address)); |
| |
| p = strchr(vhost->http.http_proxy_address, ':'); |
| if (!p && !vhost->http.http_proxy_port) { |
| lwsl_err("http_proxy needs to be ads:port\n"); |
| |
| return -1; |
| } else { |
| if (p) { |
| *p = '\0'; |
| vhost->http.http_proxy_port = atoi(p + 1); |
| } |
| } |
| |
| lwsl_info(" Proxy %s:%u\n", vhost->http.http_proxy_address, |
| vhost->http.http_proxy_port); |
| #endif |
| return 0; |
| |
| auth_too_long: |
| lwsl_err("proxy auth too long\n"); |
| |
| return -1; |
| } |
| #endif |
| |
| #if defined(LWS_WITH_SOCKS5) |
| LWS_VISIBLE int |
| lws_set_socks(struct lws_vhost *vhost, const char *socks) |
| { |
| char *p_at, *p_colon; |
| char user[96]; |
| char password[96]; |
| |
| if (!socks) |
| return -1; |
| |
| vhost->socks_user[0] = '\0'; |
| vhost->socks_password[0] = '\0'; |
| |
| p_at = strrchr(socks, '@'); |
| if (p_at) { /* auth is around */ |
| if ((unsigned int)(p_at - socks) > (sizeof(user) |
| + sizeof(password) - 2)) { |
| lwsl_err("Socks auth too long\n"); |
| goto bail; |
| } |
| |
| p_colon = strchr(socks, ':'); |
| if (p_colon) { |
| if ((unsigned int)(p_colon - socks) > (sizeof(user) |
| - 1) ) { |
| lwsl_err("Socks user too long\n"); |
| goto bail; |
| } |
| if ((unsigned int)(p_at - p_colon) > (sizeof(password) |
| - 1) ) { |
| lwsl_err("Socks password too long\n"); |
| goto bail; |
| } |
| |
| lws_strncpy(vhost->socks_user, socks, p_colon - socks + 1); |
| lws_strncpy(vhost->socks_password, p_colon + 1, |
| p_at - (p_colon + 1) + 1); |
| } |
| |
| lwsl_info(" Socks auth, user: %s, password: %s\n", |
| vhost->socks_user, vhost->socks_password ); |
| |
| socks = p_at + 1; |
| } |
| |
| lws_strncpy(vhost->socks_proxy_address, socks, |
| sizeof(vhost->socks_proxy_address)); |
| |
| p_colon = strchr(vhost->socks_proxy_address, ':'); |
| if (!p_colon && !vhost->socks_proxy_port) { |
| lwsl_err("socks_proxy needs to be address:port\n"); |
| return -1; |
| } else { |
| if (p_colon) { |
| *p_colon = '\0'; |
| vhost->socks_proxy_port = atoi(p_colon + 1); |
| } |
| } |
| |
| lwsl_info(" Socks %s:%u\n", vhost->socks_proxy_address, |
| vhost->socks_proxy_port); |
| |
| return 0; |
| |
| bail: |
| return -1; |
| } |
| #endif |
| |
| LWS_VISIBLE const struct lws_protocols * |
| lws_get_protocol(struct lws *wsi) |
| { |
| return wsi->protocol; |
| } |
| |
| |
| int |
| lws_ensure_user_space(struct lws *wsi) |
| { |
| if (!wsi->protocol) |
| return 0; |
| |
| /* allocate the per-connection user memory (if any) */ |
| |
| if (wsi->protocol->per_session_data_size && !wsi->user_space) { |
| wsi->user_space = lws_zalloc( |
| wsi->protocol->per_session_data_size, "user space"); |
| if (wsi->user_space == NULL) { |
| lwsl_err("%s: OOM\n", __func__); |
| return 1; |
| } |
| } else |
| lwsl_debug("%s: %p protocol pss %lu, user_space=%p\n", __func__, |
| wsi, (long)wsi->protocol->per_session_data_size, |
| wsi->user_space); |
| return 0; |
| } |
| |
| LWS_VISIBLE void * |
| lws_adjust_protocol_psds(struct lws *wsi, size_t new_size) |
| { |
| ((struct lws_protocols *)lws_get_protocol(wsi))->per_session_data_size = |
| new_size; |
| |
| if (lws_ensure_user_space(wsi)) |
| return NULL; |
| |
| return wsi->user_space; |
| } |
| |
| LWS_VISIBLE int |
| lwsl_timestamp(int level, char *p, int len) |
| { |
| #ifndef LWS_PLAT_OPTEE |
| #ifndef _WIN32_WCE |
| time_t o_now = time(NULL); |
| #endif |
| unsigned long long now; |
| struct tm *ptm = NULL; |
| #ifndef WIN32 |
| struct tm tm; |
| #endif |
| int n; |
| |
| #ifndef _WIN32_WCE |
| #ifdef WIN32 |
| ptm = localtime(&o_now); |
| #else |
| if (localtime_r(&o_now, &tm)) |
| ptm = &tm; |
| #endif |
| #endif |
| p[0] = '\0'; |
| for (n = 0; n < LLL_COUNT; n++) { |
| if (level != (1 << n)) |
| continue; |
| now = time_in_microseconds() / 100; |
| if (ptm) |
| n = lws_snprintf(p, len, |
| "[%04d/%02d/%02d %02d:%02d:%02d:%04d] %s: ", |
| ptm->tm_year + 1900, |
| ptm->tm_mon + 1, |
| ptm->tm_mday, |
| ptm->tm_hour, |
| ptm->tm_min, |
| ptm->tm_sec, |
| (int)(now % 10000), log_level_names[n]); |
| else |
| n = lws_snprintf(p, len, "[%llu:%04d] %s: ", |
| (unsigned long long) now / 10000, |
| (int)(now % 10000), log_level_names[n]); |
| return n; |
| } |
| #else |
| p[0] = '\0'; |
| #endif |
| |
| return 0; |
| } |
| |
| #ifndef LWS_PLAT_OPTEE |
| static const char * const colours[] = { |
| "[31;1m", /* LLL_ERR */ |
| "[36;1m", /* LLL_WARN */ |
| "[35;1m", /* LLL_NOTICE */ |
| "[32;1m", /* LLL_INFO */ |
| "[34;1m", /* LLL_DEBUG */ |
| "[33;1m", /* LLL_PARSER */ |
| "[33m", /* LLL_HEADER */ |
| "[33m", /* LLL_EXT */ |
| "[33m", /* LLL_CLIENT */ |
| "[33;1m", /* LLL_LATENCY */ |
| "[30;1m", /* LLL_USER */ |
| "[31m", /* LLL_THREAD */ |
| }; |
| |
| LWS_VISIBLE void lwsl_emit_stderr(int level, const char *line) |
| { |
| char buf[50]; |
| static char tty = 3; |
| int n, m = LWS_ARRAY_SIZE(colours) - 1; |
| |
| if (!tty) |
| tty = isatty(2) | 2; |
| lwsl_timestamp(level, buf, sizeof(buf)); |
| |
| if (tty == 3) { |
| n = 1 << (LWS_ARRAY_SIZE(colours) - 1); |
| while (n) { |
| if (level & n) |
| break; |
| m--; |
| n >>= 1; |
| } |
| fprintf(stderr, "%c%s%s%s%c[0m", 27, colours[m], buf, line, 27); |
| } else |
| fprintf(stderr, "%s%s", buf, line); |
| } |
| #endif |
| |
| LWS_VISIBLE void _lws_logv(int filter, const char *format, va_list vl) |
| { |
| char buf[256]; |
| int n; |
| |
| if (!(log_level & filter)) |
| return; |
| |
| n = vsnprintf(buf, sizeof(buf) - 1, format, vl); |
| (void)n; |
| /* vnsprintf returns what it would have written, even if truncated */ |
| if (n > (int)sizeof(buf) - 1) { |
| n = sizeof(buf) - 5; |
| buf[n++] = '.'; |
| buf[n++] = '.'; |
| buf[n++] = '.'; |
| buf[n++] = '\n'; |
| buf[n] = '\0'; |
| } |
| if (n > 0) |
| buf[n] = '\0'; |
| |
| lwsl_emit(filter, buf); |
| } |
| |
| LWS_VISIBLE void _lws_log(int filter, const char *format, ...) |
| { |
| va_list ap; |
| |
| va_start(ap, format); |
| _lws_logv(filter, format, ap); |
| va_end(ap); |
| } |
| |
| LWS_VISIBLE void lws_set_log_level(int level, |
| void (*func)(int level, const char *line)) |
| { |
| log_level = level; |
| if (func) |
| lwsl_emit = func; |
| } |
| |
| LWS_VISIBLE int lwsl_visible(int level) |
| { |
| return log_level & level; |
| } |
| |
| LWS_VISIBLE void |
| lwsl_hexdump_level(int hexdump_level, const void *vbuf, size_t len) |
| { |
| unsigned char *buf = (unsigned char *)vbuf; |
| unsigned int n; |
| |
| if (!lwsl_visible(hexdump_level)) |
| return; |
| |
| if (!len) |
| return; |
| |
| if (!vbuf) |
| return; |
| |
| _lws_log(hexdump_level, "\n"); |
| |
| for (n = 0; n < len;) { |
| unsigned int start = n, m; |
| char line[80], *p = line; |
| |
| p += sprintf(p, "%04X: ", start); |
| |
| for (m = 0; m < 16 && n < len; m++) |
| p += sprintf(p, "%02X ", buf[n++]); |
| while (m++ < 16) |
| p += sprintf(p, " "); |
| |
| p += sprintf(p, " "); |
| |
| for (m = 0; m < 16 && (start + m) < len; m++) { |
| if (buf[start + m] >= ' ' && buf[start + m] < 127) |
| *p++ = buf[start + m]; |
| else |
| *p++ = '.'; |
| } |
| while (m++ < 16) |
| *p++ = ' '; |
| |
| *p++ = '\n'; |
| *p = '\0'; |
| _lws_log(hexdump_level, "%s", line); |
| (void)line; |
| } |
| |
| _lws_log(hexdump_level, "\n"); |
| } |
| |
| LWS_VISIBLE void |
| lwsl_hexdump(const void *vbuf, size_t len) |
| { |
| #if defined(_DEBUG) |
| lwsl_hexdump_level(LLL_DEBUG, vbuf, len); |
| #endif |
| } |
| |
| LWS_VISIBLE int |
| lws_is_ssl(struct lws *wsi) |
| { |
| #if defined(LWS_WITH_TLS) |
| return wsi->tls.use_ssl & LCCSCF_USE_SSL; |
| #else |
| (void)wsi; |
| return 0; |
| #endif |
| } |
| |
| #if defined(LWS_WITH_TLS) && !defined(LWS_WITH_MBEDTLS) |
| LWS_VISIBLE lws_tls_conn* |
| lws_get_ssl(struct lws *wsi) |
| { |
| return wsi->tls.ssl; |
| } |
| #endif |
| |
| LWS_VISIBLE int |
| lws_partial_buffered(struct lws *wsi) |
| { |
| return lws_has_buffered_out(wsi); |
| } |
| |
| LWS_VISIBLE lws_fileofs_t |
| lws_get_peer_write_allowance(struct lws *wsi) |
| { |
| if (!wsi->role_ops->tx_credit) |
| return -1; |
| return wsi->role_ops->tx_credit(wsi); |
| } |
| |
| LWS_VISIBLE void |
| lws_role_transition(struct lws *wsi, enum lwsi_role role, enum lwsi_state state, |
| struct lws_role_ops *ops) |
| { |
| #if defined(_DEBUG) |
| const char *name = "(unset)"; |
| #endif |
| wsi->wsistate = role | state; |
| if (ops) |
| wsi->role_ops = ops; |
| #if defined(_DEBUG) |
| if (wsi->role_ops) |
| name = wsi->role_ops->name; |
| lwsl_debug("%s: %p: wsistate 0x%x, ops %s\n", __func__, wsi, |
| wsi->wsistate, name); |
| #endif |
| } |
| |
| LWS_VISIBLE struct lws_plat_file_ops * |
| lws_get_fops(struct lws_context *context) |
| { |
| return (struct lws_plat_file_ops *)context->fops; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN struct lws_context * |
| lws_get_context(const struct lws *wsi) |
| { |
| return wsi->context; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_get_count_threads(struct lws_context *context) |
| { |
| return context->count_threads; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void * |
| lws_wsi_user(struct lws *wsi) |
| { |
| return wsi->user_space; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_set_wsi_user(struct lws *wsi, void *data) |
| { |
| if (wsi->user_space_externally_allocated) |
| wsi->user_space = data; |
| else |
| lwsl_err("%s: Cannot set internally-allocated user_space\n", |
| __func__); |
| } |
| |
| LWS_VISIBLE LWS_EXTERN struct lws * |
| lws_get_parent(const struct lws *wsi) |
| { |
| return wsi->parent; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN struct lws * |
| lws_get_child(const struct lws *wsi) |
| { |
| return wsi->child_list; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void * |
| lws_get_opaque_parent_data(const struct lws *wsi) |
| { |
| return wsi->opaque_parent_data; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_set_opaque_parent_data(struct lws *wsi, void *data) |
| { |
| wsi->opaque_parent_data = data; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_get_child_pending_on_writable(const struct lws *wsi) |
| { |
| return wsi->parent_pending_cb_on_writable; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_clear_child_pending_on_writable(struct lws *wsi) |
| { |
| wsi->parent_pending_cb_on_writable = 0; |
| } |
| |
| |
| LWS_EXTERN int |
| __lws_rx_flow_control(struct lws *wsi) |
| { |
| struct lws *wsic = wsi->child_list; |
| |
| // h2 ignores rx flow control atm |
| if (lwsi_role_h2(wsi) || wsi->http2_substream || |
| lwsi_role_h2_ENCAPSULATION(wsi)) |
| return 0; // !!! |
| |
| /* if he has children, do those if they were changed */ |
| while (wsic) { |
| if (wsic->rxflow_change_to & LWS_RXFLOW_PENDING_CHANGE) |
| __lws_rx_flow_control(wsic); |
| |
| wsic = wsic->sibling_list; |
| } |
| |
| /* there is no pending change */ |
| if (!(wsi->rxflow_change_to & LWS_RXFLOW_PENDING_CHANGE)) |
| return 0; |
| |
| /* stuff is still buffered, not ready to really accept new input */ |
| if (lws_buflist_next_segment_len(&wsi->buflist, NULL)) { |
| /* get ourselves called back to deal with stashed buffer */ |
| lws_callback_on_writable(wsi); |
| return 0; |
| } |
| |
| /* now the pending is cleared, we can change rxflow state */ |
| |
| wsi->rxflow_change_to &= ~LWS_RXFLOW_PENDING_CHANGE; |
| |
| lwsl_info("rxflow: wsi %p change_to %d\n", wsi, |
| wsi->rxflow_change_to & LWS_RXFLOW_ALLOW); |
| |
| /* adjust the pollfd for this wsi */ |
| |
| if (wsi->rxflow_change_to & LWS_RXFLOW_ALLOW) { |
| if (__lws_change_pollfd(wsi, 0, LWS_POLLIN)) { |
| lwsl_info("%s: fail\n", __func__); |
| return -1; |
| } |
| } else |
| if (__lws_change_pollfd(wsi, LWS_POLLIN, 0)) |
| return -1; |
| |
| return 0; |
| } |
| |
| static const unsigned char e0f4[] = { |
| 0xa0 | ((2 - 1) << 2) | 1, /* e0 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e1 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e2 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e3 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e4 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e5 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e6 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e7 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e8 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* e9 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* ea */ |
| 0x80 | ((4 - 1) << 2) | 1, /* eb */ |
| 0x80 | ((4 - 1) << 2) | 1, /* ec */ |
| 0x80 | ((2 - 1) << 2) | 1, /* ed */ |
| 0x80 | ((4 - 1) << 2) | 1, /* ee */ |
| 0x80 | ((4 - 1) << 2) | 1, /* ef */ |
| 0x90 | ((3 - 1) << 2) | 2, /* f0 */ |
| 0x80 | ((4 - 1) << 2) | 2, /* f1 */ |
| 0x80 | ((4 - 1) << 2) | 2, /* f2 */ |
| 0x80 | ((4 - 1) << 2) | 2, /* f3 */ |
| 0x80 | ((1 - 1) << 2) | 2, /* f4 */ |
| |
| 0, /* s0 */ |
| 0x80 | ((4 - 1) << 2) | 0, /* s2 */ |
| 0x80 | ((4 - 1) << 2) | 1, /* s3 */ |
| }; |
| |
| LWS_EXTERN int |
| lws_check_byte_utf8(unsigned char state, unsigned char c) |
| { |
| unsigned char s = state; |
| |
| if (!s) { |
| if (c >= 0x80) { |
| if (c < 0xc2 || c > 0xf4) |
| return -1; |
| if (c < 0xe0) |
| return 0x80 | ((4 - 1) << 2); |
| else |
| return e0f4[c - 0xe0]; |
| } |
| |
| return s; |
| } |
| if (c < (s & 0xf0) || c >= (s & 0xf0) + 0x10 + ((s << 2) & 0x30)) |
| return -1; |
| |
| return e0f4[21 + (s & 3)]; |
| } |
| |
| LWS_EXTERN int |
| lws_check_utf8(unsigned char *state, unsigned char *buf, size_t len) |
| { |
| unsigned char s = *state; |
| |
| while (len--) { |
| unsigned char c = *buf++; |
| |
| if (!s) { |
| if (c >= 0x80) { |
| if (c < 0xc2 || c > 0xf4) |
| return 1; |
| if (c < 0xe0) |
| s = 0x80 | ((4 - 1) << 2); |
| else |
| s = e0f4[c - 0xe0]; |
| } |
| } else { |
| if (c < (s & 0xf0) || |
| c >= (s & 0xf0) + 0x10 + ((s << 2) & 0x30)) |
| return 1; |
| s = e0f4[21 + (s & 3)]; |
| } |
| } |
| |
| *state = s; |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_parse_uri(char *p, const char **prot, const char **ads, int *port, |
| const char **path) |
| { |
| const char *end; |
| char unix_skt = 0; |
| |
| /* cut up the location into address, port and path */ |
| *prot = p; |
| while (*p && (*p != ':' || p[1] != '/' || p[2] != '/')) |
| p++; |
| if (!*p) { |
| end = p; |
| p = (char *)*prot; |
| *prot = end; |
| } else { |
| *p = '\0'; |
| p += 3; |
| } |
| if (*p == '+') /* unix skt */ |
| unix_skt = 1; |
| |
| *ads = p; |
| if (!strcmp(*prot, "http") || !strcmp(*prot, "ws")) |
| *port = 80; |
| else if (!strcmp(*prot, "https") || !strcmp(*prot, "wss")) |
| *port = 443; |
| |
| if (*p == '[') { |
| ++(*ads); |
| while (*p && *p != ']') |
| p++; |
| if (*p) |
| *p++ = '\0'; |
| } else |
| while (*p && *p != ':' && (unix_skt || *p != '/')) |
| p++; |
| |
| if (*p == ':') { |
| *p++ = '\0'; |
| *port = atoi(p); |
| while (*p && *p != '/') |
| p++; |
| } |
| *path = "/"; |
| if (*p) { |
| *p++ = '\0'; |
| if (*p) |
| *path = p; |
| } |
| |
| return 0; |
| } |
| |
| char * |
| lws_strdup(const char *s) |
| { |
| char *d = lws_malloc(strlen(s) + 1, "strdup"); |
| |
| if (d) |
| strcpy(d, s); |
| |
| return d; |
| } |
| |
| #if defined(LWS_WITHOUT_EXTENSIONS) |
| |
| /* we need to provide dummy callbacks for internal exts |
| * so user code runs when faced with a lib compiled with |
| * extensions disabled. |
| */ |
| |
| LWS_VISIBLE int |
| lws_extension_callback_pm_deflate(struct lws_context *context, |
| const struct lws_extension *ext, |
| struct lws *wsi, |
| enum lws_extension_callback_reasons reason, |
| void *user, void *in, size_t len) |
| { |
| (void)context; |
| (void)ext; |
| (void)wsi; |
| (void)reason; |
| (void)user; |
| (void)in; |
| (void)len; |
| |
| return 0; |
| } |
| |
| LWS_EXTERN int |
| lws_set_extension_option(struct lws *wsi, const char *ext_name, |
| const char *opt_name, const char *opt_val) |
| { |
| return -1; |
| } |
| #endif |
| |
| LWS_EXTERN int |
| lws_socket_bind(struct lws_vhost *vhost, lws_sockfd_type sockfd, int port, |
| const char *iface) |
| { |
| #ifdef LWS_WITH_UNIX_SOCK |
| struct sockaddr_un serv_unix; |
| #endif |
| #ifdef LWS_WITH_IPV6 |
| struct sockaddr_in6 serv_addr6; |
| #endif |
| struct sockaddr_in serv_addr4; |
| #ifndef LWS_PLAT_OPTEE |
| socklen_t len = sizeof(struct sockaddr_storage); |
| #endif |
| int n; |
| #if !defined(LWS_WITH_ESP32) |
| int m; |
| #endif |
| struct sockaddr_storage sin; |
| struct sockaddr *v; |
| |
| memset(&sin, 0, sizeof(sin)); |
| |
| #if defined(LWS_WITH_UNIX_SOCK) |
| if (LWS_UNIX_SOCK_ENABLED(vhost)) { |
| v = (struct sockaddr *)&serv_unix; |
| n = sizeof(struct sockaddr_un); |
| bzero((char *) &serv_unix, sizeof(serv_unix)); |
| serv_unix.sun_family = AF_UNIX; |
| if (!iface) |
| return -1; |
| if (sizeof(serv_unix.sun_path) <= strlen(iface)) { |
| lwsl_err("\"%s\" too long for UNIX domain socket\n", |
| iface); |
| return -1; |
| } |
| strcpy(serv_unix.sun_path, iface); |
| if (serv_unix.sun_path[0] == '@') |
| serv_unix.sun_path[0] = '\0'; |
| else |
| unlink(serv_unix.sun_path); |
| |
| } else |
| #endif |
| #if defined(LWS_WITH_IPV6) && !defined(LWS_WITH_ESP32) |
| if (LWS_IPV6_ENABLED(vhost)) { |
| v = (struct sockaddr *)&serv_addr6; |
| n = sizeof(struct sockaddr_in6); |
| bzero((char *) &serv_addr6, sizeof(serv_addr6)); |
| if (iface) { |
| m = interface_to_sa(vhost, iface, |
| (struct sockaddr_in *)v, n); |
| if (m == LWS_ITOSA_NOT_USABLE) { |
| lwsl_info("%s: netif %s: Not usable\n", |
| __func__, iface); |
| return m; |
| } |
| if (m == LWS_ITOSA_NOT_EXIST) { |
| lwsl_info("%s: netif %s: Does not exist\n", |
| __func__, iface); |
| return m; |
| } |
| serv_addr6.sin6_scope_id = lws_get_addr_scope(iface); |
| } |
| |
| serv_addr6.sin6_family = AF_INET6; |
| serv_addr6.sin6_port = htons(port); |
| } else |
| #endif |
| { |
| v = (struct sockaddr *)&serv_addr4; |
| n = sizeof(serv_addr4); |
| bzero((char *) &serv_addr4, sizeof(serv_addr4)); |
| serv_addr4.sin_addr.s_addr = INADDR_ANY; |
| serv_addr4.sin_family = AF_INET; |
| #if !defined(LWS_WITH_ESP32) |
| |
| if (iface) { |
| m = interface_to_sa(vhost, iface, |
| (struct sockaddr_in *)v, n); |
| if (m == LWS_ITOSA_NOT_USABLE) { |
| lwsl_info("%s: netif %s: Not usable\n", |
| __func__, iface); |
| return m; |
| } |
| if (m == LWS_ITOSA_NOT_EXIST) { |
| lwsl_info("%s: netif %s: Does not exist\n", |
| __func__, iface); |
| return m; |
| } |
| } |
| #endif |
| serv_addr4.sin_port = htons(port); |
| } /* ipv4 */ |
| |
| /* just checking for the interface extant */ |
| if (sockfd == LWS_SOCK_INVALID) |
| return 0; |
| |
| n = bind(sockfd, v, n); |
| #ifdef LWS_WITH_UNIX_SOCK |
| if (n < 0 && LWS_UNIX_SOCK_ENABLED(vhost)) { |
| lwsl_err("ERROR on binding fd %d to \"%s\" (%d %d)\n", |
| sockfd, iface, n, LWS_ERRNO); |
| return -1; |
| } else |
| #endif |
| if (n < 0) { |
| lwsl_err("ERROR on binding fd %d to port %d (%d %d)\n", |
| sockfd, port, n, LWS_ERRNO); |
| return -1; |
| } |
| |
| #if defined(LWS_WITH_UNIX_SOCK) |
| if (LWS_UNIX_SOCK_ENABLED(vhost) && vhost->context->uid) |
| if (chown(serv_unix.sun_path, vhost->context->uid, |
| vhost->context->gid)) |
| lwsl_notice("%s: chown for unix skt %s failed\n", |
| __func__, serv_unix.sun_path); |
| #endif |
| |
| #ifndef LWS_PLAT_OPTEE |
| if (getsockname(sockfd, (struct sockaddr *)&sin, &len) == -1) |
| lwsl_warn("getsockname: %s\n", strerror(LWS_ERRNO)); |
| else |
| #endif |
| #if defined(LWS_WITH_IPV6) |
| port = (sin.ss_family == AF_INET6) ? |
| ntohs(((struct sockaddr_in6 *) &sin)->sin6_port) : |
| ntohs(((struct sockaddr_in *) &sin)->sin_port); |
| #else |
| { |
| struct sockaddr_in sain; |
| memcpy(&sain, &sin, sizeof(sain)); |
| port = ntohs(sain.sin_port); |
| } |
| #endif |
| |
| return port; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_get_vhost_listen_port(struct lws_vhost *vhost) |
| { |
| return vhost->listen_port; |
| } |
| |
| #if defined(LWS_WITH_IPV6) |
| LWS_EXTERN unsigned long |
| lws_get_addr_scope(const char *ipaddr) |
| { |
| unsigned long scope = 0; |
| |
| #ifndef WIN32 |
| struct ifaddrs *addrs, *addr; |
| char ip[NI_MAXHOST]; |
| unsigned int i; |
| |
| getifaddrs(&addrs); |
| for (addr = addrs; addr; addr = addr->ifa_next) { |
| if (!addr->ifa_addr || |
| addr->ifa_addr->sa_family != AF_INET6) |
| continue; |
| |
| getnameinfo(addr->ifa_addr, |
| sizeof(struct sockaddr_in6), |
| ip, sizeof(ip), |
| NULL, 0, NI_NUMERICHOST); |
| |
| i = 0; |
| while (ip[i]) |
| if (ip[i++] == '%') { |
| ip[i - 1] = '\0'; |
| break; |
| } |
| |
| if (!strcmp(ip, ipaddr)) { |
| scope = if_nametoindex(addr->ifa_name); |
| break; |
| } |
| } |
| freeifaddrs(addrs); |
| #else |
| PIP_ADAPTER_ADDRESSES adapter, addrs = NULL; |
| PIP_ADAPTER_UNICAST_ADDRESS addr; |
| ULONG size = 0; |
| DWORD ret; |
| struct sockaddr_in6 *sockaddr; |
| char ip[NI_MAXHOST]; |
| unsigned int i; |
| int found = 0; |
| |
| for (i = 0; i < 5; i++) |
| { |
| ret = GetAdaptersAddresses(AF_INET6, GAA_FLAG_INCLUDE_PREFIX, |
| NULL, addrs, &size); |
| if ((ret == NO_ERROR) || (ret == ERROR_NO_DATA)) { |
| break; |
| } else if (ret == ERROR_BUFFER_OVERFLOW) |
| { |
| if (addrs) |
| free(addrs); |
| addrs = (IP_ADAPTER_ADDRESSES *)malloc(size); |
| } else |
| { |
| if (addrs) |
| { |
| free(addrs); |
| addrs = NULL; |
| } |
| lwsl_err("Failed to get IPv6 address table (%d)", ret); |
| break; |
| } |
| } |
| |
| if ((ret == NO_ERROR) && (addrs)) { |
| adapter = addrs; |
| while (adapter && !found) { |
| addr = adapter->FirstUnicastAddress; |
| while (addr && !found) { |
| if (addr->Address.lpSockaddr->sa_family == |
| AF_INET6) { |
| sockaddr = (struct sockaddr_in6 *) |
| (addr->Address.lpSockaddr); |
| |
| lws_plat_inet_ntop(sockaddr->sin6_family, |
| &sockaddr->sin6_addr, |
| ip, sizeof(ip)); |
| |
| if (!strcmp(ip, ipaddr)) { |
| scope = sockaddr->sin6_scope_id; |
| found = 1; |
| break; |
| } |
| } |
| addr = addr->Next; |
| } |
| adapter = adapter->Next; |
| } |
| } |
| if (addrs) |
| free(addrs); |
| #endif |
| |
| return scope; |
| } |
| #endif |
| |
| static const char *hex = "0123456789ABCDEF"; |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_sql_purify(char *escaped, const char *string, int len) |
| { |
| const char *p = string; |
| char *q = escaped; |
| |
| while (*p && len-- > 2) { |
| if (*p == '\'') { |
| *q++ = '\''; |
| *q++ = '\''; |
| len --; |
| p++; |
| } else |
| *q++ = *p++; |
| } |
| *q = '\0'; |
| |
| return escaped; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_json_purify(char *escaped, const char *string, int len) |
| { |
| const char *p = string; |
| char *q = escaped; |
| |
| if (!p) { |
| escaped[0] = '\0'; |
| return escaped; |
| } |
| |
| while (*p && len-- > 6) { |
| if (*p == '\t') { |
| p++; |
| *q++ = '\\'; |
| *q++ = 't'; |
| continue; |
| } |
| |
| if (*p == '\n') { |
| p++; |
| *q++ = '\\'; |
| *q++ = 'n'; |
| continue; |
| } |
| |
| if (*p == '\r') { |
| p++; |
| *q++ = '\\'; |
| *q++ = 'r'; |
| continue; |
| } |
| |
| if (*p == '\"' || *p == '\\' || *p < 0x20) { |
| *q++ = '\\'; |
| *q++ = 'u'; |
| *q++ = '0'; |
| *q++ = '0'; |
| *q++ = hex[((*p) >> 4) & 15]; |
| *q++ = hex[(*p) & 15]; |
| len -= 5; |
| p++; |
| } else |
| *q++ = *p++; |
| } |
| *q = '\0'; |
| |
| return escaped; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_filename_purify_inplace(char *filename) |
| { |
| while (*filename) { |
| |
| if (*filename == '.' && filename[1] == '.') { |
| *filename = '_'; |
| filename[1] = '_'; |
| } |
| |
| if (*filename == ':' || |
| *filename == '/' || |
| *filename == '\\' || |
| *filename == '$' || |
| *filename == '%') |
| *filename = '_'; |
| |
| filename++; |
| } |
| } |
| |
| LWS_VISIBLE LWS_EXTERN const char * |
| lws_urlencode(char *escaped, const char *string, int len) |
| { |
| const char *p = string; |
| char *q = escaped; |
| |
| while (*p && len-- > 3) { |
| if (*p == ' ') { |
| *q++ = '+'; |
| p++; |
| continue; |
| } |
| if ((*p >= '0' && *p <= '9') || |
| (*p >= 'A' && *p <= 'Z') || |
| (*p >= 'a' && *p <= 'z')) { |
| *q++ = *p++; |
| continue; |
| } |
| *q++ = '%'; |
| *q++ = hex[(*p >> 4) & 0xf]; |
| *q++ = hex[*p & 0xf]; |
| |
| len -= 2; |
| p++; |
| } |
| *q = '\0'; |
| |
| return escaped; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_urldecode(char *string, const char *escaped, int len) |
| { |
| int state = 0, n; |
| char sum = 0; |
| |
| while (*escaped && len) { |
| switch (state) { |
| case 0: |
| if (*escaped == '%') { |
| state++; |
| escaped++; |
| continue; |
| } |
| if (*escaped == '+') { |
| escaped++; |
| *string++ = ' '; |
| len--; |
| continue; |
| } |
| *string++ = *escaped++; |
| len--; |
| break; |
| case 1: |
| n = char_to_hex(*escaped); |
| if (n < 0) |
| return -1; |
| escaped++; |
| sum = n << 4; |
| state++; |
| break; |
| |
| case 2: |
| n = char_to_hex(*escaped); |
| if (n < 0) |
| return -1; |
| escaped++; |
| *string++ = sum | n; |
| len--; |
| state = 0; |
| break; |
| } |
| |
| } |
| *string = '\0'; |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_finalize_startup(struct lws_context *context) |
| { |
| struct lws_context_creation_info info; |
| |
| info.uid = context->uid; |
| info.gid = context->gid; |
| |
| #if defined(LWS_HAVE_SYS_CAPABILITY_H) && defined(LWS_HAVE_LIBCAP) |
| memcpy(info.caps, context->caps, sizeof(info.caps)); |
| info.count_caps = context->count_caps; |
| #endif |
| |
| if (lws_check_opt(context->options, LWS_SERVER_OPTION_EXPLICIT_VHOSTS)) |
| lws_plat_drop_app_privileges(&info); |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_get_effective_uid_gid(struct lws_context *context, int *uid, int *gid) |
| { |
| *uid = context->uid; |
| *gid = context->gid; |
| } |
| |
| int |
| lws_snprintf(char *str, size_t size, const char *format, ...) |
| { |
| va_list ap; |
| int n; |
| |
| if (!size) |
| return 0; |
| |
| va_start(ap, format); |
| n = vsnprintf(str, size, format, ap); |
| va_end(ap); |
| |
| if (n >= (int)size) |
| return (int)size; |
| |
| return n; |
| } |
| |
| char * |
| lws_strncpy(char *dest, const char *src, size_t size) |
| { |
| strncpy(dest, src, size - 1); |
| dest[size - 1] = '\0'; |
| |
| return dest; |
| } |
| |
| |
| typedef enum { |
| LWS_TOKZS_LEADING_WHITESPACE, |
| LWS_TOKZS_QUOTED_STRING, |
| LWS_TOKZS_TOKEN, |
| LWS_TOKZS_TOKEN_POST_TERMINAL |
| } lws_tokenize_state; |
| |
| int |
| lws_tokenize(struct lws_tokenize *ts) |
| { |
| const char *rfc7230_delims = "(),/:;<=>?@[\\]{}"; |
| lws_tokenize_state state = LWS_TOKZS_LEADING_WHITESPACE; |
| char c, num = -1, flo = 0; |
| int utf8 = 0; |
| |
| ts->token = NULL; |
| ts->token_len = 0; |
| |
| while (ts->len) { |
| c = *ts->start++; |
| ts->len--; |
| |
| utf8 = lws_check_byte_utf8((unsigned char)utf8, c); |
| if (utf8 < 0) |
| return LWS_TOKZE_ERR_BROKEN_UTF8; |
| |
| lwsl_debug("%s: %c (%d) %d\n", __func__, c, state, (int)ts->len); |
| |
| if (!c) |
| break; |
| |
| /* whitespace */ |
| |
| if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || |
| c == '\f') { |
| switch (state) { |
| case LWS_TOKZS_LEADING_WHITESPACE: |
| case LWS_TOKZS_TOKEN_POST_TERMINAL: |
| continue; |
| case LWS_TOKZS_QUOTED_STRING: |
| ts->token_len++; |
| continue; |
| case LWS_TOKZS_TOKEN: |
| /* we want to scan forward to look for = */ |
| |
| state = LWS_TOKZS_TOKEN_POST_TERMINAL; |
| continue; |
| } |
| } |
| |
| /* quoted string */ |
| |
| if (c == '\"') { |
| if (state == LWS_TOKZS_QUOTED_STRING) |
| return LWS_TOKZE_QUOTED_STRING; |
| |
| /* starting a quoted string */ |
| |
| if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) { |
| if (ts->delim == LWSTZ_DT_NEED_DELIM) |
| return LWS_TOKZE_ERR_COMMA_LIST; |
| ts->delim = LWSTZ_DT_NEED_DELIM; |
| } |
| |
| state = LWS_TOKZS_QUOTED_STRING; |
| ts->token = ts->start; |
| ts->token_len = 0; |
| |
| continue; |
| } |
| |
| /* token= aggregation */ |
| |
| if (c == '=' && (state == LWS_TOKZS_TOKEN_POST_TERMINAL || |
| state == LWS_TOKZS_TOKEN)) { |
| if (num == 1) |
| return LWS_TOKZE_ERR_NUM_ON_LHS; |
| /* swallow the = */ |
| return LWS_TOKZE_TOKEN_NAME_EQUALS; |
| } |
| |
| /* optional token: aggregation */ |
| |
| if ((ts->flags & LWS_TOKENIZE_F_AGG_COLON) && c == ':' && |
| (state == LWS_TOKZS_TOKEN_POST_TERMINAL || |
| state == LWS_TOKZS_TOKEN)) |
| /* swallow the : */ |
| return LWS_TOKZE_TOKEN_NAME_COLON; |
| |
| /* aggregate . in a number as a float */ |
| |
| if (c == '.' && state == LWS_TOKZS_TOKEN && num == 1) { |
| if (flo) |
| return LWS_TOKZE_ERR_MALFORMED_FLOAT; |
| flo = 1; |
| ts->token_len++; |
| continue; |
| } |
| |
| /* |
| * Delimiter... by default anything that: |
| * |
| * - isn't matched earlier, or |
| * - is [A-Z, a-z, 0-9, _], and |
| * - is not a partial utf8 char |
| * |
| * is a "delimiter", it marks the end of a token and is itself |
| * reported as a single LWS_TOKZE_DELIMITER each time. |
| * |
| * However with LWS_TOKENIZE_F_RFC7230_DELIMS flag, tokens may |
| * contain any noncontrol character that isn't defined in |
| * rfc7230_delims, and only characters listed there are treated |
| * as delimiters. |
| */ |
| |
| if (!utf8 && |
| ((ts->flags & LWS_TOKENIZE_F_RFC7230_DELIMS && |
| strchr(rfc7230_delims, c) && c > 32) || |
| ((!(ts->flags & LWS_TOKENIZE_F_RFC7230_DELIMS) && |
| (c < '0' || c > '9') && (c < 'A' || c > 'Z') && |
| (c < 'a' || c > 'z') && c != '_') && !(c == '-' && |
| (ts->flags & LWS_TOKENIZE_F_MINUS_NONTERM))) || |
| (c == '-' && !(ts->flags & LWS_TOKENIZE_F_MINUS_NONTERM)) |
| )) { |
| switch (state) { |
| case LWS_TOKZS_LEADING_WHITESPACE: |
| if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) { |
| if (c != ',' || |
| ts->delim != LWSTZ_DT_NEED_DELIM) |
| return LWS_TOKZE_ERR_COMMA_LIST; |
| ts->delim = LWSTZ_DT_NEED_NEXT_CONTENT; |
| } |
| |
| ts->token = ts->start - 1; |
| ts->token_len = 1; |
| return LWS_TOKZE_DELIMITER; |
| |
| case LWS_TOKZS_QUOTED_STRING: |
| ts->token_len++; |
| continue; |
| |
| case LWS_TOKZS_TOKEN_POST_TERMINAL: |
| case LWS_TOKZS_TOKEN: |
| /* report the delimiter next time */ |
| ts->start--; |
| ts->len++; |
| goto token_or_numeric; |
| } |
| } |
| |
| /* anything that's not whitespace or delimiter is payload */ |
| |
| switch (state) { |
| case LWS_TOKZS_LEADING_WHITESPACE: |
| |
| if (ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) { |
| if (ts->delim == LWSTZ_DT_NEED_DELIM) |
| return LWS_TOKZE_ERR_COMMA_LIST; |
| ts->delim = LWSTZ_DT_NEED_DELIM; |
| } |
| |
| state = LWS_TOKZS_TOKEN; |
| ts->token = ts->start - 1; |
| ts->token_len = 1; |
| if (c < '0' || c > '9') |
| num = 0; |
| else |
| if (num < 0) |
| num = 1; |
| continue; |
| case LWS_TOKZS_QUOTED_STRING: |
| case LWS_TOKZS_TOKEN: |
| if (c < '0' || c > '9') |
| num = 0; |
| else |
| if (num < 0) |
| num = 1; |
| ts->token_len++; |
| continue; |
| case LWS_TOKZS_TOKEN_POST_TERMINAL: |
| /* report the new token next time */ |
| ts->start--; |
| ts->len++; |
| goto token_or_numeric; |
| } |
| } |
| |
| /* we ran out of content */ |
| |
| if (utf8) /* ended partway through a multibyte char */ |
| return LWS_TOKZE_ERR_BROKEN_UTF8; |
| |
| if (state == LWS_TOKZS_QUOTED_STRING) |
| return LWS_TOKZE_ERR_UNTERM_STRING; |
| |
| if (state != LWS_TOKZS_TOKEN_POST_TERMINAL && |
| state != LWS_TOKZS_TOKEN) { |
| if ((ts->flags & LWS_TOKENIZE_F_COMMA_SEP_LIST) && |
| ts->delim == LWSTZ_DT_NEED_NEXT_CONTENT) |
| return LWS_TOKZE_ERR_COMMA_LIST; |
| |
| return LWS_TOKZE_ENDED; |
| } |
| |
| /* report the pending token */ |
| |
| token_or_numeric: |
| |
| if (num != 1) |
| return LWS_TOKZE_TOKEN; |
| if (flo) |
| return LWS_TOKZE_FLOAT; |
| |
| return LWS_TOKZE_INTEGER; |
| } |
| |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_tokenize_cstr(struct lws_tokenize *ts, char *str, int max) |
| { |
| if (ts->token_len + 1 >= max) |
| return 1; |
| |
| memcpy(str, ts->token, ts->token_len); |
| str[ts->token_len] = '\0'; |
| |
| return 0; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_tokenize_init(struct lws_tokenize *ts, const char *start, int flags) |
| { |
| ts->start = start; |
| ts->len = 0x7fffffff; |
| ts->flags = flags; |
| ts->delim = LWSTZ_DT_NEED_FIRST_CONTENT; |
| } |
| |
| #if LWS_MAX_SMP > 1 |
| |
| void |
| lws_mutex_refcount_init(struct lws_mutex_refcount *mr) |
| { |
| pthread_mutex_init(&mr->lock, NULL); |
| mr->last_lock_reason = NULL; |
| mr->lock_depth = 0; |
| mr->metadata = 0; |
| mr->lock_owner = 0; |
| } |
| |
| void |
| lws_mutex_refcount_destroy(struct lws_mutex_refcount *mr) |
| { |
| pthread_mutex_destroy(&mr->lock); |
| } |
| |
| void |
| lws_mutex_refcount_lock(struct lws_mutex_refcount *mr, const char *reason) |
| { |
| /* if true, this sequence is atomic because our thread has the lock |
| * |
| * - if true, only guy who can race to make it untrue is our thread, |
| * and we are here. |
| * |
| * - if false, only guy who could race to make it true is our thread, |
| * and we are here |
| * |
| * - it can be false and change to a different tid that is also false |
| */ |
| if (mr->lock_owner == pthread_self()) { |
| /* atomic because we only change it if we own the lock */ |
| mr->lock_depth++; |
| return; |
| } |
| |
| pthread_mutex_lock(&mr->lock); |
| /* atomic because only we can have the lock */ |
| mr->last_lock_reason = reason; |
| mr->lock_owner = pthread_self(); |
| mr->lock_depth = 1; |
| //lwsl_notice("tid %d: lock %s\n", mr->tid, reason); |
| } |
| |
| void |
| lws_mutex_refcount_unlock(struct lws_mutex_refcount *mr) |
| { |
| if (--mr->lock_depth) |
| /* atomic because only thread that has the lock can unlock */ |
| return; |
| |
| mr->last_lock_reason = "free"; |
| mr->lock_owner = 0; |
| //lwsl_notice("tid %d: unlock %s\n", mr->tid, mr->last_lock_reason); |
| pthread_mutex_unlock(&mr->lock); |
| } |
| |
| #endif /* SMP */ |
| |
| LWS_VISIBLE LWS_EXTERN int |
| lws_is_cgi(struct lws *wsi) { |
| #ifdef LWS_WITH_CGI |
| return !!wsi->http.cgi; |
| #else |
| return 0; |
| #endif |
| } |
| |
| const struct lws_protocol_vhost_options * |
| lws_pvo_search(const struct lws_protocol_vhost_options *pvo, const char *name) |
| { |
| while (pvo) { |
| if (!strcmp(pvo->name, name)) |
| break; |
| |
| pvo = pvo->next; |
| } |
| |
| return pvo; |
| } |
| |
| int |
| lws_pvo_get_str(void *in, const char *name, const char **result) |
| { |
| const struct lws_protocol_vhost_options *pv = |
| lws_pvo_search((const struct lws_protocol_vhost_options *)in, |
| name); |
| |
| if (!pv) |
| return 1; |
| |
| *result = (const char *)pv->value; |
| |
| return 0; |
| } |
| |
| void |
| lws_sum_stats(const struct lws_context *ctx, struct lws_conn_stats *cs) |
| { |
| const struct lws_vhost *vh = ctx->vhost_list; |
| |
| while (vh) { |
| |
| cs->rx += vh->conn_stats.rx; |
| cs->tx += vh->conn_stats.tx; |
| cs->h1_conn += vh->conn_stats.h1_conn; |
| cs->h1_trans += vh->conn_stats.h1_trans; |
| cs->h2_trans += vh->conn_stats.h2_trans; |
| cs->ws_upg += vh->conn_stats.ws_upg; |
| cs->h2_upg += vh->conn_stats.h2_upg; |
| cs->h2_alpn += vh->conn_stats.h2_alpn; |
| cs->h2_subs += vh->conn_stats.h2_subs; |
| cs->rejected += vh->conn_stats.rejected; |
| |
| vh = vh->vhost_next; |
| } |
| } |
| |
| const char * |
| lws_cmdline_option(int argc, const char **argv, const char *val) |
| { |
| int n = (int)strlen(val), c = argc; |
| |
| while (--c > 0) { |
| |
| if (!strncmp(argv[c], val, n)) { |
| if (!*(argv[c] + n) && c < argc - 1) { |
| /* coverity treats unchecked argv as "tainted" */ |
| if (!argv[c + 1] || strlen(argv[c + 1]) > 1024) |
| return NULL; |
| return argv[c + 1]; |
| } |
| |
| return argv[c] + n; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| #ifdef LWS_WITH_SERVER_STATUS |
| |
| LWS_EXTERN int |
| lws_json_dump_vhost(const struct lws_vhost *vh, char *buf, int len) |
| { |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| static const char * const prots[] = { |
| "http://", |
| "https://", |
| "file://", |
| "cgi://", |
| ">http://", |
| ">https://", |
| "callback://" |
| }; |
| #endif |
| char *orig = buf, *end = buf + len - 1, first = 1; |
| int n = 0; |
| |
| if (len < 100) |
| return 0; |
| |
| buf += lws_snprintf(buf, end - buf, |
| "{\n \"name\":\"%s\",\n" |
| " \"port\":\"%d\",\n" |
| " \"use_ssl\":\"%d\",\n" |
| " \"sts\":\"%d\",\n" |
| " \"rx\":\"%llu\",\n" |
| " \"tx\":\"%llu\",\n" |
| " \"h1_conn\":\"%lu\",\n" |
| " \"h1_trans\":\"%lu\",\n" |
| " \"h2_trans\":\"%lu\",\n" |
| " \"ws_upg\":\"%lu\",\n" |
| " \"rejected\":\"%lu\",\n" |
| " \"h2_upg\":\"%lu\",\n" |
| " \"h2_alpn\":\"%lu\",\n" |
| " \"h2_subs\":\"%lu\"" |
| , |
| vh->name, vh->listen_port, |
| #if defined(LWS_WITH_TLS) |
| vh->tls.use_ssl & LCCSCF_USE_SSL, |
| #else |
| 0, |
| #endif |
| !!(vh->options & LWS_SERVER_OPTION_STS), |
| vh->conn_stats.rx, vh->conn_stats.tx, |
| vh->conn_stats.h1_conn, |
| vh->conn_stats.h1_trans, |
| vh->conn_stats.h2_trans, |
| vh->conn_stats.ws_upg, |
| vh->conn_stats.rejected, |
| vh->conn_stats.h2_upg, |
| vh->conn_stats.h2_alpn, |
| vh->conn_stats.h2_subs |
| ); |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| if (vh->http.mount_list) { |
| const struct lws_http_mount *m = vh->http.mount_list; |
| |
| buf += lws_snprintf(buf, end - buf, ",\n \"mounts\":["); |
| while (m) { |
| if (!first) |
| buf += lws_snprintf(buf, end - buf, ","); |
| buf += lws_snprintf(buf, end - buf, |
| "\n {\n \"mountpoint\":\"%s\",\n" |
| " \"origin\":\"%s%s\",\n" |
| " \"cache_max_age\":\"%d\",\n" |
| " \"cache_reuse\":\"%d\",\n" |
| " \"cache_revalidate\":\"%d\",\n" |
| " \"cache_intermediaries\":\"%d\"\n" |
| , |
| m->mountpoint, |
| prots[m->origin_protocol], |
| m->origin, |
| m->cache_max_age, |
| m->cache_reusable, |
| m->cache_revalidate, |
| m->cache_intermediaries); |
| if (m->def) |
| buf += lws_snprintf(buf, end - buf, |
| ",\n \"default\":\"%s\"", |
| m->def); |
| buf += lws_snprintf(buf, end - buf, "\n }"); |
| first = 0; |
| m = m->mount_next; |
| } |
| buf += lws_snprintf(buf, end - buf, "\n ]"); |
| } |
| #endif |
| if (vh->protocols) { |
| n = 0; |
| first = 1; |
| |
| buf += lws_snprintf(buf, end - buf, ",\n \"ws-protocols\":["); |
| while (n < vh->count_protocols) { |
| if (!first) |
| buf += lws_snprintf(buf, end - buf, ","); |
| buf += lws_snprintf(buf, end - buf, |
| "\n {\n \"%s\":{\n" |
| " \"status\":\"ok\"\n }\n }" |
| , |
| vh->protocols[n].name); |
| first = 0; |
| n++; |
| } |
| buf += lws_snprintf(buf, end - buf, "\n ]"); |
| } |
| |
| buf += lws_snprintf(buf, end - buf, "\n}"); |
| |
| return buf - orig; |
| } |
| |
| |
| LWS_EXTERN LWS_VISIBLE int |
| lws_json_dump_context(const struct lws_context *context, char *buf, int len, |
| int hide_vhosts) |
| { |
| char *orig = buf, *end = buf + len - 1, first = 1; |
| const struct lws_vhost *vh = context->vhost_list; |
| const struct lws_context_per_thread *pt; |
| time_t t = time(NULL); |
| int n, listening = 0, cgi_count = 0; |
| struct lws_conn_stats cs; |
| double d = 0; |
| #ifdef LWS_WITH_CGI |
| struct lws_cgi * const *pcgi; |
| #endif |
| |
| #ifdef LWS_WITH_LIBUV |
| uv_uptime(&d); |
| #endif |
| |
| buf += lws_snprintf(buf, end - buf, "{ " |
| "\"version\":\"%s\",\n" |
| "\"uptime\":\"%ld\",\n", |
| lws_get_library_version(), |
| (long)d); |
| |
| #ifdef LWS_HAVE_GETLOADAVG |
| { |
| double d[3]; |
| int m; |
| |
| m = getloadavg(d, 3); |
| for (n = 0; n < m; n++) { |
| buf += lws_snprintf(buf, end - buf, |
| "\"l%d\":\"%.2f\",\n", |
| n + 1, d[n]); |
| } |
| } |
| #endif |
| |
| buf += lws_snprintf(buf, end - buf, "\"contexts\":[\n"); |
| |
| buf += lws_snprintf(buf, end - buf, "{ " |
| "\"context_uptime\":\"%ld\",\n" |
| "\"cgi_spawned\":\"%d\",\n" |
| "\"pt_fd_max\":\"%d\",\n" |
| "\"ah_pool_max\":\"%d\",\n" |
| "\"deprecated\":\"%d\",\n" |
| "\"wsi_alive\":\"%d\",\n", |
| (unsigned long)(t - context->time_up), |
| context->count_cgi_spawned, |
| context->fd_limit_per_thread, |
| context->max_http_header_pool, |
| context->deprecated, |
| context->count_wsi_allocated); |
| |
| buf += lws_snprintf(buf, end - buf, "\"pt\":[\n "); |
| for (n = 0; n < context->count_threads; n++) { |
| pt = &context->pt[n]; |
| if (n) |
| buf += lws_snprintf(buf, end - buf, ","); |
| buf += lws_snprintf(buf, end - buf, |
| "\n {\n" |
| " \"fds_count\":\"%d\",\n" |
| " \"ah_pool_inuse\":\"%d\",\n" |
| " \"ah_wait_list\":\"%d\"\n" |
| " }", |
| pt->fds_count, |
| pt->http.ah_count_in_use, |
| pt->http.ah_wait_list_length); |
| } |
| |
| buf += lws_snprintf(buf, end - buf, "]"); |
| |
| buf += lws_snprintf(buf, end - buf, ", \"vhosts\":[\n "); |
| |
| first = 1; |
| vh = context->vhost_list; |
| listening = 0; |
| cs = context->conn_stats; |
| lws_sum_stats(context, &cs); |
| while (vh) { |
| |
| if (!hide_vhosts) { |
| if (!first) |
| if(buf != end) |
| *buf++ = ','; |
| buf += lws_json_dump_vhost(vh, buf, end - buf); |
| first = 0; |
| } |
| if (vh->lserv_wsi) |
| listening++; |
| vh = vh->vhost_next; |
| } |
| |
| buf += lws_snprintf(buf, end - buf, |
| "],\n\"listen_wsi\":\"%d\",\n" |
| " \"rx\":\"%llu\",\n" |
| " \"tx\":\"%llu\",\n" |
| " \"h1_conn\":\"%lu\",\n" |
| " \"h1_trans\":\"%lu\",\n" |
| " \"h2_trans\":\"%lu\",\n" |
| " \"ws_upg\":\"%lu\",\n" |
| " \"rejected\":\"%lu\",\n" |
| " \"h2_alpn\":\"%lu\",\n" |
| " \"h2_subs\":\"%lu\",\n" |
| " \"h2_upg\":\"%lu\"", |
| listening, cs.rx, cs.tx, |
| cs.h1_conn, |
| cs.h1_trans, |
| cs.h2_trans, |
| cs.ws_upg, |
| cs.rejected, |
| cs.h2_alpn, |
| cs.h2_subs, |
| cs.h2_upg); |
| |
| #ifdef LWS_WITH_CGI |
| for (n = 0; n < context->count_threads; n++) { |
| pt = &context->pt[n]; |
| pcgi = &pt->http.cgi_list; |
| |
| while (*pcgi) { |
| pcgi = &(*pcgi)->cgi_list; |
| |
| cgi_count++; |
| } |
| } |
| #endif |
| buf += lws_snprintf(buf, end - buf, ",\n \"cgi_alive\":\"%d\"\n ", |
| cgi_count); |
| |
| buf += lws_snprintf(buf, end - buf, "}"); |
| |
| |
| buf += lws_snprintf(buf, end - buf, "]}\n "); |
| |
| return buf - orig; |
| } |
| |
| #endif |
| |
| #if defined(LWS_WITH_STATS) |
| |
| LWS_VISIBLE LWS_EXTERN uint64_t |
| lws_stats_get(struct lws_context *context, int index) |
| { |
| if (index >= LWSSTATS_SIZE) |
| return 0; |
| |
| return context->lws_stats[index]; |
| } |
| |
| LWS_VISIBLE LWS_EXTERN void |
| lws_stats_log_dump(struct lws_context *context) |
| { |
| struct lws_vhost *v = context->vhost_list; |
| int n; |
| #if defined(LWS_WITH_PEER_LIMITS) |
| int m; |
| #endif |
| |
| if (!context->updated) |
| return; |
| |
| context->updated = 0; |
| |
| lwsl_notice("\n"); |
| lwsl_notice("LWS internal statistics dump ----->\n"); |
| lwsl_notice("LWSSTATS_C_CONNECTIONS: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_CONNECTIONS)); |
| lwsl_notice("LWSSTATS_C_API_CLOSE: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_API_CLOSE)); |
| lwsl_notice("LWSSTATS_C_API_READ: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_API_READ)); |
| lwsl_notice("LWSSTATS_C_API_LWS_WRITE: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_API_LWS_WRITE)); |
| lwsl_notice("LWSSTATS_C_API_WRITE: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_API_WRITE)); |
| lwsl_notice("LWSSTATS_C_WRITE_PARTIALS: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_WRITE_PARTIALS)); |
| lwsl_notice("LWSSTATS_C_WRITEABLE_CB_REQ: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_WRITEABLE_CB_REQ)); |
| lwsl_notice("LWSSTATS_C_WRITEABLE_CB_EFF_REQ: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_WRITEABLE_CB_EFF_REQ)); |
| lwsl_notice("LWSSTATS_C_WRITEABLE_CB: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_WRITEABLE_CB)); |
| lwsl_notice("LWSSTATS_C_SSL_CONNECTIONS_ACCEPT_SPIN: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNECTIONS_ACCEPT_SPIN)); |
| lwsl_notice("LWSSTATS_C_SSL_CONNECTIONS_FAILED: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNECTIONS_FAILED)); |
| lwsl_notice("LWSSTATS_C_SSL_CONNECTIONS_ACCEPTED: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNECTIONS_ACCEPTED)); |
| lwsl_notice("LWSSTATS_C_SSL_CONNS_HAD_RX: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNS_HAD_RX)); |
| lwsl_notice("LWSSTATS_C_PEER_LIMIT_AH_DENIED: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_PEER_LIMIT_AH_DENIED)); |
| lwsl_notice("LWSSTATS_C_PEER_LIMIT_WSI_DENIED: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_PEER_LIMIT_WSI_DENIED)); |
| |
| lwsl_notice("LWSSTATS_C_TIMEOUTS: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_TIMEOUTS)); |
| lwsl_notice("LWSSTATS_C_SERVICE_ENTRY: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_C_SERVICE_ENTRY)); |
| lwsl_notice("LWSSTATS_B_READ: %8llu\n", |
| (unsigned long long)lws_stats_get(context, LWSSTATS_B_READ)); |
| lwsl_notice("LWSSTATS_B_WRITE: %8llu\n", |
| (unsigned long long)lws_stats_get(context, LWSSTATS_B_WRITE)); |
| lwsl_notice("LWSSTATS_B_PARTIALS_ACCEPTED_PARTS: %8llu\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_B_PARTIALS_ACCEPTED_PARTS)); |
| lwsl_notice("LWSSTATS_MS_SSL_CONNECTIONS_ACCEPTED_DELAY: %8llums\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_MS_SSL_CONNECTIONS_ACCEPTED_DELAY) / 1000); |
| if (lws_stats_get(context, LWSSTATS_C_SSL_CONNECTIONS_ACCEPTED)) |
| lwsl_notice(" Avg accept delay: %8llums\n", |
| (unsigned long long)(lws_stats_get(context, |
| LWSSTATS_MS_SSL_CONNECTIONS_ACCEPTED_DELAY) / |
| lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNECTIONS_ACCEPTED)) / 1000); |
| lwsl_notice("LWSSTATS_MS_SSL_RX_DELAY: %8llums\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_MS_SSL_RX_DELAY) / 1000); |
| if (lws_stats_get(context, LWSSTATS_C_SSL_CONNS_HAD_RX)) |
| lwsl_notice(" Avg accept-rx delay: %8llums\n", |
| (unsigned long long)(lws_stats_get(context, |
| LWSSTATS_MS_SSL_RX_DELAY) / |
| lws_stats_get(context, |
| LWSSTATS_C_SSL_CONNS_HAD_RX)) / 1000); |
| |
| lwsl_notice("LWSSTATS_MS_WRITABLE_DELAY: %8lluus\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_MS_WRITABLE_DELAY)); |
| lwsl_notice("LWSSTATS_MS_WORST_WRITABLE_DELAY: %8lluus\n", |
| (unsigned long long)lws_stats_get(context, |
| LWSSTATS_MS_WORST_WRITABLE_DELAY)); |
| if (lws_stats_get(context, LWSSTATS_C_WRITEABLE_CB)) |
| lwsl_notice(" Avg writable delay: %8lluus\n", |
| (unsigned long long)(lws_stats_get(context, |
| LWSSTATS_MS_WRITABLE_DELAY) / |
| lws_stats_get(context, LWSSTATS_C_WRITEABLE_CB))); |
| lwsl_notice("Simultaneous SSL restriction: %8d/%d\n", |
| context->simultaneous_ssl, |
| context->simultaneous_ssl_restriction); |
| |
| lwsl_notice("Live wsi: %8d\n", |
| context->count_wsi_allocated); |
| |
| context->updated = 1; |
| |
| while (v) { |
| if (v->lserv_wsi && |
| v->lserv_wsi->position_in_fds_table != LWS_NO_FDS_POS) { |
| |
| struct lws_context_per_thread *pt = |
| &context->pt[(int)v->lserv_wsi->tsi]; |
| struct lws_pollfd *pfd; |
| |
| pfd = &pt->fds[v->lserv_wsi->position_in_fds_table]; |
| |
| lwsl_notice(" Listen port %d actual POLLIN: %d\n", |
| v->listen_port, |
| (int)pfd->events & LWS_POLLIN); |
| } |
| |
| v = v->vhost_next; |
| } |
| |
| for (n = 0; n < context->count_threads; n++) { |
| struct lws_context_per_thread *pt = &context->pt[n]; |
| struct lws *wl; |
| int m = 0; |
| |
| lwsl_notice("PT %d\n", n + 1); |
| |
| lws_pt_lock(pt, __func__); |
| |
| lwsl_notice(" AH in use / max: %d / %d\n", |
| pt->http.ah_count_in_use, |
| context->max_http_header_pool); |
| |
| wl = pt->http.ah_wait_list; |
| while (wl) { |
| m++; |
| wl = wl->http.ah_wait_list; |
| } |
| |
| lwsl_notice(" AH wait list count / actual: %d / %d\n", |
| pt->http.ah_wait_list_length, m); |
| |
| lws_pt_unlock(pt); |
| } |
| |
| #if defined(LWS_WITH_PEER_LIMITS) |
| m = 0; |
| for (n = 0; n < (int)context->pl_hash_elements; n++) { |
| lws_start_foreach_llp(struct lws_peer **, peer, |
| context->pl_hash_table[n]) { |
| m++; |
| } lws_end_foreach_llp(peer, next); |
| } |
| |
| lwsl_notice(" Peers: total active %d\n", m); |
| if (m > 10) { |
| m = 10; |
| lwsl_notice(" (showing 10 peers only)\n"); |
| } |
| |
| if (m) { |
| for (n = 0; n < (int)context->pl_hash_elements; n++) { |
| char buf[72]; |
| |
| lws_start_foreach_llp(struct lws_peer **, peer, |
| context->pl_hash_table[n]) { |
| struct lws_peer *df = *peer; |
| |
| if (!lws_plat_inet_ntop(df->af, df->addr, buf, |
| sizeof(buf) - 1)) |
| strcpy(buf, "unknown"); |
| #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) |
| lwsl_notice(" peer %s: count wsi: %d, count ah: %d\n", |
| buf, df->count_wsi, |
| df->http.count_ah); |
| #else |
| lwsl_notice(" peer %s: count wsi: %d\n", |
| buf, df->count_wsi); |
| #endif |
| |
| if (!--m) |
| break; |
| } lws_end_foreach_llp(peer, next); |
| } |
| } |
| #endif |
| |
| lwsl_notice("\n"); |
| } |
| |
| void |
| lws_stats_atomic_bump(struct lws_context * context, |
| struct lws_context_per_thread *pt, int index, uint64_t bump) |
| { |
| lws_pt_stats_lock(pt); |
| context->lws_stats[index] += bump; |
| if (index != LWSSTATS_C_SERVICE_ENTRY) |
| context->updated = 1; |
| lws_pt_stats_unlock(pt); |
| } |
| |
| void |
| lws_stats_atomic_max(struct lws_context * context, |
| struct lws_context_per_thread *pt, int index, uint64_t val) |
| { |
| lws_pt_stats_lock(pt); |
| if (val > context->lws_stats[index]) { |
| context->lws_stats[index] = val; |
| context->updated = 1; |
| } |
| lws_pt_stats_unlock(pt); |
| } |
| |
| #endif |
| |