/* * libwebsockets - small server side websockets and web server implementation * * Copyright (C) 2010 - 2019 Andy Green * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #include #ifndef min #define min(a, b) ((a) < (b) ? (a) : (b)) #endif /* * We have to take care about parsing because the headers may be split * into multiple fragments. They may contain unknown headers with arbitrary * argument lengths. So, we parse using a single-character at a time state * machine that is completely independent of packet size. * * Returns <0 for error or length of chars consumed from buf (up to len) */ int lws_read_h1(struct lws *wsi, unsigned char *buf, lws_filepos_t len) { unsigned char *last_char, *oldbuf = buf; lws_filepos_t body_chunk_len; size_t n; lwsl_debug("%s: h1 path: wsi state 0x%x\n", __func__, lwsi_state(wsi)); switch (lwsi_state(wsi)) { case LRS_ISSUING_FILE: return 0; case LRS_ESTABLISHED: if (lwsi_role_ws(wsi)) goto ws_mode; if (lwsi_role_client(wsi)) break; wsi->hdr_parsing_completed = 0; /* fallthru */ case LRS_HEADERS: if (!wsi->http.ah) { lwsl_err("%s: LRS_HEADERS: NULL ah\n", __func__); assert(0); } lwsl_parser("issuing %d bytes to parser\n", (int)len); #if defined(LWS_ROLE_WS) && defined(LWS_WITH_CLIENT) if (lws_ws_handshake_client(wsi, &buf, (size_t)len)) goto bail; #endif last_char = buf; if (lws_handshake_server(wsi, &buf, (size_t)len)) /* Handshake indicates this session is done. */ goto bail; /* we might have transitioned to RAW */ if (wsi->role_ops == &role_ops_raw_skt #if defined(LWS_ROLE_RAW_FILE) || wsi->role_ops == &role_ops_raw_file #endif ) /* we gave the read buffer to RAW handler already */ goto read_ok; /* * It's possible that we've exhausted our data already, or * rx flow control has stopped us dealing with this early, * but lws_handshake_server doesn't update len for us. * Figure out how much was read, so that we can proceed * appropriately: */ len -= (buf - last_char); if (!wsi->hdr_parsing_completed) /* More header content on the way */ goto read_ok; switch (lwsi_state(wsi)) { case LRS_ESTABLISHED: case LRS_HEADERS: goto read_ok; case LRS_ISSUING_FILE: goto read_ok; case LRS_DISCARD_BODY: case LRS_BODY: wsi->http.rx_content_remain = wsi->http.rx_content_length; if (wsi->http.rx_content_remain) goto http_postbody; /* there is no POST content */ goto postbody_completion; default: break; } break; case LRS_DISCARD_BODY: case LRS_BODY: http_postbody: lwsl_debug("%s: http post body: remain %d\n", __func__, (int)wsi->http.rx_content_remain); if (!wsi->http.rx_content_remain) goto postbody_completion; while (len && wsi->http.rx_content_remain) { /* Copy as much as possible, up to the limit of: * what we have in the read buffer (len) * remaining portion of the POST body (content_remain) */ body_chunk_len = min(wsi->http.rx_content_remain, len); wsi->http.rx_content_remain -= body_chunk_len; // len -= body_chunk_len; #ifdef LWS_WITH_CGI if (wsi->http.cgi) { struct lws_cgi_args args; args.ch = LWS_STDIN; args.stdwsi = &wsi->http.cgi->lsp->stdwsi[0]; args.data = buf; args.len = body_chunk_len; /* returns how much used */ n = user_callback_handle_rxflow( wsi->protocol->callback, wsi, LWS_CALLBACK_CGI_STDIN_DATA, wsi->user_space, (void *)&args, 0); if ((int)n < 0) goto bail; } else { #endif if (lwsi_state(wsi) != LRS_DISCARD_BODY) { n = wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP_BODY, wsi->user_space, buf, (size_t)body_chunk_len); if (n) goto bail; } n = (size_t)body_chunk_len; #ifdef LWS_WITH_CGI } #endif buf += n; if (wsi->http.rx_content_remain) { lws_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT, wsi->context->timeout_secs); break; } /* he sent all the content in time */ postbody_completion: #ifdef LWS_WITH_CGI /* * If we're running a cgi, we can't let him off the * hook just because he sent his POST data */ if (wsi->http.cgi) lws_set_timeout(wsi, PENDING_TIMEOUT_CGI, wsi->context->timeout_secs); else #endif lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0); #ifdef LWS_WITH_CGI if (!wsi->http.cgi) #endif { #if defined(LWS_WITH_SERVER) if (lwsi_state(wsi) == LRS_DISCARD_BODY) { /* * repeat the transaction completed * that got us into this state, having * consumed the pending body now */ if (lws_http_transaction_completed(wsi)) return -1; break; } #endif lwsl_info("HTTP_BODY_COMPLETION: %p (%s)\n", wsi, wsi->protocol->name); n = wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP_BODY_COMPLETION, wsi->user_space, NULL, 0); if (n) goto bail; if (wsi->mux_substream) lwsi_set_state(wsi, LRS_ESTABLISHED); } break; } break; case LRS_RETURNED_CLOSE: case LRS_AWAITING_CLOSE_ACK: case LRS_WAITING_TO_SEND_CLOSE: case LRS_SHUTDOWN: ws_mode: #if defined(LWS_WITH_CLIENT) && defined(LWS_ROLE_WS) // lwsl_notice("%s: ws_mode\n", __func__); if (lws_ws_handshake_client(wsi, &buf, (size_t)len)) goto bail; #endif #if defined(LWS_ROLE_WS) if (lwsi_role_ws(wsi) && lwsi_role_server(wsi) && /* * for h2 we are on the swsi */ lws_parse_ws(wsi, &buf, (size_t)len) < 0) { lwsl_info("%s: lws_parse_ws bailed\n", __func__); goto bail; } #endif // lwsl_notice("%s: ws_mode: buf moved on by %d\n", __func__, // lws_ptr_diff(buf, oldbuf)); break; case LRS_DEFERRING_ACTION: lwsl_notice("%s: LRS_DEFERRING_ACTION\n", __func__); break; case LRS_SSL_ACK_PENDING: break; case LRS_FLUSHING_BEFORE_CLOSE: break; case LRS_DEAD_SOCKET: lwsl_err("%s: Unhandled state LRS_DEAD_SOCKET\n", __func__); goto bail; // assert(0); /* fallthru */ default: lwsl_err("%s: Unhandled state %d\n", __func__, lwsi_state(wsi)); assert(0); goto bail; } read_ok: /* Nothing more to do for now */ // lwsl_info("%s: %p: read_ok, used %ld (len %d, state %d)\n", __func__, // wsi, (long)(buf - oldbuf), (int)len, wsi->state); return lws_ptr_diff(buf, oldbuf); bail: /* * h2 / h2-ws calls us recursively in * * lws_read_h1()-> * lws_h2_parser()-> * lws_read_h1() * * pattern, having stripped the h2 framing in the middle. * * When taking down the whole connection, make sure that only the * outer lws_read() does the wsi close. */ if (!wsi->outer_will_close) lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS, "lws_read_h1 bail"); return -1; } #if defined(LWS_WITH_SERVER) static int lws_h1_server_socket_service(struct lws *wsi, struct lws_pollfd *pollfd) { struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; struct lws_tokens ebuf; int n, buffered; if (lwsi_state(wsi) == LRS_DEFERRING_ACTION) goto try_pollout; /* any incoming data ready? */ if (!(pollfd->revents & pollfd->events & LWS_POLLIN)) goto try_pollout; /* * If we previously just did POLLIN when IN and OUT were signaled * (because POLLIN processing may have used up the POLLOUT), don't let * that happen twice in a row... next time we see the situation favour * POLLOUT */ if (wsi->favoured_pollin && (pollfd->revents & pollfd->events & LWS_POLLOUT)) { // lwsl_notice("favouring pollout\n"); wsi->favoured_pollin = 0; goto try_pollout; } /* * We haven't processed that the tunnel is set up yet, so * defer reading */ if (lwsi_state(wsi) == LRS_SSL_ACK_PENDING) return LWS_HPI_RET_HANDLED; /* these states imply we MUST have an ah attached */ if ((lwsi_state(wsi) == LRS_ESTABLISHED || lwsi_state(wsi) == LRS_ISSUING_FILE || lwsi_state(wsi) == LRS_HEADERS || lwsi_state(wsi) == LRS_DISCARD_BODY || lwsi_state(wsi) == LRS_BODY)) { if (!wsi->http.ah && lws_header_table_attach(wsi, 0)) { lwsl_info("%s: wsi %p: ah not available\n", __func__, wsi); goto try_pollout; } /* * We got here because there was specifically POLLIN... * regardless of our buflist state, we need to get it, * and either use it, or append to the buflist and use * buflist head material. * * We will not notice a connection close until the buflist is * exhausted and we tried to do a read of some kind. */ ebuf.token = NULL; ebuf.len = 0; buffered = lws_buflist_aware_read(pt, wsi, &ebuf, 0, __func__); switch (ebuf.len) { case 0: lwsl_info("%s: read 0 len a\n", __func__); wsi->seen_zero_length_recv = 1; if (lws_change_pollfd(wsi, LWS_POLLIN, 0)) goto fail; #if !defined(LWS_WITHOUT_EXTENSIONS) /* * autobahn requires us to win the race between close * and draining the extensions */ if (wsi->ws && (wsi->ws->rx_draining_ext || wsi->ws->tx_draining_ext)) goto try_pollout; #endif /* * normally, we respond to close with logically closing * our side immediately */ goto fail; case LWS_SSL_CAPABLE_ERROR: goto fail; case LWS_SSL_CAPABLE_MORE_SERVICE: goto try_pollout; } /* just ignore incoming if waiting for close */ if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE) { lwsl_notice("%s: just ignoring\n", __func__); goto try_pollout; } if (lwsi_state(wsi) == LRS_ISSUING_FILE) { // lwsl_notice("stashing: wsi %p: bd %d\n", wsi, buffered); if (lws_buflist_aware_finished_consuming(wsi, &ebuf, 0, buffered, __func__)) return LWS_HPI_RET_PLEASE_CLOSE_ME; goto try_pollout; } /* * Otherwise give it to whoever wants it according to the * connection state */ #if defined(LWS_ROLE_H2) if (lwsi_role_h2(wsi) && lwsi_state(wsi) != LRS_BODY) n = lws_read_h2(wsi, ebuf.token, ebuf.len); else #endif n = lws_read_h1(wsi, ebuf.token, ebuf.len); if (n < 0) /* we closed wsi */ return LWS_HPI_RET_WSI_ALREADY_DIED; // lwsl_notice("%s: consumed %d\n", __func__, n); if (lws_buflist_aware_finished_consuming(wsi, &ebuf, n, buffered, __func__)) return LWS_HPI_RET_PLEASE_CLOSE_ME; /* * during the parsing our role changed to something non-http, * so the ah has no further meaning */ if (wsi->http.ah && !lwsi_role_h1(wsi) && !lwsi_role_h2(wsi) && !lwsi_role_cgi(wsi)) lws_header_table_detach(wsi, 0); /* * He may have used up the writability above, if we will defer * POLLOUT processing in favour of POLLIN, note it */ if (pollfd->revents & LWS_POLLOUT) wsi->favoured_pollin = 1; return LWS_HPI_RET_HANDLED; } /* * He may have used up the writability above, if we will defer POLLOUT * processing in favour of POLLIN, note it */ if (pollfd->revents & LWS_POLLOUT) wsi->favoured_pollin = 1; try_pollout: /* this handles POLLOUT for http serving fragments */ if (!(pollfd->revents & LWS_POLLOUT)) return LWS_HPI_RET_HANDLED; /* one shot */ if (lws_change_pollfd(wsi, LWS_POLLOUT, 0)) { lwsl_notice("%s a\n", __func__); goto fail; } /* clear back-to-back write detection */ wsi->could_have_pending = 0; if (lwsi_state(wsi) == LRS_DEFERRING_ACTION) { lwsl_debug("%s: LRS_DEFERRING_ACTION now writable\n", __func__); lwsi_set_state(wsi, LRS_ESTABLISHED); if (lws_change_pollfd(wsi, LWS_POLLOUT, 0)) { lwsl_info("failed at set pollfd\n"); goto fail; } } if (!wsi->hdr_parsing_completed) return LWS_HPI_RET_HANDLED; if (lwsi_state(wsi) != LRS_ISSUING_FILE) { if (lws_has_buffered_out(wsi)) { //lwsl_notice("%s: completing partial\n", __func__); if (lws_issue_raw(wsi, NULL, 0) < 0) { lwsl_info("%s signalling to close\n", __func__); goto fail; } return LWS_HPI_RET_HANDLED; } lws_stats_bump(pt, LWSSTATS_C_WRITEABLE_CB, 1); #if defined(LWS_WITH_STATS) if (wsi->active_writable_req_us) { uint64_t ul = lws_now_usecs() - wsi->active_writable_req_us; lws_stats_bump(pt, LWSSTATS_US_WRITABLE_DELAY_AVG, ul); lws_stats_max(pt, LWSSTATS_US_WORST_WRITABLE_DELAY, ul); wsi->active_writable_req_us = 0; } #endif n = user_callback_handle_rxflow(wsi->protocol->callback, wsi, LWS_CALLBACK_HTTP_WRITEABLE, wsi->user_space, NULL, 0); if (n < 0) { lwsl_info("writeable_fail\n"); goto fail; } return LWS_HPI_RET_HANDLED; } #if defined(LWS_WITH_FILE_OPS) /* >0 == completion, <0 == error * * We'll get a LWS_CALLBACK_HTTP_FILE_COMPLETION callback when * it's done. That's the case even if we just completed the * send, so wait for that. */ n = lws_serve_http_file_fragment(wsi); if (n < 0) goto fail; #endif return LWS_HPI_RET_HANDLED; fail: lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS, "server socket svc fail"); return LWS_HPI_RET_WSI_ALREADY_DIED; } #endif static int rops_handle_POLLIN_h1(struct lws_context_per_thread *pt, struct lws *wsi, struct lws_pollfd *pollfd) { if (lwsi_state(wsi) == LRS_IDLING) { uint8_t buf[1]; int rlen; /* * h1 staggered spins here in IDLING if we don't close it. * It shows POLLIN but the tls connection returns ERROR if * you try to read it. */ // lwsl_notice("%s: %p: wsistate 0x%x %s, revents 0x%x\n", // __func__, wsi, wsi->wsistate, wsi->role_ops->name, // pollfd->revents); rlen = lws_ssl_capable_read(wsi, buf, sizeof(buf)); if (rlen == LWS_SSL_CAPABLE_ERROR) return LWS_HPI_RET_PLEASE_CLOSE_ME; } #ifdef LWS_WITH_CGI if (wsi->http.cgi && (pollfd->revents & LWS_POLLOUT)) { if (lws_handle_POLLOUT_event(wsi, pollfd)) return LWS_HPI_RET_PLEASE_CLOSE_ME; return LWS_HPI_RET_HANDLED; } #endif #if 0 /* * !!! lws_serve_http_file_fragment() seems to duplicate most of * lws_handle_POLLOUT_event() in its own loop... */ lwsl_debug("%s: %d %d\n", __func__, (pollfd->revents & LWS_POLLOUT), lwsi_state_can_handle_POLLOUT(wsi)); if ((pollfd->revents & LWS_POLLOUT) && lwsi_state_can_handle_POLLOUT(wsi) && lws_handle_POLLOUT_event(wsi, pollfd)) { if (lwsi_state(wsi) == LRS_RETURNED_CLOSE) lwsi_set_state(wsi, LRS_FLUSHING_BEFORE_CLOSE); /* the write failed... it's had it */ wsi->socket_is_permanently_unusable = 1; return LWS_HPI_RET_PLEASE_CLOSE_ME; } #endif /* Priority 2: pre- compression transform */ #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) if (wsi->http.comp_ctx.buflist_comp || wsi->http.comp_ctx.may_have_more) { enum lws_write_protocol wp = LWS_WRITE_HTTP; lwsl_info("%s: completing comp partial (buflist_comp %p, may %d)\n", __func__, wsi->http.comp_ctx.buflist_comp, wsi->http.comp_ctx.may_have_more ); if (wsi->role_ops->write_role_protocol(wsi, NULL, 0, &wp) < 0) { lwsl_info("%s signalling to close\n", __func__); return LWS_HPI_RET_PLEASE_CLOSE_ME; } lws_callback_on_writable(wsi); if (!wsi->http.comp_ctx.buflist_comp && !wsi->http.comp_ctx.may_have_more && wsi->http.deferred_transaction_completed) { wsi->http.deferred_transaction_completed = 0; if (lws_http_transaction_completed(wsi)) return LWS_HPI_RET_PLEASE_CLOSE_ME; } return LWS_HPI_RET_HANDLED; } #endif if (lws_is_flowcontrolled(wsi)) /* We cannot deal with any kind of new RX because we are * RX-flowcontrolled. */ return LWS_HPI_RET_HANDLED; #if defined(LWS_WITH_SERVER) if (!lwsi_role_client(wsi)) { int n; lwsl_debug("%s: %p: wsistate 0x%x\n", __func__, wsi, (int)wsi->wsistate); n = lws_h1_server_socket_service(wsi, pollfd); if (n != LWS_HPI_RET_HANDLED) return n; if (lwsi_state(wsi) != LRS_SSL_INIT) if (lws_server_socket_service_ssl(wsi, LWS_SOCK_INVALID)) return LWS_HPI_RET_PLEASE_CLOSE_ME; return LWS_HPI_RET_HANDLED; } #endif #if defined(LWS_WITH_CLIENT) if ((pollfd->revents & LWS_POLLIN) && wsi->hdr_parsing_completed && !wsi->told_user_closed) { /* * In SSL mode we get POLLIN notification about * encrypted data in. * * But that is not necessarily related to decrypted * data out becoming available; in may need to perform * other in or out before that happens. * * simply mark ourselves as having readable data * and turn off our POLLIN */ wsi->client_rx_avail = 1; if (lws_change_pollfd(wsi, LWS_POLLIN, 0)) return LWS_HPI_RET_PLEASE_CLOSE_ME; //lwsl_notice("calling back %s\n", wsi->protocol->name); /* let user code know, he'll usually ask for writeable * callback and drain / re-enable it there */ if (user_callback_handle_rxflow(wsi->protocol->callback, wsi, LWS_CALLBACK_RECEIVE_CLIENT_HTTP, wsi->user_space, NULL, 0)) { lwsl_info("RECEIVE_CLIENT_HTTP closed it\n"); return LWS_HPI_RET_PLEASE_CLOSE_ME; } return LWS_HPI_RET_HANDLED; } #endif // if (lwsi_state(wsi) == LRS_ESTABLISHED) // return LWS_HPI_RET_HANDLED; #if defined(LWS_WITH_CLIENT) if ((pollfd->revents & LWS_POLLOUT) && lws_handle_POLLOUT_event(wsi, pollfd)) { lwsl_debug("POLLOUT event closed it\n"); return LWS_HPI_RET_PLEASE_CLOSE_ME; } if (lws_client_socket_service(wsi, pollfd)) return LWS_HPI_RET_WSI_ALREADY_DIED; #endif return LWS_HPI_RET_HANDLED; } static int rops_handle_POLLOUT_h1(struct lws *wsi) { if (lwsi_state(wsi) == LRS_ISSUE_HTTP_BODY) { #if defined(LWS_WITH_HTTP_PROXY) if (wsi->http.proxy_clientside) { unsigned char *buf, prebuf[LWS_PRE + 1024]; size_t len = lws_buflist_next_segment_len( &wsi->parent->http.buflist_post_body, &buf); int n; if (len > sizeof(prebuf) - LWS_PRE) len = sizeof(prebuf) - LWS_PRE; if (len) { memcpy(prebuf + LWS_PRE, buf, len); lwsl_debug("%s: %p: proxying body %d %d %d %d %d\n", __func__, wsi, (int)len, (int)wsi->http.tx_content_length, (int)wsi->http.tx_content_remain, (int)wsi->http.rx_content_length, (int)wsi->http.rx_content_remain ); n = lws_write(wsi, prebuf + LWS_PRE, len, LWS_WRITE_HTTP); if (n < 0) { lwsl_err("%s: PROXY_BODY: write %d failed\n", __func__, (int)len); return LWS_HP_RET_BAIL_DIE; } lws_buflist_use_segment(&wsi->parent->http.buflist_post_body, len); } if (wsi->parent->http.buflist_post_body) lws_callback_on_writable(wsi); else { #if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2) /* prepare ourselves to do the parsing */ wsi->http.ah->parser_state = WSI_TOKEN_NAME_PART; wsi->http.ah->lextable_pos = 0; #if defined(LWS_WITH_CUSTOM_HEADERS) wsi->http.ah->unk_pos = 0; #endif #endif lwsi_set_state(wsi, LRS_WAITING_SERVER_REPLY); lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE, wsi->context->timeout_secs); } } #endif return LWS_HP_RET_USER_SERVICE; } if (lwsi_role_client(wsi)) return LWS_HP_RET_USER_SERVICE; return LWS_HP_RET_BAIL_OK; } static int rops_write_role_protocol_h1(struct lws *wsi, unsigned char *buf, size_t len, enum lws_write_protocol *wp) { size_t olen = len; int n; #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) if (wsi->http.lcs && (((*wp) & 0x1f) == LWS_WRITE_HTTP_FINAL || ((*wp) & 0x1f) == LWS_WRITE_HTTP)) { unsigned char mtubuf[1500 + LWS_PRE + LWS_HTTP_CHUNK_HDR_MAX_SIZE + LWS_HTTP_CHUNK_TRL_MAX_SIZE], *out = mtubuf + LWS_PRE + LWS_HTTP_CHUNK_HDR_MAX_SIZE; size_t o = sizeof(mtubuf) - LWS_PRE - LWS_HTTP_CHUNK_HDR_MAX_SIZE - LWS_HTTP_CHUNK_TRL_MAX_SIZE; n = lws_http_compression_transform(wsi, buf, len, wp, &out, &o); if (n) return n; lwsl_info("%s: %p: transformed %d bytes to %d " "(wp 0x%x, more %d)\n", __func__, wsi, (int)len, (int)o, (int)*wp, wsi->http.comp_ctx.may_have_more); if (!o) return olen; if (wsi->http.comp_ctx.chunking) { char c[LWS_HTTP_CHUNK_HDR_MAX_SIZE + 2]; /* * this only needs dealing with on http/1.1 to allow * pipelining */ n = lws_snprintf(c, sizeof(c), "%X\x0d\x0a", (int)o); lwsl_info("%s: chunk (%d) %s", __func__, (int)o, c); out -= n; o += n; memcpy(out, c, n); out[o++] = '\x0d'; out[o++] = '\x0a'; if (((*wp) & 0x1f) == LWS_WRITE_HTTP_FINAL) { lwsl_info("%s: final chunk\n", __func__); out[o++] = '0'; out[o++] = '\x0d'; out[o++] = '\x0a'; out[o++] = '\x0d'; out[o++] = '\x0a'; } } buf = out; len = o; } #endif n = lws_issue_raw(wsi, (unsigned char *)buf, len); if (n < 0) return n; /* hide there may have been compression */ return (int)olen; } static int rops_alpn_negotiated_h1(struct lws *wsi, const char *alpn) { lwsl_debug("%s: client %d\n", __func__, lwsi_role_client(wsi)); #if defined(LWS_WITH_CLIENT) if (lwsi_role_client(wsi)) { /* * If alpn asserts it is http/1.1, server support for KA is * mandatory. * * Knowing this lets us proceed with sending pipelined headers * before we received the first response headers. */ wsi->keepalive_active = 1; } #endif return 0; } static int rops_destroy_role_h1(struct lws *wsi) { struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi]; struct allocated_headers *ah; /* we may not have an ah, but may be on the waiting list... */ lwsl_info("%s: ah det due to close\n", __func__); __lws_header_table_detach(wsi, 0); ah = pt->http.ah_list; while (ah) { if (ah->in_use && ah->wsi == wsi) { lwsl_err("%s: ah leak: wsi %p\n", __func__, wsi); ah->in_use = 0; ah->wsi = NULL; pt->http.ah_count_in_use--; break; } ah = ah->next; } #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) lws_http_compression_destroy(wsi); #endif #ifdef LWS_ROLE_WS lws_free_set_NULL(wsi->ws); #endif return 0; } #if defined(LWS_WITH_SERVER) static int rops_adoption_bind_h1(struct lws *wsi, int type, const char *vh_prot_name) { if (!(type & LWS_ADOPT_HTTP)) return 0; /* no match */ if (type & _LWS_ADOPT_FINISH && !lwsi_role_http(wsi)) return 0; if (type & _LWS_ADOPT_FINISH) { if (!lws_header_table_attach(wsi, 0)) lwsl_debug("Attached ah immediately\n"); else lwsl_info("%s: waiting for ah\n", __func__); return 1; } lws_role_transition(wsi, LWSIFR_SERVER, (type & LWS_ADOPT_ALLOW_SSL) ? LRS_SSL_INIT : LRS_HEADERS, &role_ops_h1); /* * We have to bind to h1 as a default even when we're actually going to * replace it as an h2 bind later. So don't take this seriously if the * default is disabled (ws upgrade caees properly about it) */ if (!vh_prot_name && wsi->vhost->default_protocol_index < wsi->vhost->count_protocols) wsi->protocol = &wsi->vhost->protocols[ wsi->vhost->default_protocol_index]; else wsi->protocol = &wsi->vhost->protocols[0]; /* the transport is accepted... give him time to negotiate */ lws_set_timeout(wsi, PENDING_TIMEOUT_ESTABLISH_WITH_SERVER, wsi->context->timeout_secs); return 1; /* bound */ } #endif #if defined(LWS_WITH_CLIENT) static const char * const http_methods[] = { "GET", "POST", "OPTIONS", "HEAD", "PUT", "PATCH", "DELETE", "CONNECT" }; static int rops_client_bind_h1(struct lws *wsi, const struct lws_client_connect_info *i) { int n; if (!i) { /* we are finalizing an already-selected role */ /* * If we stay in http, assuming there wasn't already-set * external user_space, since we know our initial protocol * we can assign the user space now, otherwise do it after the * ws subprotocol negotiated */ if (!wsi->user_space && wsi->stash->cis[CIS_METHOD]) if (lws_ensure_user_space(wsi)) return 1; /* * For ws, default to http/1.1 only. If i->alpn had been set * though, defer to whatever he has set in there (eg, "h2"). * * The problem is he has to commit to h2 before he can find * out if the server has the SETTINGS for ws-over-h2 enabled; * if not then ws is not possible on that connection. So we * only try h2 if he assertively said to use h2 alpn, otherwise * ws implies alpn restriction to h1. */ if (!wsi->stash->cis[CIS_METHOD] && !wsi->stash->cis[CIS_ALPN]) wsi->stash->cis[CIS_ALPN] = "http/1.1"; /* if we went on the ah waiting list, it's ok, we can wait. * * When we do get the ah, now or later, he will end up at * lws_http_client_connect_via_info2(). */ if (lws_header_table_attach(wsi, 0) #if defined(LWS_WITH_CLIENT) < 0) /* * if we failed here, the connection is already closed * and freed. */ return -1; #else ) return 0; #endif return 0; } /* * Clients that want to be h1, h2, or ws all start out as h1 * (we don't yet know if the server supports h2 or ws), unless their * alpn is only "h2" */ // if (i->alpn && !strcmp(i->alpn, "h2")) // return 0; /* we are h1, he only wants h2 */ if (!i->method) { /* websockets */ #if defined(LWS_ROLE_WS) if (lws_create_client_ws_object(i, wsi)) goto fail_wsi; #else lwsl_err("%s: ws role not configured\n", __func__); goto fail_wsi; #endif goto bind_h1; } /* if a recognized http method, bind to it */ for (n = 0; n < (int)LWS_ARRAY_SIZE(http_methods); n++) if (!strcmp(i->method, http_methods[n])) goto bind_h1; /* other roles may bind to it */ return 0; /* no match */ bind_h1: /* assert the mode and union status (hdr) clearly */ lws_role_transition(wsi, LWSIFR_CLIENT, LRS_UNCONNECTED, &role_ops_h1); return 1; /* matched */ fail_wsi: return -1; } #endif #if 0 static int rops_perform_user_POLLOUT_h1(struct lws *wsi) { volatile struct lws *vwsi = (volatile struct lws *)wsi; int n; /* priority 1: post compression-transform buffered output */ if (lws_has_buffered_out(wsi)) { lwsl_debug("%s: completing partial\n", __func__); if (lws_issue_raw(wsi, NULL, 0) < 0) { lwsl_info("%s signalling to close\n", __func__); return -1; } n = 0; vwsi->leave_pollout_active = 1; goto cleanup; } /* priority 2: pre compression-transform buffered output */ #if defined(LWS_WITH_HTTP_STREAM_COMPRESSION) if (wsi->http.comp_ctx.buflist_comp || wsi->http.comp_ctx.may_have_more) { enum lws_write_protocol wp = LWS_WRITE_HTTP; lwsl_info("%s: completing comp partial" "(buflist_comp %p, may %d)\n", __func__, wsi->http.comp_ctx.buflist_comp, wsi->http.comp_ctx.may_have_more); if (rops_write_role_protocol_h1(wsi, NULL, 0, &wp) < 0) { lwsl_info("%s signalling to close\n", __func__); lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS, "comp write fail"); } n = 0; vwsi->leave_pollout_active = 1; goto cleanup; } #endif /* priority 3: if no buffered out and waiting for that... */ if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE) { wsi->socket_is_permanently_unusable = 1; return -1; } /* priority 4: user writeable callback */ vwsi = (volatile struct lws *)wsi; vwsi->leave_pollout_active = 0; n = lws_callback_as_writeable(wsi); cleanup: vwsi->handling_pollout = 0; if (vwsi->leave_pollout_active) lws_change_pollfd(wsi, 0, LWS_POLLOUT); return n; } #endif static int rops_close_kill_connection_h1(struct lws *wsi, enum lws_close_status reason) { #if defined(LWS_WITH_HTTP_PROXY) if (!wsi->http.proxy_clientside) return 0; wsi->http.proxy_clientside = 0; if (user_callback_handle_rxflow(wsi->protocol->callback, wsi, LWS_CALLBACK_COMPLETED_CLIENT_HTTP, wsi->user_space, NULL, 0)) return 0; #endif return 0; } int rops_pt_init_destroy_h1(struct lws_context *context, const struct lws_context_creation_info *info, struct lws_context_per_thread *pt, int destroy) { /* * We only want to do this once... we will do it if no h2 support * otherwise let h2 ops do it. */ #if !defined(LWS_ROLE_H2) && defined(LWS_WITH_SERVER) if (!destroy) { pt->sul_ah_lifecheck.cb = lws_sul_http_ah_lifecheck; __lws_sul_insert(&pt->pt_sul_owner, &pt->sul_ah_lifecheck, 30 * LWS_US_PER_SEC); } else lws_dll2_remove(&pt->sul_ah_lifecheck.list); #endif return 0; } const struct lws_role_ops role_ops_h1 = { /* role name */ "h1", /* alpn id */ "http/1.1", /* check_upgrades */ NULL, /* pt_init_destroy */ rops_pt_init_destroy_h1, /* init_vhost */ NULL, /* destroy_vhost */ NULL, /* service_flag_pending */ NULL, /* handle_POLLIN */ rops_handle_POLLIN_h1, /* handle_POLLOUT */ rops_handle_POLLOUT_h1, /* perform_user_POLLOUT */ NULL, /* callback_on_writable */ NULL, /* tx_credit */ NULL, /* write_role_protocol */ rops_write_role_protocol_h1, /* encapsulation_parent */ NULL, /* alpn_negotiated */ rops_alpn_negotiated_h1, /* close_via_role_protocol */ NULL, /* close_role */ NULL, /* close_kill_connection */ rops_close_kill_connection_h1, /* destroy_role */ rops_destroy_role_h1, #if defined(LWS_WITH_SERVER) /* adoption_bind */ rops_adoption_bind_h1, #else NULL, #endif #if defined(LWS_WITH_CLIENT) /* client_bind */ rops_client_bind_h1, #else NULL, #endif /* issue_keepalive */ NULL, /* adoption_cb clnt, srv */ { LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED, LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED }, /* rx_cb clnt, srv */ { LWS_CALLBACK_RECEIVE_CLIENT_HTTP, 0 /* may be POST, etc */ }, /* writeable cb clnt, srv */ { LWS_CALLBACK_CLIENT_HTTP_WRITEABLE, LWS_CALLBACK_HTTP_WRITEABLE }, /* close cb clnt, srv */ { LWS_CALLBACK_CLOSED_CLIENT_HTTP, LWS_CALLBACK_CLOSED_HTTP }, /* protocol_bind cb c, srv */ { LWS_CALLBACK_CLIENT_HTTP_BIND_PROTOCOL, LWS_CALLBACK_HTTP_BIND_PROTOCOL }, /* protocol_unbind cb c, srv */ { LWS_CALLBACK_CLIENT_HTTP_DROP_PROTOCOL, LWS_CALLBACK_HTTP_DROP_PROTOCOL }, /* file_handle */ 0, };