ws.h

Go to the documentation of this file.

/*
 * 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/>
 */
 
#ifndef WS_H
#define WS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
                #include <stdbool.h>
                #include <stdint.h>
                #include <inttypes.h>
 
#ifndef MAX_CLIENTS
                #define MAX_CLIENTS    8
#endif
 
                #define MESSAGE_LENGTH 2048
 
                #define MAX_FRAME_LENGTH (16*1024*1024)
 
                #define WS_KEY_LEN     24
 
                #define WS_MS_LEN      36
 
                #define WS_KEYMS_LEN   (WS_KEY_LEN + WS_MS_LEN)
 
                #define MAGIC_STRING   "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
 
                #define WS_HS_REQ      "Sec-WebSocket-Key"
 
                #define WS_HS_ACCLEN   130
 
                #define WS_HS_ACCEPT                       \
                                "HTTP/1.1 101 Switching Protocols\r\n" \
                                "Upgrade: websocket\r\n"               \
                                "Connection: Upgrade\r\n"              \
                                "Sec-WebSocket-Accept: "
 
                #define WS_FIN      128
 
                #define WS_FIN_SHIFT  7
 
                #define WS_FR_OP_CONT 0
 
                #define WS_FR_OP_TXT  1
 
                #define WS_FR_OP_BIN  2
 
                #define WS_FR_OP_CLSE 8
 
                #define WS_FR_OP_PING 0x9
 
                #define WS_FR_OP_PONG 0xA
 
                #define WS_FR_OP_UNSUPPORTED 0xF
 
                #define WS_CLSE_NORMAL  1000
 
                #define WS_CLSE_PROTERR 1002
 
                #define WS_CLSE_INVUTF8 1007
 
                #define WS_STATE_CONNECTING 0
 
                #define WS_STATE_OPEN       1
 
                #define WS_STATE_CLOSING    2
 
                #define WS_STATE_CLOSED     3
 
                #define MS_TO_NS(x) ((x)*1000000)
 
                #define TIMEOUT_MS (500)
 
                #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 struct ws_connection ws_cli_conn_t;
 
                /* Opaque server instance type. */
                typedef struct ws_server ws_server_t;
 
                void *ws_get_server_context(ws_cli_conn_t *cli);
 
                void ws_set_connection_context(ws_cli_conn_t *cli, void *ptr);
 
                void *ws_get_connection_context(ws_cli_conn_t *cli);
 
                struct ws_events
                {
                                void (*onopen)(ws_cli_conn_t *client);
                                void (*onclose)(ws_cli_conn_t *client);
                                void (*onmessage)(ws_cli_conn_t *client,
                                                const unsigned char *msg, uint64_t msg_size, int type);
                };
 
                struct ws_server
                {
                                const char *host;
                                uint16_t port;
                                int thread_loop;
                                uint32_t timeout_ms;
                                struct ws_events evs;
                                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 *cli, 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 *cli, const char *msg);
                extern int ws_sendframe_txt_bcast(uint16_t port, const char *msg);
                extern int ws_sendframe_bin(ws_cli_conn_t *cli, 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 *cli);
                extern int ws_close_client(ws_cli_conn_t *cli);
                extern int ws_socket(struct ws_server *ws_srv);
 
                /* Ping routines. */
                extern void ws_ping(ws_cli_conn_t *cli, int threshold);
 
#ifdef AFL_FUZZ
                extern int ws_file(struct ws_events *evs, const char *file);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* WS_H */