/*
* libwebsockets - small server side websockets and web server implementation
*
- * Copyright (C) 2010 - 201
3 Andy Green <andy@warmcat.com>
+ * Copyright (C) 2010 - 201
6 Andy Green <andy@warmcat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include <limits.h>
#include <stdarg.h>
#include <assert.h>
+#if LWS_MAX_SMP > 1
+#include <pthread.h>
+#endif
#ifdef LWS_HAVE_SYS_STAT_H
#include <sys/stat.h>
#define MSG_NOSIGNAL 0
#define SHUT_RDWR SD_BOTH
#define SOL_TCP IPPROTO_TCP
+#define SHUT_WR SD_SEND
#define compatible_close(fd) closesocket(fd)
-#define compatible_file_close(fd) CloseHandle(fd)
-#define compatible_file_seek_cur(fd, offset) \
- SetFilePointer(fd, offset, NULL, FILE_CURRENT)
-#define compatible_file_read(amount, fd, buf, len) {\
- DWORD _amount; \
- if (!ReadFile(fd, buf, len, &_amount, NULL)) \
- amount = -1; \
- else \
- amount = _amount; \
- }
-#define lws_set_blocking_send(wsi) wsi->sock_send_blocking = TRUE
+#define lws_set_blocking_send(wsi) wsi->sock_send_blocking = 1
#define lws_socket_is_valid(x) (!!x)
-#define LWS_SOCK_INVALID 0
+#define LWS_SOCK_INVALID 0
#include <winsock2.h>
+#include <ws2tcpip.h>
#include <windows.h>
#include <tchar.h>
#ifdef LWS_HAVE_IN6ADDR_H
#ifdef _WIN32_WCE
#define vsnprintf _vsnprintf
+#else
+#ifdef LWS_HAVE__VSNPRINTF
+#define vsnprintf _vsnprintf
+#endif
+#endif
+
+#ifdef LWS_HAVE__SNPRINTF
+#define lws_snprintf _snprintf
#endif
-#define LWS_INVALID_FILE INVALID_HANDLE_VALUE
#else /* not windows --> */
#include <fcntl.h>
#endif
#if defined (__ANDROID__)
#include <syslog.h>
+#include <sys/resource.h>
#else
#include <sys/syslog.h>
#endif
#include <poll.h>
#ifdef LWS_USE_LIBEV
#include <ev.h>
-#endif /* LWS_USE_LIBEV */
+#endif
+#ifdef LWS_USE_LIBUV
+#include <uv.h>
+#endif
#include <sys/mman.h>
#endif /* MBED */
#define LWS_EINTR EINTR
#define LWS_EISCONN EISCONN
#define LWS_EWOULDBLOCK EWOULDBLOCK
-#define LWS_INVALID_FILE -1
#define LWS_POLLHUP (POLLHUP|POLLERR)
#define LWS_POLLIN (POLLIN)
#define LWS_POLLOUT (POLLOUT)
#define compatible_close(fd) close(fd)
-#define compatible_file_close(fd) close(fd)
-#define compatible_file_seek_cur(fd, offset) lseek(fd, offset, SEEK_CUR)
-#define compatible_file_read(amount, fd, buf, len) \
- amount = read(fd, buf, len);
#define lws_set_blocking_send(wsi)
#ifdef MBED_OPERATORS
#endif
#endif
+#include <stddef.h>
+
+#ifndef container_of
+#define container_of(P,T,M) ((T *)((char *)(P) - offsetof(T, M)))
+#endif
+
#else
#include <sys/stat.h>
-#include <sys/cdefs.h>
#include <sys/time.h>
#if defined(__APPLE__)
#endif
#endif
-#ifndef LWS_MAX_HEADER_LEN
-#define LWS_MAX_HEADER_LEN 1024
+#ifndef LWS_DEF_HEADER_LEN
+#define LWS_DEF_HEADER_LEN 1024
+#endif
+#ifndef LWS_DEF_HEADER_POOL
+#define LWS_DEF_HEADER_POOL 16
#endif
#ifndef LWS_MAX_PROTOCOLS
#define LWS_MAX_PROTOCOLS 5
#endif
#ifndef LWS_MAX_EXTENSIONS_ACTIVE
-#define LWS_MAX_EXTENSIONS_ACTIVE 3
+#define LWS_MAX_EXTENSIONS_ACTIVE 2
+#endif
+#ifndef LWS_MAX_EXT_OFFERS
+#define LWS_MAX_EXT_OFFERS 8
#endif
#ifndef SPEC_LATEST_SUPPORTED
#define SPEC_LATEST_SUPPORTED 13
#endif
#ifndef AWAITING_TIMEOUT
-#define AWAITING_TIMEOUT 5
+#define AWAITING_TIMEOUT 20
#endif
#ifndef CIPHERS_LIST_STRING
#define CIPHERS_LIST_STRING "DEFAULT"
#ifndef SYSTEM_RANDOM_FILEPATH
#define SYSTEM_RANDOM_FILEPATH "/dev/urandom"
#endif
-#ifndef LWS_MAX_ZLIB_CONN_BUFFER
-#define LWS_MAX_ZLIB_CONN_BUFFER (64 * 1024)
-#endif
-
-/*
- * if not in a connection storm, check for incoming
- * connections this many normal connection services
- */
-#define LWS_LISTEN_SERVICE_MODULO 10
enum lws_websocket_opcodes_07 {
- LWS_WS_OPCODE_07__CONTINUATION = 0,
- LWS_WS_OPCODE_07__TEXT_FRAME = 1,
- LWS_WS_OPCODE_07__BINARY_FRAME = 2,
+ LWSWSOPC_CONTINUATION = 0,
+ LWSWSOPC_TEXT_FRAME = 1,
+ LWSWSOPC_BINARY_FRAME = 2,
- LWS_WS_OPCODE_07__NOSPEC__MUX = 7,
+ LWSWSOPC_NOSPEC__MUX = 7,
/* control extensions 8+ */
- LWS_WS_OPCODE_07__CLOSE = 8,
- LWS_WS_OPCODE_07__PING = 9,
- LWS_WS_OPCODE_07__PONG = 0xa,
+ LWSWSOPC_CLOSE = 8,
+ LWSWSOPC_PING = 9,
+ LWSWSOPC_PONG = 0xa,
};
enum lws_connection_states {
- WSI_STATE_HTTP,
- WSI_STATE_HTTP_ISSUING_FILE,
- WSI_STATE_HTTP_HEADERS,
- WSI_STATE_HTTP_BODY,
- WSI_STATE_DEAD_SOCKET,
- WSI_STATE_ESTABLISHED,
- WSI_STATE_CLIENT_UNCONNECTED,
- WSI_STATE_RETURNED_CLOSE_ALREADY,
- WSI_STATE_AWAITING_CLOSE_ACK,
- WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE,
-
- WSI_STATE_HTTP2_AWAIT_CLIENT_PREFACE,
- WSI_STATE_HTTP2_ESTABLISHED_PRE_SETTINGS,
- WSI_STATE_HTTP2_ESTABLISHED,
+ LWSS_HTTP,
+ LWSS_HTTP_ISSUING_FILE,
+ LWSS_HTTP_HEADERS,
+ LWSS_HTTP_BODY,
+ LWSS_DEAD_SOCKET,
+ LWSS_ESTABLISHED,
+ LWSS_CLIENT_UNCONNECTED,
+ LWSS_RETURNED_CLOSE_ALREADY,
+ LWSS_AWAITING_CLOSE_ACK,
+ LWSS_FLUSHING_STORED_SEND_BEFORE_CLOSE,
+ LWSS_SHUTDOWN,
+
+ LWSS_HTTP2_AWAIT_CLIENT_PREFACE,
+ LWSS_HTTP2_ESTABLISHED_PRE_SETTINGS,
+ LWSS_HTTP2_ESTABLISHED,
};
enum http_version {
enum lws_rx_parse_state {
LWS_RXPS_NEW,
- LWS_RXPS_04_MASK_NONCE_1,
- LWS_RXPS_04_MASK_NONCE_2,
- LWS_RXPS_04_MASK_NONCE_3,
+ LWS_RXPS_04_mask_1,
+ LWS_RXPS_04_mask_2,
+ LWS_RXPS_04_mask_3,
LWS_RXPS_04_FRAME_HDR_1,
LWS_RXPS_04_FRAME_HDR_LEN,
enum connection_mode {
- LWS_CONNMODE_HTTP_SERVING,
- LWS_CONNMODE_HTTP_SERVING_ACCEPTED, /* actual HTTP service going on */
- LWS_CONNMODE_PRE_WS_SERVING_ACCEPT,
+ LWSCM_HTTP_SERVING,
+ LWSCM_HTTP_SERVING_ACCEPTED, /* actual HTTP service going on */
+ LWSCM_PRE_WS_SERVING_ACCEPT,
- LWS_CONNMODE_WS_SERVING,
- LWS_CONNMODE_WS_CLIENT,
-
- LWS_CONNMODE_HTTP2_SERVING,
+ LWSCM_WS_SERVING,
+ LWSCM_WS_CLIENT,
+
+ LWSCM_HTTP2_SERVING,
/* transient, ssl delay hiding */
- LWS_CONNMODE_SSL_ACK_PENDING,
+ LWSCM_SSL_ACK_PENDING,
+ LWSCM_SSL_INIT,
/* transient modes */
- LWS_CONNMODE_WS_CLIENT_WAITING_CONNECT,
- LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY,
- LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE,
- LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE2,
- LWS_CONNMODE_WS_CLIENT_WAITING_SSL,
- LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY,
- LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT,
- LWS_CONNMODE_WS_CLIENT_PENDING_CANDIDATE_CHILD,
+ LWSCM_WSCL_WAITING_CONNECT,
+ LWSCM_WSCL_WAITING_PROXY_REPLY,
+ LWSCM_WSCL_ISSUE_HANDSHAKE,
+ LWSCM_WSCL_ISSUE_HANDSHAKE2,
+ LWSCM_WSCL_WAITING_SSL,
+ LWSCM_WSCL_WAITING_SERVER_REPLY,
+ LWSCM_WSCL_WAITING_EXTENSION_CONNECT,
+ LWSCM_WSCL_PENDING_CANDIDATE_CHILD,
/* special internal types */
- LWS_CONNMODE_SERVER_LISTENER,
+ LWSCM_SERVER_LISTENER,
};
enum {
LWS_RXFLOW_PENDING_CHANGE = (1 << 1),
};
+/* this is not usable directly by user code any more, lws_close_reason() */
+#define LWS_WRITE_CLOSE 4
+
struct lws_protocols;
struct lws;
-#ifdef LWS_USE_LIBEV
+#if defined(LWS_USE_LIBEV) || defined(LWS_USE_LIBUV)
+
struct lws_io_watcher {
- struct ev_io watcher;
- struct lws_context* context;
+#ifdef LWS_USE_LIBEV
+ ev_io ev_watcher;
+#endif
+#ifdef LWS_USE_LIBUV
+ uv_poll_t uv_watcher;
+#endif
+ struct lws_context *context;
};
struct lws_signal_watcher {
- struct ev_signal watcher;
- struct lws_context* context;
+#ifdef LWS_USE_LIBEV
+ ev_signal ev_watcher;
+#endif
+#ifdef LWS_USE_LIBUV
+ uv_signal_t uv_watcher;
+#endif
+ struct lws_context *context;
};
-#endif /* LWS_USE_LIBEV */
+#endif
#ifdef _WIN32
#define LWS_FD_HASH(fd) ((fd ^ (fd >> 8) ^ (fd >> 16)) % FD_HASHTABLE_MODULUS)
};
#endif
-struct lws_context {
+/*
+ * This is totally opaque to code using the library. It's exported as a
+ * forward-reference pointer-only declaration; the user can use the pointer with
+ * other APIs to get information out of it.
+ */
+
+struct lws_fragments {
+ unsigned short offset;
+ unsigned short len;
+ unsigned char nfrag; /* which ah->frag[] continues this content, or 0 */
+};
+
+/*
+ * these are assigned from a pool held in the context.
+ * Both client and server mode uses them for http header analysis
+ */
+
+struct allocated_headers {
+ struct lws *wsi; /* owner */
+ char *data; /* prepared by context init to point to dedicated storage */
+ /*
+ * the randomly ordered fragments, indexed by frag_index and
+ * lws_fragments->nfrag for continuation.
+ */
+ struct lws_fragments frags[WSI_TOKEN_COUNT * 2];
+ time_t assigned;
+ /*
+ * for each recognized token, frag_index says which frag[] his data
+ * starts in (0 means the token did not appear)
+ * the actual header data gets dumped as it comes in, into data[]
+ */
+ unsigned char frag_index[WSI_TOKEN_COUNT];
+ unsigned char rx[2048];
+ unsigned int rxpos;
+ unsigned int rxlen;
+
+#ifndef LWS_NO_CLIENT
+ char initial_handshake_hash_base64[30];
+ unsigned short c_port;
+#endif
+
+ unsigned short pos;
+ unsigned char in_use;
+ unsigned char nfrag;
+};
+
+/*
+ * so we can have n connections being serviced simultaneously,
+ * these things need to be isolated per-thread.
+ */
+
+struct lws_context_per_thread {
+#if LWS_MAX_SMP > 1
+ pthread_mutex_t lock;
+#endif
+ struct lws_pollfd *fds;
+ struct lws *rx_draining_ext_list;
+ struct lws *tx_draining_ext_list;
+ struct lws *timeout_list;
+ struct lws_context *context;
+ void *http_header_data;
+ struct allocated_headers *ah_pool;
+ struct lws *ah_wait_list;
+ int ah_wait_list_length;
+#ifdef LWS_OPENSSL_SUPPORT
+ struct lws *pending_read_list; /* linked list */
+#endif
+#ifndef LWS_NO_SERVER
+ struct lws *wsi_listening;
+#endif
+#if defined(LWS_USE_LIBEV)
+ struct ev_loop *io_loop_ev;
+#endif
+#if defined(LWS_USE_LIBUV)
+ uv_loop_t *io_loop_uv;
+ uv_signal_t signals[8];
+ uv_timer_t uv_timeout_watcher;
+ uv_idle_t uv_idle;
+#endif
+#if defined(LWS_USE_LIBEV)
+ struct lws_io_watcher w_accept;
+#endif
+#if defined(LWS_USE_LIBEV) || defined(LWS_USE_LIBUV)
+ struct lws_signal_watcher w_sigint;
+ unsigned char ev_loop_foreign:1;
+#endif
+ lws_sockfd_type lserv_fd;
+
+ unsigned long count_conns;
+ /*
+ * usable by anything in the service code, but only if the scope
+ * does not last longer than the service action (since next service
+ * of any socket can likewise use it and overwrite)
+ */
+ unsigned char *serv_buf;
#ifdef _WIN32
WSAEVENT *events;
+#else
+ int dummy_pipe_fds[2];
#endif
- struct lws_pollfd *fds;
+ unsigned int fds_count;
+
+ short ah_count_in_use;
+ unsigned char tid;
+};
+
+/*
+ * the rest is managed per-context, that includes
+ *
+ * - processwide single fd -> wsi lookup
+ * - contextwide headers pool
+ * - contextwide ssl context
+ * - contextwide proxy
+ */
+
+struct lws_context {
+ time_t last_timeout_check_s;
+ struct lws_plat_file_ops fops;
+ struct lws_context_per_thread pt[LWS_MAX_SMP];
#ifdef _WIN32
/* different implementation between unix and windows */
struct lws_fd_hashtable fd_hashtable[FD_HASHTABLE_MODULUS];
#else
struct lws **lws_lookup; /* fd to wsi */
#endif
- int fds_count;
-#ifdef LWS_USE_LIBEV
- struct ev_loop* io_loop;
- struct lws_io_watcher w_accept;
- struct lws_signal_watcher w_sigint;
- lws_ev_signal_cb* lws_ev_sigint_cb;
- int use_ev_sigint;
-#endif /* LWS_USE_LIBEV */
- int max_fds;
- int listen_port;
const char *iface;
+ const struct lws_token_limits *token_limits;
+ void *user_space;
+
+ const struct lws_protocols *protocols;
+
+#ifdef LWS_OPENSSL_SUPPORT
+ SSL_CTX *ssl_ctx;
+ SSL_CTX *ssl_client_ctx;
+#endif
+#ifndef LWS_NO_EXTENSIONS
+ const struct lws_extension *extensions;
+#endif
+#if defined(LWS_USE_LIBEV)
+ lws_ev_signal_cb_t * lws_ev_sigint_cb;
+#endif
+#if defined(LWS_USE_LIBUV)
+ lws_uv_signal_cb_t * lws_uv_sigint_cb;
+#endif
char http_proxy_address[128];
- char canonical_hostname[128];
char proxy_basic_auth_token[128];
- unsigned int http_proxy_port;
- unsigned int options;
- time_t last_timeout_check_s;
-
- /*
- * usable by anything in the service code, but only if the scope
- * does not last longer than the service action (since next service
- * of any socket can likewise use it and overwrite)
- */
- unsigned char service_buffer[LWS_MAX_SOCKET_IO_BUF];
+ char canonical_hostname[128];
+#ifdef LWS_LATENCY
+ unsigned long worst_latency;
+ char worst_latency_info[256];
+#endif
+ int max_fds;
+ int listen_port;
+#if defined(LWS_USE_LIBEV) || defined(LWS_USE_LIBUV)
+ int use_ev_sigint;
+#endif
int started_with_parent;
int fd_random;
- int listen_service_modulo;
- int listen_service_count;
- lws_sockfd_type listen_service_fd;
- int listen_service_extraseen;
+ int lserv_mod;
+ int count_wsi_allocated;
+ unsigned int http_proxy_port;
+ unsigned int options;
+ unsigned int fd_limit_per_thread;
+ unsigned int timeout_secs;
/*
* set to the Thread ID that's doing the service loop just before entry
* for pollfd event change.
*/
volatile int service_tid;
-#ifndef _WIN32
- int dummy_pipe_fds[2];
-#endif
+ int service_tid_detected;
+ int count_protocols;
int ka_time;
int ka_probes;
int ka_interval;
-#ifdef LWS_LATENCY
- unsigned long worst_latency;
- char worst_latency_info[256];
-#endif
-
#ifdef LWS_OPENSSL_SUPPORT
int use_ssl;
int allow_non_ssl_on_ssl_port;
unsigned int user_supplied_ssl_ctx:1;
- SSL_CTX *ssl_ctx;
- SSL_CTX *ssl_client_ctx;
- struct lws *pending_read_list; /* linked list */
-#define lws_ssl_anybody_has_buffered_read(ctx) (ctx->use_ssl && ctx->pending_read_list)
+#define lws_ssl_anybody_has_buffered_read(w) \
+ (w->context->use_ssl && \
+ w->context->pt[(int)w->tsi].pending_read_list)
+#define lws_ssl_anybody_has_buffered_read_tsi(c, t) \
+ (c->use_ssl && \
+ c->pt[(int)t].pending_read_list)
#else
#define lws_ssl_anybody_has_buffered_read(ctx) (0)
+#define lws_ssl_anybody_has_buffered_read_tsi(ctx, t) (0)
#endif
- struct lws_protocols *protocols;
- int count_protocols;
-#ifndef LWS_NO_EXTENSIONS
- struct lws_extension *extensions;
-#endif
- struct lws_token_limits *token_limits;
- void *user_space;
+
+ short max_http_header_data;
+ short max_http_header_pool;
+ short count_threads;
+
+ unsigned int being_destroyed:1;
+ unsigned int requested_kill:1;
};
+LWS_EXTERN void
+lws_close_free_wsi_final(struct lws *wsi);
+LWS_EXTERN void
+lws_libuv_closehandle(struct lws *wsi);
+
enum {
LWS_EV_READ = (1 << 0),
LWS_EV_WRITE = (1 << 1),
LWS_EV_START = (1 << 2),
LWS_EV_STOP = (1 << 3),
+
+ LWS_EV_PREPARE_DELETION = (1 << 31),
};
-#ifdef LWS_USE_LIBEV
-#define LWS_LIBEV_ENABLED(context) (context->options & LWS_SERVER_OPTION_LIBEV)
-LWS_EXTERN void lws_feature_status_libev(struct lws_context_creation_info *info);
+#if defined(LWS_USE_LIBEV)
LWS_EXTERN void
-lws_libev_accept(struct lws_context *context,
- struct lws *new_wsi, lws_sockfd_type accept_fd);
+lws_libev_accept(struct lws *new_wsi, lws_sockfd_type accept_fd);
LWS_EXTERN void
-lws_libev_io(struct lws_context *context,
- struct lws *wsi, int flags);
+lws_libev_io(struct lws *wsi, int flags);
LWS_EXTERN int
lws_libev_init_fd_table(struct lws_context *context);
LWS_EXTERN void
-lws_libev_run(struct lws_context *context);
+lws_libev_destroyloop(struct lws_context *context, int tsi);
+LWS_EXTERN void
+lws_libev_run(const struct lws_context *context, int tsi);
+#define LWS_LIBEV_ENABLED(context) (context->options & LWS_SERVER_OPTION_LIBEV)
+LWS_EXTERN void lws_feature_status_libev(struct lws_context_creation_info *info);
#else
+#define lws_libev_accept(_a, _b) ((void) 0)
+#define lws_libev_io(_a, _b) ((void) 0)
+#define lws_libev_init_fd_table(_a) (0)
+#define lws_libev_run(_a, _b) ((void) 0)
+#define lws_libev_destroyloop(_a, _b) ((void) 0)
#define LWS_LIBEV_ENABLED(context) (0)
-#ifdef LWS_POSIX
+#if LWS_POSIX
#define lws_feature_status_libev(_a) \
lwsl_notice("libev support not compiled in\n")
#else
#define lws_feature_status_libev(_a)
#endif
-#define lws_libev_accept(_a, _b, _c) ((void) 0)
-#define lws_libev_io(_a, _b, _c) ((void) 0)
-#define lws_libev_init_fd_table(_a) (0)
-#define lws_libev_run(_a) ((void) 0)
#endif
+#if defined(LWS_USE_LIBUV)
+LWS_EXTERN void
+lws_libuv_accept(struct lws *new_wsi, lws_sockfd_type accept_fd);
+LWS_EXTERN void
+lws_libuv_io(struct lws *wsi, int flags);
+LWS_EXTERN int
+lws_libuv_init_fd_table(struct lws_context *context);
+LWS_EXTERN void
+lws_libuv_run(const struct lws_context *context, int tsi);
+LWS_EXTERN void
+lws_libuv_destroyloop(struct lws_context *context, int tsi);
+#define LWS_LIBUV_ENABLED(context) (context->options & LWS_SERVER_OPTION_LIBUV)
+LWS_EXTERN void lws_feature_status_libuv(struct lws_context_creation_info *info);
+#else
+#define lws_libuv_accept(_a, _b) ((void) 0)
+#define lws_libuv_io(_a, _b) ((void) 0)
+#define lws_libuv_init_fd_table(_a) (0)
+#define lws_libuv_run(_a, _b) ((void) 0)
+#define lws_libuv_destroyloop(_a, _b) ((void) 0)
+#define LWS_LIBUV_ENABLED(context) (0)
+#if LWS_POSIX
+#define lws_feature_status_libuv(_a) \
+ lwsl_notice("libuv support not compiled in\n")
+#else
+#define lws_feature_status_libuv(_a)
+#endif
+#endif
+
+
#ifdef LWS_USE_IPV6
#define LWS_IPV6_ENABLED(context) \
(!(context->options & LWS_SERVER_OPTION_DISABLE_IPV6))
URIPS_SEEN_SLASH,
URIPS_SEEN_SLASH_DOT,
URIPS_SEEN_SLASH_DOT_DOT,
- URIPS_ARGUMENTS,
};
enum uri_esc_states {
URIES_SEEN_PERCENT_H1,
};
-/*
- * This is totally opaque to code using the library. It's exported as a
- * forward-reference pointer-only declaration; the user can use the pointer with
- * other APIs to get information out of it.
- */
-
-struct lws_fragments {
- unsigned short offset;
- unsigned short len;
- unsigned char next_frag_index;
-};
-
/* notice that these union members:
- *
+ *
* hdr
* http
* http2
- *
+ *
* all have a pointer to allocated_headers struct as their first member.
- *
+ *
* It means for allocated_headers access, the three union paths can all be
* used interchangeably to access the same data
*/
-struct allocated_headers {
- unsigned char next_frag_index;
- unsigned short pos;
- unsigned char frag_index[WSI_TOKEN_COUNT];
- struct lws_fragments frags[WSI_TOKEN_COUNT * 2];
- char data[LWS_MAX_HEADER_LEN];
-#ifndef LWS_NO_CLIENT
- char initial_handshake_hash_base64[30];
- unsigned short c_port;
-#endif
-};
-
struct _lws_http_mode_related {
/* MUST be first in struct */
struct allocated_headers *ah; /* mirroring _lws_header_related */
-#if defined(WIN32) || defined(_WIN32)
- HANDLE fd;
-#else
- int fd;
-#endif
+ struct lws *ah_wait_list;
+ struct lws *new_wsi_list;
unsigned long filepos;
unsigned long filelen;
+ lws_filefd_type fd;
enum http_version request_version;
enum http_connection_type connection_type;
LWS_HTTP2_SETTINGS__INITIAL_WINDOW_SIZE,
LWS_HTTP2_SETTINGS__MAX_FRAME_SIZE,
LWS_HTTP2_SETTINGS__MAX_HEADER_LIST_SIZE,
-
+
LWS_HTTP2_SETTINGS__COUNT /* always last */
};
LWS_HTTP2_FRAME_TYPE_GOAWAY,
LWS_HTTP2_FRAME_TYPE_WINDOW_UPDATE,
LWS_HTTP2_FRAME_TYPE_CONTINUATION,
-
+
LWS_HTTP2_FRAME_TYPE_COUNT /* always last */
};
};
enum http2_hpack_state {
-
+
/* optional before first header block */
HPKS_OPT_PADDING,
HKPS_OPT_E_DEPENDENCY,
HKPS_OPT_WEIGHT,
-
+
/* header block */
HPKS_TYPE,
-
+
HPKS_IDX_EXT,
-
+
HPKS_HLEN,
HPKS_HLEN_EXT,
HPKS_DATA,
-
+
/* optional after last header block */
HKPS_OPT_DISCARD_PADDING,
};
};
struct _lws_http2_related {
- /*
+ /*
* having this first lets us also re-use all HTTP union code
* and in turn, http_mode_related has allocated headers in right
* place so we can use the header apis on the wsi directly still
struct http2_settings my_settings;
struct http2_settings peer_settings;
-
+
struct lws *parent_wsi;
struct lws *next_child_wsi;
struct hpack_dynamic_table *hpack_dyn_table;
-
+ struct lws *stream_wsi;
+ unsigned char ping_payload[8];
+ unsigned char one_setting[LWS_HTTP2_SETTINGS_LENGTH];
+
unsigned int count;
-
- /* frame */
unsigned int length;
unsigned int stream_id;
- struct lws *stream_wsi;
- unsigned char type;
- unsigned char flags;
- unsigned char frame_state;
- unsigned char padding;
-
- unsigned char ping_payload[8];
-
- unsigned short round_robin_POLLOUT;
- unsigned short count_POLLOUT_children;
+ enum http2_hpack_state hpack;
+ enum http2_hpack_type hpack_type;
+ unsigned int header_index;
+ unsigned int hpack_len;
+ unsigned int hpack_e_dep;
+ int tx_credit;
+ unsigned int my_stream_id;
+ unsigned int child_count;
+ int my_priority;
unsigned int END_STREAM:1;
unsigned int END_HEADERS:1;
unsigned int GOING_AWAY;
unsigned int requested_POLLOUT:1;
unsigned int waiting_tx_credit:1;
+ unsigned int huff:1;
+ unsigned int value:1;
- /* hpack */
- enum http2_hpack_state hpack;
- enum http2_hpack_type hpack_type;
- unsigned int header_index;
- unsigned int hpack_len;
+ unsigned short round_robin_POLLOUT;
+ unsigned short count_POLLOUT_children;
unsigned short hpack_pos;
+
+ unsigned char type;
+ unsigned char flags;
+ unsigned char frame_state;
+ unsigned char padding;
unsigned char hpack_m;
- unsigned int hpack_e_dep;
- unsigned int huff:1;
- unsigned int value:1;
-
- /* negative credit is mandated by the spec */
- int tx_credit;
- unsigned int my_stream_id;
- unsigned int child_count;
- int my_priority;
unsigned char initialized;
- unsigned char one_setting[LWS_HTTP2_SETTINGS_LENGTH];
};
#define HTTP2_IS_TOPLEVEL_WSI(wsi) (!wsi->u.http2.parent_wsi)
struct _lws_header_related {
/* MUST be first in struct */
struct allocated_headers *ah;
- short lextable_pos;
- unsigned short current_token_limit;
- unsigned char parser_state; /* enum lws_token_indexes */
+ struct lws *ah_wait_list;
enum uri_path_states ups;
enum uri_esc_states ues;
+ short lextable_pos;
+ unsigned short current_token_limit;
char esc_stash;
+ char post_literal_equal;
+ unsigned char parser_state; /* enum lws_token_indexes */
+ char redirects;
};
struct _lws_websocket_related {
- char *rx_user_buffer;
- unsigned int rx_user_buffer_head;
- unsigned char frame_masking_nonce_04[4];
- unsigned char frame_mask_index;
+ /* cheapest way to deal with ah overlap with ws union transition */
+ struct _lws_header_related hdr;
+ char *rx_ubuf;
+ unsigned int rx_ubuf_alloc;
+ struct lws *rx_draining_ext_list;
+ struct lws *tx_draining_ext_list;
size_t rx_packet_length;
+ unsigned int rx_ubuf_head;
+ unsigned char mask[4];
+ /* Also used for close content... control opcode == < 128 */
+ unsigned char ping_payload_buf[128 - 3 + LWS_PRE];
+
+ unsigned char ping_payload_len;
+ unsigned char mask_idx;
unsigned char opcode;
- unsigned int final:1;
unsigned char rsv;
+ unsigned char rsv_first_msg;
+ /* zero if no info, or length including 2-byte close code */
+ unsigned char close_in_ping_buffer_len;
+ unsigned char utf8;
+ unsigned char stashed_write_type;
+ unsigned char tx_draining_stashed_wp;
+
+ unsigned int final:1;
unsigned int frame_is_binary:1;
unsigned int all_zero_nonce:1;
- short close_reason; /* enum lws_close_status */
-
unsigned int this_frame_masked:1;
unsigned int inside_frame:1; /* next write will be more of frame */
unsigned int clean_buffer:1; /* buffer not rewritten by extension */
unsigned int payload_is_close:1; /* process as PONG, but it is close */
-
- unsigned char *ping_payload_buf; /* non-NULL if malloc'd */
- unsigned int ping_payload_alloc; /* length malloc'd */
- unsigned int ping_payload_len;
- unsigned char ping_pending_flag;
+ unsigned int ping_pending_flag:1;
+ unsigned int continuation_possible:1;
+ unsigned int owed_a_fin:1;
+ unsigned int check_utf8:1;
+ unsigned int defeat_check_utf8:1;
+ unsigned int pmce_compressed_message:1;
+ unsigned int stashed_write_pending:1;
+ unsigned int rx_draining_ext:1;
+ unsigned int tx_draining_ext:1;
};
struct lws {
- /* lifetime members */
-
-#ifdef LWS_USE_LIBEV
- struct lws_io_watcher w_read;
- struct lws_io_watcher w_write;
-#endif /* LWS_USE_LIBEV */
- const struct lws_protocols *protocol;
-#ifndef LWS_NO_EXTENSIONS
- struct lws_extension *active_extensions[LWS_MAX_EXTENSIONS_ACTIVE];
- void *active_extensions_user[LWS_MAX_EXTENSIONS_ACTIVE];
- unsigned char count_active_extensions;
- unsigned int extension_data_pending:1;
-#endif
- unsigned char ietf_spec_revision;
- enum lws_pending_protocol_send pps;
-
- char mode; /* enum connection_mode */
- char state; /* enum lws_connection_states */
- char lws_rx_parse_state; /* enum lws_rx_parse_state */
- char rx_frame_type; /* enum lws_write_protocol */
-
- unsigned int hdr_parsing_completed:1;
- unsigned int user_space_externally_allocated:1;
- unsigned int socket_is_permanently_unusable:1;
-
- char pending_timeout; /* enum pending_timeout */
- time_t pending_timeout_limit;
- lws_sockfd_type sock;
- int position_in_fds_table;
-#ifdef LWS_LATENCY
- unsigned long action_start;
- unsigned long latency_start;
-#endif
- /* rxflow handling */
- unsigned char *rxflow_buffer;
- int rxflow_len;
- int rxflow_pos;
- unsigned int rxflow_change_to:2;
-
- /* truncated send handling */
- unsigned char *truncated_send_malloc; /* non-NULL means buffering in progress */
- unsigned int truncated_send_allocation; /* size of malloc */
- unsigned int truncated_send_offset; /* where we are in terms of spilling */
- unsigned int truncated_send_len; /* how much is buffered */
-
- void *user_space;
-
+ /* structs */
/* members with mutually exclusive lifetimes are unionized */
union u {
struct _lws_websocket_related ws;
} u;
+ /* lifetime members */
+
+#if defined(LWS_USE_LIBEV) || defined(LWS_USE_LIBUV)
+ struct lws_io_watcher w_read;
+#endif
+#if defined(LWS_USE_LIBEV)
+ struct lws_io_watcher w_write;
+#endif
+ time_t pending_timeout_limit;
+
+ /* pointers */
+
+ struct lws_context *context;
+ const struct lws_protocols *protocol;
+ struct lws *timeout_list;
+ struct lws **timeout_list_prev;
+ void *user_space;
+ /* rxflow handling */
+ unsigned char *rxflow_buffer;
+ /* truncated send handling */
+ unsigned char *trunc_alloc; /* non-NULL means buffering in progress */
+#ifndef LWS_NO_EXTENSIONS
+ const struct lws_extension *active_extensions[LWS_MAX_EXTENSIONS_ACTIVE];
+ void *act_ext_user[LWS_MAX_EXTENSIONS_ACTIVE];
+#endif
#ifdef LWS_OPENSSL_SUPPORT
SSL *ssl;
BIO *client_bio;
struct lws *pending_read_list_prev, *pending_read_list_next;
+#endif
+#ifdef LWS_LATENCY
+ unsigned long action_start;
+ unsigned long latency_start;
+#endif
+ /* pointer / int */
+ lws_sockfd_type sock;
+
+ /* ints */
+ int position_in_fds_table;
+ int rxflow_len;
+ int rxflow_pos;
+ unsigned int trunc_alloc_len; /* size of malloc */
+ unsigned int trunc_offset; /* where we are in terms of spilling */
+ unsigned int trunc_len; /* how much is buffered */
+
+ unsigned int hdr_parsing_completed:1;
+ unsigned int user_space_externally_allocated:1;
+ unsigned int socket_is_permanently_unusable:1;
+ unsigned int rxflow_change_to:2;
+ unsigned int more_rx_waiting:1; /* has to live here since ah may stick to end */
+#ifndef LWS_NO_EXTENSIONS
+ unsigned int extension_data_pending:1;
+#endif
+#ifdef LWS_OPENSSL_SUPPORT
unsigned int use_ssl:2;
unsigned int upgraded:1;
#endif
-
#ifdef _WIN32
- BOOL sock_send_blocking;
+ unsigned int sock_send_blocking:1;
#endif
+
+ /* chars */
+#ifndef LWS_NO_EXTENSIONS
+ unsigned char count_act_ext;
+#endif
+ unsigned char ietf_spec_revision;
+ char mode; /* enum connection_mode */
+ char state; /* enum lws_connection_states */
+ char state_pre_close;
+ char lws_rx_parse_state; /* enum lws_rx_parse_state */
+ char rx_frame_type; /* enum lws_write_protocol */
+ char pending_timeout; /* enum pending_timeout */
+ char pps; /* enum lws_pending_protocol_send */
+ char tsi; /* thread service index we belong to */
};
LWS_EXTERN int log_level;
LWS_EXTERN void
-lws_close_and_free_session(struct lws_context *context,
- struct lws *wsi, enum lws_close_status);
+lws_close_free_wsi(struct lws *wsi, enum lws_close_status);
LWS_EXTERN int
-remove_wsi_socket_from_fds(struct lws_context *context, struct lws *wsi);
+remove_wsi_socket_from_fds(struct lws *wsi);
LWS_EXTERN int
lws_rxflow_cache(struct lws *wsi, unsigned char *buf, int n, int len);
static inline void
lws_latency(struct lws_context *context, struct lws *wsi, const char *action,
int ret, int completion) {
- do { (void)context; (void)wsi; (void)action; (void)ret; (void)completion;
+ do {
+ (void)context; (void)wsi; (void)action; (void)ret;
+ (void)completion;
} while (0);
}
static inline void
#endif
LWS_EXTERN void
-lws_set_protocol_write_pending(struct lws_context *context, struct lws *wsi,
+lws_set_protocol_write_pending(struct lws *wsi,
enum lws_pending_protocol_send pend);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_client_rx_sm(struct lws *wsi, unsigned char c);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_parse(struct lws *wsi, unsigned char c);
+
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_http_action(struct lws *wsi);
+
LWS_EXTERN int
-lws_parse(struct lws_context *context, struct lws *wsi, unsigned char c);
+lws_b64_selftest(void);
LWS_EXTERN int
-lws_http_action(struct lws_context *context, struct lws *wsi);
+lws_service_adjust_timeout(struct lws_context *context, int timeout_ms, int tsi);
LWS_EXTERN int
-lws_b64_selftest(void);
+lws_service_flag_pending(struct lws_context *context, int tsi);
#if defined(_WIN32) || defined(MBED_OPERATORS)
LWS_EXTERN struct lws *
-wsi_from_fd(struct lws_context *context, lws_sockfd_type fd);
+wsi_from_fd(const struct lws_context *context, lws_sockfd_type fd);
-LWS_EXTERN int
+LWS_EXTERN int
insert_wsi(struct lws_context *context, struct lws *wsi);
LWS_EXTERN int
delete_from_fd(struct lws_context *context, lws_sockfd_type fd);
#else
-#define wsi_from_fd(A,B) A->lws_lookup[B]
-#define insert_wsi(A,B) A->lws_lookup[B->sock]=B
+#define wsi_from_fd(A,B) A->lws_lookup[B]
+#define insert_wsi(A,B) assert(A->lws_lookup[B->sock] == 0); A->lws_lookup[B->sock]=B
#define delete_from_fd(A,B) A->lws_lookup[B]=0
#endif
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
insert_wsi_socket_into_fds(struct lws_context *context, struct lws *wsi);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len);
-LWS_EXTERN int
-lws_service_timeout_check(struct lws_context *context,
- struct lws *wsi, unsigned int sec);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_service_timeout_check(struct lws *wsi, unsigned int sec);
-LWS_EXTERN struct lws *
-lws_client_connect_2(struct lws_context *context, struct lws *wsi);
+LWS_EXTERN struct lws * LWS_WARN_UNUSED_RESULT
+lws_client_connect_2(struct lws *wsi);
-LWS_EXTERN struct lws *
+LWS_VISIBLE struct lws * LWS_WARN_UNUSED_RESULT
+lws_client_reset(struct lws *wsi, int ssl, const char *address, int port,
+ const char *path, const char *host);
+
+LWS_EXTERN struct lws * LWS_WARN_UNUSED_RESULT
lws_create_new_server_wsi(struct lws_context *context);
-LWS_EXTERN char *
-lws_generate_client_handshake(struct lws_context *context, struct lws *wsi,
- char *pkt);
+LWS_EXTERN char * LWS_WARN_UNUSED_RESULT
+lws_generate_client_handshake(struct lws *wsi, char *pkt);
LWS_EXTERN int
-lws_handle_POLLOUT_event(struct lws_context *context, struct lws *wsi,
- struct lws_pollfd *pollfd);
+lws_handle_POLLOUT_event(struct lws *wsi, struct lws_pollfd *pollfd);
/*
* EXTENSIONS
lws_context_init_extensions(struct lws_context_creation_info *info,
struct lws_context *context);
LWS_EXTERN int
-lws_any_extension_handled(struct lws_context *context, struct lws *wsi,
- enum lws_extension_callback_reasons r,
+lws_any_extension_handled(struct lws *wsi, enum lws_extension_callback_reasons r,
void *v, size_t len);
LWS_EXTERN int
-lws_ext_callback_for_each_active(struct lws *wsi, int reason,
- void *buf, int len);
+lws_ext_cb_active(struct lws *wsi, int reason, void *buf, int len);
LWS_EXTERN int
-lws_ext_callback_for_each_extension_type(struct lws_context *context,
- struct lws *wsi, int reason,
- void *arg, int len);
+lws_ext_cb_all_exts(struct lws_context *context, struct lws *wsi, int reason,
+ void *arg, int len);
+
#else
-#define lws_any_extension_handled(_a, _b, _c, _d, _e) (0)
-#define lws_ext_callback_for_each_active(_a, _b, _c, _d) (0)
-#define lws_ext_callback_for_each_extension_type(_a, _b, _c, _d, _e) (0)
+#define lws_any_extension_handled(_a, _b, _c, _d) (0)
+#define lws_ext_cb_active(_a, _b, _c, _d) (0)
+#define lws_ext_cb_all_exts(_a, _b, _c, _d, _e) (0)
#define lws_issue_raw_ext_access lws_issue_raw
#define lws_context_init_extensions(_a, _b)
#endif
-LWS_EXTERN int
-lws_client_interpret_server_handshake(struct lws_context *context,
- struct lws *wsi);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_client_interpret_server_handshake(struct lws *wsi);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_rx_sm(struct lws *wsi, unsigned char c);
-LWS_EXTERN int
-lws_issue_raw_ext_access(struct lws *wsi, unsigned char *buf, size_t len);
+LWS_EXTERN void
+lws_payload_until_length_exhausted(struct lws *wsi, unsigned char **buf, size_t *len);
-LWS_EXTERN int
-_lws_rx_flow_control(struct lws *wsi);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_issue_raw_ext_access(struct lws *wsi, unsigned char *buf, size_t len);
LWS_EXTERN void
lws_union_transition(struct lws *wsi, enum connection_mode mode);
-LWS_EXTERN int
-user_callback_handle_rxflow(callback_function, struct lws_context *context,
- struct lws *wsi, enum lws_callback_reasons reason,
- void *user, void *in, size_t len);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+user_callback_handle_rxflow(lws_callback_function, struct lws *wsi,
+ enum lws_callback_reasons reason, void *user,
+ void *in, size_t len);
#ifdef LWS_USE_HTTP2
LWS_EXTERN struct lws *lws_http2_get_network_wsi(struct lws *wsi);
struct lws * lws_http2_get_nth_child(struct lws *wsi, int n);
unsigned char *buf, int len);
LWS_EXTERN void lws_http2_init(struct http2_settings *settings);
LWS_EXTERN int
-lws_http2_parser(struct lws_context *context,
- struct lws *wsi, unsigned char c);
+lws_http2_parser(struct lws *wsi, unsigned char c);
LWS_EXTERN int lws_http2_do_pps_send(struct lws_context *context,
struct lws *wsi);
LWS_EXTERN int lws_http2_frame_write(struct lws *wsi, int type, int flags,
unsigned char *buf);
LWS_EXTERN struct lws *
lws_http2_wsi_from_id(struct lws *wsi, unsigned int sid);
-LWS_EXTERN int lws_hpack_interpret(struct lws_context *context,
- struct lws *wsi,
+LWS_EXTERN int lws_hpack_interpret(struct lws *wsi,
unsigned char c);
LWS_EXTERN int
-lws_add_http2_header_by_name(struct lws_context *context, struct lws *wsi,
+lws_add_http2_header_by_name(struct lws *wsi,
const unsigned char *name,
const unsigned char *value, int length,
unsigned char **p, unsigned char *end);
LWS_EXTERN int
-lws_add_http2_header_by_token(struct lws_context *context, struct lws *wsi,
+lws_add_http2_header_by_token(struct lws *wsi,
enum lws_token_indexes token,
const unsigned char *value, int length,
unsigned char **p, unsigned char *end);
LWS_EXTERN int
-lws_add_http2_header_status(struct lws_context *context, struct lws *wsi,
+lws_add_http2_header_status(struct lws *wsi,
unsigned int code, unsigned char **p,
unsigned char *end);
LWS_EXTERN
LWS_EXTERN int
lws_plat_set_socket_options(struct lws_context *context, lws_sockfd_type fd);
-LWS_EXTERN int
-lws_allocate_header_table(struct lws *wsi);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_header_table_attach(struct lws *wsi);
LWS_EXTERN int
-lws_free_header_table(struct lws *wsi);
+lws_header_table_detach(struct lws *wsi);
-LWS_EXTERN char *
+LWS_EXTERN void
+lws_header_table_reset(struct lws *wsi);
+
+LWS_EXTERN char * LWS_WARN_UNUSED_RESULT
lws_hdr_simple_ptr(struct lws *wsi, enum lws_token_indexes h);
-LWS_EXTERN int
-lws_hdr_simple_create(struct lws *wsi,
- enum lws_token_indexes h, const char *s);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_hdr_simple_create(struct lws *wsi, enum lws_token_indexes h, const char *s);
LWS_EXTERN int
lws_ensure_user_space(struct lws *wsi);
struct lws_context *context);
LWS_EXTERN int
handshake_0405(struct lws_context *context, struct lws *wsi);
-LWS_EXTERN int
-lws_interpret_incoming_packet(struct lws *wsi, unsigned char *buf, size_t len);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_interpret_incoming_packet(struct lws *wsi, unsigned char **buf, size_t len);
LWS_EXTERN void
lws_server_get_canonical_hostname(struct lws_context *context,
struct lws_context_creation_info *info);
#endif
#if !defined(MBED_OPERATORS)
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
interface_to_sa(struct lws_context *context, const char *ifname,
struct sockaddr_in *addr, size_t addrlen);
#endif
LWS_EXTERN void lwsl_emit_stderr(int level, const char *line);
-#ifdef _WIN32
-LWS_EXTERN HANDLE lws_plat_open_file(const char* filename, unsigned long* filelen);
-#else
-LWS_EXTERN int lws_plat_open_file(const char* filename, unsigned long* filelen);
-#endif
-
enum lws_ssl_capable_status {
LWS_SSL_CAPABLE_ERROR = -1,
LWS_SSL_CAPABLE_MORE_SERVICE = -2,
#define lws_ssl_capable_read lws_ssl_capable_read_no_ssl
#define lws_ssl_capable_write lws_ssl_capable_write_no_ssl
#define lws_ssl_pending lws_ssl_pending_no_ssl
-#define lws_server_socket_service_ssl(_a, _b, _c, _d, _e) (0)
+#define lws_server_socket_service_ssl(_b, _c) (0)
#define lws_ssl_close(_a) (0)
#define lws_ssl_context_destroy(_a)
-#define lws_ssl_remove_wsi_from_buffered_list(_a, _b)
+#define lws_ssl_remove_wsi_from_buffered_list(_a)
#else
#define LWS_SSL_ENABLED(context) (context->use_ssl)
LWS_EXTERN int openssl_websocket_private_data_index;
-LWS_EXTERN int
-lws_ssl_capable_read(struct lws_context *context,
- struct lws *wsi, unsigned char *buf, int len);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_ssl_capable_read(struct lws *wsi, unsigned char *buf, int len);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_ssl_capable_write(struct lws *wsi, unsigned char *buf, int len);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_ssl_pending(struct lws *wsi);
-LWS_EXTERN int
-lws_server_socket_service_ssl(struct lws_context *context, struct lws **wsi,
- struct lws *new_wsi, lws_sockfd_type accept_fd,
- struct lws_pollfd *pollfd);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_server_socket_service_ssl(struct lws *new_wsi, lws_sockfd_type accept_fd);
LWS_EXTERN int
lws_ssl_close(struct lws *wsi);
LWS_EXTERN void
lws_ssl_context_destroy(struct lws_context *context);
LWS_VISIBLE void
-lws_ssl_remove_wsi_from_buffered_list(struct lws_context *context,
- struct lws *wsi);
+lws_ssl_remove_wsi_from_buffered_list(struct lws *wsi);
#ifndef LWS_NO_SERVER
LWS_EXTERN int
lws_context_init_server_ssl(struct lws_context_creation_info *info,
#endif
#endif
-LWS_EXTERN int
-lws_ssl_capable_read_no_ssl(struct lws_context *context,
- struct lws *wsi, unsigned char *buf, int len);
+#if LWS_MAX_SMP > 1
+static LWS_INLINE void
+lws_pt_mutex_init(struct lws_context_per_thread *pt)
+{
+ pthread_mutex_init(&pt->lock, NULL);
+}
-LWS_EXTERN int
+static LWS_INLINE void
+lws_pt_mutex_destroy(struct lws_context_per_thread *pt)
+{
+ pthread_mutex_destroy(&pt->lock);
+}
+
+static LWS_INLINE void
+lws_pt_lock(struct lws_context_per_thread *pt)
+{
+ pthread_mutex_lock(&pt->lock);
+}
+
+static LWS_INLINE void
+lws_pt_unlock(struct lws_context_per_thread *pt)
+{
+ pthread_mutex_unlock(&pt->lock);
+}
+#else
+#define lws_pt_mutex_init(_a) (void)(_a)
+#define lws_pt_mutex_destroy(_a) (void)(_a)
+#define lws_pt_lock(_a) (void)(_a)
+#define lws_pt_unlock(_a) (void)(_a)
+#endif
+
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_ssl_capable_read_no_ssl(struct lws *wsi, unsigned char *buf, int len);
+
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, int len);
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_ssl_pending_no_ssl(struct lws *wsi);
#ifndef LWS_NO_CLIENT
#else
#define lws_context_init_client_ssl(_a, _b) (0)
#endif
-LWS_EXTERN int
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_handshake_client(struct lws *wsi, unsigned char **buf, size_t len);
LWS_EXTERN void
lws_decode_ssl_error(void);
#define lws_context_init_client_ssl(_a, _b) (0)
#define lws_handshake_client(_a, _b, _c) (0)
#endif
+
+LWS_EXTERN int
+_lws_rx_flow_control(struct lws *wsi);
+
+LWS_EXTERN int
+_lws_change_pollfd(struct lws *wsi, int _and, int _or, struct lws_pollargs *pa);
+
#ifndef LWS_NO_SERVER
LWS_EXTERN int
lws_server_socket_service(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pollfd);
LWS_EXTERN int
-_lws_rx_flow_control(struct lws *wsi);
+lws_handshake_server(struct lws *wsi, unsigned char **buf, size_t len);
LWS_EXTERN int
-lws_handshake_server(struct lws_context *context,
- struct lws *wsi, unsigned char **buf, size_t len);
+_lws_server_listen_accept_flow_control(struct lws *twsi, int on);
#else
#define lws_server_socket_service(_a, _b, _c) (0)
-#define _lws_rx_flow_control(_a) (0)
-#define lws_handshake_server(_a, _b, _c, _d) (0)
+#define lws_handshake_server(_a, _b, _c) (0)
+#define _lws_server_listen_accept_flow_control(a, b) (0)
#endif
-
+
LWS_EXTERN int
lws_get_addresses(struct lws_context *context, void *ads, char *name,
int name_len, char *rip, int rip_len);
/*
* custom allocator
*/
-LWS_EXTERN void*
+LWS_EXTERN void *
lws_realloc(void *ptr, size_t size);
-LWS_EXTERN void*
+LWS_EXTERN void * LWS_WARN_UNUSED_RESULT
lws_zalloc(size_t size);
#define lws_malloc(S) lws_realloc(NULL, S)
#define lws_free(P) lws_realloc(P, 0)
-#define lws_free2(P) do { lws_realloc(P, 0); (P) = NULL; } while(0)
+#define lws_free_set_NULL(P) do { lws_realloc(P, 0); (P) = NULL; } while(0)
/* lws_plat_ */
LWS_EXTERN void
lws_poll_listen_fd(struct lws_pollfd *fd);
LWS_EXTERN int
lws_plat_service(struct lws_context *context, int timeout_ms);
+LWS_EXTERN LWS_VISIBLE int
+lws_plat_service_tsi(struct lws_context *context, int timeout_ms, int tsi);
LWS_EXTERN int
-lws_plat_init_lookup(struct lws_context *context);
-LWS_EXTERN int
-lws_plat_init_fd_tables(struct lws_context *context);
+lws_plat_init(struct lws_context *context,
+ struct lws_context_creation_info *info);
LWS_EXTERN void
lws_plat_drop_app_privileges(struct lws_context_creation_info *info);
LWS_EXTERN unsigned long long
time_in_microseconds(void);
-LWS_EXTERN const char *
+LWS_EXTERN const char * LWS_WARN_UNUSED_RESULT
lws_plat_inet_ntop(int af, const void *src, char *dst, int cnt);
+LWS_EXTERN int LWS_WARN_UNUSED_RESULT
+lws_check_utf8(unsigned char *state, unsigned char *buf, size_t len);
+
#ifdef __cplusplus
};
#endif
projects / platform / upstream / libwebsockets.git / blobdiff