/**************************************************************************/ /* wsl_peer.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /**************************************************************************/ /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ /* */ /* 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 "wsl_peer.h" #ifndef WEB_ENABLED #include "core/io/stream_peer_tls.h" CryptoCore::RandomGenerator *WSLPeer::_static_rng = nullptr; void WSLPeer::initialize() { WebSocketPeer::_create = WSLPeer::_create; _static_rng = memnew(CryptoCore::RandomGenerator); _static_rng->init(); } void WSLPeer::deinitialize() { if (_static_rng) { memdelete(_static_rng); _static_rng = nullptr; } } /// /// Resolver /// void WSLPeer::Resolver::start(const String &p_host, int p_port) { stop(); port = p_port; if (p_host.is_valid_ip_address()) { ip_candidates.push_back(IPAddress(p_host)); } else { // Queue hostname for resolution. resolver_id = IP::get_singleton()->resolve_hostname_queue_item(p_host); ERR_FAIL_COND(resolver_id == IP::RESOLVER_INVALID_ID); // Check if it was found in cache. IP::ResolverStatus ip_status = IP::get_singleton()->get_resolve_item_status(resolver_id); if (ip_status == IP::RESOLVER_STATUS_DONE) { ip_candidates = IP::get_singleton()->get_resolve_item_addresses(resolver_id); IP::get_singleton()->erase_resolve_item(resolver_id); resolver_id = IP::RESOLVER_INVALID_ID; } } } void WSLPeer::Resolver::stop() { if (resolver_id != IP::RESOLVER_INVALID_ID) { IP::get_singleton()->erase_resolve_item(resolver_id); resolver_id = IP::RESOLVER_INVALID_ID; } port = 0; } void WSLPeer::Resolver::try_next_candidate(Ref<StreamPeerTCP> &p_tcp) { // Check if we still need resolving. if (resolver_id != IP::RESOLVER_INVALID_ID) { IP::ResolverStatus ip_status = IP::get_singleton()->get_resolve_item_status(resolver_id); if (ip_status == IP::RESOLVER_STATUS_WAITING) { return; } if (ip_status == IP::RESOLVER_STATUS_DONE) { ip_candidates = IP::get_singleton()->get_resolve_item_addresses(resolver_id); } IP::get_singleton()->erase_resolve_item(resolver_id); resolver_id = IP::RESOLVER_INVALID_ID; } // Try the current candidate if we have one. if (p_tcp->get_status() != StreamPeerTCP::STATUS_NONE) { p_tcp->poll(); StreamPeerTCP::Status status = p_tcp->get_status(); if (status == StreamPeerTCP::STATUS_CONNECTED) { p_tcp->set_no_delay(true); ip_candidates.clear(); return; } else if (status == StreamPeerTCP::STATUS_CONNECTING) { return; // Keep connecting. } else { p_tcp->disconnect_from_host(); } } // Keep trying next candidate. while (ip_candidates.size()) { Error err = p_tcp->connect_to_host(ip_candidates.pop_front(), port); if (err == OK) { return; } else { p_tcp->disconnect_from_host(); } } } /// /// Server functions /// Error WSLPeer::accept_stream(Ref<StreamPeer> p_stream) { ERR_FAIL_COND_V(wsl_ctx || tcp.is_valid(), ERR_ALREADY_IN_USE); ERR_FAIL_COND_V(p_stream.is_null(), ERR_INVALID_PARAMETER); _clear(); if (p_stream->is_class_ptr(StreamPeerTCP::get_class_ptr_static())) { tcp = p_stream; connection = p_stream; use_tls = false; } else if (p_stream->is_class_ptr(StreamPeerTLS::get_class_ptr_static())) { Ref<StreamPeer> base_stream = static_cast<Ref<StreamPeerTLS>>(p_stream)->get_stream(); ERR_FAIL_COND_V(base_stream.is_null() || !base_stream->is_class_ptr(StreamPeerTCP::get_class_ptr_static()), ERR_INVALID_PARAMETER); tcp = static_cast<Ref<StreamPeerTCP>>(base_stream); connection = p_stream; use_tls = true; } ERR_FAIL_COND_V(connection.is_null() || tcp.is_null(), ERR_INVALID_PARAMETER); is_server = true; ready_state = STATE_CONNECTING; handshake_buffer->resize(WSL_MAX_HEADER_SIZE); handshake_buffer->seek(0); return OK; } bool WSLPeer::_parse_client_request() { Vector<String> psa = String((const char *)handshake_buffer->get_data_array().ptr(), handshake_buffer->get_position() - 4).split("\r\n"); int len = psa.size(); ERR_FAIL_COND_V_MSG(len < 4, false, "Not enough response headers, got: " + itos(len) + ", expected >= 4."); Vector<String> req = psa[0].split(" ", false); ERR_FAIL_COND_V_MSG(req.size() < 2, false, "Invalid protocol or status code."); // Wrong protocol ERR_FAIL_COND_V_MSG(req[0] != "GET" || req[2] != "HTTP/1.1", false, "Invalid method or HTTP version."); HashMap<String, String> headers; for (int i = 1; i < len; i++) { Vector<String> header = psa[i].split(":", false, 1); ERR_FAIL_COND_V_MSG(header.size() != 2, false, "Invalid header -> " + psa[i]); String name = header[0].to_lower(); String value = header[1].strip_edges(); if (headers.has(name)) { headers[name] += "," + value; } else { headers[name] = value; } } requested_host = headers.has("host") ? headers.get("host") : ""; requested_url = (use_tls ? "wss://" : "ws://") + requested_host + req[1]; #define WSL_CHECK(NAME, VALUE) \ ERR_FAIL_COND_V_MSG(!headers.has(NAME) || headers[NAME].to_lower() != VALUE, false, \ "Missing or invalid header '" + String(NAME) + "'. Expected value '" + VALUE + "'."); #define WSL_CHECK_EX(NAME) \ ERR_FAIL_COND_V_MSG(!headers.has(NAME), false, "Missing header '" + String(NAME) + "'."); WSL_CHECK("upgrade", "websocket"); WSL_CHECK("sec-websocket-version", "13"); WSL_CHECK_EX("sec-websocket-key"); WSL_CHECK_EX("connection"); #undef WSL_CHECK_EX #undef WSL_CHECK session_key = headers["sec-websocket-key"]; if (headers.has("sec-websocket-protocol")) { Vector<String> protos = headers["sec-websocket-protocol"].split(","); for (int i = 0; i < protos.size(); i++) { String proto = protos[i].strip_edges(); // Check if we have the given protocol for (int j = 0; j < supported_protocols.size(); j++) { if (proto != supported_protocols[j]) { continue; } selected_protocol = proto; break; } // Found a protocol if (!selected_protocol.is_empty()) { break; } } if (selected_protocol.is_empty()) { // Invalid protocol(s) requested return false; } } else if (supported_protocols.size() > 0) { // No protocol requested, but we need one return false; } return true; } Error WSLPeer::_do_server_handshake() { if (use_tls) { Ref<StreamPeerTLS> tls = static_cast<Ref<StreamPeerTLS>>(connection); if (tls.is_null()) { ERR_FAIL_V_MSG(ERR_BUG, "Couldn't get StreamPeerTLS for WebSocket handshake."); close(-1); return FAILED; } tls->poll(); if (tls->get_status() == StreamPeerTLS::STATUS_HANDSHAKING) { return OK; // Pending handshake } else if (tls->get_status() != StreamPeerTLS::STATUS_CONNECTED) { print_verbose(vformat("WebSocket SSL connection error during handshake (StreamPeerTLS status code %d).", tls->get_status())); close(-1); return FAILED; } } if (pending_request) { int read = 0; while (true) { ERR_FAIL_COND_V_MSG(handshake_buffer->get_available_bytes() < 1, ERR_OUT_OF_MEMORY, "WebSocket response headers are too big."); int pos = handshake_buffer->get_position(); uint8_t byte; Error err = connection->get_partial_data(&byte, 1, read); if (err != OK) { // Got an error print_verbose(vformat("WebSocket error while getting partial data (StreamPeer error code %d).", err)); close(-1); return FAILED; } else if (read != 1) { // Busy, wait next poll return OK; } handshake_buffer->put_u8(byte); const char *r = (const char *)handshake_buffer->get_data_array().ptr(); int l = pos; if (l > 3 && r[l] == '\n' && r[l - 1] == '\r' && r[l - 2] == '\n' && r[l - 3] == '\r') { if (!_parse_client_request()) { close(-1); return FAILED; } String s = "HTTP/1.1 101 Switching Protocols\r\n"; s += "Upgrade: websocket\r\n"; s += "Connection: Upgrade\r\n"; s += "Sec-WebSocket-Accept: " + _compute_key_response(session_key) + "\r\n"; if (!selected_protocol.is_empty()) { s += "Sec-WebSocket-Protocol: " + selected_protocol + "\r\n"; } for (int i = 0; i < handshake_headers.size(); i++) { s += handshake_headers[i] + "\r\n"; } s += "\r\n"; CharString cs = s.utf8(); handshake_buffer->clear(); handshake_buffer->put_data((const uint8_t *)cs.get_data(), cs.length()); handshake_buffer->seek(0); pending_request = false; break; } } } if (pending_request) { // Still pending. return OK; } int left = handshake_buffer->get_available_bytes(); if (left) { Vector<uint8_t> data = handshake_buffer->get_data_array(); int pos = handshake_buffer->get_position(); int sent = 0; Error err = connection->put_partial_data(data.ptr() + pos, left, sent); if (err != OK) { print_verbose(vformat("WebSocket error while putting partial data (StreamPeer error code %d).", err)); close(-1); return err; } handshake_buffer->seek(pos + sent); left -= sent; if (left == 0) { resolver.stop(); // Response sent, initialize wslay context. wslay_event_context_server_init(&wsl_ctx, &_wsl_callbacks, this); wslay_event_config_set_max_recv_msg_length(wsl_ctx, inbound_buffer_size); in_buffer.resize(nearest_shift(inbound_buffer_size), max_queued_packets); packet_buffer.resize(inbound_buffer_size); ready_state = STATE_OPEN; } } return OK; } /// /// Client functions /// void WSLPeer::_do_client_handshake() { ERR_FAIL_COND(tcp.is_null()); // Try to connect to candidates. if (resolver.has_more_candidates()) { resolver.try_next_candidate(tcp); if (resolver.has_more_candidates()) { return; // Still pending. } } tcp->poll(); if (tcp->get_status() == StreamPeerTCP::STATUS_CONNECTING) { return; // Keep connecting. } else if (tcp->get_status() != StreamPeerTCP::STATUS_CONNECTED) { close(-1); // Failed to connect. return; } if (use_tls) { Ref<StreamPeerTLS> tls; if (connection == tcp) { // Start SSL handshake tls = Ref<StreamPeerTLS>(StreamPeerTLS::create()); ERR_FAIL_COND(tls.is_null()); if (tls->connect_to_stream(tcp, requested_host, tls_options) != OK) { close(-1); return; // Error. } connection = tls; } else { tls = static_cast<Ref<StreamPeerTLS>>(connection); ERR_FAIL_COND(tls.is_null()); tls->poll(); } if (tls->get_status() == StreamPeerTLS::STATUS_HANDSHAKING) { return; // Need more polling. } else if (tls->get_status() != StreamPeerTLS::STATUS_CONNECTED) { close(-1); return; // Error. } } // Do websocket handshake. if (pending_request) { int left = handshake_buffer->get_available_bytes(); int pos = handshake_buffer->get_position(); const Vector<uint8_t> data = handshake_buffer->get_data_array(); int sent = 0; Error err = connection->put_partial_data(data.ptr() + pos, left, sent); // Sending handshake failed if (err != OK) { close(-1); return; // Error. } handshake_buffer->seek(pos + sent); if (handshake_buffer->get_available_bytes() == 0) { pending_request = false; handshake_buffer->clear(); handshake_buffer->resize(WSL_MAX_HEADER_SIZE); handshake_buffer->seek(0); } } else { int read = 0; while (true) { int left = handshake_buffer->get_available_bytes(); int pos = handshake_buffer->get_position(); if (left == 0) { // Header is too big close(-1); ERR_FAIL_MSG("Response headers too big."); } uint8_t byte; Error err = connection->get_partial_data(&byte, 1, read); if (err != OK) { // Got some error. close(-1); return; } else if (read != 1) { // Busy, wait next poll. break; } handshake_buffer->put_u8(byte); // Check "\r\n\r\n" header terminator const char *r = (const char *)handshake_buffer->get_data_array().ptr(); int l = pos; if (l > 3 && r[l] == '\n' && r[l - 1] == '\r' && r[l - 2] == '\n' && r[l - 3] == '\r') { // Response is over, verify headers and initialize wslay context/ if (!_verify_server_response()) { close(-1); ERR_FAIL_MSG("Invalid response headers."); } wslay_event_context_client_init(&wsl_ctx, &_wsl_callbacks, this); wslay_event_config_set_max_recv_msg_length(wsl_ctx, inbound_buffer_size); in_buffer.resize(nearest_shift(inbound_buffer_size), max_queued_packets); packet_buffer.resize(inbound_buffer_size); ready_state = STATE_OPEN; break; } } } } bool WSLPeer::_verify_server_response() { Vector<String> psa = String((const char *)handshake_buffer->get_data_array().ptr(), handshake_buffer->get_position() - 4).split("\r\n"); int len = psa.size(); ERR_FAIL_COND_V_MSG(len < 4, false, "Not enough response headers. Got: " + itos(len) + ", expected >= 4."); Vector<String> req = psa[0].split(" ", false); ERR_FAIL_COND_V_MSG(req.size() < 2, false, "Invalid protocol or status code. Got '" + psa[0] + "', expected 'HTTP/1.1 101'."); // Wrong protocol ERR_FAIL_COND_V_MSG(req[0] != "HTTP/1.1", false, "Invalid protocol. Got: '" + req[0] + "', expected 'HTTP/1.1'."); ERR_FAIL_COND_V_MSG(req[1] != "101", false, "Invalid status code. Got: '" + req[1] + "', expected '101'."); HashMap<String, String> headers; for (int i = 1; i < len; i++) { Vector<String> header = psa[i].split(":", false, 1); ERR_FAIL_COND_V_MSG(header.size() != 2, false, "Invalid header -> " + psa[i] + "."); String name = header[0].to_lower(); String value = header[1].strip_edges(); if (headers.has(name)) { headers[name] += "," + value; } else { headers[name] = value; } } #define WSL_CHECK(NAME, VALUE) \ ERR_FAIL_COND_V_MSG(!headers.has(NAME) || headers[NAME].to_lower() != VALUE, false, \ "Missing or invalid header '" + String(NAME) + "'. Expected value '" + VALUE + "'."); #define WSL_CHECK_NC(NAME, VALUE) \ ERR_FAIL_COND_V_MSG(!headers.has(NAME) || headers[NAME] != VALUE, false, \ "Missing or invalid header '" + String(NAME) + "'. Expected value '" + VALUE + "'."); WSL_CHECK("connection", "upgrade"); WSL_CHECK("upgrade", "websocket"); WSL_CHECK_NC("sec-websocket-accept", _compute_key_response(session_key)); #undef WSL_CHECK_NC #undef WSL_CHECK if (supported_protocols.size() == 0) { // We didn't request a custom protocol ERR_FAIL_COND_V_MSG(headers.has("sec-websocket-protocol"), false, "Received unrequested sub-protocol -> " + headers["sec-websocket-protocol"]); } else { // We requested at least one custom protocol but didn't receive one ERR_FAIL_COND_V_MSG(!headers.has("sec-websocket-protocol"), false, "Requested sub-protocol(s) but received none."); // Check received sub-protocol was one of those requested. selected_protocol = headers["sec-websocket-protocol"]; bool valid = false; for (int i = 0; i < supported_protocols.size(); i++) { if (supported_protocols[i] != selected_protocol) { continue; } valid = true; break; } if (!valid) { ERR_FAIL_V_MSG(false, "Received unrequested sub-protocol -> " + selected_protocol); } } return true; } Error WSLPeer::connect_to_url(const String &p_url, Ref<TLSOptions> p_options) { ERR_FAIL_COND_V(wsl_ctx || tcp.is_valid(), ERR_ALREADY_IN_USE); ERR_FAIL_COND_V(p_url.is_empty(), ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(p_options.is_valid() && p_options->is_server(), ERR_INVALID_PARAMETER); _clear(); String host; String path; String scheme; int port = 0; Error err = p_url.parse_url(scheme, host, port, path); ERR_FAIL_COND_V_MSG(err != OK, err, "Invalid URL: " + p_url); if (scheme.is_empty()) { scheme = "ws://"; } ERR_FAIL_COND_V_MSG(scheme != "ws://" && scheme != "wss://", ERR_INVALID_PARAMETER, vformat("Invalid protocol: \"%s\" (must be either \"ws://\" or \"wss://\").", scheme)); use_tls = false; if (scheme == "wss://") { use_tls = true; } if (port == 0) { port = use_tls ? 443 : 80; } if (path.is_empty()) { path = "/"; } ERR_FAIL_COND_V_MSG(use_tls && !StreamPeerTLS::is_available(), ERR_UNAVAILABLE, "WSS is not available in this build."); requested_url = p_url; requested_host = host; if (p_options.is_valid()) { tls_options = p_options; } else { tls_options = TLSOptions::client(); } tcp.instantiate(); resolver.start(host, port); resolver.try_next_candidate(tcp); if (tcp->get_status() != StreamPeerTCP::STATUS_CONNECTING && tcp->get_status() != StreamPeerTCP::STATUS_CONNECTED && !resolver.has_more_candidates()) { _clear(); return FAILED; } connection = tcp; // Prepare handshake request. session_key = _generate_key(); String request = "GET " + path + " HTTP/1.1\r\n"; String port_string; if ((port != 80 && !use_tls) || (port != 443 && use_tls)) { port_string = ":" + itos(port); } request += "Host: " + host + port_string + "\r\n"; request += "Upgrade: websocket\r\n"; request += "Connection: Upgrade\r\n"; request += "Sec-WebSocket-Key: " + session_key + "\r\n"; request += "Sec-WebSocket-Version: 13\r\n"; if (supported_protocols.size() > 0) { request += "Sec-WebSocket-Protocol: "; for (int i = 0; i < supported_protocols.size(); i++) { if (i != 0) { request += ","; } request += supported_protocols[i]; } request += "\r\n"; } for (int i = 0; i < handshake_headers.size(); i++) { request += handshake_headers[i] + "\r\n"; } request += "\r\n"; CharString cs = request.utf8(); handshake_buffer->put_data((const uint8_t *)cs.get_data(), cs.length()); handshake_buffer->seek(0); ready_state = STATE_CONNECTING; is_server = false; return OK; } /// /// Callback functions. /// ssize_t WSLPeer::_wsl_recv_callback(wslay_event_context_ptr ctx, uint8_t *data, size_t len, int flags, void *user_data) { WSLPeer *peer = (WSLPeer *)user_data; Ref<StreamPeer> conn = peer->connection; if (conn.is_null()) { wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE); return -1; } int read = 0; Error err = conn->get_partial_data(data, len, read); if (err != OK) { print_verbose("Websocket get data error: " + itos(err) + ", read (should be 0!): " + itos(read)); wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE); return -1; } if (read == 0) { wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK); return -1; } return read; } ssize_t WSLPeer::_wsl_send_callback(wslay_event_context_ptr ctx, const uint8_t *data, size_t len, int flags, void *user_data) { WSLPeer *peer = (WSLPeer *)user_data; Ref<StreamPeer> conn = peer->connection; if (conn.is_null()) { wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE); return -1; } int sent = 0; Error err = conn->put_partial_data(data, len, sent); if (err != OK) { wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE); return -1; } if (sent == 0) { wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK); return -1; } return sent; } int WSLPeer::_wsl_genmask_callback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, void *user_data) { ERR_FAIL_COND_V(!_static_rng, WSLAY_ERR_CALLBACK_FAILURE); Error err = _static_rng->get_random_bytes(buf, len); ERR_FAIL_COND_V(err != OK, WSLAY_ERR_CALLBACK_FAILURE); return 0; } void WSLPeer::_wsl_msg_recv_callback(wslay_event_context_ptr ctx, const struct wslay_event_on_msg_recv_arg *arg, void *user_data) { WSLPeer *peer = (WSLPeer *)user_data; uint8_t op = arg->opcode; if (op == WSLAY_CONNECTION_CLOSE) { // Close request or confirmation. peer->close_code = arg->status_code; size_t len = arg->msg_length; peer->close_reason = ""; if (len > 2 /* first 2 bytes = close code */) { peer->close_reason.parse_utf8((char *)arg->msg + 2, len - 2); } if (peer->ready_state == STATE_OPEN) { peer->ready_state = STATE_CLOSING; } return; } if (peer->ready_state == STATE_CLOSING) { return; } if (op == WSLAY_TEXT_FRAME || op == WSLAY_BINARY_FRAME) { // Message. uint8_t is_string = arg->opcode == WSLAY_TEXT_FRAME ? 1 : 0; peer->in_buffer.write_packet(arg->msg, arg->msg_length, &is_string); } // Ping or pong. } wslay_event_callbacks WSLPeer::_wsl_callbacks = { _wsl_recv_callback, _wsl_send_callback, _wsl_genmask_callback, nullptr, /* on_frame_recv_start_callback */ nullptr, /* on_frame_recv_callback */ nullptr, /* on_frame_recv_end_callback */ _wsl_msg_recv_callback }; String WSLPeer::_generate_key() { // Random key Vector<uint8_t> bkey; int len = 16; // 16 bytes, as per RFC bkey.resize(len); _wsl_genmask_callback(nullptr, bkey.ptrw(), len, nullptr); return CryptoCore::b64_encode_str(bkey.ptrw(), len); } String WSLPeer::_compute_key_response(String p_key) { String key = p_key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; // Magic UUID as per RFC Vector<uint8_t> sha = key.sha1_buffer(); return CryptoCore::b64_encode_str(sha.ptr(), sha.size()); } void WSLPeer::poll() { // Nothing to do. if (ready_state == STATE_CLOSED) { return; } if (ready_state == STATE_CONNECTING) { if (is_server) { _do_server_handshake(); } else { _do_client_handshake(); } } if (ready_state == STATE_OPEN || ready_state == STATE_CLOSING) { ERR_FAIL_COND(!wsl_ctx); int err = 0; if ((err = wslay_event_recv(wsl_ctx)) != 0 || (err = wslay_event_send(wsl_ctx)) != 0) { // Error close. print_verbose("Websocket (wslay) poll error: " + itos(err)); wslay_event_context_free(wsl_ctx); wsl_ctx = nullptr; close(-1); return; } if (wslay_event_get_close_sent(wsl_ctx) && wslay_event_get_close_received(wsl_ctx)) { // Clean close. wslay_event_context_free(wsl_ctx); wsl_ctx = nullptr; close(-1); return; } } } Error WSLPeer::_send(const uint8_t *p_buffer, int p_buffer_size, wslay_opcode p_opcode) { ERR_FAIL_COND_V(ready_state != STATE_OPEN, FAILED); ERR_FAIL_COND_V(wslay_event_get_queued_msg_count(wsl_ctx) >= (uint32_t)max_queued_packets, ERR_OUT_OF_MEMORY); ERR_FAIL_COND_V(outbound_buffer_size > 0 && (wslay_event_get_queued_msg_length(wsl_ctx) + p_buffer_size > (uint32_t)outbound_buffer_size), ERR_OUT_OF_MEMORY); struct wslay_event_msg msg; msg.opcode = p_opcode; msg.msg = p_buffer; msg.msg_length = p_buffer_size; // Queue & send message. if (wslay_event_queue_msg(wsl_ctx, &msg) != 0 || wslay_event_send(wsl_ctx) != 0) { close(-1); return FAILED; } return OK; } Error WSLPeer::send(const uint8_t *p_buffer, int p_buffer_size, WriteMode p_mode) { wslay_opcode opcode = p_mode == WRITE_MODE_TEXT ? WSLAY_TEXT_FRAME : WSLAY_BINARY_FRAME; return _send(p_buffer, p_buffer_size, opcode); } Error WSLPeer::put_packet(const uint8_t *p_buffer, int p_buffer_size) { return _send(p_buffer, p_buffer_size, WSLAY_BINARY_FRAME); } Error WSLPeer::get_packet(const uint8_t **r_buffer, int &r_buffer_size) { r_buffer_size = 0; ERR_FAIL_COND_V(ready_state != STATE_OPEN, FAILED); if (in_buffer.packets_left() == 0) { return ERR_UNAVAILABLE; } int read = 0; uint8_t *rw = packet_buffer.ptrw(); in_buffer.read_packet(rw, packet_buffer.size(), &was_string, read); *r_buffer = rw; r_buffer_size = read; return OK; } int WSLPeer::get_available_packet_count() const { if (ready_state != STATE_OPEN) { return 0; } return in_buffer.packets_left(); } int WSLPeer::get_current_outbound_buffered_amount() const { if (ready_state != STATE_OPEN) { return 0; } return wslay_event_get_queued_msg_length(wsl_ctx); } void WSLPeer::close(int p_code, String p_reason) { if (p_code < 0) { // Force immediate close. ready_state = STATE_CLOSED; } if (ready_state == STATE_OPEN && !wslay_event_get_close_sent(wsl_ctx)) { CharString cs = p_reason.utf8(); wslay_event_queue_close(wsl_ctx, p_code, (uint8_t *)cs.ptr(), cs.length()); wslay_event_send(wsl_ctx); ready_state = STATE_CLOSING; } else if (ready_state == STATE_CONNECTING || ready_state == STATE_CLOSED) { ready_state = STATE_CLOSED; connection.unref(); if (tcp.is_valid()) { tcp->disconnect_from_host(); tcp.unref(); } } in_buffer.clear(); packet_buffer.resize(0); } IPAddress WSLPeer::get_connected_host() const { ERR_FAIL_COND_V(tcp.is_null(), IPAddress()); return tcp->get_connected_host(); } uint16_t WSLPeer::get_connected_port() const { ERR_FAIL_COND_V(tcp.is_null(), 0); return tcp->get_connected_port(); } String WSLPeer::get_selected_protocol() const { return selected_protocol; } String WSLPeer::get_requested_url() const { return requested_url; } void WSLPeer::set_no_delay(bool p_enabled) { ERR_FAIL_COND(tcp.is_null()); tcp->set_no_delay(p_enabled); } void WSLPeer::_clear() { // Connection info. ready_state = STATE_CLOSED; is_server = false; connection.unref(); if (tcp.is_valid()) { tcp->disconnect_from_host(); tcp.unref(); } if (wsl_ctx) { wslay_event_context_free(wsl_ctx); wsl_ctx = nullptr; } resolver.stop(); requested_url.clear(); requested_host.clear(); pending_request = true; handshake_buffer->clear(); selected_protocol.clear(); session_key.clear(); // Pending packets info. was_string = 0; in_buffer.clear(); packet_buffer.clear(); // Close code info. close_code = -1; close_reason.clear(); } WSLPeer::WSLPeer() { handshake_buffer.instantiate(); } WSLPeer::~WSLPeer() { close(-1); } #endif // WEB_ENABLED