diff options
Diffstat (limited to 'ws/libs/wsServer')
| -rw-r--r-- | ws/libs/wsServer/include/base64.h | 19 | ||||
| -rw-r--r-- | ws/libs/wsServer/include/sha1.h | 73 | ||||
| -rw-r--r-- | ws/libs/wsServer/include/utf8.h | 37 | ||||
| -rw-r--r-- | ws/libs/wsServer/include/ws.h | 337 | ||||
| -rw-r--r-- | ws/libs/wsServer/src/base64.c | 155 | ||||
| -rw-r--r-- | ws/libs/wsServer/src/handshake.c | 144 | ||||
| -rw-r--r-- | ws/libs/wsServer/src/sha1.c | 389 | ||||
| -rw-r--r-- | ws/libs/wsServer/src/utf8.c | 89 | ||||
| -rw-r--r-- | ws/libs/wsServer/src/ws.c | 2101 |
9 files changed, 3344 insertions, 0 deletions
diff --git a/ws/libs/wsServer/include/base64.h b/ws/libs/wsServer/include/base64.h new file mode 100644 index 0000000..5ea7f13 --- /dev/null +++ b/ws/libs/wsServer/include/base64.h @@ -0,0 +1,19 @@ +/* + * Base64 encoding/decoding (RFC1341) + * Copyright (c) 2005, Jouni Malinen <j@w1.fi> + * + * This software may be distributed under the terms of the BSD license. + * See README for more details. + */ + +#ifndef BASE64_H +#define BASE64_H + +#include <sys/types.h> + +unsigned char * base64_encode(const unsigned char *src, size_t len, + size_t *out_len); +unsigned char * base64_decode(const unsigned char *src, size_t len, + size_t *out_len); + +#endif /* BASE64_H */ diff --git a/ws/libs/wsServer/include/sha1.h b/ws/libs/wsServer/include/sha1.h new file mode 100644 index 0000000..eb51ed5 --- /dev/null +++ b/ws/libs/wsServer/include/sha1.h @@ -0,0 +1,73 @@ +/* + * sha1.h + * + * Description: + * This is the header file for code which implements the Secure + * Hashing Algorithm 1 as defined in FIPS PUB 180-1 published + * April 17, 1995. + * + * Many of the variable names in this code, especially the + * single character names, were used because those were the names + * used in the publication. + * + * Please read the file sha1.c for more information. + * + */ + +#ifndef _SHA1_H_ +#define _SHA1_H_ + +#include <stdint.h> +/* + * If you do not have the ISO standard stdint.h header file, then you + * must typdef the following: + * name meaning + * uint32_t unsigned 32 bit integer + * uint8_t unsigned 8 bit integer (i.e., unsigned char) + * int_least16_t integer of >= 16 bits + * + */ + +#ifndef _SHA_enum_ +#define _SHA_enum_ +enum +{ + shaSuccess = 0, + shaNull, /* Null pointer parameter */ + shaInputTooLong, /* input data too long */ + shaStateError /* called Input after Result */ +}; +#endif +#define SHA1HashSize 20 + +/* + * This structure will hold context information for the SHA-1 + * hashing operation + */ +typedef struct SHA1Context +{ + uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */ + + uint32_t Length_Low; /* Message length in bits */ + uint32_t Length_High; /* Message length in bits */ + + /* Index into message block array */ + int_least16_t Message_Block_Index; + uint8_t Message_Block[64]; /* 512-bit message blocks */ + + int Computed; /* Is the digest computed? */ + int Corrupted; /* Is the message digest corrupted? */ +} SHA1Context; + +/* + * Function Prototypes + */ + +int SHA1Reset( SHA1Context *); +int SHA1Input( SHA1Context *, + const uint8_t *, + unsigned int); +int SHA1Result( SHA1Context *, + uint8_t Message_Digest[SHA1HashSize]); + +#endif diff --git a/ws/libs/wsServer/include/utf8.h b/ws/libs/wsServer/include/utf8.h new file mode 100644 index 0000000..b30a62b --- /dev/null +++ b/ws/libs/wsServer/include/utf8.h @@ -0,0 +1,37 @@ +/** + * Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de> + * + * 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. + */ + +#ifndef UTF8_DECODE_H +#define UTF8_DECODE_H + + #include <inttypes.h> + #include <stddef.h> + + /* UTF8 return state. */ + #define UTF8_ACCEPT 0 + #define UTF8_REJECT 1 + + extern int is_utf8(uint8_t* s); + extern int is_utf8_len(uint8_t *s, size_t len); + extern uint32_t is_utf8_len_state(uint8_t *s, size_t len, uint32_t state); + +#endif diff --git a/ws/libs/wsServer/include/ws.h b/ws/libs/wsServer/include/ws.h new file mode 100644 index 0000000..900d03b --- /dev/null +++ b/ws/libs/wsServer/include/ws.h @@ -0,0 +1,337 @@ +/* + * Copyright (C) 2016-2022 Davidson Francis <davidsondfgl@gmail.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/> + */ + +/** + * @dir include/ + * @brief wsServer include directory + * + * @file ws.h + * @brief wsServer constants and functions. + */ +#ifndef WS_H +#define WS_H + +#ifdef __cplusplus +extern "C" { +#endif + + #include <stdbool.h> + #include <stdint.h> + #include <inttypes.h> + + /** + * @name Global configurations + */ + /**@{*/ + /** + * @brief Max clients connected simultaneously. + */ +#ifndef MAX_CLIENTS + #define MAX_CLIENTS 8 +#endif + + /** + * @name Key and message configurations. + */ + /**@{*/ + /** + * @brief Message buffer length. + */ + #define MESSAGE_LENGTH 2048 + /** + * @brief Maximum frame/message length. + */ + #define MAX_FRAME_LENGTH (16*1024*1024) + /** + * @brief WebSocket key length. + */ + #define WS_KEY_LEN 24 + /** + * @brief Magic string length. + */ + #define WS_MS_LEN 36 + /** + * @brief Accept message response length. + */ + #define WS_KEYMS_LEN (WS_KEY_LEN + WS_MS_LEN) + /** + * @brief Magic string. + */ + #define MAGIC_STRING "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" + /**@}*/ + + /** + * @name Handshake constants. + */ + /**@{*/ + /** + * @brief Alias for 'Sec-WebSocket-Key'. + */ + #define WS_HS_REQ "Sec-WebSocket-Key" + + /** + * @brief Handshake accept message length. + */ + #define WS_HS_ACCLEN 130 + + /** + * @brief Handshake accept message. + */ + #define WS_HS_ACCEPT \ + "HTTP/1.1 101 Switching Protocols\r\n" \ + "Upgrade: websocket\r\n" \ + "Connection: Upgrade\r\n" \ + "Sec-WebSocket-Accept: " + /**@}*/ + + /** + * @name Frame types. + */ + /**@{*/ + /** + * @brief Frame FIN. + */ + #define WS_FIN 128 + + /** + * @brief Frame FIN shift + */ + #define WS_FIN_SHIFT 7 + + /** + * @brief Continuation frame. + */ + #define WS_FR_OP_CONT 0 + + /** + * @brief Text frame. + */ + #define WS_FR_OP_TXT 1 + + /** + * @brief Binary frame. + */ + #define WS_FR_OP_BIN 2 + + /** + * @brief Close frame. + */ + #define WS_FR_OP_CLSE 8 + + /** + * @brief Ping frame. + */ + #define WS_FR_OP_PING 0x9 + + /** + * @brief Pong frame. + */ + #define WS_FR_OP_PONG 0xA + + /** + * @brief Unsupported frame. + */ + #define WS_FR_OP_UNSUPPORTED 0xF + /**@}*/ + + /** + * @name Close codes + */ + /**@{*/ + /** + * @brief Normal close + */ + #define WS_CLSE_NORMAL 1000 + /** + * @brief Protocol error + */ + #define WS_CLSE_PROTERR 1002 + /**@}*/ + /** + * @brief Inconsistent message (invalid utf-8) + */ + #define WS_CLSE_INVUTF8 1007 + + /** + * @name Connection states + */ + /**@{*/ + /** + * @brief Connection not established yet. + */ + #define WS_STATE_CONNECTING 0 + /** + * @brief Communicating. + */ + #define WS_STATE_OPEN 1 + /** + * @brief Closing state. + */ + #define WS_STATE_CLOSING 2 + /** + * @brief Closed. + */ + #define WS_STATE_CLOSED 3 + /**@}*/ + + /** + * @name Timeout util + */ + /**@{*/ + /** + * @brief Nanoseconds macro converter + */ + #define MS_TO_NS(x) ((x)*1000000) + /** + * @brief Timeout in milliseconds. + */ + #define TIMEOUT_MS (500) + /**@}*/ + + /** + * @name Handshake constants. + */ + /**@{*/ + /** + * @brief Debug + */ + #ifdef VERBOSE_MODE + #define DEBUG(...) fprintf(stderr, __VA_ARGS__) + #else + #define DEBUG(...) + #endif + /**@}*/ + + #ifndef AFL_FUZZ + #define SEND(client,buf,len) send_all((client), (buf), (len), MSG_NOSIGNAL) + #define RECV(fd,buf,len) recv((fd)->client_sock, (buf), (len), 0) + #else + #define SEND(client,buf,len) write(fileno(stdout), (buf), (len)) + #define RECV(fd,buf,len) read((fd)->client_sock, (buf), (len)) + #endif + + /* Opaque client connection type. */ + typedef uint64_t ws_cli_conn_t; + + /* Opaque server instance type. */ + typedef struct ws_server ws_server_t; + + /** + * @brief Get server context. + * Set when initializing `.context` in `struct ws_server`. + */ + void *ws_get_server_context(ws_cli_conn_t client); + + /** + * @brief Set connection context. + */ + void ws_set_connection_context(ws_cli_conn_t client, void *ptr); + + /** + * @brief Get connection context. + */ + void *ws_get_connection_context(ws_cli_conn_t client); + + /** + * @brief events Web Socket events types. + */ + struct ws_events + { + /** + * @brief On open event, called when a new client connects. + */ + void (*onopen)(ws_cli_conn_t client); + /** + * @brief On close event, called when a client disconnects. + */ + void (*onclose)(ws_cli_conn_t client); + /** + * @brief On message event, called when a client sends a text + * or binary message. + */ + void (*onmessage)(ws_cli_conn_t client, + const unsigned char *msg, uint64_t msg_size, int type); + }; + + /** + * @brief server Web Socket server parameters + */ + struct ws_server + { + /** + * @brief Required hostname that the wsServer will bind to + */ + const char *host; + /** + * @brief Listening port + */ + uint16_t port; + /** + * @brief Whether if the ws_socket() should create a new thread + * and be non-blocking (1) or not (0). + */ + int thread_loop; + /** + * @brief Ping timeout in milliseconds + */ + uint32_t timeout_ms; + /** + * @brief Server events. + */ + struct ws_events evs; + /** + * @brief Server context. + * Provided by the user, can be accessed via `ws_get_server_context` from `onopen`. + */ + void* context; + }; + + /* Forward declarations. */ + + /* Internal usage. */ + extern int get_handshake_accept(char *wsKey, unsigned char **dest); + extern int get_handshake_response(char *hsrequest, char **hsresponse); + + /* External usage. */ + extern char *ws_getaddress(ws_cli_conn_t client); + extern char *ws_getport(ws_cli_conn_t client); + extern int ws_sendframe( + ws_cli_conn_t client, const char *msg, uint64_t size, int type); + extern int ws_sendframe_bcast( + uint16_t port, const char *msg, uint64_t size, int type); + extern int ws_sendframe_txt(ws_cli_conn_t client, const char *msg); + extern int ws_sendframe_txt_bcast(uint16_t port, const char *msg); + extern int ws_sendframe_bin(ws_cli_conn_t client, const char *msg, + uint64_t size); + extern int ws_sendframe_bin_bcast(uint16_t port, const char *msg, + uint64_t size); + extern int ws_get_state(ws_cli_conn_t client); + extern int ws_close_client(ws_cli_conn_t client); + extern int ws_socket(struct ws_server *ws_srv); + + /* Ping routines. */ + extern void ws_ping(ws_cli_conn_t cid, int threshold); + +#ifdef AFL_FUZZ + extern int ws_file(struct ws_events *evs, const char *file); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* WS_H */ diff --git a/ws/libs/wsServer/src/base64.c b/ws/libs/wsServer/src/base64.c new file mode 100644 index 0000000..4523734 --- /dev/null +++ b/ws/libs/wsServer/src/base64.c @@ -0,0 +1,155 @@ +/* + * Base64 encoding/decoding (RFC1341) + * Copyright (c) 2005-2011, Jouni Malinen <j@w1.fi> + * + * This software may be distributed under the terms of the BSD license. + * See README for more details. + */ + +#include <string.h> +#include <stdlib.h> +#include <stdint.h> +#include <base64.h> + +static const unsigned char base64_table[65] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +/** + * base64_encode - Base64 encode + * @src: Data to be encoded + * @len: Length of the data to be encoded + * @out_len: Pointer to output length variable, or %NULL if not used + * Returns: Allocated buffer of out_len bytes of encoded data, + * or %NULL on failure + * + * Caller is responsible for freeing the returned buffer. Returned buffer is + * nul terminated to make it easier to use as a C string. The nul terminator is + * not included in out_len. + */ +unsigned char * base64_encode(const unsigned char *src, size_t len, + size_t *out_len) +{ + unsigned char *out, *pos; + const unsigned char *end, *in; + size_t olen; + int line_len; + + olen = len * 4 / 3 + 4; /* 3-byte blocks to 4-byte */ + olen += olen / 72; /* line feeds */ + olen++; /* nul termination */ + if (olen < len) + return NULL; /* integer overflow */ + out = malloc(olen); + if (out == NULL) + return NULL; + + end = src + len; + in = src; + pos = out; + line_len = 0; + while (end - in >= 3) { + *pos++ = base64_table[in[0] >> 2]; + *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; + *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)]; + *pos++ = base64_table[in[2] & 0x3f]; + in += 3; + line_len += 4; + if (line_len >= 72) { + *pos++ = '\n'; + line_len = 0; + } + } + + if (end - in) { + *pos++ = base64_table[in[0] >> 2]; + if (end - in == 1) { + *pos++ = base64_table[(in[0] & 0x03) << 4]; + *pos++ = '='; + } else { + *pos++ = base64_table[((in[0] & 0x03) << 4) | + (in[1] >> 4)]; + *pos++ = base64_table[(in[1] & 0x0f) << 2]; + } + *pos++ = '='; + line_len += 4; + } + + if (line_len) + *pos++ = '\n'; + + *pos = '\0'; + if (out_len) + *out_len = pos - out; + return out; +} + + +/** + * base64_decode - Base64 decode + * @src: Data to be decoded + * @len: Length of the data to be decoded + * @out_len: Pointer to output length variable + * Returns: Allocated buffer of out_len bytes of decoded data, + * or %NULL on failure + * + * Caller is responsible for freeing the returned buffer. + */ +unsigned char * base64_decode(const unsigned char *src, size_t len, + size_t *out_len) +{ + unsigned char dtable[256], *out, *pos, block[4], tmp; + size_t i, count, olen; + int pad = 0; + + memset(dtable, 0x80, 256); + for (i = 0; i < sizeof(base64_table) - 1; i++) + dtable[base64_table[i]] = (unsigned char) i; + dtable['='] = 0; + + count = 0; + for (i = 0; i < len; i++) { + if (dtable[src[i]] != 0x80) + count++; + } + + if (count == 0 || count % 4) + return NULL; + + olen = count / 4 * 3; + pos = out = malloc(olen); + if (out == NULL) + return NULL; + + count = 0; + for (i = 0; i < len; i++) { + tmp = dtable[src[i]]; + if (tmp == 0x80) + continue; + + if (src[i] == '=') + pad++; + block[count] = tmp; + count++; + if (count == 4) { + *pos++ = (block[0] << 2) | (block[1] >> 4); + *pos++ = (block[1] << 4) | (block[2] >> 2); + *pos++ = (block[2] << 6) | block[3]; + count = 0; + if (pad) { + if (pad == 1) + pos--; + else if (pad == 2) + pos -= 2; + else { + /* Invalid padding */ + free(out); + return NULL; + } + break; + } + } + } + + *out_len = pos - out; + return out; +} diff --git a/ws/libs/wsServer/src/handshake.c b/ws/libs/wsServer/src/handshake.c new file mode 100644 index 0000000..4b8ac30 --- /dev/null +++ b/ws/libs/wsServer/src/handshake.c @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2016-2024 Davidson Francis <davidsondfgl@gmail.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/> + */ +#define _POSIX_C_SOURCE 200809L +#include <base64.h> +#include <sha1.h> +#include <ws.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <strings.h> + +/** + * @dir src/ + * @brief Handshake routines directory + * + * @file handshake.c + * @brief Handshake routines. + */ + +/** + * @brief Gets the field Sec-WebSocket-Accept on response, by + * an previously informed key. + * + * @param wsKey Sec-WebSocket-Key + * @param dest source to be stored the value. + * + * @return Returns 0 if success and a negative number + * otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +int get_handshake_accept(char *wsKey, unsigned char **dest) +{ + unsigned char hash[SHA1HashSize]; /* SHA-1 Hash. */ + SHA1Context ctx; /* SHA-1 Context. */ + char *str; /* WebSocket key + magic string. */ + + /* Invalid key. */ + if (!wsKey) + return (-1); + + str = calloc(1, sizeof(char) * (WS_KEY_LEN + WS_MS_LEN + 1)); + if (!str) + return (-1); + + strncpy(str, wsKey, WS_KEY_LEN); + strcat(str, MAGIC_STRING); + + SHA1Reset(&ctx); + SHA1Input(&ctx, (const uint8_t *)str, WS_KEYMS_LEN); + SHA1Result(&ctx, hash); + + *dest = base64_encode(hash, SHA1HashSize, NULL); + *(*dest + strlen((const char *)*dest) - 1) = '\0'; + free(str); + return (0); +} + +/** + * @brief Finds the ocorrence of @p needle in @p haystack, case + * insensitive. + * + * @param haystack Target string to be searched. + * @param needle Substring to search for. + * + * @returns If found, returns a pointer at the beginning of the + * found substring. Otherwise, returns NULL. + */ +static char *strstricase(const char *haystack, const char *needle) +{ + size_t length; + for (length = strlen(needle); *haystack; haystack++) + if (!strncasecmp(haystack, needle, length)) + return (char*)haystack; + return (NULL); +} + +/** + * @brief Gets the complete response to accomplish a succesfully + * handshake. + * + * @param hsrequest Client request. + * @param hsresponse Server response. + * + * @return Returns 0 if success and a negative number + * otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +int get_handshake_response(char *hsrequest, char **hsresponse) +{ + unsigned char *accept; /* Accept message. */ + char *saveptr; /* strtok_r() pointer. */ + char *s; /* Current string. */ + int ret; /* Return value. */ + + saveptr = NULL; + for (s = strtok_r(hsrequest, "\r\n", &saveptr); s != NULL; + s = strtok_r(NULL, "\r\n", &saveptr)) + { + if (strstricase(s, WS_HS_REQ) != NULL) + break; + } + + /* Ensure that we have a valid pointer. */ + if (s == NULL) + return (-1); + + saveptr = NULL; + s = strtok_r(s, " ", &saveptr); + s = strtok_r(NULL, " ", &saveptr); + + ret = get_handshake_accept(s, &accept); + if (ret < 0) + return (ret); + + *hsresponse = malloc(sizeof(char) * WS_HS_ACCLEN); + if (*hsresponse == NULL) + return (-1); + + strcpy(*hsresponse, WS_HS_ACCEPT); + strcat(*hsresponse, (const char *)accept); + strcat(*hsresponse, "\r\n\r\n"); + + free(accept); + return (0); +} diff --git a/ws/libs/wsServer/src/sha1.c b/ws/libs/wsServer/src/sha1.c new file mode 100644 index 0000000..8cdec64 --- /dev/null +++ b/ws/libs/wsServer/src/sha1.c @@ -0,0 +1,389 @@ +/* + * sha1.c + * + * Description: + * This file implements the Secure Hashing Algorithm 1 as + * defined in FIPS PUB 180-1 published April 17, 1995. + * + * The SHA-1, produces a 160-bit message digest for a given + * data stream. It should take about 2**n steps to find a + * message with the same digest as a given message and + * 2**(n/2) to find any two messages with the same digest, + * when n is the digest size in bits. Therefore, this + * algorithm can serve as a means of providing a + * "fingerprint" for a message. + * + * Portability Issues: + * SHA-1 is defined in terms of 32-bit "words". This code + * uses <stdint.h> (included via "sha1.h" to define 32 and 8 + * bit unsigned integer types. If your C compiler does not + * support 32 bit unsigned integers, this code is not + * appropriate. + * + * Caveats: + * SHA-1 is designed to work with messages less than 2^64 bits + * long. Although SHA-1 allows a message digest to be generated + * for messages of any number of bits less than 2^64, this + * implementation only works with messages with a length that is + * a multiple of the size of an 8-bit character. + * + */ + +#include <sha1.h> + +/* + * Define the SHA1 circular left shift macro + */ +#define SHA1CircularShift(bits,word) \ + (((word) << (bits)) | ((word) >> (32-(bits)))) + +/* Local Function Prototyptes */ +void SHA1PadMessage(SHA1Context *); +void SHA1ProcessMessageBlock(SHA1Context *); + +/* + * SHA1Reset + * + * Description: + * This function will initialize the SHA1Context in preparation + * for computing a new SHA1 message digest. + * + * Parameters: + * context: [in/out] + * The context to reset. + * + * Returns: + * sha Error Code. + * + */ +int SHA1Reset(SHA1Context *context) +{ + if (!context) + { + return shaNull; + } + + context->Length_Low = 0; + context->Length_High = 0; + context->Message_Block_Index = 0; + + context->Intermediate_Hash[0] = 0x67452301; + context->Intermediate_Hash[1] = 0xEFCDAB89; + context->Intermediate_Hash[2] = 0x98BADCFE; + context->Intermediate_Hash[3] = 0x10325476; + context->Intermediate_Hash[4] = 0xC3D2E1F0; + + context->Computed = 0; + context->Corrupted = 0; + + return shaSuccess; +} + +/* + * SHA1Result + * + * Description: + * This function will return the 160-bit message digest into the + * Message_Digest array provided by the caller. + * NOTE: The first octet of hash is stored in the 0th element, + * the last octet of hash in the 19th element. + * + * Parameters: + * context: [in/out] + * The context to use to calculate the SHA-1 hash. + * Message_Digest: [out] + * Where the digest is returned. + * + * Returns: + * sha Error Code. + * + */ +int SHA1Result( SHA1Context *context, + uint8_t Message_Digest[SHA1HashSize]) +{ + int i; + + if (!context || !Message_Digest) + { + return shaNull; + } + + if (context->Corrupted) + { + return context->Corrupted; + } + + if (!context->Computed) + { + SHA1PadMessage(context); + for(i=0; i<64; ++i) + { + /* message may be sensitive, clear it out */ + context->Message_Block[i] = 0; + } + context->Length_Low = 0; /* and clear length */ + context->Length_High = 0; + context->Computed = 1; + + } + + for(i = 0; i < SHA1HashSize; ++i) + { + Message_Digest[i] = context->Intermediate_Hash[i>>2] + >> 8 * ( 3 - ( i & 0x03 ) ); + } + + return shaSuccess; +} + +/* + * SHA1Input + * + * Description: + * This function accepts an array of octets as the next portion + * of the message. + * + * Parameters: + * context: [in/out] + * The SHA context to update + * message_array: [in] + * An array of characters representing the next portion of + * the message. + * length: [in] + * The length of the message in message_array + * + * Returns: + * sha Error Code. + * + */ +int SHA1Input( SHA1Context *context, + const uint8_t *message_array, + unsigned length) +{ + if (!length) + { + return shaSuccess; + } + + if (!context || !message_array) + { + return shaNull; + } + + if (context->Computed) + { + context->Corrupted = shaStateError; + + return shaStateError; + } + + if (context->Corrupted) + { + return context->Corrupted; + } + while(length-- && !context->Corrupted) + { + context->Message_Block[context->Message_Block_Index++] = + (*message_array & 0xFF); + + context->Length_Low += 8; + if (context->Length_Low == 0) + { + context->Length_High++; + if (context->Length_High == 0) + { + /* Message is too long */ + context->Corrupted = 1; + } + } + + if (context->Message_Block_Index == 64) + { + SHA1ProcessMessageBlock(context); + } + + message_array++; + } + + return shaSuccess; +} + +/* + * SHA1ProcessMessageBlock + * + * Description: + * This function will process the next 512 bits of the message + * stored in the Message_Block array. + * + * Parameters: + * None. + * + * Returns: + * Nothing. + * + * Comments: + + * Many of the variable names in this code, especially the + * single character names, were used because those were the + * names used in the publication. + * + * + */ +void SHA1ProcessMessageBlock(SHA1Context *context) +{ + const uint32_t K[] = { /* Constants defined in SHA-1 */ + 0x5A827999, + 0x6ED9EBA1, + 0x8F1BBCDC, + 0xCA62C1D6 + }; + int t; /* Loop counter */ + uint32_t temp; /* Temporary word value */ + uint32_t W[80]; /* Word sequence */ + uint32_t A, B, C, D, E; /* Word buffers */ + + /* + * Initialize the first 16 words in the array W + */ + for(t = 0; t < 16; t++) + { + W[t] = (uint32_t)context->Message_Block[t * 4] << 24; + W[t] |= (uint32_t)context->Message_Block[t * 4 + 1] << 16; + W[t] |= (uint32_t)context->Message_Block[t * 4 + 2] << 8; + W[t] |= (uint32_t)context->Message_Block[t * 4 + 3]; + } + + for(t = 16; t < 80; t++) + { + W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); + } + + A = context->Intermediate_Hash[0]; + B = context->Intermediate_Hash[1]; + C = context->Intermediate_Hash[2]; + D = context->Intermediate_Hash[3]; + E = context->Intermediate_Hash[4]; + + for(t = 0; t < 20; t++) + { + temp = SHA1CircularShift(5,A) + + ((B & C) | ((~B) & D)) + E + W[t] + K[0]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + + B = A; + A = temp; + } + + for(t = 20; t < 40; t++) + { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + for(t = 40; t < 60; t++) + { + temp = SHA1CircularShift(5,A) + + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + for(t = 60; t < 80; t++) + { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + context->Intermediate_Hash[0] += A; + context->Intermediate_Hash[1] += B; + context->Intermediate_Hash[2] += C; + context->Intermediate_Hash[3] += D; + context->Intermediate_Hash[4] += E; + + context->Message_Block_Index = 0; +} + +/* + * SHA1PadMessage + * + + * Description: + * According to the standard, the message must be padded to an even + * 512 bits. The first padding bit must be a '1'. The last 64 + * bits represent the length of the original message. All bits in + * between should be 0. This function will pad the message + * according to those rules by filling the Message_Block array + * accordingly. It will also call the ProcessMessageBlock function + * provided appropriately. When it returns, it can be assumed that + * the message digest has been computed. + * + * Parameters: + * context: [in/out] + * The context to pad + * ProcessMessageBlock: [in] + * The appropriate SHA*ProcessMessageBlock function + * Returns: + * Nothing. + * + */ + +void SHA1PadMessage(SHA1Context *context) +{ + /* + * Check to see if the current message block is too small to hold + * the initial padding bits and length. If so, we will pad the + * block, process it, and then continue padding into a second + * block. + */ + if (context->Message_Block_Index > 55) + { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 64) + { + context->Message_Block[context->Message_Block_Index++] = 0; + } + + SHA1ProcessMessageBlock(context); + + while(context->Message_Block_Index < 56) + { + context->Message_Block[context->Message_Block_Index++] = 0; + } + } + else + { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 56) + { + + context->Message_Block[context->Message_Block_Index++] = 0; + } + } + + /* + * Store the message length as the last 8 octets + */ + context->Message_Block[56] = context->Length_High >> 24; + context->Message_Block[57] = context->Length_High >> 16; + context->Message_Block[58] = context->Length_High >> 8; + context->Message_Block[59] = context->Length_High; + context->Message_Block[60] = context->Length_Low >> 24; + context->Message_Block[61] = context->Length_Low >> 16; + context->Message_Block[62] = context->Length_Low >> 8; + context->Message_Block[63] = context->Length_Low; + + SHA1ProcessMessageBlock(context); +} diff --git a/ws/libs/wsServer/src/utf8.c b/ws/libs/wsServer/src/utf8.c new file mode 100644 index 0000000..824060f --- /dev/null +++ b/ws/libs/wsServer/src/utf8.c @@ -0,0 +1,89 @@ +/** + * Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de> + * + * 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. + */ + +/* + * Amazing utf8 decoder & validator grabbed from: + * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ + * + * All rights goes to the original author. + */ + +#include "utf8.h" + +static const uint8_t utf8d[] = { + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf + 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df + 0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef + 0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff + 0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0 + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2 + 1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4 + 1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6 + 1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8 +}; + +static +uint32_t decode(uint32_t* state, uint32_t* codep, uint32_t byte) { + uint32_t type = utf8d[byte]; + + *codep = (*state != UTF8_ACCEPT) ? + (byte & 0x3fu) | (*codep << 6) : + (0xff >> type) & (byte); + + *state = utf8d[256 + *state*16 + type]; + return *state; +} + +int is_utf8(uint8_t *s) { + uint32_t codepoint, state = 0; + + while (*s) + decode(&state, &codepoint, *s++); + + return state == UTF8_ACCEPT; +} + +int is_utf8_len(uint8_t *s, size_t len) { + uint32_t codepoint, state = 0; + size_t i; + + for (i = 0; i < len; i++) + decode(&state, &codepoint, *s++); + + return state == UTF8_ACCEPT; +} + +uint32_t is_utf8_len_state(uint8_t *s, size_t len, uint32_t state) { + uint32_t codepoint; + size_t i; + + codepoint = 0; + for (i = 0; i < len; i++) + decode(&state, &codepoint, *s++); + + return state; +} diff --git a/ws/libs/wsServer/src/ws.c b/ws/libs/wsServer/src/ws.c new file mode 100644 index 0000000..f0a3de3 --- /dev/null +++ b/ws/libs/wsServer/src/ws.c @@ -0,0 +1,2101 @@ +/* + * Copyright (C) 2016-2023 Davidson Francis <davidsondfgl@gmail.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/> + */ +#define _POSIX_C_SOURCE 200809L +#include <errno.h> +#include <fcntl.h> +#include <pthread.h> +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <sys/time.h> + +/* clang-format off */ +#ifndef _WIN32 +#include <arpa/inet.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#else +#include <winsock2.h> +#include <ws2tcpip.h> +#include <windows.h> +typedef int socklen_t; +#endif +/* clang-format on */ + +/* Windows and macOS seems to not have MSG_NOSIGNAL */ +#ifndef MSG_NOSIGNAL +#define MSG_NOSIGNAL 0 +#endif + +#include <unistd.h> + +#include <utf8.h> +#include <ws.h> + +/** + * @dir src/ + * @brief wsServer source code + * + * @file ws.c + * @brief wsServer main routines. + */ + +/** + * @brief Client socks. + */ +struct ws_connection +{ + int client_sock; /**< Client socket FD. */ + int state; /**< WebSocket current state. */ + + /* wsServer structure copy. */ + struct ws_server ws_srv; + + /* Timeout thread and locks. */ + pthread_mutex_t mtx_state; + pthread_cond_t cnd_state_close; + pthread_t thrd_tout; + bool close_thrd; + + /* Send lock. */ + pthread_mutex_t mtx_snd; + + /* IP address and port. */ + char ip[1025]; /* NI_MAXHOST. */ + char port[32]; /* NI_MAXSERV. */ + + /* Ping/Pong IDs and locks. */ + int32_t last_pong_id; + int32_t current_ping_id; + pthread_mutex_t mtx_ping; + + /* Connection context */ + void *connection_context; + + ws_cli_conn_t client_id; +}; + +static struct ws_connection *get_client_by_cid(ws_cli_conn_t cid); + +/** + * @brief Clients list. + */ +static struct ws_connection client_socks[MAX_CLIENTS]; + +/** + * @brief Timeout to a single send(). + */ +static uint32_t timeout; + +/** + * @brief Client validity macro + */ +#define CLIENT_VALID(cli) \ +((cli) != NULL && (cli) >= &client_socks[0] && \ +(cli) <= &client_socks[MAX_CLIENTS - 1] && \ +(cli)->client_sock > -1) + + +/** + * @brief Get server context. + * Assumed to be set once, when initializing `.context` in `struct ws_server`. + */ +void *ws_get_server_context(ws_cli_conn_t cli) +{ + struct ws_connection *client = get_client_by_cid(cli); + if (!CLIENT_VALID(client)) + return NULL; + return client->ws_srv.context; +} + +/** + * @brief Set connection context. + */ +void ws_set_connection_context(ws_cli_conn_t client, void *ptr) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return; + cli->connection_context = ptr; +} + +/** + * @brief Get connection context. + */ +void *ws_get_connection_context(ws_cli_conn_t client) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return NULL; + return cli->connection_context; +} + +/** + * @brief WebSocket frame data + */ +struct ws_frame_data +{ + /** + * @brief Frame read. + */ + unsigned char frm[MESSAGE_LENGTH]; + /** + * @brief Processed message at the moment. + */ + unsigned char *msg; + /** + * @brief Control frame payload + */ + unsigned char msg_ctrl[125]; + /** + * @brief Current byte position. + */ + size_t cur_pos; + /** + * @brief Amount of read bytes. + */ + size_t amt_read; + /** + * @brief Frame type, like text or binary. + */ + int frame_type; + /** + * @brief Frame size. + */ + uint64_t frame_size; + /** + * @brief Error flag, set when a read was not possible. + */ + int error; + /** + * @brief Client connection structure. + */ + struct ws_connection *client; +}; + +/** + * @brief Global mutex. + */ +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + +/** + * @brief Issues an error message and aborts the program. + * + * @param s Error message. + */ +#define panic(s) \ +do \ +{ \ +perror(s); \ +exit(-1); \ +} while (0); + +static struct ws_connection *get_client_by_cid(ws_cli_conn_t cid) +{ + pthread_mutex_lock(&mutex); + for (int i = 0; i < MAX_CLIENTS; i++) + { + if (client_socks[i].client_id == cid) + { + pthread_mutex_unlock(&mutex); + return &client_socks[i]; + } + } + pthread_mutex_unlock(&mutex); + return NULL; +} +/** + * @brief Shutdown and close a given socket. + * + * @param fd Socket file descriptor to be closed. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void close_socket(int fd) +{ +#ifndef _WIN32 + shutdown(fd, SHUT_RDWR); + close(fd); +#else + closesocket(fd); +#endif +} + + +static uint64_t cid_generator = 1; + +static pthread_mutex_t cid_mutex = PTHREAD_MUTEX_INITIALIZER; + +static uint64_t get_next_cid() +{ + uint64_t next_cid; + + pthread_mutex_lock(&cid_mutex); + next_cid = cid_generator++; + pthread_mutex_unlock(&cid_mutex); + + return next_cid; +} + +/** + * @brief Returns the current client state for a given + * client @p client. + * + * @param client Client structure. + * + * @return Returns the client state, -1 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int get_client_state(struct ws_connection *client) +{ + int state; + + if (!CLIENT_VALID(client)) + return (-1); + + pthread_mutex_lock(&client->mtx_state); + state = client->state; + pthread_mutex_unlock(&client->mtx_state); + return (state); +} + +/** + * @brief Set a state @p state to the client index + * @p client. + * + * @param client Client structure. + * @param state State to be set. + * + * @return Returns 0 if success, -1 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int set_client_state(struct ws_connection *client, int state) +{ + if (!CLIENT_VALID(client)) + return (-1); + + if (state < 0 || state > 3) + return (-1); + + pthread_mutex_lock(&client->mtx_state); + client->state = state; + pthread_mutex_unlock(&client->mtx_state); + return (0); +} + +/** + * @brief Send a given message @p buf on a socket @p sockfd. + * + * @param client Target client. + * @param buf Message to be sent. + * @param len Message length. + * @param flags Send flags. + * + * @return If success (i.e: all message was sent), returns + * the amount of bytes sent. Otherwise, -1. + * + * @note Technically this shouldn't be necessary, since send() should + * block until all content is sent, since _we_ don't use 'O_NONBLOCK'. + * However, it was reported (issue #22 on GitHub) that this was + * happening, so just to be cautious, I will keep using this routine. + */ +static ssize_t send_all( + struct ws_connection *client, const void *buf, size_t len, int flags) +{ + const char *p; + ssize_t ret; + ssize_t r; + + ret = 0; + + /* Sanity check. */ + if (!CLIENT_VALID(client)) + return (-1); + + p = buf; + /* clang-format off */ + pthread_mutex_lock(&client->mtx_snd); + while (len) + { + r = send(client->client_sock, p, len, flags); + if (r == -1) + { + pthread_mutex_unlock(&client->mtx_snd); + return (-1); + } + p += r; + len -= r; + ret += r; + } + pthread_mutex_unlock(&client->mtx_snd); + /* clang-format on */ + return (ret); +} + +/** + * @brief Close client connection (no close handshake, this should + * be done earlier), set appropriate state and destroy mutexes. + * + * @param client Client connection. + * @param lock Should lock the global mutex?. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void close_client(struct ws_connection *client, int lock) +{ + if (!CLIENT_VALID(client)) + return; + + set_client_state(client, WS_STATE_CLOSED); + + close_socket(client->client_sock); + + /* Destroy client mutexes and clear fd 'slot'. */ + /* clang-format off */ + if (lock) + pthread_mutex_lock(&mutex); + client->client_sock = -1; + pthread_cond_destroy(&client->cnd_state_close); + pthread_mutex_destroy(&client->mtx_state); + pthread_mutex_destroy(&client->mtx_snd); + pthread_mutex_destroy(&client->mtx_ping); + if (lock) + pthread_mutex_unlock(&mutex); + /* clang-format on */ +} + +/** + * @brief Close time-out thread. + * + * For a given client, this routine sleeps until + * TIMEOUT_MS and closes the connection or returns + * sooner if already closed connection. + * + * @param p ws_connection/ws_cli_conn_t Structure Pointer. + * + * @return Always NULL. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void *close_timeout(void *p) +{ + struct ws_connection *conn = p; + struct timespec ts; + int state; + + pthread_mutex_lock(&conn->mtx_state); + + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_nsec += MS_TO_NS(TIMEOUT_MS); + + /* Normalize the time. */ + while (ts.tv_nsec >= 1000000000) + { + ts.tv_sec++; + ts.tv_nsec -= 1000000000; + } + + while (conn->state != WS_STATE_CLOSED && + pthread_cond_timedwait(&conn->cnd_state_close, &conn->mtx_state, &ts) != + ETIMEDOUT) + ; + + state = conn->state; + pthread_mutex_unlock(&conn->mtx_state); + + /* If already closed. */ + if (state == WS_STATE_CLOSED) + goto quit; + + DEBUG("Timer expired, closing client %d\n", conn->client_sock); + + close_client(conn, 1); + quit: + return (NULL); +} + +/** + * @brief For a valid client index @p client, starts + * the timeout thread and set the current state + * to 'CLOSING'. + * + * @param client Client connection. + * + * @return Returns 0 if success, -1 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int start_close_timeout(struct ws_connection *client) +{ + if (!CLIENT_VALID(client)) + return (-1); + + pthread_mutex_lock(&client->mtx_state); + + if (client->state != WS_STATE_OPEN) + goto out; + + client->state = WS_STATE_CLOSING; + + if (pthread_create(&client->thrd_tout, NULL, close_timeout, client)) + { + pthread_mutex_unlock(&client->mtx_state); + panic("Unable to create timeout thread\n"); + } + client->close_thrd = true; + out: + pthread_mutex_unlock(&client->mtx_state); + return (0); +} + +/** + * @brief Sets the IP address relative to a client connection opened + * by the server and save inside the client structure. + * + * @param client Client connection. + */ +static void set_client_address(struct ws_connection *client) +{ + struct sockaddr_storage addr; + socklen_t hlen = sizeof(addr); + + if (!CLIENT_VALID(client)) + return; + + memset(client->ip, 0, sizeof(client->ip)); + memset(client->port, 0, sizeof(client->port)); + + if (getpeername(client->client_sock, (struct sockaddr *)&addr, &hlen) < 0) + return; + + getnameinfo((struct sockaddr *)&addr, hlen, + client->ip, sizeof(client->ip), + client->port, sizeof(client->port), + NI_NUMERICHOST|NI_NUMERICSERV); +} + +/** + * @brief Gets the IP address relative to a client connection opened + * by the server. + * + * @param client Client connection. + * + * @return Pointer the ip address, or NULL if fails. + * + * @note The returned string is static, no need to free up memory. + */ +char *ws_getaddress(ws_cli_conn_t client) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return (NULL); + + return (cli->ip); +} + +/** + * @brief Gets the IP port relative to a client connection opened + * by the server. + * + * @param client Client connection. + * + * @return Pointer the port, or NULL if fails. + * + * @note The returned string is static, no need to free up memory. + */ +char *ws_getport(ws_cli_conn_t client) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return (NULL); + + return (cli->port); +} + +/** + * @brief Creates and send an WebSocket frame with some payload data. + * + * This routine is intended to be used to create a websocket frame for + * a given type e sending to the client. For higher level routines, + * please check @ref ws_sendframe_txt and @ref ws_sendframe_bin. + * + * @param client Target to be send. If NULL, broadcast the message. + * @param msg Message to be send. + * @param size Binary message size. + * @param type Frame type. + * @param port Server listen port to broadcast message (if any). + * + * @return Returns the number of bytes written, -1 if error. + * + * @note If @p size is -1, it is assumed that a text frame is being sent, + * otherwise, a binary frame. In the later case, the @p size is used. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int ws_sendframe_internal(struct ws_connection *client, const char *msg, + uint64_t size, int type, uint16_t port) +{ + unsigned char *response; /* Response data. */ + unsigned char frame[10]; /* Frame. */ + uint8_t idx_first_rData; /* Index data. */ + struct ws_connection *cli; /* Client. */ + int idx_response; /* Index response. */ + ssize_t send_ret; /* Ret send function */ + uint64_t length; /* Message length. */ + ssize_t output; /* Bytes sent. */ + uint64_t i; /* Loop index. */ + + /* + * Check if there is a valid condition before proceeding. + * + * Valid ones: + * client == true && port == 0 + * -> send to single client + * + * client == false && port != 0 + * -> send to all clients within single port + * + * Other options are invalid! + */ + + if (client) + { + if (port != 0) + return (-1); + } + else + { + if (port == 0) + return (-1); + } + + frame[0] = (WS_FIN | type); + length = (uint64_t)size; + + /* Split the size between octets. */ + if (length <= 125) + { + frame[1] = length & 0x7F; + idx_first_rData = 2; + } + + /* Size between 126 and 65535 bytes. */ + else if (length >= 126 && length <= 65535) + { + frame[1] = 126; + frame[2] = (length >> 8) & 255; + frame[3] = length & 255; + idx_first_rData = 4; + } + + /* More than 65535 bytes. */ + else + { + frame[1] = 127; + frame[2] = (unsigned char)((length >> 56) & 255); + frame[3] = (unsigned char)((length >> 48) & 255); + frame[4] = (unsigned char)((length >> 40) & 255); + frame[5] = (unsigned char)((length >> 32) & 255); + frame[6] = (unsigned char)((length >> 24) & 255); + frame[7] = (unsigned char)((length >> 16) & 255); + frame[8] = (unsigned char)((length >> 8) & 255); + frame[9] = (unsigned char)(length & 255); + idx_first_rData = 10; + } + + /* Add frame bytes. */ + idx_response = 0; + response = malloc(sizeof(unsigned char) * (idx_first_rData + length + 1)); + if (!response) + return (-1); + + for (i = 0; i < idx_first_rData; i++) + { + response[i] = frame[i]; + idx_response++; + } + + /* Add data bytes. */ + for (i = 0; i < length; i++) + { + response[idx_response] = msg[i]; + idx_response++; + } + + response[idx_response] = '\0'; + + /* Send to the client if there is one. */ + output = 0; + if (client && port == 0) + { + output = SEND(client, response, idx_response); + goto skip_broadcast; + } + + /* clang-format off */ + pthread_mutex_lock(&mutex); + /* Do broadcast. */ + for (i = 0; i < MAX_CLIENTS; i++) + { + cli = &client_socks[i]; + + if ((cli->client_sock > -1) && + get_client_state(cli) == WS_STATE_OPEN && + (cli->ws_srv.port == port)) + { + if ((send_ret = SEND(cli, response, idx_response)) != -1) + output += send_ret; + else + { + output = -1; + break; + } + } + } + pthread_mutex_unlock(&mutex); + /* clang-format on */ + + skip_broadcast: + free(response); + return ((int)output); +} + +/** + * @brief Send an WebSocket frame with some payload data. + * + * @param client Target to be send. If NULL, broadcast the message. + * @param msg Message to be send. + * @param size Binary message size. + * @param type Frame type. + * + * @return Returns the number of bytes written, -1 if error. + * + * @note If @p size is -1, it is assumed that a text frame is being sent, + * otherwise, a binary frame. In the later case, the @p size is used. + */ +int ws_sendframe(ws_cli_conn_t client, const char *msg, uint64_t size, int type) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return (-1); + return ws_sendframe_internal(cli, msg, size, type, 0); +} + +/** + * @brief Send an WebSocket frame with some payload data to all clients + * connected into the same port. + * + * @param port Server listen port to broadcast message. + * @param msg Message to be send. + * @param size Binary message size. + * @param type Frame type. + * + * @return Returns the number of bytes written, -1 if error. + * + * @note If @p size is -1, it is assumed that a text frame is being sent, + * otherwise, a binary frame. In the later case, the @p size is used. + */ +int ws_sendframe_bcast(uint16_t port, const char *msg, uint64_t size, int type) +{ + return ws_sendframe_internal(NULL, msg, size, type, port); +} + +/** + * @brief Given a PONG message, decodes the content + * as a int32_t number that corresponds to our + * PONG id. + * + * @param msg Content to be decoded. + * + * @return Returns the PONG id. + */ +static inline int32_t pong_msg_to_int32(uint8_t *msg) +{ + int32_t pong_id; + /* Decodes as big-endian. */ + pong_id = (msg[3] << 0) | (msg[2] << 8) | (msg[1] << 16) | (msg[0] << 24); + return (pong_id); +} + +/** + * @brief Given a PING id, encodes the content to be sent + * as payload of a PING frame. + * + * @param ping_id PING id to be encoded. + * @param msg Target buffer. + */ +static inline void int32_to_ping_msg(int32_t ping_id, uint8_t *msg) +{ + /* Encodes as big-endian. */ + msg[0] = (ping_id >> 24); + msg[1] = (ping_id >> 16); + msg[2] = (ping_id >> 8); + msg[3] = (ping_id >> 0); +} + +/** + * @brief Send a ping message and close if the client surpasses + * the threshold imposed. + * + * @param cli Client to be sent. + * @param threshold How many pings can miss?. + * @param lock Should lock global mutex or not?. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void send_ping_close(struct ws_connection *cli, int threshold, int lock) +{ + uint8_t ping_msg[4]; + + if (!CLIENT_VALID(cli) || get_client_state(cli) != WS_STATE_OPEN) + return; + + /* clang-format off */ + pthread_mutex_lock(&cli->mtx_ping); + + cli->current_ping_id++; + int32_to_ping_msg(cli->current_ping_id, ping_msg); + + /* Send PING. */ + ws_sendframe_internal(cli, (const char*)ping_msg, sizeof(ping_msg), + WS_FR_OP_PING, 0); + + /* Check previous PONG: if greater than threshold, abort. */ + if ((cli->current_ping_id - cli->last_pong_id) > threshold) { + DEBUG("Closing, reason: many unanswered PINGs\n"); + close_client(cli, lock); + } + + pthread_mutex_unlock(&cli->mtx_ping); + /* clang-format on */ +} + +/** + * @brief Sends a PING frame to the client @p cli with threshold + * @p threshold. + * + * This routine sends a PING to a single client pointed to by + * @p cli or a broadcast PING if @p cli is NULL. If the specified + * client does not respond up to @p threshold PINGs, the connection + * is aborted. + * + * ws_ping() is not automatic: the user who wants to send keep-alive + * PINGs *must* call this routine in a timely manner, whether on + * a different thread or inside an event. + * + * See examples/ping/ping.c for a minimal example usage. + * + * @param cli Client to be sent, if NULL, broadcast. + * @param threshold How many ignored PINGs should tolerate? (should be + * positive and greater than 0). + * + * @note It should be noted that the time between each call to + * ws_ping() is the timeout itself for receiving the PONG. + * + * It is also important to note that for devices with unstable + * connections (such as a weak WiFi signal or 3/4/5G from a cell phone), + * a threshold greater than 1 is advisable. + */ +void ws_ping(ws_cli_conn_t client, int threshold) +{ + struct ws_connection *cli = get_client_by_cid(client); + int i; + + /* Sanity check. */ + if (threshold <= 0) + return; + + /* PING a single client. */ + if (cli) + send_ping_close(cli, threshold, 1); + + /* PING broadcast. */ + else + { + /* clang-format off */ + pthread_mutex_lock(&mutex); + for (i = 0; i < MAX_CLIENTS; i++) + send_ping_close(&client_socks[i], threshold, 0); + pthread_mutex_unlock(&mutex); + /* clang-format on */ + } +} + +/** + * @brief Sends a WebSocket text frame. + * + * @param client Target to be send. + * @param msg Message to be send, null terminated. + * + * @return Returns the number of bytes written, -1 if error. + */ +int ws_sendframe_txt(ws_cli_conn_t client, const char *msg) +{ + return ws_sendframe(client, msg, (uint64_t)strlen(msg), WS_FR_OP_TXT); +} + +/** + * @brief Sends a broadcast WebSocket text frame. + * + * @param port Server listen port to broadcast message. + * @param msg Message to be send, null terminated. + * + * @return Returns the number of bytes written, -1 if error. + */ +int ws_sendframe_txt_bcast(uint16_t port, const char *msg) +{ + return ws_sendframe_bcast(port, msg, (uint64_t)strlen(msg), WS_FR_OP_TXT); +} + +/** + * @brief Sends a WebSocket binary frame. + * + * @param client Target to be send. + * @param msg Message to be send. + * @param size Binary message size. + * + * @return Returns the number of bytes written, -1 if error. + */ +int ws_sendframe_bin(ws_cli_conn_t client, const char *msg, uint64_t size) +{ + return ws_sendframe(client, msg, size, WS_FR_OP_BIN); +} + +/** + * @brief Sends a broadcast WebSocket binary frame. + * + * @param port Server listen port to broadcast message. + * @param msg Message to be send. + * @param size Binary message size. + * + * @return Returns the number of bytes written, -1 if error. + */ +int ws_sendframe_bin_bcast(uint16_t port, const char *msg, uint64_t size) +{ + return ws_sendframe_bcast(port, msg, size, WS_FR_OP_BIN); +} + +/** + * @brief For a given @p client, gets the current state for + * the connection, or -1 if invalid. + * + * @param client Client connection. + * + * @return Returns the connection state or -1 if + * invalid @p client. + * + * @see WS_STATE_CONNECTING + * @see WS_STATE_OPEN + * @see WS_STATE_CLOSING + * @see WS_STATE_CLOSED + */ +int ws_get_state(ws_cli_conn_t client) +{ + struct ws_connection *cli = get_client_by_cid(client); + if (!CLIENT_VALID(cli)) + return -1; + return (get_client_state(cli)); +} + +/** + * @brief Close the client connection for the given @p + * client with normal close code (1000) and no reason + * string. + * + * @param client Client connection. + * + * @return Returns 0 on success, -1 otherwise. + * + * @note If the client did not send a close frame in + * TIMEOUT_MS milliseconds, the server will close the + * connection with error code (1002). + */ +int ws_close_client(ws_cli_conn_t client) +{ + struct ws_connection *cli = get_client_by_cid(client); + + unsigned char clse_code[2]; + int cc; + + /* Check if client is a valid and connected client. */ + if (!CLIENT_VALID(cli) || cli->client_sock == -1) + return (-1); + + /* + * Instead of using do_close(), we use this to avoid using + * msg_ctrl buffer from wfd and avoid a race condition + * if this is invoked asynchronously. + */ + cc = WS_CLSE_NORMAL; + clse_code[0] = (cc >> 8); + clse_code[1] = (cc & 0xFF); + if (ws_sendframe( + client, (const char *)clse_code, sizeof(char) * 2, WS_FR_OP_CLSE) < 0) + { + DEBUG("An error has occurred while sending closing frame!\n"); + return (-1); + } + + /* + * Starts the timeout thread: if the client did not send + * a close frame in TIMEOUT_MS milliseconds, the server + * will close the connection with error code (1002). + */ + start_close_timeout(cli); + return (0); +} + +/** + * @brief Checks is a given opcode @p frame + * belongs to a control frame or not. + * + * @param frame Frame opcode to be checked. + * + * @return Returns 1 if is a control frame, 0 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static inline int is_control_frame(int frame) +{ + return ( + frame == WS_FR_OP_CLSE || frame == WS_FR_OP_PING || frame == WS_FR_OP_PONG); +} + +/** + * @brief Checks is a given opcode @p opcode is valid or not. + * + * @param opcode Frame opcode to be checked. + * + * @return Returns 1 if valid, 0 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static inline int is_valid_frame(int opcode) +{ + return ( + opcode == WS_FR_OP_TXT || opcode == WS_FR_OP_BIN || + opcode == WS_FR_OP_CONT || opcode == WS_FR_OP_PING || + opcode == WS_FR_OP_PONG || opcode == WS_FR_OP_CLSE + ); +} + +/** + * @brief Do the handshake process. + * + * @param wfd Websocket Frame Data. + * + * @return Returns 0 if success, a negative number otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int do_handshake(struct ws_frame_data *wfd) +{ + char *response; /* Handshake response message. */ + char *p; /* Last request line pointer. */ + ssize_t n; /* Read/Write bytes. */ + + /* Read the very first client message. */ + if ((n = RECV(wfd->client, wfd->frm, sizeof(wfd->frm) - 1)) < 0) + return (-1); + + /* Advance our pointers before the first next_byte(). */ + p = strstr((const char *)wfd->frm, "\r\n\r\n"); + if (p == NULL) + { + DEBUG("An empty line with \\r\\n was expected!\n"); + return (-1); + } + wfd->amt_read = n; + wfd->cur_pos = (size_t)((ptrdiff_t)(p - (char *)wfd->frm)) + 4; + + /* Get response. */ + if (get_handshake_response((char *)wfd->frm, &response) < 0) + { + DEBUG("Cannot get handshake response, request was: %s\n", wfd->frm); + return (-1); + } + + /* Valid request. */ + DEBUG("Handshaked, response: \n" + "------------------------------------\n" + "%s" + "------------------------------------\n", + response); + + /* Send handshake. */ + if (SEND(wfd->client, response, strlen(response)) < 0) + { + free(response); + DEBUG("As error has occurred while handshaking!\n"); + return (-1); + } + + /* Change state. */ + set_client_state(wfd->client, WS_STATE_OPEN); + + /* Trigger events and clean up buffers. */ + wfd->client->ws_srv.evs.onopen(wfd->client->client_id); + free(response); + return (0); +} + +/** + * @brief Sends a close frame, accordingly with the @p close_code + * or the message inside @p wfd. + * + * @param wfd Websocket Frame Data. + * @param close_code Websocket close code. + * + * @return Returns 0 if success, a negative number otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int do_close(struct ws_frame_data *wfd, int close_code) +{ + int cc; /* Close code. */ + + /* If custom close-code. */ + if (close_code != -1) + { + cc = close_code; + goto custom_close; + } + + /* If empty or have a close reason, just re-send. */ + if (wfd->frame_size == 0 || wfd->frame_size > 2) + goto send; + + /* Parse close code and check if valid, if not, we issue an protocol error. + */ + if (wfd->frame_size == 1) + cc = wfd->msg_ctrl[0]; + else + cc = ((int)wfd->msg_ctrl[0]) << 8 | wfd->msg_ctrl[1]; + + /* Check if it's not valid, if so, we send a protocol error (1002). */ + if ((cc < 1000 || cc > 1003) && (cc < 1007 || cc > 1011) && + (cc < 3000 || cc > 4999)) + { + cc = WS_CLSE_PROTERR; + + custom_close: + wfd->msg_ctrl[0] = (cc >> 8); + wfd->msg_ctrl[1] = (cc & 0xFF); + + if (ws_sendframe(wfd->client->client_id, (const char *)wfd->msg_ctrl, sizeof(char) * 2, + WS_FR_OP_CLSE) < 0) + { + DEBUG("An error has occurred while sending closing frame!\n"); + return (-1); + } + return (0); + } + + /* Send the data inside wfd->msg_ctrl. */ + send: + if (ws_sendframe(wfd->client->client_id, (const char *)wfd->msg_ctrl, wfd->frame_size, + WS_FR_OP_CLSE) < 0) + { + DEBUG("An error has occurred while sending closing frame!\n"); + return (-1); + } + return (0); +} + +/** + * @brief Send a pong frame in response to a ping frame. + * + * Accordingly to the RFC, a pong frame must have the same + * data payload as the ping frame, so we just send a + * ordinary frame with PONG opcode. + * + * @param wfd Websocket frame data. + * + * @param frame_size Pong frame size. + * + * @return Returns 0 if success and a negative number + * otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int do_pong(struct ws_frame_data *wfd, uint64_t frame_size) +{ + if (ws_sendframe( + wfd->client->client_id, (const char *)wfd->msg_ctrl, frame_size, WS_FR_OP_PONG) < 0) + { + wfd->error = 1; + DEBUG("An error has occurred while ponging!\n"); + return (-1); + } + return (0); +} + +/** + * @brief Read a chunk of bytes and return the next byte + * belonging to the frame. + * + * @param wfd Websocket Frame Data. + * + * @return Returns the byte read, or -1 if error. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static inline int next_byte(struct ws_frame_data *wfd) +{ + ssize_t n; + + /* If empty or full. */ + if (wfd->cur_pos == 0 || wfd->cur_pos == wfd->amt_read) + { + if ((n = RECV(wfd->client, wfd->frm, sizeof(wfd->frm))) <= 0) + { + wfd->error = 1; + DEBUG("An error has occurred while trying to read next byte\n"); + return (-1); + } + wfd->amt_read = (size_t)n; + wfd->cur_pos = 0; + } + return (wfd->frm[wfd->cur_pos++]); +} + +/** + * @brief Skips @p frame_size bytes of the current frame. + * + * @param wfd Websocket Frame Data. + * @param frame_size Amount of bytes to be skipped. + * + * @return Returns 0 if success, a negative number + * otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int skip_frame(struct ws_frame_data *wfd, uint64_t frame_size) +{ + uint64_t i; + for (i = 0; i < frame_size; i++) + { + if (next_byte(wfd) == -1) + { + wfd->error = 1; + return (-1); + } + } + return (0); +} + +/** + * Frame state data + * + * This structure holds the current data for handling the + * received frames. + */ +struct frame_state_data +{ + unsigned char *msg_data; /* Data frame. */ + unsigned char *msg_ctrl; /* Control frame. */ + uint8_t masks_data[4]; /* Masks data frame array. */ + uint8_t masks_ctrl[4]; /* Masks control frame array. */ + uint64_t msg_idx_data; /* Current msg index. */ + uint64_t msg_idx_ctrl; /* Current msg index. */ + uint64_t frame_length; /* Frame length. */ + uint64_t frame_size; /* Current frame size. */ +#ifdef VALIDATE_UTF8 + uint32_t utf8_state; /* Current UTF-8 state. */ +#endif + int32_t pong_id; /* Current PONG id. */ + uint8_t opcode; /* Frame opcode. */ + uint8_t is_fin; /* Is FIN frame flag. */ + uint8_t mask; /* Mask. */ + int cur_byte; /* Current frame byte. */ +}; + +/** + * @brief Validates TXT frames if UTF8 validation is enabled. + * If the content is not valid, the connection is aborted. + * + * @param wfd WebSocket frame data. + * @param fsd Frame state data. + * + * @return Always 0. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int validate_utf8_txt(struct ws_frame_data *wfd, + struct frame_state_data *fsd) +{ +#ifdef VALIDATE_UTF8 + /* UTF-8 Validate partial (or not) frame. */ + if (wfd->frame_type != WS_FR_OP_TXT) + return (0); + + if (fsd->is_fin) + { + if (is_utf8_len_state( + fsd->msg_data + (fsd->msg_idx_data - fsd->frame_length), + fsd->frame_length, fsd->utf8_state) != UTF8_ACCEPT) + { + DEBUG("Dropping invalid complete message!\n"); + wfd->error = 1; + do_close(wfd, WS_CLSE_INVUTF8); + } + + return (0); + } + + /* Check current state for a CONT or initial TXT frame. */ + fsd->utf8_state = + is_utf8_len_state(fsd->msg_data + + (fsd->msg_idx_data - fsd->frame_length), + fsd->frame_length, fsd->utf8_state); + + /* We can be in any state, except reject. */ + if (fsd->utf8_state == UTF8_REJECT) + { + DEBUG("Dropping invalid cont/initial frame!\n"); + wfd->error = 1; + do_close(wfd, WS_CLSE_INVUTF8); + } +#endif + return (0); +} + +/** + * @brief Handle PONG frames in response to our PING + * (or not, unsolicited is possible too). + * + * @param wfd WebSocket frame data. + * @param fsd Frame state data. + * + * @return Always 0. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int handle_pong_frame(struct ws_frame_data *wfd, + struct frame_state_data *fsd) +{ + fsd->is_fin = 0; + + /* If there is no content and/or differs the size, ignore it. */ + if (fsd->frame_size != sizeof(wfd->client->last_pong_id)) + return (0); + + /* + * Our PONG id should be positive and smaller than our + * current PING id. If not, ignore. + */ + /* clang-format off */ + pthread_mutex_lock(&wfd->client->mtx_ping); + fsd->pong_id = pong_msg_to_int32(fsd->msg_ctrl); + if (fsd->pong_id < 0 || fsd->pong_id > wfd->client->current_ping_id) + { + pthread_mutex_unlock(&wfd->client->mtx_ping); + return (0); + } + wfd->client->last_pong_id = fsd->pong_id; + pthread_mutex_unlock(&wfd->client->mtx_ping); + /* clang-format on */ + + return (0); +} + +/** + * @brief Handle PING frames sending a PONG response. + * + * @param wfd WebSocket frame data. + * @param fsd Frame state data. + * + * @return Returns 0 if success, -1 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int handle_ping_frame(struct ws_frame_data *wfd, + struct frame_state_data *fsd) +{ + if (do_pong(wfd, fsd->frame_size) < 0) + return (-1); + + /* Quick hack to keep our loop. */ + fsd->is_fin = 0; + return (0); +} + +/** + * @brief Handle close frames while checking for UTF8 + * in the close reason. + * + * @param wfd WebSocket frame data. + * @param fsd Frame state data. + * + * @return Returns 0 if success, -1 otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int handle_close_frame(struct ws_frame_data *wfd, + struct frame_state_data *fsd) +{ +#ifdef VALIDATE_UTF8 + /* If there is a close reason, check if it is UTF-8 valid. */ + if (fsd->frame_size > 2 && + !is_utf8_len(fsd->msg_ctrl + 2, fsd->frame_size - 2)) + { + DEBUG("Invalid close frame payload reason! (not UTF-8)\n"); + wfd->error = 1; + return (-1); + } +#endif + + /* + * Since we're aborting, we can scratch the 'data'-related + * vars here. + */ + wfd->frame_size = fsd->frame_size; + wfd->frame_type = WS_FR_OP_CLSE; + free(fsd->msg_data); + return (0); +} + +/** + * @brief Reads the current frame isolating data from control frames. + * The parameters are changed in order to reflect the current state. + * + * @param wfd Websocket Frame Data. + * @param fsd Frame state data. + * + * @return Returns 0 if success, a negative number otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int read_single_frame(struct ws_frame_data *wfd, + struct frame_state_data *fsd) +{ + uint64_t *frame_size; /* Curr frame size. */ + unsigned char *tmp; /* Tmp message. */ + unsigned char *msg; /* Current message. */ + uint64_t *msg_idx; /* Message index. */ + uint8_t *masks; /* Current mask. */ + int cur_byte; /* Curr byte read. */ + uint64_t i; /* Loop index. */ + + /* Decide which mask and msg to use. */ + if (is_control_frame(fsd->opcode)) { + frame_size = &fsd->frame_size; + msg_idx = &fsd->msg_idx_ctrl; + masks = fsd->masks_ctrl; + msg = fsd->msg_ctrl; + } + else { + frame_size = &wfd->frame_size; + msg_idx = &fsd->msg_idx_data; + masks = fsd->masks_data; + msg = fsd->msg_data; + } + + /* Decode masks and length for 16-bit messages. */ + if (fsd->frame_length == 126) + fsd->frame_length = (((uint64_t)next_byte(wfd)) << 8) | next_byte(wfd); + + /* 64-bit messages. */ + else if (fsd->frame_length == 127) + { + fsd->frame_length = + (((uint64_t)next_byte(wfd)) << 56) | /* frame[2]. */ + (((uint64_t)next_byte(wfd)) << 48) | /* frame[3]. */ + (((uint64_t)next_byte(wfd)) << 40) | + (((uint64_t)next_byte(wfd)) << 32) | + (((uint64_t)next_byte(wfd)) << 24) | + (((uint64_t)next_byte(wfd)) << 16) | + (((uint64_t)next_byte(wfd)) << 8) | + (((uint64_t)next_byte(wfd))); /* frame[9]. */ + } + + *frame_size += fsd->frame_length; + + /* + * Check frame size + * + * We need to limit the amount supported here, since if + * we follow strictly to the RFC, we have to allow 2^64 + * bytes. Also keep in mind that this is still true + * for continuation frames. + */ + if (*frame_size > MAX_FRAME_LENGTH) + { + DEBUG("Current frame from client %d, exceeds the maximum\n" + "amount of bytes allowed (%" PRId64 "/%d)!", + wfd->client->client_sock, *frame_size + fsd->frame_length, + MAX_FRAME_LENGTH); + + wfd->error = 1; + return (-1); + } + + /* Read masks. */ + masks[0] = next_byte(wfd); + masks[1] = next_byte(wfd); + masks[2] = next_byte(wfd); + masks[3] = next_byte(wfd); + + /* + * Abort if error. + * + * This is tricky: we may have multiples error codes from the + * previous next_bytes() calls, but, since we're only setting + * variables and flags, there is no major issue in setting + * them wrong _if_ we do not use their values, thing that + * we do here. + */ + if (wfd->error) + return (-1); + + /* + * Allocate memory. + * + * The statement below will allocate a new chunk of memory + * if msg is NULL with size total_length. Otherwise, it will + * resize the total memory accordingly with the message index + * and if the current frame is a FIN frame or not, if so, + * increment the size by 1 to accommodate the line ending \0. + */ + if (fsd->frame_length > 0) + { + if (!is_control_frame(fsd->opcode)) + { + tmp = realloc(msg, *msg_idx + fsd->frame_length + fsd->is_fin); + if (!tmp) + { + DEBUG("Cannot allocate memory, requested: % " PRId64 "\n", + (*msg_idx + fsd->frame_length + fsd->is_fin)); + + wfd->error = 1; + return (-1); + } + msg = tmp; + fsd->msg_data = msg; + } + + /* Copy to the proper location. */ + for (i = 0; i < fsd->frame_length; i++, (*msg_idx)++) + { + /* We were able to read? .*/ + cur_byte = next_byte(wfd); + if (cur_byte == -1) + return (-1); + + msg[*msg_idx] = cur_byte ^ masks[i % 4]; + } + } + + /* If we're inside a FIN frame, lets... */ + if (fsd->is_fin && *frame_size > 0) + { + /* Increase memory if our FIN frame is of length 0. */ + if (!fsd->frame_length && !is_control_frame(fsd->opcode)) + { + tmp = realloc(msg, *msg_idx + 1); + if (!tmp) + { + DEBUG("Cannot allocate memory, requested: %" PRId64 "\n", + (*msg_idx + 1)); + + wfd->error = 1; + return (-1); + } + msg = tmp; + fsd->msg_data = msg; + } + msg[*msg_idx] = '\0'; + } + + return (0); +} + +/** + * @brief Reads the next frame, whether if a TXT/BIN/CLOSE + * of arbitrary size. + * + * @param wfd Websocket Frame Data. + * + * @return Returns 0 if success, a negative number otherwise. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static int next_complete_frame(struct ws_frame_data *wfd) +{ + struct frame_state_data fsd = {0}; + fsd.msg_data = NULL; + fsd.msg_ctrl = wfd->msg_ctrl; + +#ifdef VALIDATE_UTF8 + fsd.utf8_state = UTF8_ACCEPT; +#endif + + wfd->frame_size = 0; + wfd->frame_type = -1; + wfd->msg = NULL; + + /* Read until find a FIN or a unsupported frame. */ + do + { + fsd.cur_byte = next_byte(wfd); + if (fsd.cur_byte == -1) + return (-1); + + fsd.is_fin = (fsd.cur_byte & 0xFF) >> WS_FIN_SHIFT; + fsd.opcode = (fsd.cur_byte & 0xF); + + /* Check for RSV field. */ + if (fsd.cur_byte & 0x70) + { + DEBUG("RSV is set while wsServer do not negotiate extensions!\n"); + wfd->error = 1; + break; + } + + /* + * Check if the current opcode makes sense: + * a) If we're inside a cont frame but no previous data frame + * + * b) If we're handling a data-frame and receive another data + * frame. (it's expected to receive only CONT or control + * frames). + * + * It is worth to note that in a), we do not need to check + * if the previous frame was FIN or not: if was FIN, an + * on_message event was triggered and this function returned; + * so the only possibility here is a previous non-FIN data + * frame, ;-). + */ + if ((wfd->frame_type == -1 && fsd.opcode == WS_FR_OP_CONT) || + (wfd->frame_type != -1 && !is_control_frame(fsd.opcode) && + fsd.opcode != WS_FR_OP_CONT)) + { + DEBUG("Unexpected frame was received!, opcode: %d, previous: %d\n", + fsd.opcode, wfd->frame_type); + wfd->error = 1; + break; + } + + /* Check if one of the valid opcodes. */ + if (!is_valid_frame(fsd.opcode)) + { + DEBUG("Unsupported frame opcode: %d\n", fsd.opcode); + /* We should consider as error receive an unknown frame. */ + wfd->frame_type = fsd.opcode; + wfd->error = 1; + break; + } + + /* Check our current state: if CLOSING, we only accept close frames. */ + if (get_client_state(wfd->client) == WS_STATE_CLOSING && + fsd.opcode != WS_FR_OP_CLSE) + { + DEBUG("Unexpected frame received, expected CLOSE (%d), " + "received: (%d)", + WS_FR_OP_CLSE, fsd.opcode); + wfd->error = 1; + break; + } + + /* Only change frame type if not a CONT frame. */ + if (fsd.opcode != WS_FR_OP_CONT && !is_control_frame(fsd.opcode)) + wfd->frame_type = fsd.opcode; + + fsd.mask = next_byte(wfd); + fsd.frame_length = fsd.mask & 0x7F; + fsd.frame_size = 0; + fsd.msg_idx_ctrl = 0; + + /* + * We should deny non-FIN control frames or that have + * more than 125 octets. + */ + if (is_control_frame(fsd.opcode) && + (!fsd.is_fin || fsd.frame_length > 125)) + { + DEBUG("Control frame bigger than 125 octets or not a FIN " + "frame!\n"); + wfd->error = 1; + break; + } + + /* Read a single frame, and then handle accordingly. */ + if (read_single_frame(wfd, &fsd) < 0) + break; + + /* Handle each frame + * Obs: If BIN, nothing should be done unless we got + * a FIN-frame. + */ + switch (fsd.opcode) { + /* UTF-8 Validate partial (or not) frame. */ + case WS_FR_OP_CONT: + case WS_FR_OP_TXT: { + validate_utf8_txt(wfd, &fsd); + break; + } + /* + * We _may_ send a PING frame if the ws_ping() routine was invoked. + * + * If the content is invalid and/or differs the size, ignore it. + * (maybe unsolicited PONG). + */ + case WS_FR_OP_PONG: { + handle_pong_frame(wfd, &fsd); + goto next_it; + break; + } + /* We should answer to a PING frame as soon as possible. */ + case WS_FR_OP_PING: { + if (handle_ping_frame(wfd, &fsd) < 0) + goto done; + break; + } + /* We interrupt the loop as soon as we find a CLOSE frame. */ + case WS_FR_OP_CLSE: { + if (handle_close_frame(wfd, &fsd) < 0) + goto done; + return (0); + break; + } + } + + next_it:; + + } while (!fsd.is_fin && !wfd->error); + + done: + /* Check for error. */ + if (wfd->error) + { + free(fsd.msg_data); + wfd->msg = NULL; + return (-1); + } + + wfd->msg = fsd.msg_data; + return (0); +} + +/** + * @brief Establishes to connection with the client and trigger + * events when occurs one. + * + * @param vclient Client connection. + * + * @return Returns @p vclient. + * + * @note This will be run on a different thread. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void *ws_establishconnection(void *vclient) +{ + struct ws_frame_data wfd; /* WebSocket frame data. */ + struct ws_connection *client; /* Client structure. */ + int clse_thrd; /* Time-out close thread. */ + + client = vclient; + + /* Prepare frame data. */ + memset(&wfd, 0, sizeof(wfd)); + wfd.client = client; + + /* Do handshake. */ + if (do_handshake(&wfd) < 0) + goto closed; + + /* Read next frame until client disconnects or an error occur. */ + while (next_complete_frame(&wfd) >= 0) + { + /* Text/binary event. */ + if ((wfd.frame_type == WS_FR_OP_TXT || + wfd.frame_type == WS_FR_OP_BIN) && !wfd.error) + { + client->ws_srv.evs.onmessage(client->client_id, wfd.msg, wfd.frame_size, + wfd.frame_type); + } + + /* Close event. */ + else if (wfd.frame_type == WS_FR_OP_CLSE && !wfd.error) + { + /* + * We only send a CLOSE frame once, if we're already + * in CLOSING state, there is no need to send. + */ + if (get_client_state(client) != WS_STATE_CLOSING) + { + set_client_state(client, WS_STATE_CLOSING); + + /* We only send a close frameSend close frame */ + do_close(&wfd, -1); + } + + free(wfd.msg); + break; + } + + free(wfd.msg); + } + + /* + * on_close events always occur, whether for client closure + * or server closure, as the server is expected to + * always know when the client disconnects. + */ + client->ws_srv.evs.onclose(client->client_id); + + closed: + clse_thrd = client->close_thrd; + + /* Wait for timeout thread if necessary. */ + if (clse_thrd) + { + pthread_cond_signal(&client->cnd_state_close); + pthread_join(client->thrd_tout, NULL); + } + + /* Close connectin properly. */ + if (get_client_state(client) != WS_STATE_CLOSED) { + DEBUG("Closing: normal close\n"); + close_client(client, 1); + } + + return (vclient); +} + +/** + * Accept parameters. + */ +struct ws_accept_params +{ + int sock; + struct ws_server ws_srv; +}; + +/** + * @brief Main loop that keeps accepting new connections. + * + * @param data Server socket. + * + * @return Returns @p data. + * + * @note This may be run on a different thread. + * + * @attention This is part of the internal API and is documented just + * for completeness. + */ +static void *ws_accept(void *data) +{ + struct ws_accept_params *ws_prm; /* wsServer parameters. */ + struct sockaddr_storage sa; /* Client. */ + pthread_t client_thread; /* Client thread. */ + struct timeval time; /* Client socket timeout. */ + socklen_t salen; /* Length of sockaddr. */ + int new_sock; /* New opened connection. */ + int sock; /* Server sock. */ + int i; /* Loop index. */ + + ws_prm = data; + sock = ws_prm->sock; + salen = sizeof(sa); + + while (1) + { + /* Accept. */ + new_sock = accept(sock, (struct sockaddr *)&sa, &salen); + if (new_sock < 0) + panic("Error on accepting connections.."); + + if (timeout) + { + time.tv_sec = timeout / 1000; + time.tv_usec = (timeout % 1000) * 1000; + + /* + * Socket timeout + * This feature seems to be supported on Linux, Windows, + * macOS and FreeBSD. + * + * See: + * https://linux.die.net/man/3/setsockopt + */ + setsockopt(new_sock, SOL_SOCKET, SO_SNDTIMEO, (const char*)&time, + sizeof(struct timeval)); + } + + /* Adds client socket to socks list. */ + pthread_mutex_lock(&mutex); + for (i = 0; i < MAX_CLIENTS; i++) + { + if (client_socks[i].client_sock == -1) + { + memcpy(&client_socks[i].ws_srv, &ws_prm->ws_srv, + sizeof(struct ws_server)); + + client_socks[i].client_sock = new_sock; + client_socks[i].state = WS_STATE_CONNECTING; + client_socks[i].close_thrd = false; + client_socks[i].last_pong_id = -1; + client_socks[i].current_ping_id = -1; + client_socks[i].client_id = get_next_cid(); + set_client_address(&client_socks[i]); + + if (pthread_mutex_init(&client_socks[i].mtx_state, NULL)) + panic("Error on allocating close mutex"); + if (pthread_cond_init(&client_socks[i].cnd_state_close, NULL)) + panic("Error on allocating condition var\n"); + if (pthread_mutex_init(&client_socks[i].mtx_snd, NULL)) + panic("Error on allocating send mutex"); + if (pthread_mutex_init(&client_socks[i].mtx_ping, NULL)) + panic("Error on allocating ping/pong mutex"); + break; + } + } + pthread_mutex_unlock(&mutex); + + /* Client socket added to socks list ? */ + if (i != MAX_CLIENTS) + { + if (pthread_create( + &client_thread, NULL, ws_establishconnection, &client_socks[i])) + panic("Could not create the client thread!"); + + pthread_detach(client_thread); + } + else + close_socket(new_sock); + } + + free(data); + return (data); +} + +/** + * @brief By using the server parameters provided in @p ws_srv, + * create a socket and bind it accordingly with the server + * configurations. + * + * @param ws_srv Web Socket configurations. + * + * @return Returns the socket file descriptor. + */ +static int do_bind_socket(struct ws_server *ws_srv) +{ + struct addrinfo hints, *results, *try; + char port[8] = {0}; + int reuse; + int sock; + + reuse = 1; + + /* Prepare the getaddrinfo structure. */ + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_flags = AI_PASSIVE; + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + /* Port. */ + snprintf(port, sizeof port - 1, "%d", ws_srv->port); + + if (getaddrinfo(ws_srv->host, port, &hints, &results) != 0) + panic("getaddrinfo() failed"); + + /* Try to create a socket with one of the returned addresses. */ + for (try = results; try != NULL; try = try->ai_next) + { + /* try to make a socket with this setup */ + if ((sock = socket(try->ai_family, try->ai_socktype, + try->ai_protocol)) < 0) + { + continue; + } + + /* Reuse previous address. */ + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse, + sizeof(reuse)) < 0) + { + panic("setsockopt(SO_REUSEADDR) failed"); + } + + /* Bind. */ + if (bind(sock, try->ai_addr, try->ai_addrlen) < 0) + panic("Bind failed"); + + /* if it worked, we're done. */ + break; + } + + freeaddrinfo(results); + + /* Check if binded with success. */ + if (try == NULL) + panic("couldn't find a port to bind to"); + + return (sock); +} + +/** + * @brief Main loop for the server. + * + * @param ws_srv Web Socket server parameters. + * + * @return If @p thread_loop != 0, returns 0. Otherwise, never + * returns. + */ +int ws_socket(struct ws_server *ws_srv) +{ + struct ws_accept_params *ws_prm; /* Accept parameters. */ + pthread_t accept_thread; /* Accept thread. */ + int sock; /* Client sock. */ + + timeout = ws_srv->timeout_ms; + + /* Ignore 'unused functions' warnings. */ + ((void)skip_frame); + + /* Allocates our parameters data and copy the ws_server structure. */ + ws_prm = malloc(sizeof(*ws_prm)); + if (!ws_prm) + panic("Unable to allocate ws parameters, out of memory!\n"); + + memcpy(&ws_prm->ws_srv, ws_srv, sizeof(*ws_srv)); + +#ifdef _WIN32 + WSADATA wsaData; + if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) + panic("WSAStartup failed!"); + + /** + * Sets stdout to be non-buffered. + * + * According to the docs from MSDN (setvbuf page), Windows do not + * really supports line buffering but full-buffering instead. + * + * Quote from the docs: + * "... _IOLBF For some systems, this provides line buffering. + * However, for Win32, the behavior is the same as _IOFBF" + */ + setvbuf(stdout, NULL, _IONBF, 0); +#endif + + /* Create socket and bind. */ + sock = do_bind_socket(ws_srv); + + /* Listen. */ + if (listen(sock, MAX_CLIENTS) < 0) + panic("Unable to listen!\n"); + + /* Wait for incoming connections. */ + printf("Waiting for incoming connections...\n"); + memset(client_socks, -1, sizeof(client_socks)); + + /* Accept connections. */ + ws_prm->sock = sock; + + if (!ws_srv->thread_loop) + ws_accept(ws_prm); + else + { + if (pthread_create(&accept_thread, NULL, ws_accept, (void *)ws_prm)) + panic("Could not create the client thread!"); + pthread_detach(accept_thread); + } + + return (0); +} + +#ifdef AFL_FUZZ +/** + * @brief WebSocket fuzzy test routine + * + * @param evs Events structure. + * + * @param file File to be read. + * + * @return Returns 0, or crash. + * + * @note This is a 'fuzzy version' of the function @ref ws_socket. + * This routine do not listen to any port nor accept multiples + * connections. It is intended to read a stream of frames through a + * file and process it as if they are coming from a socket. + * + * This behavior enables us to test wsServer against fuzzers, like + * AFL, and see if it crashes, hangs or behaves normally, even under + * weird conditions. + */ +int ws_file(struct ws_events *evs, const char *file) +{ + int sock; + sock = open(file, O_RDONLY); + if (sock < 0) + panic("Invalid file\n"); + + /* Copy events. */ + memcpy(&cli_events, evs, sizeof(struct ws_events)); + + /* Clear client socks list. */ + memset(client_socks, -1, sizeof(client_socks)); + + /* Set client settings. */ + client_socks[0].client_sock = sock; + client_socks[0].state = WS_STATE_CONNECTING; + client_socks[0].close_thrd = false; + + /* Initialize mutexes. */ + if (pthread_mutex_init(&client_socks[0].mtx_state, NULL)) + panic("Error on allocating close mutex"); + if (pthread_cond_init(&client_socks[0].cnd_state_close, NULL)) + panic("Error on allocating condition var\n"); + if (pthread_mutex_init(&client_socks[0].mtx_snd, NULL)) + panic("Error on allocating send mutex"); + if (pthread_mutex_init(&client_socks[0].mtx_ping, NULL)) + panic("Error on allocating ping/pong mutex"); + + ws_establishconnection(&client_socks[0]); + return (0); +} +#endif |