Mirrors/libwebsockets
1
0
Fork 0
mirror of https://github.com/warmcat/libwebsockets.git synced 2025-03-16 00:00:07 +01:00
Code Issues Releases Wiki Activity

Merge branch 'master' of https://github.com/warmcat/libwebsockets

Browse source
This commit is contained in:
SoapyMan 2015-12-09 14:42:45 +06:00
commit 419548ba73
49 changed files with 3426 additions and 2418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.travis.yml
View file

@ -2,7 +2,7 @@ env:
# The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
# via the "travis encrypt" command using the project repo's public key
global:
- secure: "amfzN1OzBBZYPJVx8TCYsV1nQ5SPm7QswgGpuHcNKaMAixn1s4tKliR0wyVs1aiMqKco1zrJ3vXll+D5gknKr5obWOeZ61T3PYyZmhjB0n/D+7Y41EikNa1Hn1pP6etcHh3ciJ0qe8FC+9YB5yEII3G/jHsltge8Nu+5o2YCSCw="
- secure: "KhAdQ9ja+LBObWNQTYO7Df5J4DyOih6S+eerDMu8UPSO+CoWV2pWoQzbOfocjyOscGOwC+2PrrHDNZyGfqkCLDXg1BxynXPCFerHC1yc2IajvKpGXmAAygNIvp4KACDfGv/dkXrViqIzr/CdcNaU4vIMHSVb5xkeLi0W1dPnQOI="
matrix:
- LWS_METHOD=default
- LWS_METHOD=noserver CMAKE_ARGS="-DLWS_WITHOUT_SERVER=ON"
@ -29,3 +29,4 @@ addons:
build_command_prepend: "mkdir build && cd build && cmake .."
build_command: "cmake --build ."
branch_pattern: coverity_scan

32
CMakeLists.txt
View file

@ -13,7 +13,7 @@ set(CPACK_PACKAGE_VERSION_MINOR "5")
set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
set(CPACK_PACKAGE_VENDOR "andy@warmcat.com")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PACKAGE} ${PACKAGE_VERSION}")
set(SOVERSION "5")
set(SOVERSION "6")
set(CPACK_SOURCE_GENERATOR "TGZ")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
set(VERSION "${CPACK_PACKAGE_VERSION}")
@ -68,6 +68,7 @@ option(LWS_WITHOUT_DAEMONIZE "Don't build the daemonization api" ON)
option(LWS_IPV6 "Compile with support for ipv6" OFF)
option(LWS_WITH_HTTP2 "Compile with support for http2" OFF)
option(LWS_MBED3 "Platform is MBED3" OFF)
option(LWS_WITH_OLD_API_WRAPPERS "Compile with binary compatibility with pre-v1.6 apis" OFF)
if (DEFINED YOTTA_WEBSOCKETS_VERSION_STRING)
@ -475,7 +476,7 @@ if (UNIX)
endif()
endif()
if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_C_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
include (CheckCCompilerFlag)
CHECK_C_COMPILER_FLAG(-fvisibility=hidden LWS_HAVE_VISIBILITY)
if (LWS_HAVE_VISIBILITY)
@ -488,6 +489,19 @@ if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
endif(UNIX)
endif ()
if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
if (UNIX)
# jeez clang understands -pthread but dies if he sees it at link time!
# http://stackoverflow.com/questions/2391194/what-is-gs-pthread-equiv-in-clang
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread" )
endif()
endif()
if ((CMAKE_C_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
# otherwise osx blows a bunch of openssl deprecated api errors
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations" )
endif()
source_group("Headers Private" FILES ${HDR_PRIVATE})
source_group("Headers Public" FILES ${HDR_PUBLIC})
source_group("Sources" FILES ${SOURCES})
@ -542,7 +556,7 @@ endif()
# Set the so version of the lib.
# Equivalent to LDFLAGS=-version-info x:x:x
if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_C_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
foreach(lib ${LWS_LIBRARIES})
set_target_properties(${lib}
PROPERTIES
@ -614,7 +628,7 @@ if (LWS_WITH_SSL)
# Additional to the root directory we need to include
# the wolfssl/ subdirectory which contains the OpenSSL
# compatability layer headers.
# compatibility layer headers.
if (LWS_USE_CYASSL)
foreach(inc ${WOLFSSL_INCLUDE_DIRS})
@ -756,6 +770,9 @@ if (NOT LWS_WITHOUT_TESTAPPS)
#
if (NOT LWS_WITHOUT_TEST_SERVER)
create_test_app(test-server "test-server/test-server.c" "test-server/test-server-http.c" "test-server/test-server-dumb-increment.c" "test-server/test-server-mirror.c")
if (UNIX AND NOT ((CMAKE_C_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang")))
create_test_app(test-server-pthreads "test-server/test-server-pthreads.c" "test-server/test-server-http.c" "test-server/test-server-dumb-increment.c" "test-server/test-server-mirror.c")
endif()
endif()
#
@ -1032,6 +1049,12 @@ if (NOT LWS_WITHOUT_TESTAPPS AND NOT LWS_WITHOUT_SERVER)
COMPONENT examples)
endif()
# Install the LibwebsocketsConfig.cmake and LibwebsocketsConfigVersion.cmake
install(FILES
"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/LibwebsocketsConfig.cmake"
"${PROJECT_BINARY_DIR}/LibwebsocketsConfigVersion.cmake"
DESTINATION "${LWS_INSTALL_CMAKE_DIR}" COMPONENT dev)
# build subdir is not part of sources
set(CPACK_SOURCE_IGNORE_FILES $(CPACK_SOURCE_IGNORE_FILES) ".git" "build" "tgz" "tar.gz")
@ -1073,6 +1096,7 @@ message(" LWS_USE_LIBEV = ${LWS_USE_LIBEV}")
message(" LWS_IPV6 = ${LWS_IPV6}")
message(" LWS_WITH_HTTP2 = ${LWS_WITH_HTTP2}")
message(" LWS_MBED3 = ${LWS_MBED3}")
message(" LWS_WITH_OLD_API_WRAPPERS = ${LWS_WITH_OLD_API_WRAPPERS}")
message("---------------------------------------------------------------------")
# These will be available to parent projects including libwebsockets using add_subdirectory()

18
README.coding.md
View file

@ -61,8 +61,8 @@ clients).
If you want to send something, do not just send it but request a callback
when the socket is writeable using
- `libwebsocket_callback_on_writable(context, wsi)`` for a specific `wsi`, or
- `libwebsocket_callback_on_writable_all_protocol(protocol)` for all connections
- `lws_callback_on_writable(context, wsi)`` for a specific `wsi`, or
- `lws_callback_on_writable_all_protocol(protocol)` for all connections
using that protocol to get a callback when next writeable.
Usually you will get called back immediately next time around the service
@ -93,7 +93,7 @@ Closing connections from the user side
When you want to close a connection, you do it by returning `-1` from a
callback for that connection.
You can provoke a callback by calling `libwebsocket_callback_on_writable` on
You can provoke a callback by calling `lws_callback_on_writable` on
the wsi, then notice in the callback you want to close it and just return -1.
But usually, the decision to close is made in a callback already and returning
-1 is simple.
@ -112,7 +112,7 @@ Fragmented messages
-------------------
To support fragmented messages you need to check for the final
frame of a message with `libwebsocket_is_final_fragment`. This
frame of a message with `lws_is_final_fragment`. This
check can be combined with `libwebsockets_remaining_packet_payload`
to gather the whole contents of a message, eg:
@ -120,9 +120,9 @@ to gather the whole contents of a message, eg:
case LWS_CALLBACK_RECEIVE:
{
Client * const client = (Client *)user;
const size_t remaining = libwebsockets_remaining_packet_payload(wsi);
const size_t remaining = lws_remaining_packet_payload(wsi);
if (!remaining && libwebsocket_is_final_fragment(wsi)) {
if (!remaining && lws_is_final_fragment(wsi)) {
if (client->HasFragments()) {
client->AppendMessageFragment(in, len, 0);
in = (void *)client->GetMessage();
@ -178,7 +178,7 @@ Four callbacks `LWS_CALLBACK_ADD_POLL_FD`, `LWS_CALLBACK_DEL_POLL_FD`,
appear in the callback for protocol 0 and allow interface code to
manage socket descriptors in other poll loops.
You can pass all pollfds that need service to `libwebsocket_service_fd()`, even
You can pass all pollfds that need service to `lws_service_fd()`, even
if the socket or file does not belong to **libwebsockets** it is safe.
If **libwebsocket** handled it, it zeros the pollfd `revents` field before returning.
@ -261,7 +261,7 @@ if left `NULL`, then the "DEFAULT" set of ciphers are all possible to select.
Async nature of client connections
----------------------------------
When you call `libwebsocket_client_connect(..)` and get a `wsi` back, it does not
When you call `lws_client_connect(..)` and get a `wsi` back, it does not
mean your connection is active. It just mean it started trying to connect.
Your client connection is actually active only when you receive
@ -273,6 +273,6 @@ other reasons, if any of that happens you'll get a
`wsi`.
After attempting the connection and getting back a non-`NULL` `wsi` you should
loop calling `libwebsocket_service()` until one of the above callbacks occurs.
loop calling `lws_service()` until one of the above callbacks occurs.
As usual, see [test-client.c](test-server/test-client.c) for example code.

25
changelog
View file

@ -1,6 +1,27 @@
Changelog
---------
User api changes
----------------
Several older apis start with libwebsocket_ or libwebsockets_ while newer ones
all begin lws_. These apis have been changed to all begin with lws_.
However compatibility defines have been added in libwebsockets.h, so it is
perfectly build-compatible with older sources using the old api names.
If you are using lws with a distro, or otherwise can't rebuild the user code,
you should add
-DLWS_WITH_OLD_API_WRAPPERS=1
to your cmake args. This builds lws with all the old apis as wrappers around
the new apis, so the library still exports the old apis.
In this way you can have lws export both the new and old apis simultaneously
for compatibility.
v1.5-chrome47-firefox41
=======================
@ -97,7 +118,7 @@ User api removal
----------------
protocols struct member no_buffer_all_partial_tx is removed. Under some
conditions like rewriting extention such as compression in use, the built-in
conditions like rewriting extension such as compression in use, the built-in
partial send buffering is the only way to deal with the problem, so turning
it off is deprecated.
@ -348,7 +369,7 @@ User api additions
- if your OS does not support the http_proxy environment variable convention
(eg, reportedly OSX), you can use a new api libwebsocket_set_proxy()
to set the proxy details inbetween context creation and the connection
to set the proxy details in between context creation and the connection
action. For OSes that support http_proxy, that's used automatically.
User api changes

140
lib/client-handshake.c
View file

@ -1,10 +1,8 @@
#include "private-libwebsockets.h"
struct libwebsocket *libwebsocket_client_connect_2(
struct libwebsocket_context *context,
struct libwebsocket *wsi
) {
struct libwebsocket_pollfd pfd;
struct lws *
lws_client_connect_2(struct lws_context *context, struct lws *wsi)
{
#ifdef LWS_USE_IPV6
struct sockaddr_in6 server_addr6;
struct sockaddr_in6 client_addr6;
@ -12,17 +10,14 @@ struct libwebsocket *libwebsocket_client_connect_2(
#endif
struct sockaddr_in server_addr4;
struct sockaddr_in client_addr4;
struct lws_pollfd pfd;
struct sockaddr *v;
int n;
int plen = 0;
int n, plen = 0;
const char *ads;
lwsl_client("libwebsocket_client_connect_2\n");
lwsl_client("lws_client_connect_2\n");
/*
* proxy?
*/
/* proxy? */
if (context->http_proxy_port) {
plen = sprintf((char *)context->service_buffer,
@ -42,18 +37,20 @@ struct libwebsocket *libwebsocket_client_connect_2(
ads = context->http_proxy_address;
#ifdef LWS_USE_IPV6
if (LWS_IPV6_ENABLED(context))
if (LWS_IPV6_ENABLED(context)) {
memset(&server_addr6, 0, sizeof(struct sockaddr_in6));
server_addr6.sin6_port = htons(context->http_proxy_port);
else
} else
#endif
server_addr4.sin_port = htons(context->http_proxy_port);
} else {
ads = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS);
#ifdef LWS_USE_IPV6
if (LWS_IPV6_ENABLED(context))
if (LWS_IPV6_ENABLED(context)) {
memset(&server_addr6, 0, sizeof(struct sockaddr_in6));
server_addr6.sin6_port = htons(wsi->u.hdr.ah->c_port);
else
} else
#endif
server_addr4.sin_port = htons(wsi->u.hdr.ah->c_port);
}
@ -169,7 +166,7 @@ struct libwebsocket *libwebsocket_client_connect_2(
* handling as oom4 does. We have to run the whole close flow.
*/
libwebsocket_set_timeout(wsi,
lws_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_CONNECT_RESPONSE,
AWAITING_TIMEOUT);
#ifdef LWS_USE_IPV6
@ -216,14 +213,13 @@ struct libwebsocket *libwebsocket_client_connect_2(
if (connect(wsi->sock, v, n) == -1 || LWS_ERRNO == LWS_EISCONN) {
if (LWS_ERRNO == LWS_EALREADY
|| LWS_ERRNO == LWS_EINPROGRESS
|| LWS_ERRNO == LWS_EWOULDBLOCK
if (LWS_ERRNO == LWS_EALREADY ||
LWS_ERRNO == LWS_EINPROGRESS ||
LWS_ERRNO == LWS_EWOULDBLOCK
#ifdef _WIN32
|| LWS_ERRNO == WSAEINVAL
#endif
)
{
) {
lwsl_client("nonblocking connect retry\n");
/*
@ -249,26 +245,26 @@ struct libwebsocket *libwebsocket_client_connect_2(
if (context->http_proxy_port) {
/* OK from now on we talk via the proxy, so connect to that */
/*
* OK from now on we talk via the proxy, so connect to that
*
* (will overwrite existing pointer,
* leaving old string/frag there but unreferenced)
*/
if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS,
context->http_proxy_address))
context->http_proxy_address))
goto failed;
wsi->u.hdr.ah->c_port = context->http_proxy_port;
n = send(wsi->sock, (char *)context->service_buffer, plen, MSG_NOSIGNAL);
n = send(wsi->sock, (char *)context->service_buffer, plen,
MSG_NOSIGNAL);
if (n < 0) {
lwsl_debug("ERROR writing to proxy socket\n");
goto failed;
}
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_PROXY_RESPONSE,
AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_PROXY_RESPONSE,
AWAITING_TIMEOUT);
wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY;
@ -285,14 +281,14 @@ struct libwebsocket *libwebsocket_client_connect_2(
* cover with a timeout.
*/
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE, AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE,
AWAITING_TIMEOUT);
wsi->mode = LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE;
pfd.fd = wsi->sock;
pfd.revents = LWS_POLLIN;
n = libwebsocket_service_fd(context, &pfd);
n = lws_service_fd(context, &pfd);
if (n < 0)
goto failed;
@ -308,13 +304,13 @@ oom4:
return NULL;
failed:
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
return NULL;
}
/**
* libwebsocket_client_connect() - Connect to another websocket server
* lws_client_connect() - Connect to another websocket server
* @context: Websocket context
* @address: Remote server address, eg, "myserver.com"
* @port: Port to connect to on the remote server, eg, 80
@ -333,20 +329,15 @@ failed:
* This function creates a connection to a remote server
*/
LWS_VISIBLE struct libwebsocket *
libwebsocket_client_connect(struct libwebsocket_context *context,
const char *address,
int port,
int ssl_connection,
const char *path,
const char *host,
const char *origin,
const char *protocol,
int ietf_version_or_minus_one)
LWS_VISIBLE struct lws *
lws_client_connect(struct lws_context *context, const char *address,
int port, int ssl_connection, const char *path,
const char *host, const char *origin,
const char *protocol, int ietf_version_or_minus_one)
{
struct libwebsocket *wsi;
struct lws *wsi;
wsi = lws_zalloc(sizeof(struct libwebsocket));
wsi = lws_zalloc(sizeof(struct lws));
if (wsi == NULL)
goto bail;
@ -392,16 +383,15 @@ libwebsocket_client_connect(struct libwebsocket_context *context,
goto bail1;
if (origin)
if (lws_hdr_simple_create(wsi,
_WSI_TOKEN_CLIENT_ORIGIN, origin))
if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_ORIGIN, origin))
goto bail1;
/*
* this is a list of protocols we tell the server we're okay with
* stash it for later when we compare server response with it
*/
if (protocol)
if (lws_hdr_simple_create(wsi,
_WSI_TOKEN_CLIENT_SENT_PROTOCOLS, protocol))
if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_SENT_PROTOCOLS,
protocol))
goto bail1;
wsi->protocol = &context->protocols[0];
@ -415,19 +405,19 @@ libwebsocket_client_connect(struct libwebsocket_context *context,
if (lws_ext_callback_for_each_extension_type(context, wsi,
LWS_EXT_CALLBACK_CAN_PROXY_CLIENT_CONNECTION,
(void *)address, port) > 0) {
lwsl_client("libwebsocket_client_connect: ext handling conn\n");
(void *)address, port) > 0) {
lwsl_client("lws_client_connect: ext handling conn\n");
libwebsocket_set_timeout(wsi,
lws_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_EXTENSION_CONNECT_RESPONSE,
AWAITING_TIMEOUT);
AWAITING_TIMEOUT);
wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT;
return wsi;
}
lwsl_client("libwebsocket_client_connect: direct conn\n");
lwsl_client("lws_client_connect: direct conn\n");
return libwebsocket_client_connect_2(context, wsi);
return lws_client_connect_2(context, wsi);
bail1:
lws_free(wsi->u.hdr.ah);
@ -439,7 +429,7 @@ bail:
/**
* libwebsocket_client_connect_extended() - Connect to another websocket server
* lws_client_connect_extended() - Connect to another websocket server
* @context: Websocket context
* @address: Remote server address, eg, "myserver.com"
* @port: Port to connect to on the remote server, eg, 80
@ -458,27 +448,23 @@ bail:
* This function creates a connection to a remote server
*/
LWS_VISIBLE struct libwebsocket *
libwebsocket_client_connect_extended(struct libwebsocket_context *context,
const char *address,
int port,
int ssl_connection,
const char *path,
const char *host,
const char *origin,
const char *protocol,
int ietf_version_or_minus_one,
void *userdata)
LWS_VISIBLE struct lws *
lws_client_connect_extended(struct lws_context *context, const char *address,
int port, int ssl_connection, const char *path,
const char *host, const char *origin,
const char *protocol, int ietf_version_or_minus_one,
void *userdata)
{
struct libwebsocket *ws =
libwebsocket_client_connect(context, address, port,
ssl_connection, path, host, origin, protocol,
ietf_version_or_minus_one);
struct lws *wsi;
if (ws && !ws->user_space && userdata) {
ws->user_space_externally_allocated = 1;
ws->user_space = userdata ;
wsi = lws_client_connect(context, address, port, ssl_connection, path,
host, origin, protocol,
ietf_version_or_minus_one);
if (wsi && !wsi->user_space && userdata) {
wsi->user_space_externally_allocated = 1;
wsi->user_space = userdata ;
}
return ws ;
return wsi;
}

45
lib/client-parser.c
View file

@ -21,12 +21,11 @@
#include "private-libwebsockets.h"
int libwebsocket_client_rx_sm(struct libwebsocket *wsi, unsigned char c)
int lws_client_rx_sm(struct lws *wsi, unsigned char c)
{
int callback_action = LWS_CALLBACK_CLIENT_RECEIVE;
int handled;
struct lws_tokens eff_buf;
int m;
int handled, m;
switch (wsi->lws_rx_parse_state) {
case LWS_RXPS_NEW:
@ -54,7 +53,6 @@ int libwebsocket_client_rx_sm(struct libwebsocket *wsi, unsigned char c)
}
break;
case LWS_RXPS_04_FRAME_HDR_LEN:
wsi->u.ws.this_frame_masked = !!(c & 0x80);
@ -277,7 +275,7 @@ spill:
* we do not care about how it went, we are closing
* immediately afterwards
*/
libwebsocket_write(wsi, (unsigned char *)
lws_write(wsi, (unsigned char *)
&wsi->u.ws.rx_user_buffer[
LWS_SEND_BUFFER_PRE_PADDING],
wsi->u.ws.rx_user_buffer_head, LWS_WRITE_CLOSE);
@ -287,7 +285,7 @@ spill:
case LWS_WS_OPCODE_07__PING:
lwsl_info("received %d byte ping, sending pong\n",
wsi->u.ws.rx_user_buffer_head);
wsi->u.ws.rx_user_buffer_head);
if (wsi->u.ws.ping_pending_flag) {
/*
@ -306,13 +304,15 @@ spill:
/* if existing buffer is too small, drop it */
if (wsi->u.ws.ping_payload_buf &&
wsi->u.ws.ping_payload_alloc < wsi->u.ws.rx_user_buffer_head)
wsi->u.ws.ping_payload_alloc <
wsi->u.ws.rx_user_buffer_head)
lws_free2(wsi->u.ws.ping_payload_buf);
/* if no buffer, allocate it */
if (!wsi->u.ws.ping_payload_buf) {
wsi->u.ws.ping_payload_buf = lws_malloc(wsi->u.ws.rx_user_buffer_head
+ LWS_SEND_BUFFER_PRE_PADDING);
wsi->u.ws.ping_payload_buf =
lws_malloc(wsi->u.ws.rx_user_buffer_head +
LWS_SEND_BUFFER_PRE_PADDING);
wsi->u.ws.ping_payload_alloc =
wsi->u.ws.rx_user_buffer_head;
}
@ -326,7 +326,7 @@ spill:
wsi->u.ws.ping_pending_flag = 1;
/* get it sent as soon as possible */
libwebsocket_callback_on_writable(wsi->protocol->owning_server, wsi);
lws_callback_on_writable(wsi->protocol->owning_server, wsi);
ping_drop:
wsi->u.ws.rx_user_buffer_head = 0;
handled = 1;
@ -334,9 +334,8 @@ ping_drop:
case LWS_WS_OPCODE_07__PONG:
lwsl_info("client receied pong\n");
lwsl_hexdump(&wsi->u.ws.rx_user_buffer[
LWS_SEND_BUFFER_PRE_PADDING],
wsi->u.ws.rx_user_buffer_head);
lwsl_hexdump(&wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
wsi->u.ws.rx_user_buffer_head);
/* issue it */
callback_action = LWS_CALLBACK_CLIENT_RECEIVE_PONG;
@ -366,7 +365,7 @@ ping_drop:
&eff_buf, 0) <= 0) { /* not handle or fail */
lwsl_ext("Unhandled ext opc 0x%x\n",
wsi->u.ws.opcode);
wsi->u.ws.opcode);
wsi->u.ws.rx_user_buffer_head = 0;
return 0;
@ -378,7 +377,7 @@ ping_drop:
/*
* No it's real payload, pass it up to the user callback.
* It's nicely buffered with the pre-padding taken care of
* so it can be sent straight out again using libwebsocket_write
* so it can be sent straight out again using lws_write
*/
if (handled)
goto already_done;
@ -388,12 +387,12 @@ ping_drop:
eff_buf.token_len = wsi->u.ws.rx_user_buffer_head;
if (lws_ext_callback_for_each_active(wsi,
LWS_EXT_CALLBACK_PAYLOAD_RX,
&eff_buf, 0) < 0) /* fail */
LWS_EXT_CALLBACK_PAYLOAD_RX,
&eff_buf, 0) < 0) /* fail */
return -1;
if (eff_buf.token_len <= 0 &&
callback_action != LWS_CALLBACK_CLIENT_RECEIVE_PONG)
callback_action != LWS_CALLBACK_CLIENT_RECEIVE_PONG)
goto already_done;
eff_buf.token[eff_buf.token_len] = '\0';
@ -404,13 +403,9 @@ ping_drop:
if (callback_action == LWS_CALLBACK_CLIENT_RECEIVE_PONG)
lwsl_info("Client doing pong callback\n");
m = wsi->protocol->callback(
wsi->protocol->owning_server,
wsi,
(enum libwebsocket_callback_reasons)callback_action,
wsi->user_space,
eff_buf.token,
eff_buf.token_len);
m = wsi->protocol->callback(wsi->protocol->owning_server,
wsi, (enum lws_callback_reasons)callback_action,
wsi->user_space, eff_buf.token, eff_buf.token_len);
/* if user code wants to close, let caller know */
if (m)

225
lib/client.c
View file

@ -21,9 +21,9 @@
#include "private-libwebsockets.h"
int lws_handshake_client(struct libwebsocket *wsi, unsigned char **buf, size_t len)
int lws_handshake_client(struct lws *wsi, unsigned char **buf, size_t len)
{
int n;
unsigned int n;
switch (wsi->mode) {
case LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY:
@ -32,7 +32,7 @@ int lws_handshake_client(struct libwebsocket *wsi, unsigned char **buf, size_t l
case LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT:
case LWS_CONNMODE_WS_CLIENT:
for (n = 0; n < len; n++)
if (libwebsocket_client_rx_sm(wsi, *(*buf)++)) {
if (lws_client_rx_sm(wsi, *(*buf)++)) {
lwsl_debug("client_rx_sm failed\n");
return 1;
}
@ -43,13 +43,12 @@ int lws_handshake_client(struct libwebsocket *wsi, unsigned char **buf, size_t l
return 0;
}
int lws_client_socket_service(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd)
int lws_client_socket_service(struct lws_context *context,
struct lws *wsi, struct lws_pollfd *pollfd)
{
int n;
char *p = (char *)&context->service_buffer[0];
int len;
unsigned char c;
int n, len;
switch (wsi->mode) {
@ -60,7 +59,7 @@ int lws_client_socket_service(struct libwebsocket_context *context,
* timeout protection set in client-handshake.c
*/
if (libwebsocket_client_connect_2(context, wsi) == NULL) {
if (lws_client_connect_2(context, wsi) == NULL) {
/* closed */
lwsl_client("closed\n");
return -1;
@ -78,7 +77,7 @@ int lws_client_socket_service(struct libwebsocket_context *context,
lwsl_warn("Proxy connection %p (fd=%d) dead\n",
(void *)wsi, pollfd->fd);
libwebsocket_close_and_free_session(context, wsi,
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 0;
}
@ -88,13 +87,12 @@ int lws_client_socket_service(struct libwebsocket_context *context,
if (n < 0) {
if (LWS_ERRNO == LWS_EAGAIN) {
lwsl_debug(
"Proxy read returned EAGAIN... retrying\n");
lwsl_debug("Proxy read returned EAGAIN... retrying\n");
return 0;
}
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lwsl_err("ERROR reading from proxy socket\n");
return 0;
}
@ -103,15 +101,15 @@ int lws_client_socket_service(struct libwebsocket_context *context,
if (strcmp((char *)context->service_buffer, "HTTP/1.0 200 ") &&
strcmp((char *)context->service_buffer, "HTTP/1.1 200 ")
) {
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lwsl_err("ERROR proxy: %s\n", context->service_buffer);
return 0;
}
/* clear his proxy connection timeout */
libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
/* fallthru */
@ -123,7 +121,7 @@ int lws_client_socket_service(struct libwebsocket_context *context,
*/
/*
* take care of our libwebsocket_callback_on_writable
* take care of our lws_callback_on_writable
* happening at a time when there's no real connection yet
*/
if (lws_change_pollfd(wsi, LWS_POLLOUT, 0))
@ -215,8 +213,10 @@ int lws_client_socket_service(struct libwebsocket_context *context,
if (n < 0) {
n = SSL_get_error(wsi->ssl, n);
if (n == SSL_ERROR_WANT_READ ||
n == SSL_ERROR_WANT_WRITE) {
if (n == SSL_ERROR_WANT_READ)
goto some_wait;
if (n == SSL_ERROR_WANT_WRITE) {
/*
* wants us to retry connect due to
* state of the underlying ssl layer...
@ -231,10 +231,10 @@ int lws_client_socket_service(struct libwebsocket_context *context,
*/
lwsl_info(
"SSL_connect WANT_... retrying\n");
libwebsocket_callback_on_writable(
"SSL_connect WANT_WRITE... retrying\n");
lws_callback_on_writable(
context, wsi);
some_wait:
wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_SSL;
return 0; /* no error */
@ -270,14 +270,16 @@ int lws_client_socket_service(struct libwebsocket_context *context,
lws_latency_pre(context, wsi);
n = SSL_connect(wsi->ssl);
lws_latency(context, wsi,
"SSL_connect LWS_CONNMODE_WS_CLIENT_WAITING_SSL",
n, n > 0);
"SSL_connect LWS_CONNMODE_WS_CLIENT_WAITING_SSL",
n, n > 0);
if (n < 0) {
n = SSL_get_error(wsi->ssl, n);
if (n == SSL_ERROR_WANT_READ ||
n == SSL_ERROR_WANT_WRITE) {
if (n == SSL_ERROR_WANT_READ)
goto some_wait;
if (n == SSL_ERROR_WANT_WRITE) {
/*
* wants us to retry connect due to
* state of the underlying ssl layer...
@ -291,14 +293,10 @@ int lws_client_socket_service(struct libwebsocket_context *context,
* us to get called back when writable.
*/
lwsl_info(
"SSL_connect WANT_... retrying\n");
libwebsocket_callback_on_writable(
context, wsi);
lwsl_info("SSL_connect WANT_WRITE... retrying\n");
lws_callback_on_writable(context, wsi);
wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_SSL;
return 0; /* no error */
goto some_wait;
}
n = -1;
}
@ -311,9 +309,8 @@ int lws_client_socket_service(struct libwebsocket_context *context,
n = ERR_get_error();
if (n != SSL_ERROR_NONE) {
lwsl_err("SSL connect error %lu: %s\n",
n,
ERR_error_string(n,
(char *)context->service_buffer));
n, ERR_error_string(n,
(char *)context->service_buffer));
return 0;
}
}
@ -337,7 +334,7 @@ int lws_client_socket_service(struct libwebsocket_context *context,
} else {
lwsl_err("server's cert didn't look good, X509_V_ERR = %d: %s\n",
n, ERR_error_string(n, (char *)context->service_buffer));
libwebsocket_close_and_free_session(context,
lws_close_and_free_session(context,
wsi, LWS_CLOSE_STATUS_NOSTATUS);
return 0;
}
@ -348,18 +345,17 @@ int lws_client_socket_service(struct libwebsocket_context *context,
#endif
wsi->mode = LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE2;
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_CLIENT_HS_SEND,
AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_CLIENT_HS_SEND,
AWAITING_TIMEOUT);
/* fallthru */
case LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE2:
p = libwebsockets_generate_client_handshake(context, wsi, p);
p = lws_generate_client_handshake(context, wsi, p);
if (p == NULL) {
lwsl_err("Failed to generate handshake for client\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 0;
}
@ -367,25 +363,26 @@ int lws_client_socket_service(struct libwebsocket_context *context,
lws_latency_pre(context, wsi);
n = lws_ssl_capable_write(wsi, context->service_buffer, p - (char *)context->service_buffer);
lws_latency(context, wsi, "send lws_issue_raw", n, n == p - (char *)context->service_buffer);
n = lws_ssl_capable_write(wsi, context->service_buffer,
p - (char *)context->service_buffer);
lws_latency(context, wsi, "send lws_issue_raw", n,
n == p - (char *)context->service_buffer);
switch (n) {
case LWS_SSL_CAPABLE_ERROR:
lwsl_debug("ERROR writing to client socket\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 0;
case LWS_SSL_CAPABLE_MORE_SERVICE:
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
}
wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
wsi->u.hdr.lextable_pos = 0;
wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY;
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE,
AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE,
AWAITING_TIMEOUT);
break;
case LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY:
@ -424,9 +421,10 @@ int lws_client_socket_service(struct libwebsocket_context *context,
*/
len = 1;
while (wsi->u.hdr.parser_state != WSI_PARSING_COMPLETE &&
len > 0) {
len > 0) {
n = lws_ssl_capable_read(context, wsi, &c, 1);
lws_latency(context, wsi, "send lws_issue_raw", n, n == 1);
lws_latency(context, wsi, "send lws_issue_raw", n,
n == 1);
switch (n) {
case LWS_SSL_CAPABLE_ERROR:
goto bail3;
@ -434,7 +432,7 @@ int lws_client_socket_service(struct libwebsocket_context *context,
return 0;
}
if (libwebsocket_parse(context, wsi, c)) {
if (lws_parse(context, wsi, c)) {
lwsl_warn("problems parsing header\n");
goto bail3;
}
@ -458,10 +456,9 @@ int lws_client_socket_service(struct libwebsocket_context *context,
return lws_client_interpret_server_handshake(context, wsi);
bail3:
lwsl_info(
"closing connection at LWS_CONNMODE...SERVER_REPLY\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lwsl_info("closing conn at LWS_CONNMODE...SERVER_REPLY\n");
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return -1;
case LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT:
@ -493,23 +490,20 @@ strtolower(char *s)
}
int
lws_client_interpret_server_handshake(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_client_interpret_server_handshake(struct lws_context *context,
struct lws *wsi)
{
const char *pc;
int okay = 0;
char *p;
int len;
int isErrorCodeReceived = 0;
#ifndef LWS_NO_EXTENSIONS
char ext_name[128];
struct libwebsocket_extension *ext;
void *v;
int more = 1;
const char *c;
#endif
int n;
int close_reason = LWS_CLOSE_STATUS_PROTOCOL_ERR;
int n, len, okay = 0, isErrorCodeReceived = 0;
const char *pc;
char *p;
#ifndef LWS_NO_EXTENSIONS
struct lws_extension *ext;
char ext_name[128];
const char *c;
int more = 1;
void *v;
#endif
/*
* well, what the server sent looked reasonable for syntax.
@ -558,7 +552,7 @@ lws_client_interpret_server_handshake(struct libwebsocket_context *context,
}
pc = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_SENT_PROTOCOLS);
if (pc == NULL) {
if (!pc) {
lwsl_parser("lws_client_int_s_hs: no protocol list\n");
} else
lwsl_parser("lws_client_int_s_hs: protocol list '%s'\n", pc);
@ -665,14 +659,12 @@ check_extensions:
n = 0;
ext = wsi->protocol->owning_server->extensions;
while (ext && ext->callback) {
if (strcmp(ext_name, ext->name)) {
ext++;
continue;
}
n = 1;
lwsl_ext("instantiating client ext %s\n", ext_name);
/* instantiate the extension on this conn */
@ -690,12 +682,11 @@ check_extensions:
/* allow him to construct his context */
ext->callback(wsi->protocol->owning_server,
ext, wsi,
LWS_EXT_CALLBACK_CLIENT_CONSTRUCT,
wsi->active_extensions_user[
ext->callback(wsi->protocol->owning_server, ext, wsi,
LWS_EXT_CALLBACK_CLIENT_CONSTRUCT,
wsi->active_extensions_user[
wsi->count_active_extensions],
NULL, 0);
NULL, 0);
wsi->count_active_extensions++;
@ -725,7 +716,7 @@ check_accept:
}
/* allocate the per-connection user memory (if any) */
if (libwebsocket_ensure_user_space(wsi)) {
if (lws_ensure_user_space(wsi)) {
lwsl_err("Problem allocating wsi user mem\n");
goto bail2;
}
@ -734,14 +725,13 @@ check_accept:
* we seem to be good to go, give client last chance to check
* headers and OK it
*/
wsi->protocol->callback(context, wsi,
LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH,
wsi->user_space, NULL, 0);
wsi->user_space, NULL, 0);
/* clear his proxy connection timeout */
libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
/* free up his parsing allocations */
@ -769,7 +759,8 @@ check_accept:
}
lwsl_info("Allocating client RX buffer %d\n", n);
if (setsockopt(wsi->sock, SOL_SOCKET, SO_SNDBUF, (const char *)&n, sizeof n)) {
if (setsockopt(wsi->sock, SOL_SOCKET, SO_SNDBUF, (const char *)&n,
sizeof n)) {
lwsl_warn("Failed to set SNDBUF to %d", n);
goto bail3;
}
@ -778,9 +769,8 @@ check_accept:
/* call him back to inform him he is up */
wsi->protocol->callback(context, wsi,
LWS_CALLBACK_CLIENT_ESTABLISHED,
wsi->user_space, NULL, 0);
wsi->protocol->callback(context, wsi, LWS_CALLBACK_CLIENT_ESTABLISHED,
wsi->user_space, NULL, 0);
#ifndef LWS_NO_EXTENSIONS
/*
* inform all extensions, not just active ones since they
@ -812,50 +802,45 @@ bail2:
if (isErrorCodeReceived && p) {
wsi->protocol->callback(context, wsi,
LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
wsi->user_space, p, (unsigned int)strlen(p));
wsi->user_space, p,
(unsigned int)strlen(p));
} else {
wsi->protocol->callback(context, wsi,
LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
wsi->user_space, NULL, 0);
wsi->user_space, NULL, 0);
}
}
lwsl_info("closing connection due to bail2 connection error\n");
/* free up his parsing allocations */
lws_free2(wsi->u.hdr.ah);
libwebsocket_close_and_free_session(context, wsi, close_reason);
lws_close_and_free_session(context, wsi, close_reason);
return 1;
}
char *
libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
struct libwebsocket *wsi, char *pkt)
lws_generate_client_handshake(struct lws_context *context,
struct lws *wsi, char *pkt)
{
char buf[128];
char hash[20];
char key_b64[40];
char *p = pkt;
char buf[128], hash[20], key_b64[40], *p = pkt;
int n;
#ifndef LWS_NO_EXTENSIONS
struct libwebsocket_extension *ext;
struct lws_extension *ext;
int ext_count = 0;
#endif
/*
* create the random key
*/
n = libwebsockets_get_random(context, hash, 16);
n = lws_get_random(context, hash, 16);
if (n != 16) {
lwsl_err("Unable to read from random dev %s\n",
SYSTEM_RANDOM_FILEPATH);
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
SYSTEM_RANDOM_FILEPATH);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return NULL;
}
@ -888,15 +873,16 @@ libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
*/
p += sprintf(p, "GET %s HTTP/1.1\x0d\x0a",
lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_URI));
lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_URI));
p += sprintf(p,
"Pragma: no-cache\x0d\x0a""Cache-Control: no-cache\x0d\x0a");
p += sprintf(p, "Pragma: no-cache\x0d\x0a"
"Cache-Control: no-cache\x0d\x0a");
p += sprintf(p, "Host: %s\x0d\x0a",
lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_HOST));
p += sprintf(p,
"Upgrade: websocket\x0d\x0a""Connection: Upgrade\x0d\x0a""Sec-WebSocket-Key: ");
lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_HOST));
p += sprintf(p, "Upgrade: websocket\x0d\x0a"
"Connection: Upgrade\x0d\x0a"
"Sec-WebSocket-Key: ");
strcpy(p, key_b64);
p += strlen(key_b64);
p += sprintf(p, "\x0d\x0a");
@ -917,7 +903,7 @@ libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
n = lws_ext_callback_for_each_extension_type(context, wsi,
LWS_EXT_CALLBACK_CHECK_OK_TO_PROPOSE_EXTENSION,
(char *)ext->name, 0);
(char *)ext->name, 0);
if (n) { /* an extension vetos us */
lwsl_ext("ext %s vetoed\n", (char *)ext->name);
ext++;
@ -954,13 +940,14 @@ libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
if (wsi->ietf_spec_revision)
p += sprintf(p, "Sec-WebSocket-Version: %d\x0d\x0a",
wsi->ietf_spec_revision);
wsi->ietf_spec_revision);
/* give userland a chance to append, eg, cookies */
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
NULL, &p, (pkt + sizeof(context->service_buffer)) - p - 12);
LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
NULL, &p,
(pkt + sizeof(context->service_buffer)) - p - 12);
p += sprintf(p, "\x0d\x0a");
@ -969,11 +956,11 @@ libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
key_b64[39] = '\0'; /* enforce composed length below buf sizeof */
n = sprintf(buf, "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", key_b64);
libwebsockets_SHA1((unsigned char *)buf, n, (unsigned char *)hash);
lws_SHA1((unsigned char *)buf, n, (unsigned char *)hash);
lws_b64_encode_string(hash, 20,
wsi->u.hdr.ah->initial_handshake_hash_base64,
sizeof(wsi->u.hdr.ah->initial_handshake_hash_base64));
wsi->u.hdr.ah->initial_handshake_hash_base64,
sizeof(wsi->u.hdr.ah->initial_handshake_hash_base64));
return p;
}

124
lib/context.c
View file

@ -42,15 +42,15 @@ lws_get_library_version(void)
}
/**
* libwebsocket_create_context() - Create the websocket handler
* lws_create_context() - Create the websocket handler
* @info: pointer to struct with parameters
*
* This function creates the listening socket (if serving) and takes care
* of all initialization in one step.
*
* After initialization, it returns a struct libwebsocket_context * that
* After initialization, it returns a struct lws_context * that
* represents this server. After calling, user code needs to take care
* of calling libwebsocket_service() with the context pointer to get the
* of calling lws_service() with the context pointer to get the
* server's sockets serviced. This must be done in the same process
* context as the initialization call.
*
@ -71,14 +71,14 @@ lws_get_library_version(void)
* one place; they're all handled in the user callback.
*/
LWS_VISIBLE struct libwebsocket_context *
libwebsocket_create_context(struct lws_context_creation_info *info)
LWS_VISIBLE struct lws_context *
lws_create_context(struct lws_context_creation_info *info)
{
struct libwebsocket_context *context = NULL;
char *p;
#if LWS_POSIX
struct lws_context *context = NULL;
#ifndef LWS_NO_DAEMONIZE
int pid_daemon = get_daemonize_pid();
#endif
char *p;
lwsl_notice("Initial logging level %d\n", log_level);
@ -91,9 +91,9 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
lwsl_notice("IPV6 compiled in but disabled\n");
#else
lwsl_notice("IPV6 not compiled in\n");
#endif
#endif
lws_feature_status_libev(info);
#endif
lwsl_info(" LWS_MAX_HEADER_LEN: %u\n", LWS_MAX_HEADER_LEN);
lwsl_info(" LWS_MAX_PROTOCOLS: %u\n", LWS_MAX_PROTOCOLS);
@ -106,18 +106,17 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
if (lws_plat_context_early_init())
return NULL;
context = lws_zalloc(sizeof(struct libwebsocket_context));
context = lws_zalloc(sizeof(struct lws_context));
if (!context) {
lwsl_err("No memory for websocket context\n");
return NULL;
}
#if LWS_POSIX
#ifndef LWS_NO_DAEMONIZE
if (pid_daemon) {
context->started_with_parent = pid_daemon;
lwsl_notice(" Started with daemon pid %d\n", pid_daemon);
}
#endif
context->listen_service_extraseen = 0;
context->protocols = info->protocols;
context->token_limits = info->token_limits;
@ -138,41 +137,31 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
#ifdef LWS_USE_LIBEV
/* (Issue #264) In order to *avoid breaking backwards compatibility*, we
* enable libev mediated SIGINT handling with a default handler of
* libwebsocket_sigint_cb. The handler can be overridden or disabled
* by invoking libwebsocket_sigint_cfg after creating the context, but
* before invoking libwebsocket_initloop:
* lws_sigint_cb. The handler can be overridden or disabled
* by invoking lws_sigint_cfg after creating the context, but
* before invoking lws_initloop:
*/
context->use_ev_sigint = 1;
context->lws_ev_sigint_cb = &libwebsocket_sigint_cb;
context->lws_ev_sigint_cb = &lws_sigint_cb;
#endif /* LWS_USE_LIBEV */
/* to reduce this allocation, */
context->max_fds = getdtablesize();
lwsl_notice(" static allocation: %u + (%u x %u fds) = %u bytes\n",
sizeof(struct libwebsocket_context),
sizeof(struct libwebsocket_pollfd) +
sizeof(struct libwebsocket *),
context->max_fds,
sizeof(struct libwebsocket_context) +
((sizeof(struct libwebsocket_pollfd) +
sizeof(struct libwebsocket *)) *
context->max_fds));
lwsl_notice(" ctx mem: %u bytes\n", sizeof(struct lws_context) +
((sizeof(struct lws_pollfd) + sizeof(struct lws *)) *
context->max_fds));
context->fds = lws_zalloc(sizeof(struct libwebsocket_pollfd) *
context->max_fds);
context->fds = lws_zalloc(sizeof(struct lws_pollfd) * context->max_fds);
if (context->fds == NULL) {
lwsl_err("Unable to allocate fds array for %d connections\n",
context->max_fds);
lwsl_err("OOM allocating %d fds\n", context->max_fds);
goto bail;
}
if (lws_plat_init_lookup(context)) {
if (lws_plat_init_lookup(context))
goto bail;
}
if (lws_plat_init_fd_tables(context)) {
if (lws_plat_init_fd_tables(context))
goto bail;
}
lws_context_init_file_callbacks(info, context);
@ -190,19 +179,17 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
/* override for backwards compatibility */
if (info->http_proxy_port)
context->http_proxy_port = info->http_proxy_port;
libwebsocket_set_proxy(context, info->http_proxy_address);
lws_set_proxy(context, info->http_proxy_address);
} else {
#ifdef LWS_HAVE_GETENV
p = getenv("http_proxy");
if (p)
libwebsocket_set_proxy(context, p);
lws_set_proxy(context, p);
#endif
}
lwsl_notice(
" per-conn mem: %u + %u headers + protocol rx buf\n",
sizeof(struct libwebsocket),
sizeof(struct allocated_headers));
lwsl_notice(" per-conn mem: %u + %u headers + protocol rx buf\n",
sizeof(struct lws), sizeof(struct allocated_headers));
if (lws_context_init_server_ssl(info, context))
goto bail;
@ -223,12 +210,8 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
/* initialize supported protocols */
for (context->count_protocols = 0;
info->protocols[context->count_protocols].callback;
context->count_protocols++) {
// lwsl_notice(" Protocol: %s\n",
// info->protocols[context->count_protocols].name);
info->protocols[context->count_protocols].callback;
context->count_protocols++) {
info->protocols[context->count_protocols].owning_server =
context;
info->protocols[context->count_protocols].protocol_index =
@ -246,27 +229,24 @@ libwebsocket_create_context(struct lws_context_creation_info *info)
* give all extensions a chance to create any per-context
* allocations they need
*/
if (info->port != CONTEXT_PORT_NO_LISTEN) {
if (lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_SERVER_CONTEXT_CONSTRUCT,
NULL, 0) < 0)
LWS_EXT_CALLBACK_SERVER_CONTEXT_CONSTRUCT, NULL, 0) < 0)
goto bail;
} else
if (lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_CLIENT_CONTEXT_CONSTRUCT,
NULL, 0) < 0)
LWS_EXT_CALLBACK_CLIENT_CONTEXT_CONSTRUCT, NULL, 0) < 0)
goto bail;
return context;
bail:
libwebsocket_context_destroy(context);
lws_context_destroy(context);
return NULL;
}
/**
* libwebsocket_context_destroy() - Destroy the websocket context
* lws_context_destroy() - Destroy the websocket context
* @context: Websocket context
*
* This function closes any active connections and then frees the
@ -274,12 +254,10 @@ bail:
* undefined.
*/
LWS_VISIBLE void
libwebsocket_context_destroy(struct libwebsocket_context *context)
lws_context_destroy(struct lws_context *context)
{
/* Note that this is used for freeing partially allocated structs as well
* so make sure you don't try to free something uninitialized */
struct lws_protocols *protocol = NULL;
int n;
struct libwebsocket_protocols *protocol = NULL;
lwsl_notice("%s\n", __func__);
@ -292,12 +270,12 @@ libwebsocket_context_destroy(struct libwebsocket_context *context)
#endif
for (n = 0; n < context->fds_count; n++) {
struct libwebsocket *wsi =
wsi_from_fd(context, context->fds[n].fd);
struct lws *wsi = wsi_from_fd(context, context->fds[n].fd);
if (!wsi)
continue;
libwebsocket_close_and_free_session(context,
wsi, LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY /* no protocol close */);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY
/* no protocol close */);
n--;
}
@ -305,20 +283,12 @@ libwebsocket_context_destroy(struct libwebsocket_context *context)
* give all extensions a chance to clean up any per-context
* allocations they might have made
*/
// TODO: I am not sure, but are we never supposed to be able to run a server
// and client at the same time for a given context?
// Otherwise both of these callbacks should always be called!
if (context->listen_port != CONTEXT_PORT_NO_LISTEN) {
if (lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_SERVER_CONTEXT_DESTRUCT, NULL, 0) < 0) {
lwsl_err("Got error from server extension callback on cleanup");
}
} else {
if (lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_CLIENT_CONTEXT_DESTRUCT, NULL, 0) < 0) {
lwsl_err("Got error from client extension callback on cleanup");
}
}
n = lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_SERVER_CONTEXT_DESTRUCT, NULL, 0);
n = lws_ext_callback_for_each_extension_type(context, NULL,
LWS_EXT_CALLBACK_CLIENT_CONTEXT_DESTRUCT, NULL, 0);
/*
* inform all the protocols that they are done and will have no more
@ -327,14 +297,14 @@ libwebsocket_context_destroy(struct libwebsocket_context *context)
protocol = context->protocols;
if (protocol) {
while (protocol->callback) {
protocol->callback(context, NULL, LWS_CALLBACK_PROTOCOL_DESTROY,
NULL, NULL, 0);
protocol->callback(context, NULL,
LWS_CALLBACK_PROTOCOL_DESTROY,
NULL, NULL, 0);
protocol++;
}
}
lws_plat_context_early_destroy(context);
lws_ssl_context_destroy(context);
if (context->fds)

11
lib/daemonize.c
View file

@ -34,9 +34,7 @@ int get_daemonize_pid()
static void
child_handler(int signum)
{
int fd;
int len;
int sent;
int fd, len, sent;
char sz[20];
switch (signum) {
@ -93,11 +91,10 @@ static void lws_daemon_closing(int sigact)
LWS_VISIBLE int
lws_daemonize(const char *_lock_path)
{
pid_t sid, parent;
int fd;
char buf[10];
int n, ret;
struct sigaction act;
pid_t sid, parent;
int n, fd, ret;
char buf[10];
/* already a daemon */
if (getppid() == 1)

8
lib/extension-deflate-frame.c
View file

@ -8,10 +8,10 @@
#define LWS_ZLIB_MEMLEVEL 8
int lws_extension_callback_deflate_frame(
struct libwebsocket_context *context,
struct libwebsocket_extension *ext,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons reason,
struct lws_context *context,
struct lws_extension *ext,
struct lws *wsi,
enum lws_extension_callback_reasons reason,
void *user, void *in, size_t len)
{
struct lws_ext_deflate_frame_conn *conn =

8
lib/extension-deflate-frame.h
View file

@ -18,8 +18,8 @@ struct lws_ext_deflate_frame_conn {
};
extern int lws_extension_callback_deflate_frame(
struct libwebsocket_context *context,
struct libwebsocket_extension *ext,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons reason,
struct lws_context *context,
struct lws_extension *ext,
struct lws *wsi,
enum lws_extension_callback_reasons reason,
void *user, void *in, size_t len);

8
lib/extension-deflate-stream.c
View file

@ -8,10 +8,10 @@
#define LWS_ZLIB_MEMLEVEL 8
int lws_extension_callback_deflate_stream(
struct libwebsocket_context *context,
struct libwebsocket_extension *ext,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons reason,
struct lws_context *context,
struct lws_extension *ext,
struct lws *wsi,
enum lws_extension_callback_reasons reason,
void *user, void *in, size_t len)
{
struct lws_ext_deflate_stream_conn *conn =

8
lib/extension-deflate-stream.h
View file

@ -13,8 +13,8 @@ struct lws_ext_deflate_stream_conn {
};
extern int lws_extension_callback_deflate_stream(
struct libwebsocket_context *context,
struct libwebsocket_extension *ext,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons reason,
struct lws_context *context,
struct lws_extension *ext,
struct lws *wsi,
enum lws_extension_callback_reasons reason,
void *user, void *in, size_t len);

24
lib/extension.c
View file

@ -3,7 +3,7 @@
#include "extension-deflate-frame.h"
#include "extension-deflate-stream.h"
struct libwebsocket_extension libwebsocket_internal_extensions[] = {
struct lws_extension lws_internal_extensions[] = {
#ifdef LWS_EXT_DEFLATE_STREAM
{
"deflate-stream",
@ -29,21 +29,21 @@ struct libwebsocket_extension libwebsocket_internal_extensions[] = {
LWS_VISIBLE void
lws_context_init_extensions(struct lws_context_creation_info *info,
struct libwebsocket_context *context)
struct lws_context *context)
{
context->extensions = info->extensions;
lwsl_info(" LWS_MAX_EXTENSIONS_ACTIVE: %u\n", LWS_MAX_EXTENSIONS_ACTIVE);
}
LWS_VISIBLE struct libwebsocket_extension *libwebsocket_get_internal_extensions()
LWS_VISIBLE struct lws_extension *lws_get_internal_extensions()
{
return libwebsocket_internal_extensions;
return lws_internal_extensions;
}
/* 0 = nobody had nonzero return, 1 = somebody had positive return, -1 = fail */
int lws_ext_callback_for_each_active(struct libwebsocket *wsi, int reason,
int lws_ext_callback_for_each_active(struct lws *wsi, int reason,
void *arg, int len)
{
int n, m, handled = 0;
@ -69,11 +69,11 @@ int lws_ext_callback_for_each_active(struct libwebsocket *wsi, int reason,
}
int lws_ext_callback_for_each_extension_type(
struct libwebsocket_context *context, struct libwebsocket *wsi,
struct lws_context *context, struct lws *wsi,
int reason, void *arg, int len)
{
int n = 0, m, handled = 0;
struct libwebsocket_extension *ext = context->extensions;
struct lws_extension *ext = context->extensions;
while (ext && ext->callback && !handled) {
m = ext->callback(context, ext, wsi, reason,
@ -95,7 +95,7 @@ int lws_ext_callback_for_each_extension_type(
}
int
lws_issue_raw_ext_access(struct libwebsocket *wsi,
lws_issue_raw_ext_access(struct lws *wsi,
unsigned char *buf, size_t len)
{
int ret;
@ -175,7 +175,7 @@ lws_issue_raw_ext_access(struct libwebsocket *wsi,
* Yes, he's choked. Don't spill the rest now get a callback
* when he is ready to send and take care of it there
*/
libwebsocket_callback_on_writable(
lws_callback_on_writable(
wsi->protocol->owning_server, wsi);
wsi->extension_data_pending = 1;
ret = 0;
@ -185,9 +185,9 @@ lws_issue_raw_ext_access(struct libwebsocket *wsi,
}
int
lws_any_extension_handled(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons r,
lws_any_extension_handled(struct lws_context *context,
struct lws *wsi,
enum lws_extension_callback_reasons r,
void *v, size_t len)
{
int n;

83
lib/handshake.c
View file

@ -1,7 +1,7 @@
/*
* libwebsockets - small server side websockets and web server implementation
*
* Copyright (C) 2010-2013 Andy Green <andy@warmcat.com>
* Copyright (C) 2010-2015 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
@ -49,6 +49,7 @@
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
/*
* We have to take care about parsing because the headers may be split
* into multiple fragments. They may contain unknown headers with arbitrary
@ -57,12 +58,12 @@
*/
LWS_VISIBLE int
libwebsocket_read(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, size_t len)
lws_read(struct lws_context *context, struct lws *wsi, unsigned char *buf,
size_t len)
{
size_t n;
int body_chunk_len;
unsigned char *last_char;
int body_chunk_len;
size_t n;
switch (wsi->state) {
#ifdef LWS_USE_HTTP2
@ -124,8 +125,13 @@ http_new:
case WSI_STATE_HTTP_ISSUING_FILE:
goto read_ok;
case WSI_STATE_HTTP_BODY:
wsi->u.http.content_remain = wsi->u.http.content_length;
goto http_postbody;
wsi->u.http.content_remain =
wsi->u.http.content_length;
if (wsi->u.http.content_remain)
goto http_postbody;
/* there is no POST content */
goto postbody_completion;
default:
break;
}
@ -142,32 +148,31 @@ http_postbody:
wsi->u.http.content_remain -= body_chunk_len;
len -= body_chunk_len;
if (wsi->protocol->callback) {
n = wsi->protocol->callback(
wsi->protocol->owning_server, wsi,
LWS_CALLBACK_HTTP_BODY, wsi->user_space,
buf, body_chunk_len);
if (n)
goto bail;
}
n = wsi->protocol->callback(
wsi->protocol->owning_server, wsi,
LWS_CALLBACK_HTTP_BODY, wsi->user_space,
buf, body_chunk_len);
if (n)
goto bail;
buf += body_chunk_len;
if (!wsi->u.http.content_remain) {
/* he sent the content in time */
libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
if (wsi->protocol->callback) {
n = wsi->protocol->callback(
wsi->protocol->owning_server, wsi,
LWS_CALLBACK_HTTP_BODY_COMPLETION,
wsi->user_space, NULL, 0);
if (n)
goto bail;
}
goto http_complete;
} else
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_HTTP_CONTENT,
AWAITING_TIMEOUT);
if (wsi->u.http.content_remain) {
lws_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT,
AWAITING_TIMEOUT);
break;
}
/* he sent all the content in time */
postbody_completion:
lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
n = wsi->protocol->callback(
wsi->protocol->owning_server, wsi,
LWS_CALLBACK_HTTP_BODY_COMPLETION,
wsi->user_space, NULL, 0);
if (n)
goto bail;
goto http_complete;
}
break;
@ -178,7 +183,7 @@ http_postbody:
switch (wsi->mode) {
case LWS_CONNMODE_WS_SERVING:
if (libwebsocket_interpret_incoming_packet(wsi, buf, len) < 0) {
if (lws_interpret_incoming_packet(wsi, buf, len) < 0) {
lwsl_info("interpret_incoming_packet has bailed\n");
goto bail;
}
@ -186,18 +191,18 @@ http_postbody:
}
break;
default:
lwsl_err("libwebsocket_read: Unhandled state\n");
lwsl_err("lws_read: Unhandled state\n");
break;
}
read_ok:
/* Nothing more to do for now. */
lwsl_debug("libwebsocket_read: read_ok\n");
/* Nothing more to do for now */
lwsl_debug("lws_read: read_ok\n");
return 0;
http_complete:
lwsl_debug("libwebsocket_read: http_complete\n");
lwsl_debug("lws_read: http_complete\n");
#ifndef LWS_NO_SERVER
/* Did the client want to keep the HTTP connection going? */
@ -211,10 +216,8 @@ http_complete:
return 0;
bail:
lwsl_debug("closing connection at libwebsocket_read bail:\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lwsl_debug("closing connection at lws_read bail:\n");
lws_close_and_free_session(context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
return -1;
}

87
lib/header.c
View file

@ -24,22 +24,25 @@
const unsigned char *lws_token_to_string(enum lws_token_indexes token)
{
if (token == WSI_TOKEN_HTTP_URI_ARGS)
return (unsigned char *)"Uri-Args:";
if ((unsigned int)token >= ARRAY_SIZE(set))
return NULL;
return (unsigned char *)set[token];
}
int lws_add_http_header_by_name(struct libwebsocket_context *context,
struct libwebsocket *wsi,
int
lws_add_http_header_by_name(struct lws_context *context, struct lws *wsi,
const unsigned char *name,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end)
const unsigned char *value, int length,
unsigned char **p, unsigned char *end)
{
#ifdef LWS_USE_HTTP2
if (wsi->mode == LWS_CONNMODE_HTTP2_SERVING)
return lws_add_http2_header_by_name(context, wsi, name, value, length, p, end);
return lws_add_http2_header_by_name(context, wsi, name,
value, length, p, end);
#else
(void)wsi;
(void)context;
@ -58,13 +61,12 @@ int lws_add_http_header_by_name(struct libwebsocket_context *context,
*p += length;
*((*p)++) = '\x0d';
*((*p)++) = '\x0a';
return 0;
}
int lws_finalize_http_header(struct libwebsocket_context *context,
struct libwebsocket *wsi,
unsigned char **p,
unsigned char *end)
int lws_finalize_http_header(struct lws_context *context, struct lws *wsi,
unsigned char **p, unsigned char *end)
{
(void)context;
#ifdef LWS_USE_HTTP2
@ -77,16 +79,15 @@ int lws_finalize_http_header(struct libwebsocket_context *context,
return 1;
*((*p)++) = '\x0d';
*((*p)++) = '\x0a';
return 0;
}
int lws_add_http_header_by_token(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum lws_token_indexes token,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end)
int
lws_add_http_header_by_token(struct lws_context *context, struct lws *wsi,
enum lws_token_indexes token,
const unsigned char *value, int length,
unsigned char **p, unsigned char *end)
{
const unsigned char *name;
#ifdef LWS_USE_HTTP2
@ -99,11 +100,10 @@ int lws_add_http_header_by_token(struct libwebsocket_context *context,
return lws_add_http_header_by_name(context, wsi, name, value, length, p, end);
}
int lws_add_http_header_content_length(struct libwebsocket_context *context,
struct libwebsocket *wsi,
unsigned long content_length,
unsigned char **p,
unsigned char *end)
int lws_add_http_header_content_length(struct lws_context *context,
struct lws *wsi,
unsigned long content_length,
unsigned char **p, unsigned char *end)
{
char b[24];
int n;
@ -147,11 +147,10 @@ static const char *err500[] = {
"HTTP Version Not Supported"
};
int lws_add_http_header_status(struct libwebsocket_context *context,
struct libwebsocket *wsi,
unsigned int code,
unsigned char **p,
unsigned char *end)
int
lws_add_http_header_status(struct lws_context *context, struct lws *wsi,
unsigned int code, unsigned char **p,
unsigned char *end)
{
unsigned char code_and_desc[60];
const char *description = "";
@ -168,11 +167,12 @@ int lws_add_http_header_status(struct libwebsocket_context *context,
n = sprintf((char *)code_and_desc, "HTTP/1.0 %u %s", code, description);
return lws_add_http_header_by_name(context, wsi, NULL, code_and_desc, n, p, end);
return lws_add_http_header_by_name(context, wsi, NULL, code_and_desc,
n, p, end);
}
/**
* libwebsockets_return_http_status() - Return simple http status
* lws_return_http_status() - Return simple http status
* @context: libwebsockets context
* @wsi: Websocket instance (available from user callback)
* @code: Status index, eg, 404
@ -181,35 +181,42 @@ int lws_add_http_header_status(struct libwebsocket_context *context,
* Helper to report HTTP errors back to the client cleanly and
* consistently
*/
LWS_VISIBLE int libwebsockets_return_http_status(
struct libwebsocket_context *context, struct libwebsocket *wsi,
unsigned int code, const char *html_body)
LWS_VISIBLE int
lws_return_http_status(struct lws_context *context, struct lws *wsi,
unsigned int code, const char *html_body)
{
int n, m;
unsigned char *p = context->service_buffer + LWS_SEND_BUFFER_PRE_PADDING;
unsigned char *p = context->service_buffer +
LWS_SEND_BUFFER_PRE_PADDING;
unsigned char *start = p;
unsigned char *end = p + sizeof(context->service_buffer) -
LWS_SEND_BUFFER_PRE_PADDING;
LWS_SEND_BUFFER_PRE_PADDING;
if (!html_body)
html_body = "";
if (lws_add_http_header_status(context, wsi, code, &p, end))
return 1;
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_SERVER, (unsigned char *)"libwebsockets", 13, &p, end))
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_SERVER,
(unsigned char *)"libwebsockets", 13,
&p, end))
return 1;
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_CONTENT_TYPE, (unsigned char *)"text/html", 9, &p, end))
if (lws_add_http_header_by_token(context, wsi,
WSI_TOKEN_HTTP_CONTENT_TYPE,
(unsigned char *)"text/html", 9,
&p, end))
return 1;
if (lws_finalize_http_header(context, wsi, &p, end))
return 1;
m = libwebsocket_write(wsi, start, p - start, LWS_WRITE_HTTP_HEADERS);
m = lws_write(wsi, start, p - start, LWS_WRITE_HTTP_HEADERS);
if (m != (int)(p - start))
return 1;
n = sprintf((char *)start, "<html><body><h1>%u</h1>%s</body></html>", code, html_body);
m = libwebsocket_write(wsi, start, n, LWS_WRITE_HTTP);
n = sprintf((char *)start, "<html><body><h1>%u</h1>%s</body></html>",
code, html_body);
m = lws_write(wsi, start, n, LWS_WRITE_HTTP);
return m != n;
}

93
lib/hpack.c
View file

@ -189,13 +189,13 @@ static int huftable_decode(int pos, char c)
return pos + (lextable[q] << 1);
}
static int lws_hpack_update_table_size(struct libwebsocket *wsi, int idx)
static int lws_hpack_update_table_size(struct lws *wsi, int idx)
{
lwsl_info("hpack set table size %d\n", idx);
return 0;
}
static int lws_frag_start(struct libwebsocket *wsi, int hdr_token_idx)
static int lws_frag_start(struct lws *wsi, int hdr_token_idx)
{
struct allocated_headers * ah = wsi->u.http2.http.ah;
@ -214,7 +214,7 @@ static int lws_frag_start(struct libwebsocket *wsi, int hdr_token_idx)
return 0;
}
static int lws_frag_append(struct libwebsocket *wsi, unsigned char c)
static int lws_frag_append(struct lws *wsi, unsigned char c)
{
struct allocated_headers * ah = wsi->u.http2.http.ah;
@ -224,7 +224,7 @@ static int lws_frag_append(struct libwebsocket *wsi, unsigned char c)
return ah->pos >= sizeof(ah->data);
}
static int lws_frag_end(struct libwebsocket *wsi)
static int lws_frag_end(struct lws *wsi)
{
if (lws_frag_append(wsi, 0))
return 1;
@ -233,7 +233,7 @@ static int lws_frag_end(struct libwebsocket *wsi)
return 0;
}
static void lws_dump_header(struct libwebsocket *wsi, int hdr)
static void lws_dump_header(struct lws *wsi, int hdr)
{
char s[200];
int len = lws_hdr_copy(wsi, s, sizeof(s) - 1, hdr);
@ -241,7 +241,8 @@ static void lws_dump_header(struct libwebsocket *wsi, int hdr)
lwsl_info(" hdr tok %d (%s) = '%s'\n", hdr, lws_token_to_string(hdr), s);
}
static int lws_token_from_index(struct libwebsocket *wsi, int index, char **arg, int *len)
static int
lws_token_from_index(struct lws *wsi, int index, char **arg, int *len)
{
struct hpack_dynamic_table *dyn;
@ -269,7 +270,8 @@ static int lws_token_from_index(struct libwebsocket *wsi, int index, char **arg,
return dyn->entries[index].token;
}
static int lws_hpack_add_dynamic_header(struct libwebsocket *wsi, int token, char *arg, int len)
static int
lws_hpack_add_dynamic_header(struct lws *wsi, int token, char *arg, int len)
{
struct hpack_dynamic_table *dyn;
int ret = 1;
@ -305,7 +307,8 @@ static int lws_hpack_add_dynamic_header(struct libwebsocket *wsi, int token, cha
memcpy(dyn->args + dyn->pos, arg, len);
dyn->entries[dyn->next].arg_len = len;
lwsl_info("%s: added dynamic hdr %d, token %d (%s), len %d\n", __func__, dyn->next, token, lws_token_to_string(token), len);
lwsl_info("%s: added dynamic hdr %d, token %d (%s), len %d\n",
__func__, dyn->next, token, lws_token_to_string(token), len);
dyn->pos += len;
dyn->next++;
@ -321,12 +324,13 @@ bail1:
return ret;
}
static int lws_write_indexed_hdr(struct libwebsocket *wsi, int idx)
static int lws_write_indexed_hdr(struct lws *wsi, int idx)
{
const char *p;
int tok = lws_token_from_index(wsi, idx, NULL, 0);
lwsl_info("writing indexed hdr %d (tok %d '%s')\n", idx, tok, lws_token_to_string(tok));
lwsl_info("writing indexed hdr %d (tok %d '%s')\n", idx, tok,
lws_token_to_string(tok));
if (lws_frag_start(wsi, tok))
return 1;
@ -345,8 +349,8 @@ static int lws_write_indexed_hdr(struct libwebsocket *wsi, int idx)
return 0;
}
int lws_hpack_interpret(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char c)
int lws_hpack_interpret(struct lws_context *context,
struct lws *wsi, unsigned char c)
{
unsigned int prev;
unsigned char c1;
@ -492,9 +496,9 @@ int lws_hpack_interpret(struct libwebsocket_context *context,
if (wsi->u.http2.hpack_len < 0x7f) {
pre_data:
if (wsi->u.http2.value) {
if (lws_frag_start(wsi,
lws_token_from_index(wsi,
wsi->u.http2.header_index, NULL, NULL)))
if (lws_frag_start(wsi, lws_token_from_index(wsi,
wsi->u.http2.header_index,
NULL, NULL)))
return 1;
} else
wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
@ -518,10 +522,9 @@ pre_data:
for (n = 0; n < 8; n++) {
if (wsi->u.http2.huff) {
prev = wsi->u.http2.hpack_pos;
wsi->u.http2.hpack_pos =
huftable_decode(
wsi->u.http2.hpack_pos = huftable_decode(
wsi->u.http2.hpack_pos,
(c >> 7) & 1);
(c >> 7) & 1);
c <<= 1;
if (wsi->u.http2.hpack_pos == 0xffff)
return 1;
@ -540,7 +543,7 @@ pre_data:
if (lws_frag_append(wsi, c1))
return 1;
} else { /* name */
if (libwebsocket_parse(context, wsi, c1))
if (lws_parse(context, wsi, c1))
return 1;
}
@ -550,7 +553,10 @@ pre_data:
switch (wsi->u.http2.hpack_type) {
case HPKT_LITERAL_HDR_VALUE_INCR:
case HPKT_INDEXED_HDR_6_VALUE_INCR: // !!!
if (lws_hpack_add_dynamic_header(wsi, lws_token_from_index(wsi, wsi->u.http2.header_index, NULL, NULL), NULL, 0))
if (lws_hpack_add_dynamic_header(wsi,
lws_token_from_index(wsi,
wsi->u.http2.header_index,
NULL, NULL), NULL, 0))
return 1;
break;
default:
@ -562,8 +568,11 @@ pre_data:
if (lws_frag_end(wsi))
return 1;
lws_dump_header(wsi, lws_token_from_index(wsi, wsi->u.http2.header_index, NULL, NULL));
if (wsi->u.http2.count + wsi->u.http2.padding == wsi->u.http2.length)
lws_dump_header(wsi, lws_token_from_index(
wsi, wsi->u.http2.header_index,
NULL, NULL));
if (wsi->u.http2.count + wsi->u.http2.padding ==
wsi->u.http2.length)
wsi->u.http2.hpack = HKPS_OPT_DISCARD_PADDING;
else
wsi->u.http2.hpack = HPKS_TYPE;
@ -585,7 +594,8 @@ pre_data:
return 0;
}
static int lws_http2_num(int starting_bits, unsigned long num, unsigned char **p, unsigned char *end)
static int lws_http2_num(int starting_bits, unsigned long num,
unsigned char **p, unsigned char *end)
{
int mask = (1 << starting_bits) - 1;
@ -609,13 +619,10 @@ static int lws_http2_num(int starting_bits, unsigned long num, unsigned char **p
return 0;
}
int lws_add_http2_header_by_name(struct libwebsocket_context *context,
struct libwebsocket *wsi,
const unsigned char *name,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end)
int lws_add_http2_header_by_name(struct lws_context *context, struct lws *wsi,
const unsigned char *name,
const unsigned char *value, int length,
unsigned char **p, unsigned char *end)
{
int len;
@ -647,13 +654,10 @@ int lws_add_http2_header_by_name(struct libwebsocket_context *context,
return 0;
}
int lws_add_http2_header_by_token(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum lws_token_indexes token,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end)
int lws_add_http2_header_by_token(struct lws_context *context, struct lws *wsi,
enum lws_token_indexes token,
const unsigned char *value, int length,
unsigned char **p, unsigned char *end)
{
const unsigned char *name;
@ -661,14 +665,13 @@ int lws_add_http2_header_by_token(struct libwebsocket_context *context,
if (!name)
return 1;
return lws_add_http2_header_by_name(context, wsi, name, value, length, p, end);
return lws_add_http2_header_by_name(context, wsi, name, value,
length, p, end);
}
int lws_add_http2_header_status(struct libwebsocket_context *context,
struct libwebsocket *wsi,
unsigned int code,
unsigned char **p,
unsigned char *end)
int lws_add_http2_header_status(struct lws_context *context, struct lws *wsi,
unsigned int code, unsigned char **p,
unsigned char *end)
{
unsigned char status[10];
int n;
@ -676,7 +679,9 @@ int lws_add_http2_header_status(struct libwebsocket_context *context,
wsi->u.http2.send_END_STREAM = !!(code >= 400);
n = sprintf((char *)status, "%u", code);
if (lws_add_http2_header_by_token(context, wsi, WSI_TOKEN_HTTP_COLON_STATUS, status, n, p, end))
if (lws_add_http2_header_by_token(context, wsi,
WSI_TOKEN_HTTP_COLON_STATUS, status,
n, p, end))
return 1;
return 0;

64
lib/http2.c
View file

@ -38,8 +38,8 @@ void lws_http2_init(struct http2_settings *settings)
memcpy(settings, lws_http2_default_settings.setting, sizeof(*settings));
}
struct libwebsocket *
lws_http2_wsi_from_id(struct libwebsocket *wsi, unsigned int sid)
struct lws *
lws_http2_wsi_from_id(struct lws *wsi, unsigned int sid)
{
do {
if (wsi->u.http2.my_stream_id == sid)
@ -51,16 +51,19 @@ lws_http2_wsi_from_id(struct libwebsocket *wsi, unsigned int sid)
return NULL;
}
struct libwebsocket *
lws_create_server_child_wsi(struct libwebsocket_context *context, struct libwebsocket *parent_wsi, unsigned int sid)
struct lws *
lws_create_server_child_wsi(struct lws_context *context, struct lws *parent_wsi,
unsigned int sid)
{
struct libwebsocket *wsi = libwebsocket_create_new_server_wsi(context);
struct lws *wsi = lws_create_new_server_wsi(context);
if (!wsi)
return NULL;
/* no more children allowed by parent */
if (parent_wsi->u.http2.child_count + 1 == parent_wsi->u.http2.peer_settings.setting[LWS_HTTP2_SETTINGS__MAX_CONCURRENT_STREAMS])
if (parent_wsi->u.http2.child_count + 1 ==
parent_wsi->u.http2.peer_settings.setting[
LWS_HTTP2_SETTINGS__MAX_CONCURRENT_STREAMS])
return NULL;
lws_http2_init(&wsi->u.http2.peer_settings);
@ -80,16 +83,17 @@ lws_create_server_child_wsi(struct libwebsocket_context *context, struct libwebs
wsi->mode = parent_wsi->mode;
wsi->protocol = &context->protocols[0];
libwebsocket_ensure_user_space(wsi);
lws_ensure_user_space(wsi);
lwsl_info("%s: %p new child %p, sid %d, user_space=%p\n", __func__, parent_wsi, wsi, sid, wsi->user_space);
lwsl_info("%s: %p new child %p, sid %d, user_space=%p\n", __func__,
parent_wsi, wsi, sid, wsi->user_space);
return wsi;
}
int lws_remove_server_child_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
int lws_remove_server_child_wsi(struct lws_context *context, struct lws *wsi)
{
struct libwebsocket **w = &wsi->u.http2.parent_wsi;
struct lws **w = &wsi->u.http2.parent_wsi;
do {
if (*w == wsi) {
*w = wsi->u.http2.next_child_wsi;
@ -105,7 +109,8 @@ int lws_remove_server_child_wsi(struct libwebsocket_context *context, struct lib
}
int
lws_http2_interpret_settings_payload(struct http2_settings *settings, unsigned char *buf, int len)
lws_http2_interpret_settings_payload(struct http2_settings *settings,
unsigned char *buf, int len)
{
unsigned int a, b;
@ -132,7 +137,7 @@ lws_http2_interpret_settings_payload(struct http2_settings *settings, unsigned c
return 0;
}
struct libwebsocket *lws_http2_get_network_wsi(struct libwebsocket *wsi)
struct lws *lws_http2_get_network_wsi(struct lws *wsi)
{
while (wsi->u.http2.parent_wsi)
wsi = wsi->u.http2.parent_wsi;
@ -140,9 +145,10 @@ struct libwebsocket *lws_http2_get_network_wsi(struct libwebsocket *wsi)
return wsi;
}
int lws_http2_frame_write(struct libwebsocket *wsi, int type, int flags, unsigned int sid, unsigned int len, unsigned char *buf)
int lws_http2_frame_write(struct lws *wsi, int type, int flags,
unsigned int sid, unsigned int len, unsigned char *buf)
{
struct libwebsocket *wsi_eff = lws_http2_get_network_wsi(wsi);
struct lws *wsi_eff = lws_http2_get_network_wsi(wsi);
unsigned char *p = &buf[-LWS_HTTP2_FRAME_HEADER_LENGTH];
int n;
@ -157,22 +163,26 @@ int lws_http2_frame_write(struct libwebsocket *wsi, int type, int flags, unsigne
*p++ = sid;
lwsl_info("%s: %p (eff %p). type %d, flags 0x%x, sid=%d, len=%d\n",
__func__, wsi, wsi_eff, type, flags, sid, len, wsi->u.http2.tx_credit);
__func__, wsi, wsi_eff, type, flags, sid, len,
wsi->u.http2.tx_credit);
if (type == LWS_HTTP2_FRAME_TYPE_DATA) {
if (wsi->u.http2.tx_credit < len)
lwsl_err("%s: %p: sending payload len %d but tx_credit only %d!\n", len, wsi->u.http2.tx_credit);
lwsl_err("%s: %p: sending payload len %d"
" but tx_credit only %d!\n", len,
wsi->u.http2.tx_credit);
wsi->u.http2.tx_credit -= len;
}
n = lws_issue_raw(wsi_eff, &buf[-LWS_HTTP2_FRAME_HEADER_LENGTH], len + LWS_HTTP2_FRAME_HEADER_LENGTH);
n = lws_issue_raw(wsi_eff, &buf[-LWS_HTTP2_FRAME_HEADER_LENGTH],
len + LWS_HTTP2_FRAME_HEADER_LENGTH);
if (n >= LWS_HTTP2_FRAME_HEADER_LENGTH)
return n - LWS_HTTP2_FRAME_HEADER_LENGTH;
return n;
}
static void lws_http2_settings_write(struct libwebsocket *wsi, int n, unsigned char *buf)
static void lws_http2_settings_write(struct lws *wsi, int n, unsigned char *buf)
{
*buf++ = n >> 8;
*buf++ = n;
@ -186,12 +196,11 @@ static const char * https_client_preface =
"PRI * HTTP/2.0\x0d\x0a\x0d\x0aSM\x0d\x0a\x0d\x0a";
int
lws_http2_parser(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char c)
lws_http2_parser(struct lws_context *context, struct lws *wsi, unsigned char c)
{
struct libwebsocket *swsi;
struct lws *swsi;
int n;
//dstruct libwebsocket *wsi_new;
//dstruct lws *wsi_new;
switch (wsi->state) {
case WSI_STATE_HTTP2_AWAIT_CLIENT_PREFACE:
@ -210,7 +219,8 @@ lws_http2_parser(struct libwebsocket_context *context,
* and the peer must send a SETTINGS with ACK flag...
*/
lws_set_protocol_write_pending(context, wsi, LWS_PPS_HTTP2_MY_SETTINGS);
lws_set_protocol_write_pending(context, wsi,
LWS_PPS_HTTP2_MY_SETTINGS);
}
break;
@ -303,7 +313,7 @@ lws_http2_parser(struct libwebsocket_context *context,
if (swsi->u.http2.waiting_tx_credit && swsi->u.http2.tx_credit > 0) {
lwsl_info("%s: %p: waiting_tx_credit -> wait on writeable\n", __func__, wsi);
swsi->u.http2.waiting_tx_credit = 0;
libwebsocket_callback_on_writable(context, swsi);
lws_callback_on_writable(context, swsi);
}
break;
}
@ -413,10 +423,10 @@ update_end_headers:
return 0;
}
int lws_http2_do_pps_send(struct libwebsocket_context *context, struct libwebsocket *wsi)
int lws_http2_do_pps_send(struct lws_context *context, struct lws *wsi)
{
unsigned char settings[LWS_SEND_BUFFER_PRE_PADDING + 6 * LWS_HTTP2_SETTINGS__COUNT];
struct libwebsocket *swsi;
struct lws *swsi;
int n, m = 0;
lwsl_debug("%s: %p: %d\n", __func__, wsi, wsi->pps);
@ -497,7 +507,7 @@ int lws_http2_do_pps_send(struct libwebsocket_context *context, struct libwebsoc
return 0;
}
struct libwebsocket * lws_http2_get_nth_child(struct libwebsocket *wsi, int n)
struct lws * lws_http2_get_nth_child(struct lws *wsi, int n)
{
do {
wsi = wsi->u.http2.next_child_wsi;

38
lib/libev.c
View file

@ -30,11 +30,11 @@ void lws_feature_status_libev(struct lws_context_creation_info *info)
}
static void
libwebsocket_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
lws_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
{
struct libwebsocket_pollfd eventfd;
struct lws_pollfd eventfd;
struct lws_io_watcher *lws_io = container_of(watcher, struct lws_io_watcher, watcher);
struct libwebsocket_context *context = lws_io->context;
struct lws_context *context = lws_io->context;
if (revents & EV_ERROR)
return;
@ -47,18 +47,18 @@ libwebsocket_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
if (revents & EV_WRITE)
eventfd.revents |= LWS_POLLOUT;
libwebsocket_service_fd(context, &eventfd);
lws_service_fd(context, &eventfd);
}
LWS_VISIBLE void
libwebsocket_sigint_cb(struct ev_loop *loop,
lws_sigint_cb(struct ev_loop *loop,
struct ev_signal *watcher, int revents)
{
ev_break(loop, EVBREAK_ALL);
}
LWS_VISIBLE int libwebsocket_sigint_cfg(
struct libwebsocket_context *context,
LWS_VISIBLE int lws_sigint_cfg(
struct lws_context *context,
int use_ev_sigint,
lws_ev_signal_cb* cb)
{
@ -67,14 +67,14 @@ LWS_VISIBLE int libwebsocket_sigint_cfg(
context->lws_ev_sigint_cb = cb;
}
else {
context->lws_ev_sigint_cb = &libwebsocket_sigint_cb;
context->lws_ev_sigint_cb = &lws_sigint_cb;
};
return 0;
};
LWS_VISIBLE int
libwebsocket_initloop(
struct libwebsocket_context *context,
lws_initloop(
struct lws_context *context,
struct ev_loop *loop)
{
int status = 0;
@ -92,7 +92,7 @@ libwebsocket_initloop(
* Initialize the accept w_accept with the listening socket
* and register a callback for read operations:
*/
ev_io_init(w_accept, libwebsocket_accept_cb,
ev_io_init(w_accept, lws_accept_cb,
context->listen_service_fd, EV_READ);
ev_io_start(context->io_loop,w_accept);
@ -133,8 +133,8 @@ libwebsocket_initloop(
}
LWS_VISIBLE void
lws_libev_accept(struct libwebsocket_context *context,
struct libwebsocket *new_wsi, int accept_fd)
lws_libev_accept(struct lws_context *context,
struct lws *new_wsi, int accept_fd)
{
struct ev_io *r = &new_wsi->w_read.watcher;
struct ev_io *w = &new_wsi->w_write.watcher;
@ -144,13 +144,13 @@ lws_libev_accept(struct libwebsocket_context *context,
new_wsi->w_read.context = context;
new_wsi->w_write.context = context;
ev_io_init(r, libwebsocket_accept_cb, accept_fd, EV_READ);
ev_io_init(w, libwebsocket_accept_cb, accept_fd, EV_WRITE);
ev_io_init(r, lws_accept_cb, accept_fd, EV_READ);
ev_io_init(w, lws_accept_cb, accept_fd, EV_WRITE);
}
LWS_VISIBLE void
lws_libev_io(struct libwebsocket_context *context,
struct libwebsocket *wsi, int flags)
lws_libev_io(struct lws_context *context,
struct lws *wsi, int flags)
{
if (!LWS_LIBEV_ENABLED(context))
return;
@ -175,7 +175,7 @@ lws_libev_io(struct libwebsocket_context *context,
}
LWS_VISIBLE int
lws_libev_init_fd_table(struct libwebsocket_context *context)
lws_libev_init_fd_table(struct lws_context *context)
{
if (!LWS_LIBEV_ENABLED(context))
return 0;
@ -187,7 +187,7 @@ lws_libev_init_fd_table(struct libwebsocket_context *context)
}
LWS_VISIBLE void
lws_libev_run(struct libwebsocket_context *context)
lws_libev_run(struct lws_context *context)
{
if (context->io_loop && LWS_LIBEV_ENABLED(context))
ev_run(context->io_loop, 0);

554
lib/libwebsockets.c
View file

@ -38,43 +38,46 @@ static const char * const log_level_names[] = {
};
void
lws_free_wsi(struct libwebsocket *wsi)
lws_free_wsi(struct lws *wsi)
{
if (!wsi)
return;
/* Protocol user data may be allocated either internally by lws
* or by specified the user. Important we don't free external user data */
if (wsi->protocol && wsi->protocol->per_session_data_size
&& wsi->user_space && !wsi->user_space_externally_allocated) {
* or by specified the user.
* We should only free what we allocated. */
if (wsi->protocol && wsi->protocol->per_session_data_size &&
wsi->user_space && !wsi->user_space_externally_allocated)
lws_free(wsi->user_space);
}
lws_free2(wsi->rxflow_buffer);
lws_free2(wsi->truncated_send_malloc);
// TODO: Probably should handle the union structs in wsi->u here depending
// on connection mode as well. Too spaghetti for me to follow however...
lws_free_header_table(wsi);
lws_free(wsi);
}
void
libwebsocket_close_and_free_session(struct libwebsocket_context *context,
struct libwebsocket *wsi, enum lws_close_status reason)
lws_close_and_free_session(struct lws_context *context,
struct lws *wsi, enum lws_close_status reason)
{
int n, m, ret;
int old_state;
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 2 +
LWS_SEND_BUFFER_POST_PADDING];
int n, m, ret, old_state;
struct lws_tokens eff_buf;
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 2 +
LWS_SEND_BUFFER_POST_PADDING];
if (!wsi)
return;
old_state = wsi->state;
if (wsi->mode == LWS_CONNMODE_HTTP_SERVING_ACCEPTED &&
wsi->u.http.fd != LWS_INVALID_FILE) {
lwsl_debug("closing http file\n");
compatible_file_close(wsi->u.http.fd);
wsi->u.http.fd = LWS_INVALID_FILE;
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_CLOSED_HTTP, wsi->user_space, NULL, 0);
}
if (wsi->socket_is_permanently_unusable ||
reason == LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY)
goto just_kill_connection;
@ -89,7 +92,7 @@ libwebsocket_close_and_free_session(struct libwebsocket_context *context,
case WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE:
if (wsi->truncated_send_len) {
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
return;
}
lwsl_info("wsi %p completed WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE\n", wsi);
@ -98,7 +101,7 @@ libwebsocket_close_and_free_session(struct libwebsocket_context *context,
if (wsi->truncated_send_len) {
lwsl_info("wsi %p entering WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE\n", wsi);
wsi->state = WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE;
libwebsocket_set_timeout(wsi, PENDING_FLUSH_STORED_SEND_BEFORE_CLOSE, 5);
lws_set_timeout(wsi, PENDING_FLUSH_STORED_SEND_BEFORE_CLOSE, 5);
return;
}
break;
@ -107,24 +110,13 @@ libwebsocket_close_and_free_session(struct libwebsocket_context *context,
wsi->u.ws.close_reason = reason;
if (wsi->mode == LWS_CONNMODE_WS_CLIENT_WAITING_CONNECT ||
wsi->mode == LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE)
wsi->mode == LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE)
goto just_kill_connection;
if (wsi->mode == LWS_CONNMODE_HTTP_SERVING)
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_CLOSED_HTTP, wsi->user_space, NULL, 0);
if (wsi->mode == LWS_CONNMODE_HTTP_SERVING_ACCEPTED) {
if (wsi->u.http.fd != LWS_INVALID_FILE) {
// TODO: If we're just closing with LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY this file descriptor might leak?
lwsl_debug("closing http file\n");
context->file_callbacks.pfn_close(wsi->u.http.fd);
wsi->u.http.fd = LWS_INVALID_FILE;
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_CLOSED_HTTP, wsi->user_space, NULL, 0);
}
}
/*
* are his extensions okay with him closing? Eg he might be a mux
* parent and just his ch1 aspect is closing?
@ -165,14 +157,15 @@ libwebsocket_close_and_free_session(struct libwebsocket_context *context,
if (eff_buf.token_len)
if (lws_issue_raw(wsi, (unsigned char *)eff_buf.token,
eff_buf.token_len) != eff_buf.token_len) {
eff_buf.token_len) !=
eff_buf.token_len) {
lwsl_debug("close: ext spill failed\n");
goto just_kill_connection;
}
} while (ret);
/*
* signal we are closing, libwebsocket_write will
* signal we are closing, lws_write will
* add any necessary version-specific stuff. If the write fails,
* no worries we are closing anyway. If we didn't initiate this
* close, then our state has been changed to
@ -191,25 +184,20 @@ libwebsocket_close_and_free_session(struct libwebsocket_context *context,
/* make valgrind happy */
memset(buf, 0, sizeof(buf));
n = libwebsocket_write(wsi,
&buf[LWS_SEND_BUFFER_PRE_PADDING + 2],
0, LWS_WRITE_CLOSE);
n = lws_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING + 2],
0, LWS_WRITE_CLOSE);
if (n >= 0) {
/*
* we have sent a nice protocol level indication we
* now wish to close, we should not send anything more
*/
wsi->state = WSI_STATE_AWAITING_CLOSE_ACK;
/*
* ...and we should wait for a reply for a bit
* out of politeness
*/
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_CLOSE_ACK, 1);
lws_set_timeout(wsi, PENDING_TIMEOUT_CLOSE_ACK, 1);
lwsl_debug("sent close indication, awaiting ack\n");
return;
@ -228,10 +216,9 @@ just_kill_connection:
* we won't be servicing or receiving anything further from this guy
* delete socket from the internal poll list if still present
*/
lws_ssl_remove_wsi_from_buffered_list(context, wsi);
// checking return redundant since we anyway close
/* checking return redundant since we anyway close */
remove_wsi_socket_from_fds(context, wsi);
wsi->state = WSI_STATE_DEAD_SOCKET;
@ -245,11 +232,10 @@ just_kill_connection:
lws_free2(wsi->u.ws.rx_user_buffer);
if (wsi->truncated_send_malloc) {
if (wsi->truncated_send_malloc)
/* not going to be completed... nuke it */
lws_free2(wsi->truncated_send_malloc);
wsi->truncated_send_len = 0;
}
if (wsi->u.ws.ping_payload_buf) {
lws_free2(wsi->u.ws.ping_payload_buf);
wsi->u.ws.ping_payload_alloc = 0;
@ -261,13 +247,13 @@ just_kill_connection:
/* tell the user it's all over for this guy */
if (wsi->protocol && wsi->protocol->callback &&
((old_state == WSI_STATE_ESTABLISHED) ||
(old_state == WSI_STATE_RETURNED_CLOSE_ALREADY) ||
(old_state == WSI_STATE_AWAITING_CLOSE_ACK) ||
(old_state == WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE))) {
((old_state == WSI_STATE_ESTABLISHED) ||
(old_state == WSI_STATE_RETURNED_CLOSE_ALREADY) ||
(old_state == WSI_STATE_AWAITING_CLOSE_ACK) ||
(old_state == WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE))) {
lwsl_debug("calling back CLOSED\n");
wsi->protocol->callback(context, wsi, LWS_CALLBACK_CLOSED,
wsi->user_space, NULL, 0);
wsi->user_space, NULL, 0);
} else if (wsi->mode == LWS_CONNMODE_HTTP_SERVING_ACCEPTED) {
lwsl_debug("calling back CLOSED_HTTP\n");
context->protocols[0].callback(context, wsi,
@ -276,15 +262,16 @@ just_kill_connection:
wsi->mode == LWS_CONNMODE_WS_CLIENT_WAITING_CONNECT) {
lwsl_debug("Connection closed before server reply\n");
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
wsi->user_space, NULL, 0 );
LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
wsi->user_space, NULL, 0);
} else
lwsl_debug("not calling back closed mode=%d state=%d\n",
wsi->mode, old_state);
/* deallocate any active extension contexts */
if (lws_ext_callback_for_each_active(wsi, LWS_EXT_CALLBACK_DESTROY, NULL, 0) < 0)
if (lws_ext_callback_for_each_active(wsi, LWS_EXT_CALLBACK_DESTROY,
NULL, 0) < 0)
lwsl_warn("extension destruction failed\n");
#ifndef LWS_NO_EXTENSIONS
for (n = 0; n < wsi->count_active_extensions; n++)
@ -298,8 +285,6 @@ just_kill_connection:
LWS_EXT_CALLBACK_DESTROY_ANY_WSI_CLOSING, NULL, 0) < 0)
lwsl_warn("ext destroy wsi failed\n");
/* lwsl_info("closing fd=%d\n", wsi->sock); */
if (!lws_ssl_close(wsi) && lws_socket_is_valid(wsi->sock)) {
#if LWS_POSIX
n = shutdown(wsi->sock, SHUT_RDWR);
@ -317,22 +302,22 @@ just_kill_connection:
}
/* outermost destroy notification for wsi (user_space still intact) */
context->protocols[0].callback(context, wsi,
LWS_CALLBACK_WSI_DESTROY, wsi->user_space, NULL, 0);
context->protocols[0].callback(context, wsi, LWS_CALLBACK_WSI_DESTROY,
wsi->user_space, NULL, 0);
lws_free_wsi(wsi);
}
LWS_VISIBLE int
libwebsockets_get_addresses(struct libwebsocket_context *context,
void *ads, char *name, int name_len,
char *rip, int rip_len)
lws_get_addresses(struct lws_context *context, void *ads, char *name,
int name_len, char *rip, int rip_len)
{
#if LWS_POSIX
struct addrinfo ai, *res;
struct sockaddr_in addr4;
rip[0] = '\0';
if (rip)
rip[0] = '\0';
name[0] = '\0';
addr4.sin_family = AF_UNSPEC;
@ -406,9 +391,9 @@ libwebsockets_get_addresses(struct libwebsocket_context *context,
}
/**
* libwebsockets_get_peer_addresses() - Get client address information
* lws_get_peer_addresses() - Get client address information
* @context: Libwebsockets context
* @wsi: Local struct libwebsocket associated with
* @wsi: Local struct lws associated with
* @fd: Connection socket descriptor
* @name: Buffer to take client address name
* @name_len: Length of client address name buffer
@ -422,9 +407,9 @@ libwebsockets_get_addresses(struct libwebsocket_context *context,
*/
LWS_VISIBLE void
libwebsockets_get_peer_addresses(struct libwebsocket_context *context,
struct libwebsocket *wsi, lws_sockfd_type fd, char *name, int name_len,
char *rip, int rip_len)
lws_get_peer_addresses(struct lws_context *context, struct lws *wsi,
lws_sockfd_type fd, char *name, int name_len,
char *rip, int rip_len)
{
#if LWS_POSIX
socklen_t len;
@ -456,10 +441,10 @@ libwebsockets_get_peer_addresses(struct libwebsocket_context *context,
goto bail;
}
ret = libwebsockets_get_addresses(context, p, name, name_len, rip, rip_len);
ret = lws_get_addresses(context, p, name, name_len, rip, rip_len);
bail:
lws_latency(context, wsi, "libwebsockets_get_peer_addresses", ret, 1);
lws_latency(context, wsi, "lws_get_peer_addresses", ret, 1);
#else
(void)context;
(void)wsi;
@ -472,7 +457,7 @@ bail:
}
/**
* libwebsocket_context_user() - get the user data associated with the context
* lws_context_user() - get the user data associated with the context
* @context: Websocket context
*
* This returns the optional user allocation that can be attached to
@ -481,14 +466,14 @@ bail:
* using globals statics in the user code.
*/
LWS_EXTERN void *
libwebsocket_context_user(struct libwebsocket_context *context)
lws_context_user(struct lws_context *context)
{
return context->user_space;
}
/**
* libwebsocket_callback_all_protocol() - Callback all connections using
* lws_callback_all_protocol() - Callback all connections using
* the given protocol with the given reason
*
* @protocol: Protocol whose connections will get callbacks
@ -496,12 +481,11 @@ libwebsocket_context_user(struct libwebsocket_context *context)
*/
LWS_VISIBLE int
libwebsocket_callback_all_protocol(
const struct libwebsocket_protocols *protocol, int reason)
lws_callback_all_protocol(const struct lws_protocols *protocol, int reason)
{
struct libwebsocket_context *context = protocol->owning_server;
struct lws_context *context = protocol->owning_server;
struct lws *wsi;
int n;
struct libwebsocket *wsi;
for (n = 0; n < context->fds_count; n++) {
wsi = wsi_from_fd(context, context->fds[n].fd);
@ -509,14 +493,14 @@ libwebsocket_callback_all_protocol(
continue;
if (wsi->protocol == protocol)
protocol->callback(context, wsi,
reason, wsi->user_space, NULL, 0);
reason, wsi->user_space, NULL, 0);
}
return 0;
}
/**
* libwebsocket_set_timeout() - marks the wsi as subject to a timeout
* lws_set_timeout() - marks the wsi as subject to a timeout
*
* You will not need this unless you are doing something special
*
@ -526,8 +510,7 @@ libwebsocket_callback_all_protocol(
*/
LWS_VISIBLE void
libwebsocket_set_timeout(struct libwebsocket *wsi,
enum pending_timeout reason, int secs)
lws_set_timeout(struct lws *wsi, enum pending_timeout reason, int secs)
{
time_t now;
@ -541,7 +524,7 @@ libwebsocket_set_timeout(struct libwebsocket *wsi,
#if LWS_POSIX
/**
* libwebsocket_get_socket_fd() - returns the socket file descriptor
* lws_get_socket_fd() - returns the socket file descriptor
*
* You will not need this unless you are doing something special
*
@ -549,7 +532,7 @@ libwebsocket_set_timeout(struct libwebsocket *wsi,
*/
LWS_VISIBLE int
libwebsocket_get_socket_fd(struct libwebsocket *wsi)
lws_get_socket_fd(struct lws *wsi)
{
return wsi->sock;
}
@ -558,8 +541,8 @@ libwebsocket_get_socket_fd(struct libwebsocket *wsi)
#ifdef LWS_LATENCY
void
lws_latency(struct libwebsocket_context *context, struct libwebsocket *wsi,
const char *action, int ret, int completed)
lws_latency(struct lws_context *context, struct lws *wsi, const char *action,
int ret, int completed)
{
unsigned long long u;
char buf[256];
@ -600,7 +583,7 @@ lws_latency(struct libwebsocket_context *context, struct libwebsocket *wsi,
/**
* libwebsocket_rx_flow_control() - Enable and disable socket servicing for
* lws_rx_flow_control() - Enable and disable socket servicing for
* received packets.
*
* If the output side of a server process becomes choked, this allows flow
@ -611,19 +594,19 @@ lws_latency(struct libwebsocket_context *context, struct libwebsocket *wsi,
*/
LWS_VISIBLE int
libwebsocket_rx_flow_control(struct libwebsocket *wsi, int enable)
lws_rx_flow_control(struct lws *wsi, int enable)
{
if (enable == (wsi->rxflow_change_to & LWS_RXFLOW_ALLOW))
return 0;
lwsl_info("libwebsocket_rx_flow_control(0x%p, %d)\n", wsi, enable);
lwsl_info("%s: (0x%p, %d)\n", __func__, wsi, enable);
wsi->rxflow_change_to = LWS_RXFLOW_PENDING_CHANGE | !!enable;
return 0;
}
/**
* libwebsocket_rx_flow_allow_all_protocol() - Allow all connections with this protocol to receive
* lws_rx_flow_allow_all_protocol() - Allow all connections with this protocol to receive
*
* When the user server code realizes it can accept more input, it can
* call this to have the RX flow restriction removed from all connections using
@ -633,25 +616,24 @@ libwebsocket_rx_flow_control(struct libwebsocket *wsi, int enable)
*/
LWS_VISIBLE void
libwebsocket_rx_flow_allow_all_protocol(
const struct libwebsocket_protocols *protocol)
lws_rx_flow_allow_all_protocol(const struct lws_protocols *protocol)
{
struct libwebsocket_context *context = protocol->owning_server;
struct lws_context *context = protocol->owning_server;
int n;
struct libwebsocket *wsi;
struct lws *wsi;
for (n = 0; n < context->fds_count; n++) {
wsi = wsi_from_fd(context, context->fds[n].fd);
if (!wsi)
continue;
if (wsi->protocol == protocol)
libwebsocket_rx_flow_control(wsi, LWS_RXFLOW_ALLOW);
lws_rx_flow_control(wsi, LWS_RXFLOW_ALLOW);
}
}
/**
* libwebsocket_canonical_hostname() - returns this host's hostname
* lws_canonical_hostname() - returns this host's hostname
*
* This is typically used by client code to fill in the host parameter
* when making a client connection. You can only call it after the context
@ -660,30 +642,29 @@ libwebsocket_rx_flow_allow_all_protocol(
* @context: Websocket context
*/
LWS_VISIBLE extern const char *
libwebsocket_canonical_hostname(struct libwebsocket_context *context)
lws_canonical_hostname(struct lws_context *context)
{
return (const char *)context->canonical_hostname;
}
int user_callback_handle_rxflow(callback_function callback_function,
struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason, void *user,
void *in, size_t len)
struct lws_context *context, struct lws *wsi,
enum lws_callback_reasons reason, void *user,
void *in, size_t len)
{
int n;
n = callback_function(context, wsi, reason, user, in, len);
if (!n)
n = _libwebsocket_rx_flow_control(wsi);
n = _lws_rx_flow_control(wsi);
return n;
}
/**
* libwebsocket_set_proxy() - Setups proxy to libwebsocket_context.
* @context: pointer to struct libwebsocket_context you want set proxy to
* lws_set_proxy() - Setups proxy to lws_context.
* @context: pointer to struct lws_context you want set proxy to
* @proxy: pointer to c string containing proxy in format address:port
*
* Returns 0 if proxy string was parsed and proxy was setup.
@ -693,14 +674,14 @@ int user_callback_handle_rxflow(callback_function callback_function,
* environment variable (eg, OSX)
*
* IMPORTANT! You should call this function right after creation of the
* libwebsocket_context and before call to connect. If you call this
* lws_context and before call to connect. If you call this
* function after connect behavior is undefined.
* This function will override proxy settings made on libwebsocket_context
* This function will override proxy settings made on lws_context
* creation with genenv() call.
*/
LWS_VISIBLE int
libwebsocket_set_proxy(struct libwebsocket_context *context, const char *proxy)
lws_set_proxy(struct lws_context *context, const char *proxy)
{
char *p;
char authstring[96];
@ -738,8 +719,10 @@ libwebsocket_set_proxy(struct libwebsocket_context *context, const char *proxy)
return -1;
} else {
*p = '\0';
context->http_proxy_port = atoi(p + 1);
if (p) {
*p = '\0';
context->http_proxy_port = atoi(p + 1);
}
}
lwsl_notice(" Proxy %s:%u\n", context->http_proxy_address,
@ -754,7 +737,7 @@ auth_too_long:
}
/**
* libwebsockets_get_protocol() - Returns a protocol pointer from a websocket
* lws_get_protocol() - Returns a protocol pointer from a websocket
* connection.
* @wsi: pointer to struct websocket you want to know the protocol of
*
@ -763,26 +746,26 @@ auth_too_long:
* this is how you can get a pointer to the active protocol if needed.
*/
LWS_VISIBLE const struct libwebsocket_protocols *
libwebsockets_get_protocol(struct libwebsocket *wsi)
LWS_VISIBLE const struct lws_protocols *
lws_get_protocol(struct lws *wsi)
{
return wsi->protocol;
}
LWS_VISIBLE int
libwebsocket_is_final_fragment(struct libwebsocket *wsi)
lws_is_final_fragment(struct lws *wsi)
{
return wsi->u.ws.final;
}
LWS_VISIBLE unsigned char
libwebsocket_get_reserved_bits(struct libwebsocket *wsi)
lws_get_reserved_bits(struct lws *wsi)
{
return wsi->u.ws.rsv;
}
int
libwebsocket_ensure_user_space(struct libwebsocket *wsi)
lws_ensure_user_space(struct lws *wsi)
{
lwsl_info("%s: %p protocol %p\n", __func__, wsi, wsi->protocol);
if (!wsi->protocol)
@ -797,28 +780,33 @@ libwebsocket_ensure_user_space(struct libwebsocket *wsi)
return 1;
}
} else
lwsl_info("%s: %p protocol pss %u, user_space=%d\n", __func__, wsi, wsi->protocol->per_session_data_size, wsi->user_space);
lwsl_info("%s: %p protocol pss %u, user_space=%d\n",
__func__, wsi, wsi->protocol->per_session_data_size,
wsi->user_space);
return 0;
}
#if LWS_POSIX
LWS_VISIBLE void lwsl_emit_stderr(int level, const char *line)
{
char buf[300];
unsigned long long now;
char buf[300];
int n;
buf[0] = '\0';
for (n = 0; n < LLL_COUNT; n++)
if (level == (1 << n)) {
now = time_in_microseconds() / 100;
sprintf(buf, "[%llu:%04d] %s: ", (unsigned long long) now / 10000,
(int)(now % 10000), log_level_names[n]);
break;
}
for (n = 0; n < LLL_COUNT; n++) {
if (level != (1 << n))
continue;
now = time_in_microseconds() / 100;
sprintf(buf, "[%llu:%04d] %s: ",
(unsigned long long) now / 10000,
(int)(now % 10000), log_level_names[n]);
break;
}
fprintf(stderr, "%s%s", buf, line);
}
#endif
LWS_VISIBLE void _lws_logv(int filter, const char *format, va_list vl)
{
@ -853,12 +841,12 @@ LWS_VISIBLE void _lws_log(int filter, const char *format, ...)
* emission on stderr.
*/
LWS_VISIBLE void lws_set_log_level(int level, void (*log_emit_function)(int level,
const char *line))
LWS_VISIBLE void lws_set_log_level(int level,
void (*func)(int level, const char *line))
{
log_level = level;
if (log_emit_function)
lwsl_emit = log_emit_function;
if (func)
lwsl_emit = func;
}
/**
@ -870,7 +858,7 @@ LWS_VISIBLE void lws_set_log_level(int level, void (*log_emit_function)(int leve
* checked (appears for client wsi told to skip check on connection)
*/
LWS_VISIBLE int
lws_is_ssl(struct libwebsocket *wsi)
lws_is_ssl(struct lws *wsi)
{
#ifdef LWS_OPENSSL_SUPPORT
return wsi->use_ssl;
@ -884,12 +872,12 @@ lws_is_ssl(struct libwebsocket *wsi)
* lws_partial_buffered() - find out if lws buffered the last write
* @wsi: websocket connection to check
*
* Returns 1 if you cannot use libwebsocket_write because the last
* Returns 1 if you cannot use lws_write because the last
* write on this connection is still buffered, and can't be cleared without
* returning to the service loop and waiting for the connection to be
* writeable again.
*
* If you will try to do >1 libwebsocket_write call inside a single
* If you will try to do >1 lws_write call inside a single
* WRITEABLE callback, you must check this after every write and bail if
* set, ask for a new writeable callback and continue writing from there.
*
@ -898,13 +886,13 @@ lws_is_ssl(struct libwebsocket *wsi)
*/
LWS_VISIBLE int
lws_partial_buffered(struct libwebsocket *wsi)
lws_partial_buffered(struct lws *wsi)
{
return !!wsi->truncated_send_len;
}
void lws_set_protocol_write_pending(struct libwebsocket_context *context,
struct libwebsocket *wsi,
void lws_set_protocol_write_pending(struct lws_context *context,
struct lws *wsi,
enum lws_pending_protocol_send pend)
{
lwsl_info("setting pps %d\n", pend);
@ -912,12 +900,12 @@ void lws_set_protocol_write_pending(struct libwebsocket_context *context,
if (wsi->pps)
lwsl_err("pps overwrite\n");
wsi->pps = pend;
libwebsocket_rx_flow_control(wsi, 0);
libwebsocket_callback_on_writable(context, wsi);
lws_rx_flow_control(wsi, 0);
lws_callback_on_writable(context, wsi);
}
LWS_VISIBLE size_t
lws_get_peer_write_allowance(struct libwebsocket *wsi)
lws_get_peer_write_allowance(struct lws *wsi)
{
#ifdef LWS_USE_HTTP2
/* only if we are using HTTP2 on this connection */
@ -935,8 +923,304 @@ lws_get_peer_write_allowance(struct libwebsocket *wsi)
}
LWS_VISIBLE void
lws_union_transition(struct libwebsocket *wsi, enum connection_mode mode)
lws_union_transition(struct lws *wsi, enum connection_mode mode)
{
memset(&wsi->u, 0, sizeof(wsi->u));
wsi->mode = mode;
}
#ifdef LWS_WITH_OLD_API_WRAPPERS
/*
* To maintain .so abi, also produce wrappers using old api naming.
*
* This is disabled by default, use "LWS_WITH_OLD_API_WRAPPERS" on cmake to
* enable.
*
* You only need these if you have existing binary applications using the old
* api names and you don't want to / can't recompile them against new lws.
* With these new lws .so is compatible with old and new api names.
*
* If you can recompile your application (using old api names still) against
* current lws, you don't need these compatibility helpers since
* libwebsockets.h will map them at compile time.
*/
#undef libwebsocket
#undef libwebsocket_create_context
LWS_VISIBLE LWS_EXTERN struct lws_context *
libwebsocket_create_context(struct lws_context_creation_info *info)
{
return lws_create_context(info);
}
#undef libwebsocket_set_proxy
LWS_VISIBLE LWS_EXTERN int
libwebsocket_set_proxy(struct lws_context *context, const char *proxy)
{
return lws_set_proxy(context, proxy);
}
#undef libwebsocket_context_destroy
LWS_VISIBLE LWS_EXTERN void
libwebsocket_context_destroy(struct lws_context *context)
{
lws_context_destroy(context);
}
#undef libwebsocket_service
LWS_VISIBLE LWS_EXTERN int
libwebsocket_service(struct lws_context *context, int timeout_ms)
{
return lws_service(context, timeout_ms);
}
#undef libwebsocket_cancel_service
LWS_VISIBLE LWS_EXTERN void
libwebsocket_cancel_service(struct lws_context *context)
{
lws_cancel_service(context);
}
#ifdef LWS_USE_LIBEV
#undef libwebsocket_sigint_cfg
LWS_VISIBLE LWS_EXTERN int
libwebsocket_sigint_cfg(struct lws_context *context, int use_ev_sigint,
lws_ev_signal_cb* cb)
{
return lws_sigint_cfg(context, use_ev_sigint, cb);
}
#undef libwebsocket_initloop
LWS_VISIBLE LWS_EXTERN int
libwebsocket_initloop(struct lws_context *context, struct ev_loop *loop)
{
return lws_initloop(context, loop);
}
#undef libwebsocket_sigint_cb
LWS_VISIBLE void
libwebsocket_sigint_cb(
struct ev_loop *loop, struct ev_signal *watcher, int revents)
{
lws_sigint_cb(loop, watcher, revents);
}
#endif /* LWS_USE_LIBEV */
#undef libwebsocket_service_fd
LWS_VISIBLE LWS_EXTERN int
libwebsocket_service_fd(struct lws_context *context,
struct lws_pollfd *pollfd)
{
return lws_service_fd(context, pollfd);
}
#undef libwebsocket_context_user
LWS_VISIBLE LWS_EXTERN void *
libwebsocket_context_user(struct lws_context *context)
{
return lws_context_user(context);
}
#undef libwebsocket_set_timeout
LWS_VISIBLE LWS_EXTERN void
libwebsocket_set_timeout(struct lws *wsi,
enum pending_timeout reason, int secs)
{
lws_set_timeout(wsi, reason, secs);
}
#undef libwebsocket_write
LWS_VISIBLE LWS_EXTERN int
libwebsocket_write(struct lws *wsi, unsigned char *buf, size_t len,
enum lws_write_protocol protocol)
{
return lws_write(wsi, buf, len, protocol);
}
#undef libwebsockets_serve_http_file_fragment
LWS_VISIBLE LWS_EXTERN int
libwebsockets_serve_http_file_fragment(struct lws_context *context,
struct lws *wsi)
{
return lws_serve_http_file_fragment(context, wsi);
}
#undef libwebsockets_serve_http_file
LWS_VISIBLE LWS_EXTERN int
libwebsockets_serve_http_file(struct lws_context *context,
struct lws *wsi, const char *file,
const char *content_type, const char *other_headers,
int other_headers_len)
{
return lws_serve_http_file(context, wsi, file, content_type,
other_headers, other_headers_len);
}
#undef libwebsockets_return_http_status
LWS_VISIBLE LWS_EXTERN int
libwebsockets_return_http_status(
struct lws_context *context,
struct lws *wsi, unsigned int code,
const char *html_body)
{
return lws_return_http_status(context, wsi, code, html_body);
}
#undef libwebsockets_get_protocol
LWS_VISIBLE LWS_EXTERN const struct lws_protocols *
libwebsockets_get_protocol(struct lws *wsi)
{
return lws_get_protocol(wsi);
}
#undef libwebsocket_callback_on_writable_all_protocol
LWS_VISIBLE LWS_EXTERN int
libwebsocket_callback_on_writable_all_protocol(
const struct lws_protocols *protocol)
{
return lws_callback_on_writable_all_protocol(protocol);
}
#undef libwebsocket_callback_on_writable
LWS_VISIBLE LWS_EXTERN int
libwebsocket_callback_on_writable(struct lws_context *context,
struct lws *wsi)
{
return lws_callback_on_writable(context, wsi);
}
#undef libwebsocket_callback_all_protocol
LWS_VISIBLE LWS_EXTERN int
libwebsocket_callback_all_protocol(
const struct lws_protocols *protocol, int reason)
{
return lws_callback_all_protocol(protocol, reason);
}
#undef libwebsocket_get_socket_fd
LWS_VISIBLE LWS_EXTERN int
libwebsocket_get_socket_fd(struct lws *wsi)
{
return lws_get_socket_fd(wsi);
}
#undef libwebsocket_is_final_fragment
LWS_VISIBLE LWS_EXTERN int
libwebsocket_is_final_fragment(struct lws *wsi)
{
return lws_is_final_fragment(wsi);
}
#undef libwebsocket_get_reserved_bits
LWS_VISIBLE LWS_EXTERN unsigned char
libwebsocket_get_reserved_bits(struct lws *wsi)
{
return lws_get_reserved_bits(wsi);
}
#undef libwebsocket_rx_flow_control
LWS_VISIBLE LWS_EXTERN int
libwebsocket_rx_flow_control(struct lws *wsi, int enable)
{
return lws_rx_flow_control(wsi, enable);
}
#undef libwebsocket_rx_flow_allow_all_protocol
LWS_VISIBLE LWS_EXTERN void
libwebsocket_rx_flow_allow_all_protocol(const struct lws_protocols *protocol)
{
lws_rx_flow_allow_all_protocol(protocol);
}
#undef libwebsockets_remaining_packet_payload
LWS_VISIBLE LWS_EXTERN size_t
libwebsockets_remaining_packet_payload(struct lws *wsi)
{
return lws_remaining_packet_payload(wsi);
}
#undef libwebsocket_client_connect
LWS_VISIBLE LWS_EXTERN struct lws *
libwebsocket_client_connect(struct lws_context *clients,
const char *address,
int port,
int ssl_connection,
const char *path,
const char *host,
const char *origin,
const char *protocol,
int ietf_version_or_minus_one)
{
return lws_client_connect(clients, address, port, ssl_connection,
path, host, origin, protocol, ietf_version_or_minus_one);
}
LWS_VISIBLE LWS_EXTERN struct lws *
libwebsocket_client_connect_extended(struct lws_context *clients,
const char *address,
int port,
int ssl_connection,
const char *path,
const char *host,
const char *origin,
const char *protocol,
int ietf_version_or_minus_one, void *userdata)
{
return lws_client_connect_extended(clients, address, port, ssl_connection,
path, host, origin, protocol, ietf_version_or_minus_one,
userdata);
}
#undef libwebsocket_canonical_hostname
LWS_VISIBLE LWS_EXTERN const char *
libwebsocket_canonical_hostname(struct lws_context *context)
{
return lws_canonical_hostname(context);
}
#undef libwebsockets_get_peer_addresses
LWS_VISIBLE LWS_EXTERN void
libwebsockets_get_peer_addresses(struct lws_context *context,
struct lws *wsi, lws_sockfd_type fd, char *name,
int name_len, char *rip, int rip_len)
{
lws_get_peer_addresses(context, wsi, fd, name, name_len, rip, rip_len);
}
#undef libwebsockets_get_random
LWS_VISIBLE LWS_EXTERN int
libwebsockets_get_random(struct lws_context *context, void *buf, int len)
{
return lws_get_random(context, buf, len);
}
#ifndef LWS_SHA1_USE_OPENSSL_NAME
#undef libwebsockets_SHA1
LWS_VISIBLE LWS_EXTERN unsigned char *
libwebsockets_SHA1(const unsigned char *d, size_t n, unsigned char *md)
{
return lws_SHA1(d, n, md);
}
#endif
#undef libwebsocket_read
LWS_VISIBLE LWS_EXTERN int
libwebsocket_read(struct lws_context *context, struct lws *wsi,
unsigned char *buf, size_t len)
{
return lws_read(context, wsi, buf, len);
}
#ifndef LWS_NO_EXTENSIONS
#undef libwebsocket_get_internal_extensions
LWS_VISIBLE LWS_EXTERN struct lws_extension *
libwebsocket_get_internal_extensions()
{
return lws_get_internal_extensions();
}
#endif
#endif

755
lib/libwebsockets.h
View file

File diff suppressed because it is too large Load diff

111
lib/lws-plat-mbed3.c
View file

@ -12,7 +12,7 @@ unsigned long long time_in_microseconds(void)
return 0;
}
LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
LWS_VISIBLE int lws_get_random(struct lws_context *context,
void *buf, int len)
{
(void)context;
@ -38,10 +38,10 @@ LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
* get their turn at the network device.
*/
LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
LWS_VISIBLE int lws_send_pipe_choked(struct lws *wsi)
{
#if 0
struct libwebsocket_pollfd fds;
struct lws_pollfd fds;
/* treat the fact we got a truncated send pending as if we're choked */
if (wsi->truncated_send_len)
@ -64,24 +64,24 @@ LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
}
LWS_VISIBLE int
lws_poll_listen_fd(struct libwebsocket_pollfd *fd)
lws_poll_listen_fd(struct lws_pollfd *fd)
{
(void)fd;
return -1;
}
/**
* libwebsocket_cancel_service() - Cancel servicing of pending websocket activity
* lws_cancel_service() - Cancel servicing of pending websocket activity
* @context: Websocket context
*
* This function let a call to libwebsocket_service() waiting for a timeout
* This function let a call to lws_service() waiting for a timeout
* immediately return.
*
* There is no poll() in MBED3, he will fire callbacks when he feels like
* it.
*/
LWS_VISIBLE void
libwebsocket_cancel_service(struct libwebsocket_context *context)
lws_cancel_service(struct lws_context *context)
{
(void)context;
}
@ -92,77 +92,7 @@ LWS_VISIBLE void lwsl_emit_syslog(int level, const char *line)
}
LWS_VISIBLE int
lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
{
(void)context;
(void)timeout_ms;
#if 0
int n;
int m;
char buf;
#ifdef LWS_OPENSSL_SUPPORT
struct libwebsocket *wsi, *wsi_next;
#endif
/* stay dead once we are dead */
if (!context)
return 1;
lws_libev_run(context);
context->service_tid = context->protocols[0].callback(context, NULL,
LWS_CALLBACK_GET_THREAD_ID, NULL, NULL, 0);
#ifdef LWS_OPENSSL_SUPPORT
/* if we know we have non-network pending data, do not wait in poll */
if (lws_ssl_anybody_has_buffered_read(context))
timeout_ms = 0;
#endif
n = poll(context->fds, context->fds_count, timeout_ms);
context->service_tid = 0;
#ifdef LWS_OPENSSL_SUPPORT
if (!lws_ssl_anybody_has_buffered_read(context) && n == 0) {
#else
if (n == 0) /* poll timeout */ {
#endif
libwebsocket_service_fd(context, NULL);
return 0;
}
if (n < 0) {
if (LWS_ERRNO != LWS_EINTR)
return -1;
return 0;
}
/* any socket with events to service? */
for (n = 0; n < context->fds_count; n++) {
if (!context->fds[n].revents)
continue;
if (context->fds[n].fd == context->dummy_pipe_fds[0]) {
if (read(context->fds[n].fd, &buf, 1) != 1)
lwsl_err("Cannot read from dummy pipe.");
continue;
}
m = libwebsocket_service_fd(context, &context->fds[n]);
if (m < 0)
return -1;
/* if something closed, retry this slot */
if (m)
n--;
}
#endif
return 0;
}
LWS_VISIBLE int
lws_plat_set_socket_options(struct libwebsocket_context *context, lws_sockfd_type fd)
lws_plat_set_socket_options(struct lws_context *context, lws_sockfd_type fd)
{
(void)context;
(void)fd;
@ -176,14 +106,14 @@ lws_plat_drop_app_privileges(struct lws_context_creation_info *info)
}
LWS_VISIBLE int
lws_plat_init_lookup(struct libwebsocket_context *context)
lws_plat_init_lookup(struct lws_context *context)
{
(void)context;
return 0;
}
LWS_VISIBLE int
lws_plat_init_fd_tables(struct libwebsocket_context *context)
lws_plat_init_fd_tables(struct lws_context *context)
{
(void)context;
return 0;
@ -197,35 +127,24 @@ lws_plat_context_early_init(void)
}
LWS_VISIBLE void
lws_plat_context_early_destroy(struct libwebsocket_context *context)
lws_plat_context_early_destroy(struct lws_context *context)
{
(void)context;
}
LWS_VISIBLE void
lws_plat_context_late_destroy(struct libwebsocket_context *context)
lws_plat_context_late_destroy(struct lws_context *context)
{
(void)context;
}
LWS_VISIBLE void
lws_plat_service_periodic(struct libwebsocket_context *context)
lws_plat_service_periodic(struct lws_context *context)
{
(void)context;
}
LWS_VISIBLE int
lws_plat_change_pollfd(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pfd)
{
(void)context;
(void)wsi;
(void)pfd;
return 0;
}
LWS_VISIBLE int
lws_plat_open_file(const char* filename, unsigned long* filelen)
{
@ -245,7 +164,7 @@ lws_plat_inet_ntop(int af, const void *src, char *dst, int cnt)
}
LWS_VISIBLE int
insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
insert_wsi(struct lws_context *context, struct lws *wsi)
{
(void)context;
(void)wsi;
@ -254,7 +173,7 @@ insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
}
LWS_VISIBLE int
delete_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd)
delete_from_fd(struct lws_context *context, lws_sockfd_type fd)
{
(void)context;
(void)fd;

156
lib/lws-plat-mbed3.cpp
View file

@ -21,11 +21,28 @@ extern "C" void mbed3_delete_tcp_stream_socket(void *sock)
delete conn;
}
extern "C" void mbed3_tcp_stream_bind(void *sock, int port, struct libwebsocket *wsi)
void lws_conn::serialized_writeable(struct lws *_wsi)
{
struct lws *wsi = (struct lws *)_wsi;
struct lws_pollfd pollfd;
lws_conn *conn = (lws_conn *)wsi->sock;
conn->awaiting_on_writeable = 0;
pollfd.fd = wsi->sock;
pollfd.events = POLLOUT;
pollfd.revents = POLLOUT;
lwsl_debug("%s: wsi %p\r\n", __func__, (void *)wsi);
lws_service_fd(wsi->protocol->owning_server, &pollfd);
}
extern "C" void mbed3_tcp_stream_bind(void *sock, int port, struct lws *wsi)
{
lws_conn_listener *srv = (lws_conn_listener *)sock;
lwsl_info("%s\r\n", __func__);
lwsl_debug("%s\r\n", __func__);
/* associate us with the listening wsi */
((lws_conn *)srv)->set_wsi(wsi);
@ -33,26 +50,48 @@ extern "C" void mbed3_tcp_stream_bind(void *sock, int port, struct libwebsocket
minar::Scheduler::postCallback(fp.bind(port));
}
extern "C" void mbed3_tcp_stream_accept(void *sock, struct libwebsocket *wsi)
extern "C" void mbed3_tcp_stream_accept(void *sock, struct lws *wsi)
{
lws_conn *conn = (lws_conn *)sock;
lwsl_info("%s\r\n", __func__);
lwsl_debug("%s\r\n", __func__);
conn->set_wsi(wsi);
}
extern "C" LWS_VISIBLE int
lws_ssl_capable_read_no_ssl(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, int len)
lws_plat_change_pollfd(struct lws_context *context,
struct lws *wsi, struct lws_pollfd *pfd)
{
lws_conn *conn = (lws_conn *)wsi->sock;
(void)context;
if (pfd->events & POLLOUT) {
conn->awaiting_on_writeable = 1;
if (conn->writeable) {
mbed::util::FunctionPointer1<void, struct lws *> book(conn, &lws_conn::serialized_writeable);
minar::Scheduler::postCallback(book.bind(wsi));
lwsl_debug("%s: wsi %p (booked callback)\r\n", __func__, (void *)wsi);
} else {
lwsl_debug("%s: wsi %p (set awaiting_on_writeable)\r\n", __func__, (void *)wsi);
}
} else
conn->awaiting_on_writeable = 0;
return 0;
}
extern "C" LWS_VISIBLE int
lws_ssl_capable_read_no_ssl(struct lws_context *context,
struct lws *wsi, unsigned char *buf, int len)
{
socket_error_t err;
size_t _len = len;
lwsl_debug("%s\r\n", __func__);
(void)context;
/* s/s_HACK/ts/g when mbed3 listen payload bug fixed */
err = ((lws_conn *)wsi->sock)->s_HACK->recv((char *)buf, &_len);
err = ((lws_conn *)wsi->sock)->ts->recv((char *)buf, &_len);
if (err == SOCKET_ERROR_NONE) {
lwsl_info("%s: got %d bytes\n", __func__, _len);
return _len;
@ -66,22 +105,22 @@ lws_ssl_capable_read_no_ssl(struct libwebsocket_context *context,
#endif
return LWS_SSL_CAPABLE_MORE_SERVICE;
// !!! while listen payload mbed3 bug, don't error out if nothing */
// if (((lws_conn *)wsi->sock)->s_HACK != ((Socket *)((lws_conn *)wsi->sock)->ts))
// return 0;
lwsl_warn("error on reading from skt: %d\n", err);
return LWS_SSL_CAPABLE_ERROR;
}
extern "C" LWS_VISIBLE int
lws_ssl_capable_write_no_ssl(struct libwebsocket *wsi, unsigned char *buf, int len)
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, int len)
{
socket_error_t err;
lws_conn *conn = (lws_conn *)wsi->sock;
lwsl_debug("%s: wsi %p: write %d (from %p)\n", __func__, (void *)wsi, len, (void *)buf);
err = ((lws_conn *)wsi->sock)->ts->send((char *)buf, len);
lwsl_debug("%s: wsi %p: clear writeable\n", __func__, (void *)wsi);
conn->writeable = 0;
err = conn->ts->send((char *)buf, len);
if (err == SOCKET_ERROR_NONE)
return len;
@ -118,9 +157,11 @@ void lws_conn_listener::start(const uint16_t port)
srv.error_check(err);
}
int lws_conn::actual_onRX(Socket *s)
void lws_conn::onRX(Socket *s)
{
struct libwebsocket_pollfd pollfd;
struct lws_pollfd pollfd;
(void)s;
pollfd.fd = this;
pollfd.events = POLLIN;
@ -128,9 +169,7 @@ int lws_conn::actual_onRX(Socket *s)
lwsl_debug("%s: lws %p\n", __func__, wsi);
s_HACK = s;
return libwebsocket_service_fd(wsi->protocol->owning_server, &pollfd);
lws_service_fd(wsi->protocol->owning_server, &pollfd);
}
/*
@ -141,10 +180,9 @@ int lws_conn::actual_onRX(Socket *s)
void lws_conn_listener::onIncoming(TCPListener *tl, void *impl)
{
mbed::util::CriticalSectionLock lock;
TCPStream *ts = srv.accept(impl);
lws_conn *conn;
if (!impl || !ts) {
if (!impl) {
onError(tl, SOCKET_ERROR_NULL_PTR);
return;
}
@ -154,7 +192,9 @@ void lws_conn_listener::onIncoming(TCPListener *tl, void *impl)
lwsl_err("OOM\n");
return;
}
conn->ts = ts;
conn->ts = srv.accept(impl);
if (!conn->ts)
return;
/*
* we use the listen socket wsi to get started, but a new wsi is
@ -164,23 +204,19 @@ void lws_conn_listener::onIncoming(TCPListener *tl, void *impl)
lws_server_socket_service(wsi->protocol->owning_server,
wsi, (struct pollfd *)conn);
ts->setOnSent(Socket::SentHandler_t(conn, &lws_conn::onSent));
ts->setOnReadable(TCPStream::ReadableHandler_t(conn, &lws_conn::onRX));
ts->setOnError(TCPStream::ErrorHandler_t(conn, &lws_conn::onError));
ts->setOnDisconnect(TCPStream::DisconnectHandler_t(conn,
conn->ts->setOnError(TCPStream::ErrorHandler_t(conn, &lws_conn::onError));
conn->ts->setOnDisconnect(TCPStream::DisconnectHandler_t(conn,
&lws_conn::onDisconnect));
/*
* mbed3 is messed up as of 2015-11-08, data packets may
* appear on the listening socket initially
*/
conn->actual_onRX((Socket *)tl);
conn->actual_onRX((Socket *)conn->ts);
conn->ts->setOnSent(Socket::SentHandler_t(conn, &lws_conn::onSent));
conn->ts->setOnReadable(TCPStream::ReadableHandler_t(conn, &lws_conn::onRX));
conn->onRX((Socket *)conn->ts);
lwsl_debug("%s: exit\n", __func__);
}
extern "C" LWS_VISIBLE struct libwebsocket *
wsi_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd)
extern "C" LWS_VISIBLE struct lws *
wsi_from_fd(struct lws_context *context, lws_sockfd_type fd)
{
lws_conn *conn = (lws_conn *)fd;
(void)context;
@ -189,8 +225,8 @@ wsi_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd)
}
extern "C" LWS_VISIBLE void
lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_plat_insert_socket_into_fds(struct lws_context *context,
struct lws *wsi)
{
(void)wsi;
lws_libev_io(context, wsi, LWS_EV_START | LWS_EV_READ);
@ -198,19 +234,14 @@ lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
}
extern "C" LWS_VISIBLE void
lws_plat_delete_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi, int m)
lws_plat_delete_socket_from_fds(struct lws_context *context,
struct lws *wsi, int m)
{
(void)context;
(void)wsi;
(void)m;
}
void lws_conn::onRX(Socket *s)
{
actual_onRX(s);
}
void lws_conn_listener::onDisconnect(TCPStream *s)
{
lwsl_info("%s\r\n", __func__);
@ -218,22 +249,39 @@ void lws_conn_listener::onDisconnect(TCPStream *s)
//if (s)
//delete this;
}
extern "C" LWS_VISIBLE int
lws_plat_service(struct lws_context *context, int timeout_ms)
{
(void)context;
(void)timeout_ms;
return 0;
}
void lws_conn::onSent(Socket *s, uint16_t len)
{
struct libwebsocket_pollfd pollfd;
struct lws_pollfd pollfd;
(void)s;
(void)len;
if (!awaiting_on_writeable) {
lwsl_debug("%s: wsi %p (setting writable=1)\r\n",
__func__, (void *)wsi);
writeable = 1;
return;
}
writeable = 1;
pollfd.fd = this;
pollfd.fd = wsi->sock;
pollfd.events = POLLOUT;
pollfd.revents = POLLOUT;
s_HACK = s;
lwsl_debug("%s: wsi %p\r\n", __func__, (void *)wsi);
lwsl_debug("%s: wsi %p (servicing now)\r\n", __func__, (void *)wsi);
libwebsocket_service_fd(wsi->protocol->owning_server, &pollfd);
lws_service_fd(wsi->protocol->owning_server, &pollfd);
}
void lws_conn_listener::onError(Socket *s, socket_error_t err)
@ -246,8 +294,9 @@ void lws_conn_listener::onError(Socket *s, socket_error_t err)
void lws_conn::onDisconnect(TCPStream *s)
{
lwsl_notice("%s:\r\n", __func__);
(void)s;
libwebsocket_close_and_free_session(wsi->protocol->owning_server, wsi,
lws_close_and_free_session(wsi->protocol->owning_server, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
}
@ -256,6 +305,5 @@ void lws_conn::onError(Socket *s, socket_error_t err)
{
(void) s;
lwsl_notice("Socket Error: %s (%d)\r\n", socket_strerror(err), err);
if (ts)
ts->close();
}
s->close();
}

50
lib/lws-plat-unix.c
View file

@ -14,15 +14,15 @@ unsigned long long time_in_microseconds(void)
return ((unsigned long long)tv.tv_sec * 1000000LL) + tv.tv_usec;
}
LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
LWS_VISIBLE int lws_get_random(struct lws_context *context,
void *buf, int len)
{
return read(context->fd_random, (char *)buf, len);
}
LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
LWS_VISIBLE int lws_send_pipe_choked(struct lws *wsi)
{
struct libwebsocket_pollfd fds;
struct lws_pollfd fds;
/* treat the fact we got a truncated send pending as if we're choked */
if (wsi->truncated_send_len)
@ -44,7 +44,7 @@ LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
}
LWS_VISIBLE int
lws_poll_listen_fd(struct libwebsocket_pollfd *fd)
lws_poll_listen_fd(struct lws_pollfd *fd)
{
return poll(fd, 1, 0);
}
@ -58,14 +58,14 @@ static void lws_sigusr2(int sig)
}
/**
* libwebsocket_cancel_service() - Cancel servicing of pending websocket activity
* lws_cancel_service() - Cancel servicing of pending websocket activity
* @context: Websocket context
*
* This function let a call to libwebsocket_service() waiting for a timeout
* This function let a call to lws_service() waiting for a timeout
* immediately return.
*/
LWS_VISIBLE void
libwebsocket_cancel_service(struct libwebsocket_context *context)
lws_cancel_service(struct lws_context *context)
{
char buf = 0;
@ -95,13 +95,13 @@ LWS_VISIBLE void lwsl_emit_syslog(int level, const char *line)
}
LWS_VISIBLE int
lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
lws_plat_service(struct lws_context *context, int timeout_ms)
{
int n;
int m;
char buf;
#ifdef LWS_OPENSSL_SUPPORT
struct libwebsocket *wsi, *wsi_next;
struct lws *wsi, *wsi_next;
#endif
/* stay dead once we are dead */
@ -127,7 +127,7 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
#else
if (n == 0) /* poll timeout */ {
#endif
libwebsocket_service_fd(context, NULL);
lws_service_fd(context, NULL);
return 0;
}
@ -176,7 +176,7 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
continue;
}
m = libwebsocket_service_fd(context, &context->fds[n]);
m = lws_service_fd(context, &context->fds[n]);
if (m < 0)
return -1;
/* if something closed, retry this slot */
@ -188,7 +188,7 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
}
LWS_VISIBLE int
lws_plat_set_socket_options(struct libwebsocket_context *context, int fd)
lws_plat_set_socket_options(struct lws_context *context, int fd)
{
int optval = 1;
socklen_t optlen = sizeof(optval);
@ -272,9 +272,9 @@ lws_plat_drop_app_privileges(struct lws_context_creation_info *info)
}
LWS_VISIBLE int
lws_plat_init_lookup(struct libwebsocket_context *context)
lws_plat_init_lookup(struct lws_context *context)
{
context->lws_lookup = lws_zalloc(sizeof(struct libwebsocket *) * context->max_fds);
context->lws_lookup = lws_zalloc(sizeof(struct lws *) * context->max_fds);
if (context->lws_lookup == NULL) {
lwsl_err(
"Unable to allocate lws_lookup array for %d connections\n",
@ -286,7 +286,7 @@ lws_plat_init_lookup(struct libwebsocket_context *context)
}
LWS_VISIBLE int
lws_plat_init_fd_tables(struct libwebsocket_context *context)
lws_plat_init_fd_tables(struct lws_context *context)
{
context->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
if (context->fd_random < 0) {
@ -335,12 +335,12 @@ lws_plat_context_early_init(void)
}
LWS_VISIBLE void
lws_plat_context_early_destroy(struct libwebsocket_context *context)
lws_plat_context_early_destroy(struct lws_context *context)
{
}
LWS_VISIBLE void
lws_plat_context_late_destroy(struct libwebsocket_context *context)
lws_plat_context_late_destroy(struct lws_context *context)
{
if (context->lws_lookup)
lws_free(context->lws_lookup);
@ -353,7 +353,7 @@ lws_plat_context_late_destroy(struct libwebsocket_context *context)
/* cast a struct sockaddr_in6 * into addr for ipv6 */
LWS_VISIBLE int
interface_to_sa(struct libwebsocket_context *context,
interface_to_sa(struct lws_context *context,
const char *ifname, struct sockaddr_in *addr, size_t addrlen)
{
int rc = -1;
@ -422,21 +422,21 @@ interface_to_sa(struct libwebsocket_context *context,
}
LWS_VISIBLE void
lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_plat_insert_socket_into_fds(struct lws_context *context,
struct lws *wsi)
{
lws_libev_io(context, wsi, LWS_EV_START | LWS_EV_READ);
context->fds[context->fds_count++].revents = 0;
}
LWS_VISIBLE void
lws_plat_delete_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi, int m)
lws_plat_delete_socket_from_fds(struct lws_context *context,
struct lws *wsi, int m)
{
}
LWS_VISIBLE void
lws_plat_service_periodic(struct libwebsocket_context *context)
lws_plat_service_periodic(struct lws_context *context)
{
/* if our parent went down, don't linger around */
if (context->started_with_parent &&
@ -445,8 +445,8 @@ lws_plat_service_periodic(struct libwebsocket_context *context)
}
LWS_VISIBLE int
lws_plat_change_pollfd(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pfd)
lws_plat_change_pollfd(struct lws_context *context,
struct lws *wsi, struct lws_pollfd *pfd)
{
return 0;
}

69
lib/lws-plat-win.c
View file

@ -35,8 +35,8 @@ time_t time(time_t *t)
/* file descriptor hash management */
struct libwebsocket *
wsi_from_fd(struct libwebsocket_context *context, int fd)
struct lws *
wsi_from_fd(struct lws_context *context, lws_sockfd_type fd)
{
int h = LWS_FD_HASH(fd);
int n = 0;
@ -49,7 +49,7 @@ wsi_from_fd(struct libwebsocket_context *context, int fd)
}
int
insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
insert_wsi(struct lws_context *context, struct lws *wsi)
{
int h = LWS_FD_HASH(wsi->sock);
@ -64,7 +64,7 @@ insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
}
int
delete_from_fd(struct libwebsocket_context *context, int fd)
delete_from_fd(struct lws_context *context, lws_sockfd_type fd)
{
int h = LWS_FD_HASH(fd);
int n = 0;
@ -86,7 +86,7 @@ delete_from_fd(struct libwebsocket_context *context, int fd)
return 1;
}
LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
LWS_VISIBLE int lws_get_random(struct lws_context *context,
void *buf, int len)
{
int n;
@ -98,12 +98,12 @@ LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
return n;
}
LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
LWS_VISIBLE int lws_send_pipe_choked(struct lws *wsi)
{
return wsi->sock_send_blocking;
}
LWS_VISIBLE int lws_poll_listen_fd(struct libwebsocket_pollfd *fd)
LWS_VISIBLE int lws_poll_listen_fd(struct lws_pollfd *fd)
{
fd_set readfds;
struct timeval tv = { 0, 0 };
@ -117,14 +117,14 @@ LWS_VISIBLE int lws_poll_listen_fd(struct libwebsocket_pollfd *fd)
}
/**
* libwebsocket_cancel_service() - Cancel servicing of pending websocket activity
* lws_cancel_service() - Cancel servicing of pending websocket activity
* @context: Websocket context
*
* This function let a call to libwebsocket_service() waiting for a timeout
* This function let a call to lws_service() waiting for a timeout
* immediately return.
*/
LWS_VISIBLE void
libwebsocket_cancel_service(struct libwebsocket_context *context)
lws_cancel_service(struct lws_context *context)
{
WSASetEvent(context->events[0]);
}
@ -135,14 +135,14 @@ LWS_VISIBLE void lwsl_emit_syslog(int level, const char *line)
}
LWS_VISIBLE int
lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
lws_plat_service(struct lws_context *context, int timeout_ms)
{
int n;
int i;
DWORD ev;
WSANETWORKEVENTS networkevents;
struct libwebsocket_pollfd *pfd;
struct libwebsocket *wsi;
struct lws_pollfd *pfd;
struct lws *wsi;
/* stay dead once we are dead */
@ -162,9 +162,12 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
if (!wsi || wsi->sock_send_blocking)
continue;
pfd->revents = LWS_POLLOUT;
n = libwebsocket_service_fd(context, pfd);
n = lws_service_fd(context, pfd);
if (n < 0)
return n;
return -1;
/* if something closed, retry this slot */
if (n)
i--;
}
}
@ -173,7 +176,7 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
context->service_tid = 0;
if (ev == WSA_WAIT_TIMEOUT) {
libwebsocket_service_fd(context, NULL);
lws_service_fd(context, NULL);
return 0;
}
@ -195,7 +198,7 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
return -1;
}
pfd->revents = networkevents.lNetworkEvents;
pfd->revents = (short)networkevents.lNetworkEvents;
if (pfd->revents & LWS_POLLOUT) {
wsi = wsi_from_fd(context, pfd->fd);
@ -203,11 +206,11 @@ lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
wsi->sock_send_blocking = FALSE;
}
return libwebsocket_service_fd(context, pfd);
return lws_service_fd(context, pfd);
}
LWS_VISIBLE int
lws_plat_set_socket_options(struct libwebsocket_context *context, int fd)
lws_plat_set_socket_options(struct lws_context *context, lws_sockfd_type fd)
{
int optval = 1;
int optlen = sizeof(optval);
@ -254,12 +257,12 @@ lws_plat_drop_app_privileges(struct lws_context_creation_info *info)
}
LWS_VISIBLE int
lws_plat_init_lookup(struct libwebsocket_context *context)
lws_plat_init_lookup(struct lws_context *context)
{
int i;
for (i = 0; i < FD_HASHTABLE_MODULUS; i++) {
context->fd_hashtable[i].wsi = lws_zalloc(sizeof(struct libwebsocket*) * context->max_fds);
context->fd_hashtable[i].wsi = lws_zalloc(sizeof(struct lws*) * context->max_fds);
if (!context->fd_hashtable[i].wsi) {
return -1;
@ -270,7 +273,7 @@ lws_plat_init_lookup(struct libwebsocket_context *context)
}
LWS_VISIBLE int
lws_plat_init_fd_tables(struct libwebsocket_context *context)
lws_plat_init_fd_tables(struct lws_context *context)
{
context->events = lws_malloc(sizeof(WSAEVENT) * (context->max_fds + 1));
if (context->events == NULL) {
@ -310,7 +313,7 @@ lws_plat_context_early_init(void)
}
LWS_VISIBLE void
lws_plat_context_early_destroy(struct libwebsocket_context *context)
lws_plat_context_early_destroy(struct lws_context *context)
{
if (context->events) {
WSACloseEvent(context->events[0]);
@ -319,7 +322,7 @@ lws_plat_context_early_destroy(struct libwebsocket_context *context)
}
LWS_VISIBLE void
lws_plat_context_late_destroy(struct libwebsocket_context *context)
lws_plat_context_late_destroy(struct lws_context *context)
{
int n;
@ -332,7 +335,7 @@ lws_plat_context_late_destroy(struct libwebsocket_context *context)
}
LWS_VISIBLE int
interface_to_sa(struct libwebsocket_context *context,
interface_to_sa(struct lws_context *context,
const char *ifname, struct sockaddr_in *addr, size_t addrlen)
{
long long address = inet_addr(ifname);
@ -346,14 +349,14 @@ interface_to_sa(struct libwebsocket_context *context,
if (address == INADDR_NONE)
return -1;
addr->sin_addr.s_addr = address;
addr->sin_addr.s_addr = (unsigned long)address;
return 0;
}
LWS_VISIBLE void
lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_plat_insert_socket_into_fds(struct lws_context *context,
struct lws *wsi)
{
context->fds[context->fds_count++].revents = 0;
context->events[context->fds_count] = WSACreateEvent();
@ -361,21 +364,21 @@ lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
}
LWS_VISIBLE void
lws_plat_delete_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi, int m)
lws_plat_delete_socket_from_fds(struct lws_context *context,
struct lws *wsi, int m)
{
WSACloseEvent(context->events[m + 1]);
context->events[m + 1] = context->events[context->fds_count + 1];
}
LWS_VISIBLE void
lws_plat_service_periodic(struct libwebsocket_context *context)
lws_plat_service_periodic(struct lws_context *context)
{
}
LWS_VISIBLE int
lws_plat_change_pollfd(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pfd)
lws_plat_change_pollfd(struct lws_context *context,
struct lws *wsi, struct lws_pollfd *pfd)
{
long networkevents = LWS_POLLHUP;

102
lib/output.c
View file

@ -22,13 +22,13 @@
#include "private-libwebsockets.h"
static int
libwebsocket_0405_frame_mask_generate(struct libwebsocket *wsi)
lws_0405_frame_mask_generate(struct lws *wsi)
{
int n;
/* fetch the per-frame nonce */
n = libwebsockets_get_random(wsi->protocol->owning_server,
n = lws_get_random(wsi->protocol->owning_server,
wsi->u.ws.frame_masking_nonce_04, 4);
if (n != 4) {
lwsl_parser("Unable to read from random device %s %d\n",
@ -46,10 +46,8 @@ libwebsocket_0405_frame_mask_generate(struct libwebsocket *wsi)
LWS_VISIBLE void lwsl_hexdump(void *vbuf, size_t len)
{
unsigned int n;
unsigned int m;
unsigned int start;
unsigned char *buf = (unsigned char *)vbuf;
unsigned int n, m, start;
char line[80];
char *p;
@ -90,12 +88,11 @@ LWS_VISIBLE void lwsl_hexdump(void *vbuf, size_t len)
* notice this returns number of bytes consumed, or -1
*/
int lws_issue_raw(struct libwebsocket *wsi, unsigned char *buf, size_t len)
int lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len)
{
struct libwebsocket_context *context = wsi->protocol->owning_server;
int n;
struct lws_context *context = wsi->protocol->owning_server;
size_t real_len = len;
int m;
int n, m;
if (!len)
return 0;
@ -123,9 +120,7 @@ int lws_issue_raw(struct libwebsocket *wsi, unsigned char *buf, size_t len)
if (!lws_socket_is_valid(wsi->sock))
lwsl_warn("** error invalid sock but expected to send\n");
/*
* nope, send it on the socket directly
*/
/* nope, send it on the socket directly */
lws_latency_pre(context, wsi);
n = lws_ssl_capable_write(wsi, buf, len);
lws_latency(context, wsi, "send lws_issue_raw", n, (unsigned int)n == len);
@ -162,8 +157,7 @@ handle_truncated_send:
}
}
/* always callback on writeable */
libwebsocket_callback_on_writable(
wsi->protocol->owning_server, wsi);
lws_callback_on_writable(wsi->protocol->owning_server, wsi);
return n;
}
@ -187,7 +181,7 @@ handle_truncated_send:
* first priority next time the socket is writable)
*/
lwsl_info("***** %x new partial sent %d from %d total\n",
wsi, n, real_len);
wsi, n, real_len);
/*
* - if we still have a suitable malloc lying around, use it
@ -195,14 +189,14 @@ handle_truncated_send:
* - or, if no buffer, create it
*/
if (!wsi->truncated_send_malloc ||
real_len - n > wsi->truncated_send_allocation) {
real_len - n > wsi->truncated_send_allocation) {
lws_free(wsi->truncated_send_malloc);
wsi->truncated_send_allocation = real_len - n;
wsi->truncated_send_malloc = lws_malloc(real_len - n);
if (!wsi->truncated_send_malloc) {
lwsl_err("truncated send: unable to malloc %d\n",
real_len - n);
real_len - n);
return -1;
}
}
@ -211,13 +205,13 @@ handle_truncated_send:
memcpy(wsi->truncated_send_malloc, buf + n, real_len - n);
/* since something buffered, force it to get another chance to send */
libwebsocket_callback_on_writable(wsi->protocol->owning_server, wsi);
lws_callback_on_writable(wsi->protocol->owning_server, wsi);
return real_len;
}
/**
* libwebsocket_write() - Apply protocol then write data to client
* lws_write() - Apply protocol then write data to client
* @wsi: Websocket instance (available from user callback)
* @buf: The data to send. For data being sent on a websocket
* connection (ie, not default http), this buffer MUST have
@ -246,21 +240,19 @@ handle_truncated_send:
* pressure at any given time.
*/
LWS_VISIBLE int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
size_t len, enum libwebsocket_write_protocol protocol)
LWS_VISIBLE int lws_write(struct lws *wsi, unsigned char *buf,
size_t len, enum lws_write_protocol protocol)
{
int n;
int pre = 0;
int post = 0;
int masked7 = wsi->mode == LWS_CONNMODE_WS_CLIENT;
unsigned char *dropmask = NULL;
unsigned char is_masked_bit = 0;
size_t orig_len = len;
unsigned char *dropmask = NULL;
struct lws_tokens eff_buf;
int post = 0, pre = 0, n;
size_t orig_len = len;
if (len == 0 && protocol != LWS_WRITE_CLOSE &&
protocol != LWS_WRITE_PING && protocol != LWS_WRITE_PONG) {
lwsl_warn("zero length libwebsocket_write attempt\n");
protocol != LWS_WRITE_PING && protocol != LWS_WRITE_PONG) {
lwsl_warn("zero length lws_write attempt\n");
return 0;
}
@ -318,7 +310,6 @@ LWS_VISIBLE int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
switch (wsi->ietf_spec_revision) {
case 13:
if (masked7) {
pre += 4;
dropmask = &buf[0 - pre];
@ -347,8 +338,8 @@ LWS_VISIBLE int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
if (wsi->u.ws.close_reason) {
/* reason codes count as data bytes */
buf -= 2;
buf[0] = wsi->u.ws.close_reason >> 8;
buf[1] = wsi->u.ws.close_reason;
buf[0] = (unsigned char)(wsi->u.ws.close_reason >> 8);
buf[1] = (unsigned char)wsi->u.ws.close_reason;
len += 2;
}
break;
@ -369,14 +360,14 @@ LWS_VISIBLE int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
if (len < 126) {
pre += 2;
buf[-pre] = n;
buf[-pre + 1] = len | is_masked_bit;
buf[-pre + 1] = (unsigned char)(len | is_masked_bit);
} else {
if (len < 65536) {
pre += 4;
buf[-pre] = n;
buf[-pre + 1] = 126 | is_masked_bit;
buf[-pre + 2] = len >> 8;
buf[-pre + 3] = len;
buf[-pre + 2] = (unsigned char)(len >> 8);
buf[-pre + 3] = (unsigned char)len;
} else {
pre += 10;
buf[-pre] = n;
@ -392,10 +383,10 @@ LWS_VISIBLE int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
buf[-pre + 4] = 0;
buf[-pre + 5] = 0;
#endif
buf[-pre + 6] = len >> 24;
buf[-pre + 7] = len >> 16;
buf[-pre + 8] = len >> 8;
buf[-pre + 9] = len;
buf[-pre + 6] = (unsigned char)(len >> 24);
buf[-pre + 7] = (unsigned char)(len >> 16);
buf[-pre + 8] = (unsigned char)(len >> 8);
buf[-pre + 9] = (unsigned char)len;
}
}
break;
@ -411,7 +402,7 @@ do_more_inside_frame:
if (wsi->mode == LWS_CONNMODE_WS_CLIENT) {
if (!wsi->u.ws.inside_frame)
if (libwebsocket_0405_frame_mask_generate(wsi)) {
if (lws_0405_frame_mask_generate(wsi)) {
lwsl_err("frame mask generation failed\n");
return -1;
}
@ -508,15 +499,15 @@ send_raw:
/*
* it is how many bytes of user buffer got sent... may be < orig_len
* in which case callback when writable has already been arranged
* and user code can call libwebsocket_write() again with the rest
* and user code can call lws_write() again with the rest
* later.
*/
return n - (pre + post);
}
LWS_VISIBLE int libwebsockets_serve_http_file_fragment(
struct libwebsocket_context *context, struct libwebsocket *wsi)
LWS_VISIBLE int lws_serve_http_file_fragment(struct lws_context *context,
struct lws *wsi)
{
int n;
int m;
@ -525,9 +516,9 @@ LWS_VISIBLE int libwebsockets_serve_http_file_fragment(
if (wsi->truncated_send_len) {
if (lws_issue_raw(wsi, wsi->truncated_send_malloc +
wsi->truncated_send_offset,
wsi->truncated_send_len) < 0) {
lwsl_info("closing from libwebsockets_serve_http_file_fragment\n");
wsi->truncated_send_offset,
wsi->truncated_send_len) < 0) {
lwsl_info("closing from lws_serve_http_file_fragment\n");
return -1;
}
continue;
@ -538,13 +529,16 @@ LWS_VISIBLE int libwebsockets_serve_http_file_fragment(
context->file_callbacks.pfn_read(&n, wsi->u.http.fd, context->service_buffer,
sizeof(context->service_buffer));
if (n < 0)
return -1; /* caller will close */
if (n) {
libwebsocket_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT, AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT,
AWAITING_TIMEOUT);
wsi->u.http.filepos += n;
m = libwebsocket_write(wsi, context->service_buffer, n,
wsi->u.http.filepos == wsi->u.http.filelen ? LWS_WRITE_HTTP_FINAL : LWS_WRITE_HTTP);
m = lws_write(wsi, context->service_buffer, n,
wsi->u.http.filepos == wsi->u.http.filelen ?
LWS_WRITE_HTTP_FINAL : LWS_WRITE_HTTP);
if (m < 0)
return -1;
@ -555,7 +549,7 @@ LWS_VISIBLE int libwebsockets_serve_http_file_fragment(
}
all_sent:
if (!wsi->truncated_send_len &&
wsi->u.http.filepos == wsi->u.http.filelen) {
wsi->u.http.filepos == wsi->u.http.filelen) {
wsi->state = WSI_STATE_HTTP;
/* we might be in keepalive, so close it off here */
@ -573,15 +567,15 @@ all_sent:
}
lwsl_info("choked before able to send whole file (post)\n");
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
return 0; /* indicates further processing must be done */
}
#if LWS_POSIX
LWS_VISIBLE int
lws_ssl_capable_read_no_ssl(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, int len)
lws_ssl_capable_read_no_ssl(struct lws_context *context,
struct lws *wsi, unsigned char *buf, int len)
{
int n;
@ -601,7 +595,7 @@ lws_ssl_capable_read_no_ssl(struct libwebsocket_context *context,
}
LWS_VISIBLE int
lws_ssl_capable_write_no_ssl(struct libwebsocket *wsi, unsigned char *buf, int len)
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, int len)
{
int n = 0;
@ -631,7 +625,7 @@ lws_ssl_capable_write_no_ssl(struct libwebsocket *wsi, unsigned char *buf, int l
}
#endif
LWS_VISIBLE int
lws_ssl_pending_no_ssl(struct libwebsocket *wsi)
lws_ssl_pending_no_ssl(struct lws *wsi)
{
(void)wsi;
return 0;

71
lib/parsers.c
View file

@ -59,7 +59,7 @@ int lextable_decode(int pos, char c)
}
}
int lws_allocate_header_table(struct libwebsocket *wsi)
int lws_allocate_header_table(struct lws *wsi)
{
/* Be sure to free any existing header data to avoid mem leak: */
lws_free_header_table(wsi);
@ -75,14 +75,14 @@ int lws_allocate_header_table(struct libwebsocket *wsi)
return 0;
}
int lws_free_header_table(struct libwebsocket *wsi)
int lws_free_header_table(struct lws *wsi)
{
lws_free2(wsi->u.hdr.ah);
wsi->u.hdr.ah = NULL;
return 0;
};
LWS_VISIBLE int lws_hdr_total_length(struct libwebsocket *wsi, enum lws_token_indexes h)
LWS_VISIBLE int lws_hdr_total_length(struct lws *wsi, enum lws_token_indexes h)
{
int n;
int len = 0;
@ -98,8 +98,8 @@ LWS_VISIBLE int lws_hdr_total_length(struct libwebsocket *wsi, enum lws_token_in
return len;
}
LWS_VISIBLE int lws_hdr_copy(struct libwebsocket *wsi, char *dest, int len,
enum lws_token_indexes h)
LWS_VISIBLE int lws_hdr_copy(struct lws *wsi, char *dest, int len,
enum lws_token_indexes h)
{
int toklen = lws_hdr_total_length(wsi, h);
int n;
@ -121,7 +121,7 @@ LWS_VISIBLE int lws_hdr_copy(struct libwebsocket *wsi, char *dest, int len,
return toklen;
}
char *lws_hdr_simple_ptr(struct libwebsocket *wsi, enum lws_token_indexes h)
char *lws_hdr_simple_ptr(struct lws *wsi, enum lws_token_indexes h)
{
int n;
@ -132,8 +132,8 @@ char *lws_hdr_simple_ptr(struct libwebsocket *wsi, enum lws_token_indexes h)
return &wsi->u.hdr.ah->data[wsi->u.hdr.ah->frags[n].offset];
}
int lws_hdr_simple_create(struct libwebsocket *wsi,
enum lws_token_indexes h, const char *s)
int lws_hdr_simple_create(struct lws *wsi,
enum lws_token_indexes h, const char *s)
{
wsi->u.hdr.ah->next_frag_index++;
if (wsi->u.hdr.ah->next_frag_index ==
@ -178,29 +178,35 @@ static signed char char_to_hex(const char c)
return -1;
}
static int issue_char(struct libwebsocket *wsi, unsigned char c)
static int issue_char(struct lws *wsi, unsigned char c)
{
unsigned short frag_len;
if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
lwsl_warn("excessive header content\n");
return -1;
}
if( wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len >=
wsi->u.hdr.current_token_limit) {
lwsl_warn("header %i exceeds limit\n", wsi->u.hdr.parser_state);
return 1;
frag_len = \
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len;
/* If we haven't hit the token limit, just copy the character into
* the header: */
if( frag_len < wsi->u.hdr.current_token_limit ) {
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = c;
if (c)
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len++;
return 0;
}
else {
/* Insert a null character when we *hit* the limit: */
if( frag_len == wsi->u.hdr.current_token_limit ) {
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = '\0';
lwsl_warn("header %i exceeds limit\n", wsi->u.hdr.parser_state);
};
};
wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = c;
if (c)
wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len++;
return 0;
return 1;
}
int libwebsocket_parse(
struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char c)
int lws_parse(struct lws_context *context, struct lws *wsi, unsigned char c)
{
static const unsigned char methods[] = {
WSI_TOKEN_GET_URI,
@ -273,7 +279,7 @@ int libwebsocket_parse(
issue_char(wsi, '%');
wsi->u.hdr.ues = URIES_IDLE;
/* regurgitate + assess */
if (libwebsocket_parse(context, wsi, wsi->u.hdr.esc_stash) < 0)
if (lws_parse(context, wsi, wsi->u.hdr.esc_stash) < 0)
return -1;
/* continue on to assess c */
break;
@ -564,13 +570,13 @@ set_parsing_complete:
* mode.
*/
LWS_VISIBLE int lws_frame_is_binary(struct libwebsocket *wsi)
LWS_VISIBLE int lws_frame_is_binary(struct lws *wsi)
{
return wsi->u.ws.frame_is_binary;
}
int
libwebsocket_rx_sm(struct libwebsocket *wsi, unsigned char c)
lws_rx_sm(struct lws *wsi, unsigned char c)
{
struct lws_tokens eff_buf;
int ret = 0;
@ -921,7 +927,7 @@ process_as_ping:
wsi->u.ws.ping_pending_flag = 1;
/* get it sent as soon as possible */
libwebsocket_callback_on_writable(wsi->protocol->owning_server, wsi);
lws_callback_on_writable(wsi->protocol->owning_server, wsi);
ping_drop:
wsi->u.ws.rx_user_buffer_head = 0;
return 0;
@ -966,7 +972,7 @@ ping_drop:
/*
* No it's real payload, pass it up to the user callback.
* It's nicely buffered with the pre-padding taken care of
* so it can be sent straight out again using libwebsocket_write
* so it can be sent straight out again using lws_write
*/
eff_buf.token = &wsi->u.ws.rx_user_buffer[
@ -977,7 +983,8 @@ ping_drop:
LWS_EXT_CALLBACK_PAYLOAD_RX, &eff_buf, 0) < 0)
return -1;
if (eff_buf.token_len > 0) {
if (eff_buf.token_len > 0 ||
callback_action == LWS_CALLBACK_RECEIVE_PONG) {
eff_buf.token[eff_buf.token_len] = '\0';
if (wsi->protocol->callback) {
@ -989,7 +996,7 @@ ping_drop:
wsi->protocol->callback,
wsi->protocol->owning_server,
wsi,
(enum libwebsocket_callback_reasons)callback_action,
(enum lws_callback_reasons)callback_action,
wsi->user_space,
eff_buf.token,
eff_buf.token_len);
@ -1013,7 +1020,7 @@ illegal_ctl_length:
/**
* libwebsockets_remaining_packet_payload() - Bytes to come before "overall"
* lws_remaining_packet_payload() - Bytes to come before "overall"
* rx packet is complete
* @wsi: Websocket instance (available from user callback)
*
@ -1023,14 +1030,14 @@ illegal_ctl_length:
* additionally when it hits a built-in limit. The LWS_CALLBACK_RECEIVE
* callback handler can use this API to find out if the buffer it has just
* been given is the last piece of a "complete packet" from the client --
* when that is the case libwebsockets_remaining_packet_payload() will return
* when that is the case lws_remaining_packet_payload() will return
* 0.
*
* Many protocols won't care becuse their packets are always small.
*/
LWS_VISIBLE size_t
libwebsockets_remaining_packet_payload(struct libwebsocket *wsi)
lws_remaining_packet_payload(struct lws *wsi)
{
return wsi->u.ws.rx_packet_length;
}

55
lib/pollfd.c
View file

@ -22,10 +22,10 @@
#include "private-libwebsockets.h"
int
insert_wsi_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi)
insert_wsi_socket_into_fds(struct lws_context *context,
struct lws *wsi)
{
struct libwebsocket_pollargs pa = { wsi->sock, LWS_POLLIN, 0 };
struct lws_pollargs pa = { wsi->sock, LWS_POLLIN, 0 };
if (context->fds_count >= context->max_fds) {
lwsl_err("Too many fds (%d)\n", context->max_fds);
@ -47,7 +47,7 @@ insert_wsi_socket_into_fds(struct libwebsocket_context *context,
// wsi, wsi->sock, context->fds_count);
if (context->protocols[0].callback(context, wsi,
LWS_CALLBACK_LOCK_POLL, wsi->user_space, (void *) &pa, 0))
LWS_CALLBACK_LOCK_POLL, wsi->user_space, (void *) &pa, 1))
return -1;
insert_wsi(context, wsi);
@ -63,18 +63,18 @@ insert_wsi_socket_into_fds(struct libwebsocket_context *context,
return -1;
if (context->protocols[0].callback(context, wsi,
LWS_CALLBACK_UNLOCK_POLL, wsi->user_space, (void *)&pa, 0))
LWS_CALLBACK_UNLOCK_POLL, wsi->user_space, (void *)&pa, 1))
return -1;
return 0;
}
int
remove_wsi_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi)
remove_wsi_socket_from_fds(struct lws_context *context,
struct lws *wsi)
{
int m;
struct libwebsocket_pollargs pa = { wsi->sock, 0, 0 };
struct lws_pollargs pa = { wsi->sock, 0, 0 };
lws_libev_io(context, wsi, LWS_EV_STOP | LWS_EV_READ | LWS_EV_WRITE);
@ -92,7 +92,7 @@ remove_wsi_socket_from_fds(struct libwebsocket_context *context,
wsi, wsi->sock, wsi->position_in_fds_table);
if (context->protocols[0].callback(context, wsi,
LWS_CALLBACK_LOCK_POLL, wsi->user_space, (void *)&pa, 0))
LWS_CALLBACK_LOCK_POLL, wsi->user_space, (void *)&pa, 1))
return -1;
m = wsi->position_in_fds_table; /* replace the contents for this */
@ -123,20 +123,20 @@ remove_wsi_socket_from_fds(struct libwebsocket_context *context,
}
if (context->protocols[0].callback(context, wsi,
LWS_CALLBACK_UNLOCK_POLL,
wsi->user_space, (void *) &pa, 0))
wsi->user_space, (void *) &pa, 1))
return -1;
return 0;
}
int
lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or)
lws_change_pollfd(struct lws *wsi, int _and, int _or)
{
struct libwebsocket_context *context;
struct lws_context *context;
int tid;
int sampled_tid;
struct libwebsocket_pollfd *pfd;
struct libwebsocket_pollargs pa;
struct lws_pollfd *pfd;
struct lws_pollargs pa;
if (!wsi || !wsi->protocol || wsi->position_in_fds_table < 0)
return 1;
@ -167,7 +167,10 @@ lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or)
* ... and the service thread is waiting ...
* then cancel it to force a restart with our changed events
*/
if (pa.prev_events != pa.events) {
#if LWS_POSIX
if (pa.prev_events != pa.events)
#endif
{
if (lws_plat_change_pollfd(context, wsi, pfd)) {
lwsl_info("%s failed\n", __func__);
@ -181,7 +184,7 @@ lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or)
if (tid == -1)
return -1;
if (tid != sampled_tid)
libwebsocket_cancel_service(context);
lws_cancel_service(context);
}
}
@ -194,7 +197,7 @@ lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or)
/**
* libwebsocket_callback_on_writable() - Request a callback when this socket
* lws_callback_on_writable() - Request a callback when this socket
* becomes able to be written to without
* blocking
*
@ -203,11 +206,11 @@ lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or)
*/
LWS_VISIBLE int
libwebsocket_callback_on_writable(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_callback_on_writable(struct lws_context *context,
struct lws *wsi)
{
#ifdef LWS_USE_HTTP2
struct libwebsocket *network_wsi, *wsi2;
struct lws *network_wsi, *wsi2;
int already;
lwsl_info("%s: %p\n", __func__, wsi);
@ -272,7 +275,7 @@ network_sock:
}
/**
* libwebsocket_callback_on_writable_all_protocol() - Request a callback for
* lws_callback_on_writable_all_protocol() - Request a callback for
* all connections using the given protocol when it
* becomes possible to write to each socket without
* blocking in turn.
@ -281,19 +284,19 @@ network_sock:
*/
LWS_VISIBLE int
libwebsocket_callback_on_writable_all_protocol(
const struct libwebsocket_protocols *protocol)
lws_callback_on_writable_all_protocol(
const struct lws_protocols *protocol)
{
struct libwebsocket_context *context = protocol->owning_server;
struct lws_context *context = protocol->owning_server;
int n;
struct libwebsocket *wsi;
struct lws *wsi;
for (n = 0; n < context->fds_count; n++) {
wsi = wsi_from_fd(context,context->fds[n].fd);
if (!wsi)
continue;
if (wsi->protocol == protocol)
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
}
return 0;

374
lib/private-libwebsockets.h
View file

@ -33,6 +33,7 @@
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <assert.h>
#ifdef LWS_HAVE_SYS_STAT_H
#include <sys/stat.h>
@ -294,7 +295,7 @@ extern "C" {
#define SPEC_LATEST_SUPPORTED 13
#endif
#ifndef AWAITING_TIMEOUT
#define AWAITING_TIMEOUT 20
#define AWAITING_TIMEOUT 5
#endif
#ifndef CIPHERS_LIST_STRING
#define CIPHERS_LIST_STRING "DEFAULT"
@ -429,39 +430,39 @@ enum {
LWS_RXFLOW_PENDING_CHANGE = (1 << 1),
};
struct libwebsocket_protocols;
struct libwebsocket;
struct lws_protocols;
struct lws;
#ifdef LWS_USE_LIBEV
struct lws_io_watcher {
struct ev_io watcher;
struct libwebsocket_context* context;
struct lws_context* context;
};
struct lws_signal_watcher {
struct ev_signal watcher;
struct libwebsocket_context* context;
struct lws_context* context;
};
#endif /* LWS_USE_LIBEV */
#ifdef _WIN32
#define LWS_FD_HASH(fd) ((fd ^ (fd >> 8) ^ (fd >> 16)) % FD_HASHTABLE_MODULUS)
struct libwebsocket_fd_hashtable {
struct libwebsocket **wsi;
struct lws_fd_hashtable {
struct lws **wsi;
int length;
};
#endif
struct libwebsocket_context {
struct lws_context {
#ifdef _WIN32
WSAEVENT *events;
#endif
struct libwebsocket_pollfd *fds;
struct lws_pollfd *fds;
#ifdef _WIN32
/* different implementation between unix and windows */
struct libwebsocket_fd_hashtable fd_hashtable[FD_HASHTABLE_MODULUS];
struct lws_fd_hashtable fd_hashtable[FD_HASHTABLE_MODULUS];
#else
struct libwebsocket **lws_lookup; /* fd to wsi */
struct lws **lws_lookup; /* fd to wsi */
#endif
int fds_count;
#ifdef LWS_USE_LIBEV
@ -522,15 +523,15 @@ struct libwebsocket_context {
unsigned int user_supplied_ssl_ctx:1;
SSL_CTX *ssl_ctx;
SSL_CTX *ssl_client_ctx;
struct libwebsocket *pending_read_list; /* linked list */
struct lws *pending_read_list; /* linked list */
#define lws_ssl_anybody_has_buffered_read(ctx) (ctx->use_ssl && ctx->pending_read_list)
#else
#define lws_ssl_anybody_has_buffered_read(ctx) (0)
#endif
struct libwebsocket_protocols *protocols;
struct lws_protocols *protocols;
int count_protocols;
#ifndef LWS_NO_EXTENSIONS
struct libwebsocket_extension *extensions;
struct lws_extension *extensions;
#endif
struct libwebsocket_file_callbacks file_callbacks;
struct lws_token_limits *token_limits;
@ -548,15 +549,15 @@ enum {
#define LWS_LIBEV_ENABLED(context) (context->options & LWS_SERVER_OPTION_LIBEV)
LWS_EXTERN void lws_feature_status_libev(struct lws_context_creation_info *info);
LWS_EXTERN void
lws_libev_accept(struct libwebsocket_context *context,
struct libwebsocket *new_wsi, lws_sockfd_type accept_fd);
lws_libev_accept(struct lws_context *context,
struct lws *new_wsi, lws_sockfd_type accept_fd);
LWS_EXTERN void
lws_libev_io(struct libwebsocket_context *context,
struct libwebsocket *wsi, int flags);
lws_libev_io(struct lws_context *context,
struct lws *wsi, int flags);
LWS_EXTERN int
lws_libev_init_fd_table(struct libwebsocket_context *context);
lws_libev_init_fd_table(struct lws_context *context);
LWS_EXTERN void
lws_libev_run(struct libwebsocket_context *context);
lws_libev_run(struct lws_context *context);
#else
#define LWS_LIBEV_ENABLED(context) (0)
#ifdef LWS_POSIX
@ -572,7 +573,8 @@ lws_libev_run(struct libwebsocket_context *context);
#endif
#ifdef LWS_USE_IPV6
#define LWS_IPV6_ENABLED(context) (!(context->options & LWS_SERVER_OPTION_DISABLE_IPV6))
#define LWS_IPV6_ENABLED(context) \
(!(context->options & LWS_SERVER_OPTION_DISABLE_IPV6))
#else
#define LWS_IPV6_ENABLED(context) (0)
#endif
@ -612,11 +614,11 @@ struct lws_fragments {
* 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 interchangably to access the same data
* used interchangeably to access the same data
*/
struct allocated_headers {
unsigned short next_frag_index;
unsigned char next_frag_index;
unsigned short pos;
unsigned char frag_index[WSI_TOKEN_COUNT];
struct lws_fragments frags[WSI_TOKEN_COUNT * 2];
@ -644,7 +646,6 @@ struct _lws_http_mode_related {
unsigned int content_remain;
};
#ifdef LWS_USE_HTTP2
enum lws_http2_settings {
@ -746,8 +747,8 @@ struct _lws_http2_related {
struct http2_settings my_settings;
struct http2_settings peer_settings;
struct libwebsocket *parent_wsi;
struct libwebsocket *next_child_wsi;
struct lws *parent_wsi;
struct lws *next_child_wsi;
struct hpack_dynamic_table *hpack_dyn_table;
@ -756,7 +757,7 @@ struct _lws_http2_related {
/* frame */
unsigned int length;
unsigned int stream_id;
struct libwebsocket *stream_wsi;
struct lws *stream_wsi;
unsigned char type;
unsigned char flags;
unsigned char frame_state;
@ -833,7 +834,7 @@ struct _lws_websocket_related {
unsigned char ping_pending_flag;
};
struct libwebsocket {
struct lws {
/* lifetime members */
@ -841,10 +842,9 @@ struct libwebsocket {
struct lws_io_watcher w_read;
struct lws_io_watcher w_write;
#endif /* LWS_USE_LIBEV */
const struct libwebsocket_protocols *protocol;
const struct lws_protocols *protocol;
#ifndef LWS_NO_EXTENSIONS
struct libwebsocket_extension *
active_extensions[LWS_MAX_EXTENSIONS_ACTIVE];
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;
@ -855,7 +855,7 @@ struct libwebsocket {
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 libwebsocket_write_protocol */
char rx_frame_type; /* enum lws_write_protocol */
unsigned int hdr_parsing_completed:1;
unsigned int user_space_externally_allocated:1;
@ -897,7 +897,7 @@ struct libwebsocket {
#ifdef LWS_OPENSSL_SUPPORT
SSL *ssl;
BIO *client_bio;
struct libwebsocket *pending_read_list_prev, *pending_read_list_next;
struct lws *pending_read_list_prev, *pending_read_list_next;
unsigned int use_ssl:2;
unsigned int upgraded:1;
#endif
@ -910,54 +910,56 @@ struct libwebsocket {
LWS_EXTERN int log_level;
LWS_EXTERN void
libwebsocket_close_and_free_session(struct libwebsocket_context *context,
struct libwebsocket *wsi, enum lws_close_status);
lws_close_and_free_session(struct lws_context *context,
struct lws *wsi, enum lws_close_status);
LWS_EXTERN int
remove_wsi_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi);
remove_wsi_socket_from_fds(struct lws_context *context, struct lws *wsi);
LWS_EXTERN int
lws_rxflow_cache(struct libwebsocket *wsi, unsigned char *buf, int n, int len);
lws_rxflow_cache(struct lws *wsi, unsigned char *buf, int n, int len);
#ifndef LWS_LATENCY
static inline void lws_latency(struct libwebsocket_context *context,
struct libwebsocket *wsi, const char *action,
int ret, int completion) { do { (void)context; (void)wsi; (void)action; (void)ret; (void)completion; } while (0); }
static inline void lws_latency_pre(struct libwebsocket_context *context,
struct libwebsocket *wsi) { do { (void)context; (void)wsi; } while (0); }
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;
} while (0);
}
static inline void
lws_latency_pre(struct lws_context *context, struct lws *wsi) {
do { (void)context; (void)wsi; } while (0);
}
#else
#define lws_latency_pre(_context, _wsi) lws_latency(_context, _wsi, NULL, 0, 0)
extern void
lws_latency(struct libwebsocket_context *context,
struct libwebsocket *wsi, const char *action,
int ret, int completion);
lws_latency(struct lws_context *context, struct lws *wsi, const char *action,
int ret, int completion);
#endif
LWS_EXTERN void lws_set_protocol_write_pending(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum lws_pending_protocol_send pend);
LWS_EXTERN void
lws_set_protocol_write_pending(struct lws_context *context, struct lws *wsi,
enum lws_pending_protocol_send pend);
LWS_EXTERN int
libwebsocket_client_rx_sm(struct libwebsocket *wsi, unsigned char c);
lws_client_rx_sm(struct lws *wsi, unsigned char c);
LWS_EXTERN int
libwebsocket_parse(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char c);
lws_parse(struct lws_context *context, struct lws *wsi, unsigned char c);
LWS_EXTERN int
lws_http_action(struct libwebsocket_context *context, struct libwebsocket *wsi);
lws_http_action(struct lws_context *context, struct lws *wsi);
LWS_EXTERN int
lws_b64_selftest(void);
#if defined(_WIN32) || defined(MBED_OPERATORS)
LWS_EXTERN struct libwebsocket *
wsi_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd);
LWS_EXTERN struct lws *
wsi_from_fd(struct lws_context *context, lws_sockfd_type fd);
LWS_EXTERN int
insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi);
insert_wsi(struct lws_context *context, struct lws *wsi);
LWS_EXTERN int
delete_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd);
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
@ -965,31 +967,29 @@ delete_from_fd(struct libwebsocket_context *context, lws_sockfd_type fd);
#endif
LWS_EXTERN int
insert_wsi_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi);
insert_wsi_socket_into_fds(struct lws_context *context, struct lws *wsi);
LWS_EXTERN int
lws_issue_raw(struct libwebsocket *wsi, unsigned char *buf, size_t len);
lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len);
LWS_EXTERN int
libwebsocket_service_timeout_check(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned int sec);
lws_service_timeout_check(struct lws_context *context,
struct lws *wsi, unsigned int sec);
LWS_EXTERN struct libwebsocket *
libwebsocket_client_connect_2(struct libwebsocket_context *context,
struct libwebsocket *wsi);
LWS_EXTERN struct lws *
lws_client_connect_2(struct lws_context *context, struct lws *wsi);
LWS_EXTERN struct libwebsocket *
libwebsocket_create_new_server_wsi(struct libwebsocket_context *context);
LWS_EXTERN struct lws *
lws_create_new_server_wsi(struct lws_context *context);
LWS_EXTERN char *
libwebsockets_generate_client_handshake(struct libwebsocket_context *context,
struct libwebsocket *wsi, char *pkt);
lws_generate_client_handshake(struct lws_context *context, struct lws *wsi,
char *pkt);
LWS_EXTERN int
lws_handle_POLLOUT_event(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd);
lws_handle_POLLOUT_event(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pollfd);
/*
* EXTENSIONS
@ -998,20 +998,19 @@ lws_handle_POLLOUT_event(struct libwebsocket_context *context,
#ifndef LWS_NO_EXTENSIONS
LWS_VISIBLE void
lws_context_init_extensions(struct lws_context_creation_info *info,
struct libwebsocket_context *context);
struct lws_context *context);
LWS_EXTERN int
lws_any_extension_handled(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_extension_callback_reasons r,
lws_any_extension_handled(struct lws_context *context, struct lws *wsi,
enum lws_extension_callback_reasons r,
void *v, size_t len);
LWS_EXTERN int
lws_ext_callback_for_each_active(struct libwebsocket *wsi, int reason,
void *buf, int len);
lws_ext_callback_for_each_active(struct lws *wsi, int reason,
void *buf, int len);
LWS_EXTERN int
lws_ext_callback_for_each_extension_type(
struct libwebsocket_context *context, struct libwebsocket *wsi,
int reason, void *arg, int len);
lws_ext_callback_for_each_extension_type(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)
@ -1025,108 +1024,100 @@ lws_context_init_file_callbacks(struct lws_context_creation_info *info,
struct libwebsocket_context *context);
LWS_EXTERN int
lws_client_interpret_server_handshake(struct libwebsocket_context *context,
struct libwebsocket *wsi);
lws_client_interpret_server_handshake(struct lws_context *context,
struct lws *wsi);
LWS_EXTERN int
libwebsocket_rx_sm(struct libwebsocket *wsi, unsigned char c);
lws_rx_sm(struct lws *wsi, unsigned char c);
LWS_EXTERN int
lws_issue_raw_ext_access(struct libwebsocket *wsi,
unsigned char *buf, size_t len);
lws_issue_raw_ext_access(struct lws *wsi, unsigned char *buf, size_t len);
LWS_EXTERN int
_libwebsocket_rx_flow_control(struct libwebsocket *wsi);
_lws_rx_flow_control(struct lws *wsi);
LWS_EXTERN void
lws_union_transition(struct libwebsocket *wsi, enum connection_mode mode);
lws_union_transition(struct lws *wsi, enum connection_mode mode);
LWS_EXTERN int
user_callback_handle_rxflow(callback_function,
struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason, void *user,
void *in, size_t len);
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);
#ifdef LWS_USE_HTTP2
LWS_EXTERN struct libwebsocket *lws_http2_get_network_wsi(struct libwebsocket *wsi);
struct libwebsocket * lws_http2_get_nth_child(struct libwebsocket *wsi, int n);
LWS_EXTERN struct lws *lws_http2_get_network_wsi(struct lws *wsi);
struct lws * lws_http2_get_nth_child(struct lws *wsi, int n);
LWS_EXTERN int
lws_http2_interpret_settings_payload(struct http2_settings *settings, unsigned char *buf, int len);
lws_http2_interpret_settings_payload(struct http2_settings *settings,
unsigned char *buf, int len);
LWS_EXTERN void lws_http2_init(struct http2_settings *settings);
LWS_EXTERN int
lws_http2_parser(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char c);
LWS_EXTERN int lws_http2_do_pps_send(struct libwebsocket_context *context, struct libwebsocket *wsi);
LWS_EXTERN int lws_http2_frame_write(struct libwebsocket *wsi, int type, int flags, unsigned int sid, unsigned int len, unsigned char *buf);
LWS_EXTERN struct libwebsocket *
lws_http2_wsi_from_id(struct libwebsocket *wsi, unsigned int sid);
LWS_EXTERN int lws_hpack_interpret(struct libwebsocket_context *context,
struct libwebsocket *wsi,
lws_http2_parser(struct lws_context *context,
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 int sid, unsigned int len,
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,
unsigned char c);
LWS_EXTERN int
lws_add_http2_header_by_name(struct libwebsocket_context *context,
struct libwebsocket *wsi,
const unsigned char *name,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end);
lws_add_http2_header_by_name(struct lws_context *context, 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 libwebsocket_context *context,
struct libwebsocket *wsi,
lws_add_http2_header_by_token(struct lws_context *context, struct lws *wsi,
enum lws_token_indexes token,
const unsigned char *value,
int length,
unsigned char **p,
unsigned char *end);
const unsigned char *value, int length,
unsigned char **p, unsigned char *end);
LWS_EXTERN int
lws_add_http2_header_status(struct libwebsocket_context *context,
struct libwebsocket *wsi,
unsigned int code,
unsigned char **p,
lws_add_http2_header_status(struct lws_context *context, struct lws *wsi,
unsigned int code, unsigned char **p,
unsigned char *end);
LWS_EXTERN
void lws_http2_configure_if_upgraded(struct libwebsocket *wsi);
void lws_http2_configure_if_upgraded(struct lws *wsi);
#else
#define lws_http2_configure_if_upgraded(x)
#endif
LWS_EXTERN int
lws_plat_set_socket_options(struct libwebsocket_context *context, lws_sockfd_type fd);
lws_plat_set_socket_options(struct lws_context *context, lws_sockfd_type fd);
LWS_EXTERN int
lws_allocate_header_table(struct libwebsocket *wsi);
lws_allocate_header_table(struct lws *wsi);
LWS_EXTERN int
lws_free_header_table(struct libwebsocket *wsi);
lws_free_header_table(struct lws *wsi);
LWS_EXTERN char *
lws_hdr_simple_ptr(struct libwebsocket *wsi, enum lws_token_indexes h);
lws_hdr_simple_ptr(struct lws *wsi, enum lws_token_indexes h);
LWS_EXTERN int
lws_hdr_simple_create(struct libwebsocket *wsi,
lws_hdr_simple_create(struct lws *wsi,
enum lws_token_indexes h, const char *s);
LWS_EXTERN int
libwebsocket_ensure_user_space(struct libwebsocket *wsi);
lws_ensure_user_space(struct lws *wsi);
LWS_EXTERN int
lws_change_pollfd(struct libwebsocket *wsi, int _and, int _or);
lws_change_pollfd(struct lws *wsi, int _and, int _or);
#ifndef LWS_NO_SERVER
int lws_context_init_server(struct lws_context_creation_info *info,
struct libwebsocket_context *context);
LWS_EXTERN int handshake_0405(struct libwebsocket_context *context,
struct libwebsocket *wsi);
struct lws_context *context);
LWS_EXTERN int
libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
unsigned char *buf, size_t len);
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 void
lws_server_get_canonical_hostname(struct libwebsocket_context *context,
struct lws_context_creation_info *info);
lws_server_get_canonical_hostname(struct lws_context *context,
struct lws_context_creation_info *info);
#else
#define lws_context_init_server(_a, _b) (0)
#define libwebsocket_interpret_incoming_packet(_a, _b, _c) (0)
#define lws_interpret_incoming_packet(_a, _b, _c) (0)
#define lws_server_get_canonical_hostname(_a, _b)
#endif
@ -1137,8 +1128,9 @@ LWS_EXTERN int get_daemonize_pid();
#endif
#if !defined(MBED_OPERATORS)
LWS_EXTERN int interface_to_sa(struct libwebsocket_context *context,
const char *ifname, struct sockaddr_in *addr, size_t addrlen);
LWS_EXTERN int
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);
@ -1163,86 +1155,90 @@ enum lws_ssl_capable_status {
#define LWS_SSL_ENABLED(context) (context->use_ssl)
LWS_EXTERN int openssl_websocket_private_data_index;
LWS_EXTERN int
lws_ssl_capable_read(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, int len);
lws_ssl_capable_read(struct lws_context *context,
struct lws *wsi, unsigned char *buf, int len);
LWS_EXTERN int
lws_ssl_capable_write(struct libwebsocket *wsi, unsigned char *buf, int len);
lws_ssl_capable_write(struct lws *wsi, unsigned char *buf, int len);
LWS_EXTERN int
lws_ssl_pending(struct libwebsocket *wsi);
lws_ssl_pending(struct lws *wsi);
LWS_EXTERN int
lws_server_socket_service_ssl(struct libwebsocket_context *context,
struct libwebsocket **wsi, struct libwebsocket *new_wsi,
lws_sockfd_type accept_fd, struct libwebsocket_pollfd *pollfd);
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_ssl_close(struct libwebsocket *wsi);
lws_ssl_close(struct lws *wsi);
LWS_EXTERN void
lws_ssl_context_destroy(struct libwebsocket_context *context);
lws_ssl_context_destroy(struct lws_context *context);
LWS_VISIBLE void
lws_ssl_remove_wsi_from_buffered_list(struct libwebsocket_context *context,
struct libwebsocket *wsi);
lws_ssl_remove_wsi_from_buffered_list(struct lws_context *context,
struct lws *wsi);
#ifndef LWS_NO_SERVER
LWS_EXTERN int
lws_context_init_server_ssl(struct lws_context_creation_info *info,
struct libwebsocket_context *context);
struct lws_context *context);
#else
#define lws_context_init_server_ssl(_a, _b) (0)
#endif
LWS_EXTERN void
lws_ssl_destroy(struct libwebsocket_context *context);
lws_ssl_destroy(struct lws_context *context);
/* HTTP2-related */
#ifdef LWS_USE_HTTP2
LWS_EXTERN void
lws_context_init_http2_ssl(struct libwebsocket_context *context);
lws_context_init_http2_ssl(struct lws_context *context);
#else
#define lws_context_init_http2_ssl(_a)
#endif
#endif
LWS_EXTERN int
lws_ssl_capable_read_no_ssl(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, int len);
lws_ssl_capable_read_no_ssl(struct lws_context *context,
struct lws *wsi, unsigned char *buf, int len);
LWS_EXTERN int
lws_ssl_capable_write_no_ssl(struct libwebsocket *wsi, unsigned char *buf, int len);
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, int len);
LWS_EXTERN int
lws_ssl_pending_no_ssl(struct libwebsocket *wsi);
lws_ssl_pending_no_ssl(struct lws *wsi);
#ifndef LWS_NO_CLIENT
LWS_EXTERN int lws_client_socket_service(
struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd);
LWS_EXTERN int lws_client_socket_service(struct lws_context *context,
struct lws *wsi,
struct lws_pollfd *pollfd);
#ifdef LWS_OPENSSL_SUPPORT
LWS_EXTERN int lws_context_init_client_ssl(struct lws_context_creation_info *info,
struct libwebsocket_context *context);
LWS_EXTERN int
lws_context_init_client_ssl(struct lws_context_creation_info *info,
struct lws_context *context);
#else
#define lws_context_init_client_ssl(_a, _b) (0)
#endif
LWS_EXTERN int lws_handshake_client(struct libwebsocket *wsi, unsigned char **buf, size_t len);
LWS_EXTERN void
libwebsockets_decode_ssl_error(void);
LWS_EXTERN int
lws_handshake_client(struct lws *wsi, unsigned char **buf, size_t len);
LWS_EXTERN void
lws_decode_ssl_error(void);
#else
#define lws_context_init_client_ssl(_a, _b) (0)
#define lws_handshake_client(_a, _b, _c) (0)
#endif
#ifndef LWS_NO_SERVER
LWS_EXTERN int lws_server_socket_service(
struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd);
LWS_EXTERN int _libwebsocket_rx_flow_control(struct libwebsocket *wsi);
LWS_EXTERN int lws_handshake_server(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char **buf, size_t len);
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_EXTERN int
lws_handshake_server(struct lws_context *context,
struct lws *wsi, unsigned char **buf, size_t len);
#else
#define lws_server_socket_service(_a, _b, _c) (0)
#define _libwebsocket_rx_flow_control(_a) (0)
#define _lws_rx_flow_control(_a) (0)
#define lws_handshake_server(_a, _b, _c, _d) (0)
#endif
LWS_EXTERN int libwebsockets_get_addresses(struct libwebsocket_context *context,
void *ads, char *name, int name_len,
char *rip, int rip_len);
LWS_EXTERN int
lws_get_addresses(struct lws_context *context, void *ads, char *name,
int name_len, char *rip, int rip_len);
/*
* custom allocator
@ -1257,35 +1253,33 @@ lws_zalloc(size_t size);
#define lws_free(P) lws_realloc(P, 0)
#define lws_free2(P) do { lws_realloc(P, 0); (P) = NULL; } while(0)
/*
* lws_plat_
*/
/* lws_plat_ */
LWS_EXTERN void
lws_plat_delete_socket_from_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi, int m);
lws_plat_delete_socket_from_fds(struct lws_context *context,
struct lws *wsi, int m);
LWS_EXTERN void
lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
struct libwebsocket *wsi);
lws_plat_insert_socket_into_fds(struct lws_context *context,
struct lws *wsi);
LWS_EXTERN void
lws_plat_service_periodic(struct libwebsocket_context *context);
lws_plat_service_periodic(struct lws_context *context);
LWS_EXTERN int
lws_plat_change_pollfd(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pfd);
lws_plat_change_pollfd(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pfd);
LWS_EXTERN int
lws_plat_context_early_init(void);
LWS_EXTERN void
lws_plat_context_early_destroy(struct libwebsocket_context *context);
lws_plat_context_early_destroy(struct lws_context *context);
LWS_EXTERN void
lws_plat_context_late_destroy(struct libwebsocket_context *context);
lws_plat_context_late_destroy(struct lws_context *context);
LWS_EXTERN int
lws_poll_listen_fd(struct libwebsocket_pollfd *fd);
lws_poll_listen_fd(struct lws_pollfd *fd);
LWS_EXTERN int
lws_plat_service(struct libwebsocket_context *context, int timeout_ms);
lws_plat_service(struct lws_context *context, int timeout_ms);
LWS_EXTERN int
lws_plat_init_lookup(struct libwebsocket_context *context);
lws_plat_init_lookup(struct lws_context *context);
LWS_EXTERN int
lws_plat_init_fd_tables(struct libwebsocket_context *context);
lws_plat_init_fd_tables(struct lws_context *context);
LWS_EXTERN void
lws_plat_drop_app_privileges(struct lws_context_creation_info *info);
LWS_EXTERN unsigned long long

22
lib/server-handshake.c
View file

@ -24,13 +24,13 @@
#define LWS_CPYAPP(ptr, str) { strcpy(ptr, str); ptr += strlen(str); }
#ifndef LWS_NO_EXTENSIONS
LWS_VISIBLE int
lws_extension_server_handshake(struct libwebsocket_context *context,
struct libwebsocket *wsi, char **p)
lws_extension_server_handshake(struct lws_context *context,
struct lws *wsi, char **p)
{
int n;
char *c;
char ext_name[128];
struct libwebsocket_extension *ext;
struct lws_extension *ext;
int ext_count = 0;
int more = 1;
@ -156,7 +156,7 @@ lws_extension_server_handshake(struct libwebsocket_context *context,
}
#endif
int
handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
handshake_0405(struct lws_context *context, struct lws *wsi)
{
unsigned char hash[20];
int n;
@ -185,7 +185,7 @@ handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
"%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
lws_hdr_simple_ptr(wsi, WSI_TOKEN_KEY));
libwebsockets_SHA1(context->service_buffer, n, hash);
lws_SHA1(context->service_buffer, n, hash);
accept_len = lws_b64_encode_string((char *)hash, 20,
(char *)context->service_buffer,
@ -196,7 +196,7 @@ handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
}
/* allocate the per-connection user memory (if any) */
if (libwebsocket_ensure_user_space(wsi))
if (lws_ensure_user_space(wsi))
goto bail;
/* create the response packet */
@ -245,7 +245,7 @@ handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
#ifdef DEBUG
fwrite(response, 1, p - response, stderr);
#endif
n = libwebsocket_write(wsi, (unsigned char *)response,
n = lws_write(wsi, (unsigned char *)response,
p - response, LWS_WRITE_HTTP_HEADERS);
if (n != (p - response)) {
lwsl_debug("handshake_0405: ERROR writing to socket\n");
@ -264,7 +264,13 @@ handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
if (wsi->protocol->callback)
wsi->protocol->callback(wsi->protocol->owning_server,
wsi, LWS_CALLBACK_ESTABLISHED,
wsi->user_space, NULL, 0);
wsi->user_space,
#ifdef LWS_OPENSSL_SUPPORT
wsi->ssl,
#else
NULL,
#endif
0);
return 0;

223
lib/server.c
View file

@ -23,21 +23,20 @@
#include "private-libwebsockets.h"
int lws_context_init_server(struct lws_context_creation_info *info,
struct libwebsocket_context *context)
struct lws_context *context)
{
lws_sockfd_type sockfd;
#if LWS_POSIX
int n;
struct sockaddr_in sin;
socklen_t len = sizeof(sin);
#ifdef LWS_USE_IPV6
struct sockaddr_in6 serv_addr6;
#endif
#if LWS_POSIX
struct sockaddr_in serv_addr4;
socklen_t len = sizeof(struct sockaddr);
struct sockaddr_in sin;
struct sockaddr *v;
int opt = 1;
int n, opt = 1;
#endif
struct libwebsocket *wsi;
lws_sockfd_type sockfd;
struct lws *wsi;
/* set up our external listening socket we serve on */
@ -57,7 +56,6 @@ int lws_context_init_server(struct lws_context_creation_info *info,
sockfd = mbed3_create_tcp_stream_socket();
if (!lws_sockfd_valid(sockfd)) {
#endif
lwsl_err("ERROR opening socket\n");
return 1;
}
@ -67,7 +65,7 @@ int lws_context_init_server(struct lws_context_creation_info *info,
* allow us to restart even if old sockets in TIME_WAIT
*/
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
(const void *)&opt, sizeof(opt)) < 0) {
(const void *)&opt, sizeof(opt)) < 0) {
compatible_close(sockfd);
return 1;
}
@ -121,7 +119,7 @@ int lws_context_init_server(struct lws_context_creation_info *info,
context->listen_port = info->port;
wsi = lws_zalloc(sizeof(struct libwebsocket));
wsi = lws_zalloc(sizeof(struct lws));
if (wsi == NULL) {
lwsl_err("Out of mem\n");
compatible_close(sockfd);
@ -151,9 +149,9 @@ int lws_context_init_server(struct lws_context_creation_info *info,
}
int
_libwebsocket_rx_flow_control(struct libwebsocket *wsi)
_lws_rx_flow_control(struct lws *wsi)
{
struct libwebsocket_context *context = wsi->protocol->owning_server;
struct lws_context *context = wsi->protocol->owning_server;
/* there is no pending change */
if (!(wsi->rxflow_change_to & LWS_RXFLOW_PENDING_CHANGE))
@ -162,7 +160,7 @@ _libwebsocket_rx_flow_control(struct libwebsocket *wsi)
/* stuff is still buffered, not ready to really accept new input */
if (wsi->rxflow_buffer) {
/* get ourselves called back to deal with stashed buffer */
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
return 0;
}
@ -187,18 +185,18 @@ _libwebsocket_rx_flow_control(struct libwebsocket *wsi)
return 0;
}
int lws_http_action(struct libwebsocket_context *context,
struct libwebsocket *wsi)
int lws_http_action(struct lws_context *context, struct lws *wsi)
{
char *uri_ptr = NULL;
int uri_len = 0;
enum http_version request_version;
enum http_connection_type connection_type;
int http_version_len;
enum http_version request_version;
char content_length_str[32];
unsigned int n, count = 0;
char http_version_str[10];
char http_conn_str[20];
unsigned int n, count = 0;
int http_version_len;
char *uri_ptr = NULL;
int uri_len = 0;
static const unsigned char methods[] = {
WSI_TOKEN_GET_URI,
WSI_TOKEN_POST_URI,
@ -234,7 +232,7 @@ int lws_http_action(struct libwebsocket_context *context,
goto bail_nuke_ah;
}
if (libwebsocket_ensure_user_space(wsi))
if (lws_ensure_user_space(wsi))
goto bail_nuke_ah;
for (n = 0; n < ARRAY_SIZE(methods); n++)
@ -293,23 +291,19 @@ int lws_http_action(struct libwebsocket_context *context,
}
wsi->u.http.connection_type = connection_type;
n = 0;
if (wsi->protocol->callback)
n = wsi->protocol->callback(context, wsi,
LWS_CALLBACK_FILTER_HTTP_CONNECTION,
wsi->user_space, uri_ptr, uri_len);
n = wsi->protocol->callback(context, wsi,
LWS_CALLBACK_FILTER_HTTP_CONNECTION,
wsi->user_space, uri_ptr, uri_len);
if (!n) {
/*
* if there is content supposed to be coming,
* put a timeout on it having arrived
*/
libwebsocket_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT,
AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT,
AWAITING_TIMEOUT);
if (wsi->protocol->callback)
n = wsi->protocol->callback(context, wsi,
LWS_CALLBACK_HTTP,
n = wsi->protocol->callback(context, wsi, LWS_CALLBACK_HTTP,
wsi->user_space, uri_ptr, uri_len);
}
@ -325,7 +319,7 @@ int lws_http_action(struct libwebsocket_context *context,
* HTTP keep-alive. No keep-alive header allocation for
* ISSUING_FILE, as this uses HTTP/1.0.
*
* In any case, return 0 and let libwebsocket_read decide how to
* In any case, return 0 and let lws_read decide how to
* proceed based on state
*/
if (wsi->state != WSI_STATE_HTTP_ISSUING_FILE)
@ -343,31 +337,30 @@ bail_nuke_ah:
}
int lws_handshake_server(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char **buf, size_t len)
int lws_handshake_server(struct lws_context *context, struct lws *wsi,
unsigned char **buf, size_t len)
{
struct allocated_headers *ah;
int protocol_len;
int protocol_len, n, hit;
char protocol_list[128];
char protocol_name[32];
char *p;
int n, hit;
/* LWS_CONNMODE_WS_SERVING */
while (len--) {
if (libwebsocket_parse(context, wsi, *(*buf)++)) {
lwsl_info("libwebsocket_parse failed\n");
if (lws_parse(context, wsi, *(*buf)++)) {
lwsl_info("lws_parse failed\n");
goto bail_nuke_ah;
}
if (wsi->u.hdr.parser_state != WSI_PARSING_COMPLETE)
continue;
lwsl_parser("libwebsocket_parse sees parsing complete\n");
lwsl_parser("lws_parse sees parsing complete\n");
wsi->mode = LWS_CONNMODE_PRE_WS_SERVING_ACCEPT;
libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
/* is this websocket protocol or normal http 1.0? */
@ -389,7 +382,7 @@ int lws_handshake_server(struct libwebsocket_context *context,
}
if (!strcasecmp(lws_hdr_simple_ptr(wsi, WSI_TOKEN_UPGRADE),
"websocket"))
"websocket"))
goto upgrade_ws;
#ifdef LWS_USE_HTTP2
if (!strcasecmp(lws_hdr_simple_ptr(wsi, WSI_TOKEN_UPGRADE),
@ -410,7 +403,8 @@ upgrade_h2c:
p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP2_SETTINGS);
/* convert the peer's HTTP-Settings */
n = lws_b64_decode_string(p, protocol_list, sizeof(protocol_list));
n = lws_b64_decode_string(p, protocol_list,
sizeof(protocol_list));
if (n < 0) {
lwsl_parser("HTTP2_SETTINGS too long\n");
return 1;
@ -430,7 +424,8 @@ upgrade_h2c:
/* HTTP2 union */
lws_http2_interpret_settings_payload(&wsi->u.http2.peer_settings, (unsigned char *)protocol_list, n);
lws_http2_interpret_settings_payload(&wsi->u.http2.peer_settings,
(unsigned char *)protocol_list, n);
strcpy(protocol_list,
"HTTP/1.1 101 Switching Protocols\x0d\x0a"
@ -450,7 +445,7 @@ upgrade_h2c:
upgrade_ws:
if (!wsi->protocol)
lwsl_err("NULL protocol at libwebsocket_read\n");
lwsl_err("NULL protocol at lws_read\n");
/*
* It's websocket
@ -520,7 +515,7 @@ upgrade_ws:
}
/* allocate wsi->user storage */
if (libwebsocket_ensure_user_space(wsi))
if (lws_ensure_user_space(wsi))
goto bail_nuke_ah;
/*
@ -579,7 +574,8 @@ upgrade_ws:
}
lwsl_info("Allocating RX buffer %d\n", n);
#if LWS_POSIX
if (setsockopt(wsi->sock, SOL_SOCKET, SO_SNDBUF, (const char *)&n, sizeof n)) {
if (setsockopt(wsi->sock, SOL_SOCKET, SO_SNDBUF,
(const char *)&n, sizeof n)) {
lwsl_warn("Failed to set SNDBUF to %d", n);
return 1;
}
@ -596,12 +592,12 @@ bail_nuke_ah:
return 1;
}
struct libwebsocket *
libwebsocket_create_new_server_wsi(struct libwebsocket_context *context)
struct lws *
lws_create_new_server_wsi(struct lws_context *context)
{
struct libwebsocket *new_wsi;
struct lws *new_wsi;
new_wsi = lws_zalloc(sizeof(struct libwebsocket));
new_wsi = lws_zalloc(sizeof(struct lws));
if (new_wsi == NULL) {
lwsl_err("Out of memory for new connection\n");
return NULL;
@ -656,7 +652,7 @@ libwebsocket_create_new_server_wsi(struct libwebsocket_context *context)
*/
LWS_VISIBLE
int lws_http_transaction_completed(struct libwebsocket *wsi)
int lws_http_transaction_completed(struct lws *wsi)
{
/* if we can't go back to accept new headers, drop the connection */
if (wsi->u.http.connection_type != HTTP_CONNECTION_KEEP_ALIVE) {
@ -670,7 +666,7 @@ int lws_http_transaction_completed(struct libwebsocket *wsi)
wsi->u.http.content_length = 0;
/* He asked for it to stay alive indefinitely */
libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
if (lws_allocate_header_table(wsi))
return 1;
@ -684,17 +680,16 @@ int lws_http_transaction_completed(struct libwebsocket *wsi)
}
LWS_VISIBLE
int lws_server_socket_service(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd)
int lws_server_socket_service(struct lws_context *context,
struct lws *wsi, struct lws_pollfd *pollfd)
{
struct libwebsocket *new_wsi = NULL;
lws_sockfd_type accept_fd = LWS_SOCK_INVALID;
#if LWS_POSIX
socklen_t clilen;
struct sockaddr_in cli_addr;
socklen_t clilen;
#endif
int n;
int len;
struct lws *new_wsi = NULL;
int n, len;
switch (wsi->mode) {
@ -709,10 +704,9 @@ int lws_server_socket_service(struct libwebsocket_context *context,
if (wsi->truncated_send_len) {
if (pollfd->revents & LWS_POLLOUT)
if (lws_issue_raw(wsi, wsi->truncated_send_malloc +
wsi->truncated_send_offset,
wsi->truncated_send_len) < 0) {
lwsl_info("closing from socket service\n");
return -1;
wsi->truncated_send_offset,
wsi->truncated_send_len) < 0) {
goto fail;
}
/*
* we can't afford to allow input processing send
@ -726,8 +720,8 @@ int lws_server_socket_service(struct libwebsocket_context *context,
if (pollfd->revents & LWS_POLLIN) {
len = lws_ssl_capable_read(context, wsi,
context->service_buffer,
sizeof(context->service_buffer));
context->service_buffer,
sizeof(context->service_buffer));
lwsl_debug("%s: read %d\r\n", __func__, len);
switch (len) {
case 0:
@ -737,10 +731,7 @@ int lws_server_socket_service(struct libwebsocket_context *context,
lws_free_header_table(wsi);
/* fallthru */
case LWS_SSL_CAPABLE_ERROR:
libwebsocket_close_and_free_session(
context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 0;
goto fail;
case LWS_SSL_CAPABLE_MORE_SERVICE:
goto try_pollout;
}
@ -748,14 +739,17 @@ int lws_server_socket_service(struct libwebsocket_context *context,
/* just ignore incoming if waiting for close */
if (wsi->state != WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE) {
/* hm this may want to send (via HTTP callback for example) */
n = libwebsocket_read(context, wsi,
context->service_buffer, len);
if (n < 0)
/* we closed wsi */
return 0;
/*
* hm this may want to send
* (via HTTP callback for example)
*/
n = lws_read(context, wsi,
context->service_buffer, len);
if (n < 0) /* we closed wsi */
return 1;
/* hum he may have used up the writability above */
/* hum he may have used up the
* writability above */
break;
}
}
@ -786,7 +780,7 @@ try_pollout:
}
/* >0 == completion, <0 == error */
n = libwebsockets_serve_http_file_fragment(context, wsi);
n = lws_serve_http_file_fragment(context, wsi);
if (n < 0 || (n > 0 && lws_http_transaction_completed(wsi)))
goto fail;
break;
@ -804,12 +798,13 @@ try_pollout:
clilen = sizeof(cli_addr);
lws_latency_pre(context, wsi);
accept_fd = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
&clilen);
&clilen);
lws_latency(context, wsi,
"unencrypted accept LWS_CONNMODE_SERVER_LISTENER",
accept_fd, accept_fd >= 0);
if (accept_fd < 0) {
if (LWS_ERRNO == LWS_EAGAIN || LWS_ERRNO == LWS_EWOULDBLOCK) {
if (LWS_ERRNO == LWS_EAGAIN ||
LWS_ERRNO == LWS_EWOULDBLOCK) {
lwsl_debug("accept asks to try again\n");
break;
}
@ -836,7 +831,7 @@ try_pollout:
break;
}
new_wsi = libwebsocket_create_new_server_wsi(context);
new_wsi = lws_create_new_server_wsi(context);
if (new_wsi == NULL) {
compatible_close(accept_fd);
break;
@ -845,9 +840,8 @@ try_pollout:
new_wsi->sock = accept_fd;
/* the transport is accepted... give him time to negotiate */
libwebsocket_set_timeout(new_wsi,
PENDING_TIMEOUT_ESTABLISH_WITH_SERVER,
AWAITING_TIMEOUT);
lws_set_timeout(new_wsi, PENDING_TIMEOUT_ESTABLISH_WITH_SERVER,
AWAITING_TIMEOUT);
#if LWS_POSIX == 0
mbed3_tcp_stream_accept(accept_fd, new_wsi);
@ -858,9 +852,9 @@ try_pollout:
* set properties of the newly created wsi. There's no protocol
* selected yet so we issue this to protocols[0]
*/
(context->protocols[0].callback)(context, new_wsi,
LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED, NULL, NULL, 0);
LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED,
NULL, NULL, 0);
lws_libev_accept(context, new_wsi, accept_fd);
@ -878,20 +872,18 @@ try_pollout:
break;
}
if (lws_server_socket_service_ssl(context, &wsi, new_wsi,
accept_fd, pollfd))
goto fail;
return 0;
if (!lws_server_socket_service_ssl(context, &wsi, new_wsi, accept_fd,
pollfd))
return 0;
fail:
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
return 1;
}
/**
* libwebsockets_serve_http_file() - Send a file back to the client using http
* lws_serve_http_file() - Send a file back to the client using http
* @context: libwebsockets context
* @wsi: Websocket instance (available from user callback)
* @file: The file to issue over http
@ -909,34 +901,41 @@ fail:
* the wsi should be left alone.
*/
LWS_VISIBLE int libwebsockets_serve_http_file(
struct libwebsocket_context *context,
struct libwebsocket *wsi, const char *file,
const char *content_type, const char *other_headers,
int other_headers_len)
LWS_VISIBLE int lws_serve_http_file(struct lws_context *context,
struct lws *wsi, const char *file,
const char *content_type,
const char *other_headers,
int other_headers_len)
{
unsigned char *response = context->service_buffer + LWS_SEND_BUFFER_PRE_PADDING;
unsigned char *response = context->service_buffer +
LWS_SEND_BUFFER_PRE_PADDING;
unsigned char *p = response;
unsigned char *end = p + sizeof(context->service_buffer) -
LWS_SEND_BUFFER_PRE_PADDING;
LWS_SEND_BUFFER_PRE_PADDING;
int ret = 0;
wsi->u.http.fd = context->file_callbacks.pfn_open(file, &wsi->u.http.filelen);
if (wsi->u.http.fd == LWS_INVALID_FILE) {
lwsl_err("Unable to open '%s'\n", file);
libwebsockets_return_http_status(context, wsi,
HTTP_STATUS_NOT_FOUND, NULL);
lws_return_http_status(context, wsi, HTTP_STATUS_NOT_FOUND,
NULL);
return -1;
}
if (lws_add_http_header_status(context, wsi, 200, &p, end))
return -1;
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_SERVER, (unsigned char *)"libwebsockets", 13, &p, end))
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_SERVER,
(unsigned char *)"libwebsockets", 13,
&p, end))
return -1;
if (lws_add_http_header_by_token(context, wsi, WSI_TOKEN_HTTP_CONTENT_TYPE, (unsigned char *)content_type, strlen(content_type), &p, end))
if (lws_add_http_header_by_token(context, wsi,
WSI_TOKEN_HTTP_CONTENT_TYPE,
(unsigned char *)content_type,
strlen(content_type), &p, end))
return -1;
if (lws_add_http_header_content_length(context, wsi, wsi->u.http.filelen, &p, end))
if (lws_add_http_header_content_length(context, wsi,
wsi->u.http.filelen, &p, end))
return -1;
if (other_headers) {
@ -949,7 +948,7 @@ LWS_VISIBLE int libwebsockets_serve_http_file(
if (lws_finalize_http_header(context, wsi, &p, end))
return -1;
ret = libwebsocket_write(wsi, response,
ret = lws_write(wsi, response,
p - response, LWS_WRITE_HTTP_HEADERS);
if (ret != (p - response)) {
lwsl_err("_write returned %d from %d\n", ret, (p - response));
@ -959,12 +958,12 @@ LWS_VISIBLE int libwebsockets_serve_http_file(
wsi->u.http.filepos = 0;
wsi->state = WSI_STATE_HTTP_ISSUING_FILE;
return libwebsockets_serve_http_file_fragment(context, wsi);
return lws_serve_http_file_fragment(context, wsi);
}
int libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
unsigned char *buf, size_t len)
int lws_interpret_incoming_packet(struct lws *wsi, unsigned char *buf,
size_t len)
{
size_t n = 0;
int m;
@ -991,7 +990,7 @@ int libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
wsi->rxflow_pos++;
/* process the byte */
m = libwebsocket_rx_sm(wsi, buf[n++]);
m = lws_rx_sm(wsi, buf[n++]);
if (m < 0)
return -1;
}
@ -1000,8 +999,8 @@ int libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
}
LWS_VISIBLE void
lws_server_get_canonical_hostname(struct libwebsocket_context *context,
struct lws_context_creation_info *info)
lws_server_get_canonical_hostname(struct lws_context *context,
struct lws_context_creation_info *info)
{
if (info->options & LWS_SERVER_OPTION_SKIP_SERVER_CANONICAL_NAME)
return;

124
lib/service.c
View file

@ -22,8 +22,7 @@
#include "private-libwebsockets.h"
static int
lws_calllback_as_writeable(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_calllback_as_writeable(struct lws_context *context, struct lws *wsi)
{
int n;
@ -40,22 +39,20 @@ lws_calllback_as_writeable(struct libwebsocket_context *context,
}
lwsl_info("%s: %p (user=%p)\n", __func__, wsi, wsi->user_space);
return user_callback_handle_rxflow(wsi->protocol->callback, context,
wsi, (enum libwebsocket_callback_reasons) n,
wsi->user_space, NULL, 0);
wsi, (enum lws_callback_reasons) n,
wsi->user_space, NULL, 0);
}
int
lws_handle_POLLOUT_event(struct libwebsocket_context *context,
struct libwebsocket *wsi, struct libwebsocket_pollfd *pollfd)
lws_handle_POLLOUT_event(struct lws_context *context, struct lws *wsi,
struct lws_pollfd *pollfd)
{
int n;
int write_type = LWS_WRITE_PONG;
struct lws_tokens eff_buf;
#ifdef LWS_USE_HTTP2
struct libwebsocket *wsi2;
struct lws *wsi2;
#endif
int ret;
int m;
int write_type = LWS_WRITE_PONG;
int ret, m, n;
/* pending truncated sends have uber priority */
@ -86,7 +83,7 @@ lws_handle_POLLOUT_event(struct libwebsocket_context *context,
break;
}
wsi->pps = LWS_PPS_NONE;
libwebsocket_rx_flow_control(wsi, 1);
lws_rx_flow_control(wsi, 1);
return 0; /* leave POLLOUT active */
}
@ -101,11 +98,9 @@ lws_handle_POLLOUT_event(struct libwebsocket_context *context,
if (wsi->u.ws.payload_is_close)
write_type = LWS_WRITE_CLOSE;
n = libwebsocket_write(wsi,
&wsi->u.ws.ping_payload_buf[
n = lws_write(wsi, &wsi->u.ws.ping_payload_buf[
LWS_SEND_BUFFER_PRE_PADDING],
wsi->u.ws.ping_payload_len,
write_type);
wsi->u.ws.ping_payload_len, write_type);
if (n < 0)
return -1;
@ -263,7 +258,7 @@ user_service:
wsi2->u.http2.requested_POLLOUT = 0;
if (lws_calllback_as_writeable(context, wsi2)) {
lwsl_debug("Closing POLLOUT child\n");
libwebsocket_close_and_free_session(context, wsi2,
lws_close_and_free_session(context, wsi2,
LWS_CLOSE_STATUS_NOSTATUS);
}
wsi2 = wsi;
@ -280,14 +275,15 @@ notify:
int
libwebsocket_service_timeout_check(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned int sec)
lws_service_timeout_check(struct lws_context *context,
struct lws *wsi, unsigned int sec)
{
/*
* if extensions want in on it (eg, we are a mux parent)
* give them a chance to service child timeouts
*/
if (lws_ext_callback_for_each_active(wsi, LWS_EXT_CALLBACK_1HZ, NULL, sec) < 0)
if (lws_ext_callback_for_each_active(wsi, LWS_EXT_CALLBACK_1HZ,
NULL, sec) < 0)
return 0;
if (!wsi->pending_timeout)
@ -298,7 +294,8 @@ libwebsocket_service_timeout_check(struct libwebsocket_context *context,
* connection
*/
if ((time_t)sec > wsi->pending_timeout_limit) {
lwsl_info("wsi %p: TIMEDOUT WAITING on %d\n", (void *)wsi, wsi->pending_timeout);
lwsl_info("wsi %p: TIMEDOUT WAITING on %d\n",
(void *)wsi, wsi->pending_timeout);
/*
* Since he failed a timeout, he already had a chance to do
* something and was unable to... that includes situations like
@ -307,15 +304,15 @@ libwebsocket_service_timeout_check(struct libwebsocket_context *context,
* cleanup like flush partials.
*/
wsi->socket_is_permanently_unusable = 1;
libwebsocket_close_and_free_session(context,
wsi, LWS_CLOSE_STATUS_NOSTATUS);
lws_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 1;
}
return 0;
}
int lws_rxflow_cache(struct libwebsocket *wsi, unsigned char *buf, int n, int len)
int lws_rxflow_cache(struct lws *wsi, unsigned char *buf, int n, int len)
{
/* his RX is flowcontrolled, don't send remaining now */
if (wsi->rxflow_buffer) {
@ -335,20 +332,20 @@ int lws_rxflow_cache(struct libwebsocket *wsi, unsigned char *buf, int n, int le
}
/**
* libwebsocket_service_fd() - Service polled socket with something waiting
* lws_service_fd() - Service polled socket with something waiting
* @context: Websocket context
* @pollfd: The pollfd entry describing the socket fd and which events
* happened.
*
* This function takes a pollfd that has POLLIN or POLLOUT activity and
* services it according to the state of the associated
* struct libwebsocket.
* struct lws.
*
* The one call deals with all "service" that might happen on a socket
* including listen accepts, http files as well as websocket protocol.
*
* If a pollfd says it has something, you can just pass it to
* libwebsocket_serice_fd() whether it is a socket handled by lws or not.
* lws_service_fd() whether it is a socket handled by lws or not.
* If it sees it is a lws socket, the traffic will be handled and
* pollfd->revents will be zeroed now.
*
@ -358,26 +355,26 @@ int lws_rxflow_cache(struct libwebsocket *wsi, unsigned char *buf, int n, int le
*/
LWS_VISIBLE int
libwebsocket_service_fd(struct libwebsocket_context *context,
struct libwebsocket_pollfd *pollfd)
lws_service_fd(struct lws_context *context, struct lws_pollfd *pollfd)
{
struct libwebsocket *wsi;
int n, m;
lws_sockfd_type mfd;
#if LWS_POSIX
int listen_socket_fds_index = 0;
#endif
time_t now;
int timed_out = 0;
lws_sockfd_type our_fd = 0;
char draining_flow = 0;
int more;
struct lws_tokens eff_buf;
unsigned int pending = 0;
char draining_flow = 0;
lws_sockfd_type mfd;
int timed_out = 0;
struct lws *wsi;
time_t now;
int n, m;
int more;
#if LWS_POSIX
if (context->listen_service_fd)
listen_socket_fds_index = wsi_from_fd(context,context->listen_service_fd)->position_in_fds_table;
listen_socket_fds_index = wsi_from_fd(context,
context->listen_service_fd)->position_in_fds_table;
#endif
/*
* you can call us with pollfd = NULL to just allow the once-per-second
@ -404,13 +401,13 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
if (!wsi)
continue;
if (libwebsocket_service_timeout_check(context, wsi, now))
if (lws_service_timeout_check(context, wsi,
(unsigned int)now))
/* he did time out... */
if (mfd == our_fd) {
if (mfd == our_fd)
/* it was the guy we came to service! */
timed_out = 1;
/* he's gone, no need to mark as handled */
}
}
}
@ -419,12 +416,12 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
return 0;
/* just here for timeout management? */
if (pollfd == NULL)
if (!pollfd)
return 0;
/* no, here to service a socket descriptor */
wsi = wsi_from_fd(context, pollfd->fd);
if (wsi == NULL)
if (!wsi)
/* not lws connection ... leave revents alone and return */
return 0;
@ -458,9 +455,10 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
* even with extpoll, we prepared this
* internal fds for listen
*/
n = lws_poll_listen_fd(&context->fds[listen_socket_fds_index]);
n = lws_poll_listen_fd(
&context->fds[listen_socket_fds_index]);
if (n > 0) { /* there's a conn waiting for us */
libwebsocket_service_fd(context,
lws_service_fd(context,
&context->
fds[listen_socket_fds_index]);
context->listen_service_extraseen++;
@ -495,8 +493,11 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
case LWS_CONNMODE_SERVER_LISTENER:
case LWS_CONNMODE_SSL_ACK_PENDING:
n = lws_server_socket_service(context, wsi, pollfd);
if (n < 0)
goto close_and_handled;
if (n) /* closed by above */
return 1;
pending = lws_ssl_pending(wsi);
if (pending)
goto handle_pending;
goto handled;
case LWS_CONNMODE_WS_SERVING:
@ -514,7 +515,7 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
lws_handle_POLLOUT_event(context, wsi, pollfd)) {
if (wsi->state == WSI_STATE_RETURNED_CLOSE_ALREADY)
wsi->state = WSI_STATE_FLUSHING_STORED_SEND_BEFORE_CLOSE;
lwsl_info("libwebsocket_service_fd: closing\n");
lwsl_info("lws_service_fd: closing\n");
goto close_and_handled;
}
@ -536,8 +537,9 @@ libwebsocket_service_fd(struct libwebsocket_context *context,
read:
eff_buf.token_len = lws_ssl_capable_read(context, wsi,
context->service_buffer,
pending?pending:sizeof(context->service_buffer));
context->service_buffer,
pending ? pending :
sizeof(context->service_buffer));
switch (eff_buf.token_len) {
case 0:
lwsl_info("service_fd: closing due to 0 length read\n");
@ -567,7 +569,6 @@ read:
drain:
do {
more = 0;
m = lws_ext_callback_for_each_active(wsi,
@ -580,7 +581,7 @@ drain:
/* service incoming data */
if (eff_buf.token_len) {
n = libwebsocket_read(context, wsi,
n = lws_read(context, wsi,
(unsigned char *)eff_buf.token,
eff_buf.token_len);
if (n < 0) {
@ -596,8 +597,9 @@ drain:
pending = lws_ssl_pending(wsi);
if (pending) {
pending = pending > sizeof(context->service_buffer)?
sizeof(context->service_buffer):pending;
handle_pending:
pending = pending > sizeof(context->service_buffer) ?
sizeof(context->service_buffer) : pending;
goto read;
}
@ -609,7 +611,8 @@ drain:
#ifdef LWS_NO_SERVER
n =
#endif
_libwebsocket_rx_flow_control(wsi); /* n ignored, needed for NO_SERVER case */
_lws_rx_flow_control(wsi);
/* n ignored, needed for NO_SERVER case */
}
break;
@ -628,9 +631,12 @@ drain:
close_and_handled:
lwsl_debug("Close and handled\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
// pollfd points to something else after the close
lws_close_and_free_session(context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
/*
* pollfd may point to something else after the close
* due to pollfd swapping scheme on delete on some platforms
* we can't clear revents now because it'd be the wrong guy's revents
*/
return 1;
handled:
@ -639,7 +645,7 @@ handled:
}
/**
* libwebsocket_service() - Service any pending websocket activity
* lws_service() - Service any pending websocket activity
* @context: Websocket context
* @timeout_ms: Timeout for poll; 0 means return immediately if nothing needed
* service otherwise block and service immediately, returning
@ -671,7 +677,7 @@ handled:
*/
LWS_VISIBLE int
libwebsocket_service(struct libwebsocket_context *context, int timeout_ms)
lws_service(struct lws_context *context, int timeout_ms)
{
return lws_plat_service(context, timeout_ms);
}

8
lib/sha-1.c
View file

@ -212,14 +212,14 @@ sha1_pad(struct sha1_ctxt *ctxt)
padlen = 64 - padstart;
if (padlen < 8) {
bzero(&ctxt->m.b8[padstart], padlen);
COUNT += padlen;
COUNT += (unsigned char)padlen;
COUNT %= 64;
sha1_step(ctxt);
padstart = COUNT % 64; /* should be 0 */
padlen = 64 - padstart; /* should be 64 */
}
bzero(&ctxt->m.b8[padstart], padlen - 8);
COUNT += (padlen - 8);
COUNT += ((unsigned char)padlen - 8);
COUNT %= 64;
#if BYTE_ORDER == BIG_ENDIAN
PUTPAD(ctxt->c.b8[0]); PUTPAD(ctxt->c.b8[1]);
@ -250,7 +250,7 @@ sha1_loop(struct sha1_ctxt *ctxt, const unsigned char *input, size_t len)
copysiz = (gaplen < len - off) ? gaplen : len - off;
memcpy(&ctxt->m.b8[gapstart], &input[off], copysiz);
COUNT += copysiz;
COUNT += (unsigned char)copysiz;
COUNT %= 64;
ctxt->c.b64[0] += copysiz * 8;
if (COUNT % 64 == 0)
@ -287,7 +287,7 @@ sha1_result(struct sha1_ctxt *ctxt, void *digest0)
*/
LWS_VISIBLE unsigned char *
libwebsockets_SHA1(const unsigned char *d, size_t n, unsigned char *md)
lws_SHA1(const unsigned char *d, size_t n, unsigned char *md)
{
struct sha1_ctxt ctx;

29
lib/ssl-http2.c
View file

@ -59,7 +59,8 @@ struct alpn_ctx {
unsigned short len;
};
static int npn_cb(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
static int
npn_cb(SSL *s, const unsigned char **data, unsigned int *len, void *arg)
{
struct alpn_ctx *alpn_ctx = arg;
@ -70,15 +71,15 @@ static int npn_cb(SSL *s, const unsigned char **data, unsigned int *len, void *a
return SSL_TLSEXT_ERR_OK;
}
static int alpn_cb(SSL *s, const unsigned char **out,
unsigned char *outlen, const unsigned char *in,
unsigned int inlen, void *arg)
static int
alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
const unsigned char *in, unsigned int inlen, void *arg)
{
struct alpn_ctx *alpn_ctx = arg;
if (SSL_select_next_proto((unsigned char **)out, outlen,
alpn_ctx->data, alpn_ctx->len, in, inlen) !=
OPENSSL_NPN_NEGOTIATED)
if (SSL_select_next_proto((unsigned char **)out, outlen, alpn_ctx->data,
alpn_ctx->len, in, inlen) !=
OPENSSL_NPN_NEGOTIATED)
return SSL_TLSEXT_ERR_NOACK;
return SSL_TLSEXT_ERR_OK;
@ -86,13 +87,11 @@ static int alpn_cb(SSL *s, const unsigned char **out,
#endif
LWS_VISIBLE void
lws_context_init_http2_ssl(struct libwebsocket_context *context)
lws_context_init_http2_ssl(struct lws_context *context)
{
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
static struct alpn_ctx protos = { (unsigned char *)
"\x05h2-14"
"\x08http/1.1",
6 + 9 };
static struct alpn_ctx protos = { (unsigned char *)"\x05h2-14"
"\x08http/1.1", 6 + 9 };
SSL_CTX_set_next_protos_advertised_cb(context->ssl_ctx, npn_cb, &protos);
@ -106,13 +105,13 @@ lws_context_init_http2_ssl(struct libwebsocket_context *context)
#endif // OPENSSL_VERSION_NUMBER >= 0x10002000L
}
void lws_http2_configure_if_upgraded(struct libwebsocket *wsi)
void lws_http2_configure_if_upgraded(struct lws *wsi)
{
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
struct allocated_headers *ah;
const char *method = "alpn";
const unsigned char *name;
unsigned len;
const char *method = "alpn";
SSL_get0_alpn_selected(wsi->ssl, &name, &len);
@ -151,4 +150,4 @@ void lws_http2_configure_if_upgraded(struct libwebsocket *wsi)
}
#endif
#endif
#endif

68
lib/ssl.c
View file

@ -26,9 +26,11 @@
int openssl_websocket_private_data_index;
static int lws_context_init_ssl_pem_passwd_cb(char * buf, int size, int rwflag, void *userdata)
static int lws_context_init_ssl_pem_passwd_cb(char * buf, int size,
int rwflag, void *userdata)
{
struct lws_context_creation_info * info = (struct lws_context_creation_info *)userdata;
struct lws_context_creation_info * info =
(struct lws_context_creation_info *)userdata;
strncpy(buf, info->ssl_private_key_password, size);
buf[size - 1] = '\0';
@ -57,7 +59,7 @@ OpenSSL_verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx)
{
SSL *ssl;
int n;
struct libwebsocket_context *context;
struct lws_context *context;
ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
SSL_get_ex_data_X509_STORE_CTX_idx());
@ -78,7 +80,7 @@ OpenSSL_verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx)
LWS_VISIBLE int
lws_context_init_server_ssl(struct lws_context_creation_info *info,
struct libwebsocket_context *context)
struct lws_context *context)
{
SSL_METHOD *method;
int error;
@ -246,7 +248,7 @@ lws_context_init_server_ssl(struct lws_context_creation_info *info,
#endif
LWS_VISIBLE void
lws_ssl_destroy(struct libwebsocket_context *context)
lws_ssl_destroy(struct lws_context *context)
{
if (context->ssl_ctx)
SSL_CTX_free(context->ssl_ctx);
@ -264,7 +266,7 @@ lws_ssl_destroy(struct libwebsocket_context *context)
}
LWS_VISIBLE void
libwebsockets_decode_ssl_error(void)
lws_decode_ssl_error(void)
{
char buf[256];
u_long err;
@ -278,7 +280,7 @@ libwebsockets_decode_ssl_error(void)
#ifndef LWS_NO_CLIENT
int lws_context_init_client_ssl(struct lws_context_creation_info *info,
struct libwebsocket_context *context)
struct lws_context *context)
{
int error;
int n;
@ -406,8 +408,8 @@ int lws_context_init_client_ssl(struct lws_context_creation_info *info,
#endif
LWS_VISIBLE void
lws_ssl_remove_wsi_from_buffered_list(struct libwebsocket_context *context,
struct libwebsocket *wsi)
lws_ssl_remove_wsi_from_buffered_list(struct lws_context *context,
struct lws *wsi)
{
if (!wsi->pending_read_list_prev &&
!wsi->pending_read_list_next &&
@ -432,8 +434,8 @@ lws_ssl_remove_wsi_from_buffered_list(struct libwebsocket_context *context,
}
LWS_VISIBLE int
lws_ssl_capable_read(struct libwebsocket_context *context,
struct libwebsocket *wsi, unsigned char *buf, int len)
lws_ssl_capable_read(struct lws_context *context,
struct lws *wsi, unsigned char *buf, int len)
{
int n;
@ -441,7 +443,11 @@ lws_ssl_capable_read(struct libwebsocket_context *context,
return lws_ssl_capable_read_no_ssl(context, wsi, buf, len);
n = SSL_read(wsi->ssl, buf, len);
if (n >= 0) {
/* manpage: returning 0 means connection shut down */
if (!n)
return LWS_SSL_CAPABLE_ERROR;
if (n > 0) {
/*
* if it was our buffer that limited what we read,
* check if SSL has additional data pending inside SSL buffers.
@ -473,7 +479,7 @@ lwsl_err("%s: LWS_SSL_CAPABLE_ERROR\n", __func__);
}
LWS_VISIBLE int
lws_ssl_pending(struct libwebsocket *wsi)
lws_ssl_pending(struct lws *wsi)
{
if (!wsi->ssl)
return 0;
@ -482,7 +488,7 @@ lws_ssl_pending(struct libwebsocket *wsi)
}
LWS_VISIBLE int
lws_ssl_capable_write(struct libwebsocket *wsi, unsigned char *buf, int len)
lws_ssl_capable_write(struct lws *wsi, unsigned char *buf, int len)
{
int n;
@ -490,7 +496,7 @@ lws_ssl_capable_write(struct libwebsocket *wsi, unsigned char *buf, int len)
return lws_ssl_capable_write_no_ssl(wsi, buf, len);
n = SSL_write(wsi->ssl, buf, len);
if (n >= 0)
if (n > 0)
return n;
n = SSL_get_error(wsi->ssl, n);
@ -504,7 +510,7 @@ lwsl_err("%s: LWS_SSL_CAPABLE_ERROR\n", __func__);
}
LWS_VISIBLE int
lws_ssl_close(struct libwebsocket *wsi)
lws_ssl_close(struct lws *wsi)
{
int n;
@ -515,17 +521,20 @@ lws_ssl_close(struct libwebsocket *wsi)
SSL_shutdown(wsi->ssl);
compatible_close(n);
SSL_free(wsi->ssl);
wsi->ssl = NULL;
return 1; /* handled */
}
/* leave all wsi close processing to the caller */
LWS_VISIBLE int
lws_server_socket_service_ssl(struct libwebsocket_context *context,
struct libwebsocket **pwsi, struct libwebsocket *new_wsi,
int accept_fd, struct libwebsocket_pollfd *pollfd)
lws_server_socket_service_ssl(struct lws_context *context, struct lws **pwsi,
struct lws *new_wsi, lws_sockfd_type accept_fd,
struct lws_pollfd *pollfd)
{
struct lws *wsi = *pwsi;
int n, m;
struct libwebsocket *wsi = *pwsi;
#ifndef USE_WOLFSSL
BIO *bio;
#endif
@ -544,10 +553,8 @@ lws_server_socket_service_ssl(struct libwebsocket_context *context,
new_wsi->ssl = SSL_new(context->ssl_ctx);
if (new_wsi->ssl == NULL) {
lwsl_err("SSL_new failed: %s\n",
ERR_error_string(SSL_get_error(new_wsi->ssl, 0), NULL));
libwebsockets_decode_ssl_error();
// TODO: Shouldn't the caller handle this?
ERR_error_string(SSL_get_error(new_wsi->ssl, 0), NULL));
lws_decode_ssl_error();
compatible_close(accept_fd);
goto fail;
}
@ -589,7 +596,7 @@ lws_server_socket_service_ssl(struct libwebsocket_context *context,
if (insert_wsi_socket_into_fds(context, wsi))
goto fail;
libwebsocket_set_timeout(wsi, PENDING_TIMEOUT_SSL_ACCEPT,
lws_set_timeout(wsi, PENDING_TIMEOUT_SSL_ACCEPT,
AWAITING_TIMEOUT);
lwsl_info("inserted SSL accept into fds, trying SSL_accept\n");
@ -663,7 +670,7 @@ lws_server_socket_service_ssl(struct libwebsocket_context *context,
m = SSL_get_error(wsi->ssl, n);
lwsl_debug("SSL_accept failed %d / %s\n",
m, ERR_error_string(m, NULL));
m, ERR_error_string(m, NULL));
go_again:
if (m == SSL_ERROR_WANT_READ) {
if (lws_change_pollfd(wsi, 0, LWS_POLLIN))
@ -682,14 +689,13 @@ go_again:
break;
}
lwsl_debug("SSL_accept failed skt %u: %s\n",
pollfd->fd, ERR_error_string(m, NULL));
pollfd->fd, ERR_error_string(m, NULL));
goto fail;
accepted:
/* OK, we are accepted... give him some time to negotiate */
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_ESTABLISH_WITH_SERVER,
AWAITING_TIMEOUT);
lws_set_timeout(wsi, PENDING_TIMEOUT_ESTABLISH_WITH_SERVER,
AWAITING_TIMEOUT);
wsi->mode = LWS_CONNMODE_HTTP_SERVING;
@ -706,7 +712,7 @@ fail:
}
LWS_VISIBLE void
lws_ssl_context_destroy(struct libwebsocket_context *context)
lws_ssl_context_destroy(struct lws_context *context)
{
if (context->ssl_ctx)
SSL_CTX_free(context->ssl_ctx);

1219
libwebsockets-api-doc.html
View file

File diff suppressed because it is too large Load diff

3
lws_config.h.in
View file

@ -62,4 +62,7 @@
/* use SHA1() not internal libwebsockets_SHA1 */
#cmakedefine LWS_SHA1_USE_OPENSSL_NAME
/* whether to provide pre v1.6 compatibility wrappers */
#cmakedefine LWS_WITH_OLD_API_WRAPPERS
${LWS_SIZEOFPTR_CODE}

1
module.json
View file

@ -15,6 +15,7 @@
"extraIncludes": [ "build/frdm-k64f-gcc/generated/include" ],
"dependencies": {
"mbed-drivers": "^0.11.1",
"sal-stack-lwip": "^1.0.4",
"sockets": "^1.0.0"
}
}

7
test-server/attack.sh
View file

@ -6,6 +6,9 @@ SERVER=127.0.0.1
PORT=7681
LOG=/tmp/lwslog
A=`which libwebsockets-test-server`
INSTALLED=`dirname $A`
CPID=
LEN=0
@ -18,7 +21,7 @@ function check {
dd if=$LOG bs=1 skip=$LEN 2>/dev/null
if [ "$1" = "default" ] ; then
diff /tmp/lwscap /usr/share/libwebsockets-test-server/test.html > /dev/null
diff /tmp/lwscap $INSTALLED/../share/libwebsockets-test-server/test.html > /dev/null
if [ $? -ne 0 ] ; then
echo "FAIL: got something other than test.html back"
exit 1
@ -26,7 +29,7 @@ function check {
fi
if [ "$1" = "forbidden" ] ; then
if [ -z "`grep '<h1>403 Forbidden</h1>' /tmp/lwscap`" ] ; then
if [ -z "`grep '<h1>403</h1>' /tmp/lwscap`" ] ; then
echo "FAIL: should have told forbidden (test server has no dirs)"
exit 1
fi

210
test-server/test-client.c
View file

@ -27,20 +27,19 @@
#ifdef _WIN32
#define random rand
#include "gettimeofday.h"
#else
#include <syslog.h>
#include <sys/time.h>
#include <unistd.h>
#endif
#include "../lib/libwebsockets.h"
static int deny_deflate, deny_mux, longlived, mirror_lifetime;
static struct lws *wsi_dumb, *wsi_mirror;
static volatile int force_exit;
static unsigned int opts;
static int was_closed;
static int deny_deflate;
static int deny_mux;
static struct libwebsocket *wsi_mirror;
static int mirror_lifetime = 0;
static volatile int force_exit = 0;
static int longlived = 0;
/*
* This demo shows how to connect multiple websockets simultaneously to a
@ -65,51 +64,61 @@ enum demo_protocols {
};
/* dumb_increment protocol */
/*
* dumb_increment protocol
*
* since this also happens to be protocols[0], some callbacks that are not
* bound to a specific protocol also turn up here.
*/
static int
callback_dumb_increment(struct libwebsocket_context *this,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
void *user, void *in, size_t len)
callback_dumb_increment(struct lws_context *this,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
switch (reason) {
case LWS_CALLBACK_CLIENT_ESTABLISHED:
fprintf(stderr, "callback_dumb_increment: LWS_CALLBACK_CLIENT_ESTABLISHED\n");
break;
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
fprintf(stderr, "LWS_CALLBACK_CLIENT_CONNECTION_ERROR\n");
was_closed = 1;
lwsl_info("dumb: LWS_CALLBACK_CLIENT_ESTABLISHED\n");
break;
case LWS_CALLBACK_CLOSED:
fprintf(stderr, "LWS_CALLBACK_CLOSED\n");
was_closed = 1;
lwsl_notice("dumb: LWS_CALLBACK_CLOSED\n");
wsi_dumb = NULL;
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
((char *)in)[len] = '\0';
fprintf(stderr, "rx %d '%s'\n", (int)len, (char *)in);
lwsl_info("rx %d '%s'\n", (int)len, (char *)in);
break;
/* because we are protocols[0] ... */
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
if (wsi == wsi_dumb) {
lwsl_err("dumb: LWS_CALLBACK_CLIENT_CONNECTION_ERROR\n");
wsi_dumb = NULL;
}
if (wsi == wsi_mirror) {
lwsl_err("mirror: LWS_CALLBACK_CLIENT_CONNECTION_ERROR\n");
wsi_mirror = NULL;
}
break;
case LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED:
if ((strcmp(in, "deflate-stream") == 0) && deny_deflate) {
fprintf(stderr, "denied deflate-stream extension\n");
lwsl_notice("denied deflate-stream extension\n");
return 1;
}
if ((strcmp(in, "deflate-frame") == 0) && deny_deflate) {
fprintf(stderr, "denied deflate-frame extension\n");
lwsl_notice("denied deflate-frame extension\n");
return 1;
}
if ((strcmp(in, "x-google-mux") == 0) && deny_mux) {
fprintf(stderr, "denied x-google-mux extension\n");
lwsl_notice("denied x-google-mux extension\n");
return 1;
}
break;
default:
@ -124,60 +133,51 @@ callback_dumb_increment(struct libwebsocket_context *this,
static int
callback_lws_mirror(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
void *user, void *in, size_t len)
callback_lws_mirror(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 4096 +
LWS_SEND_BUFFER_POST_PADDING];
LWS_SEND_BUFFER_POST_PADDING];
unsigned int rands[4];
int l = 0;
int n;
unsigned int rands[4];
switch (reason) {
case LWS_CALLBACK_CLIENT_ESTABLISHED:
fprintf(stderr, "callback_lws_mirror: LWS_CALLBACK_CLIENT_ESTABLISHED\n");
lwsl_notice("mirror: LWS_CALLBACK_CLIENT_ESTABLISHED\n");
libwebsockets_get_random(context, rands, sizeof(rands[0]));
mirror_lifetime = 10 + (rands[0] & 1023);
lws_get_random(context, rands, sizeof(rands[0]));
mirror_lifetime = 16384 + (rands[0] & 65535);
/* useful to test single connection stability */
if (longlived)
mirror_lifetime += 50000;
mirror_lifetime += 500000;
fprintf(stderr, "opened mirror connection with "
"%d lifetime\n", mirror_lifetime);
lwsl_info("opened mirror connection with "
"%d lifetime\n", mirror_lifetime);
/*
* mirror_lifetime is decremented each send, when it reaches
* zero the connection is closed in the send callback.
* When the close callback comes, wsi_mirror is set to NULL
* so a new connection will be opened
*/
/*
*
* start the ball rolling,
* LWS_CALLBACK_CLIENT_WRITEABLE will come next service
*/
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
case LWS_CALLBACK_CLOSED:
fprintf(stderr, "mirror: LWS_CALLBACK_CLOSED mirror_lifetime=%d\n", mirror_lifetime);
lwsl_notice("mirror: LWS_CALLBACK_CLOSED mirror_lifetime=%d\n", mirror_lifetime);
wsi_mirror = NULL;
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
/* fprintf(stderr, "rx %d '%s'\n", (int)len, (char *)in); */
break;
case LWS_CALLBACK_CLIENT_WRITEABLE:
for (n = 0; n < 1; n++) {
libwebsockets_get_random(context, rands, sizeof(rands));
lws_get_random(context, rands, sizeof(rands));
l += sprintf((char *)&buf[LWS_SEND_BUFFER_PRE_PADDING + l],
"c #%06X %d %d %d;",
(int)rands[0] & 0xffffff,
@ -186,9 +186,8 @@ callback_lws_mirror(struct libwebsocket_context *context,
(int)rands[3] % 24);
}
n = libwebsocket_write(wsi,
&buf[LWS_SEND_BUFFER_PRE_PADDING], l, opts | LWS_WRITE_TEXT);
n = lws_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], l,
opts | LWS_WRITE_TEXT);
if (n < 0)
return -1;
if (n < l) {
@ -198,11 +197,11 @@ callback_lws_mirror(struct libwebsocket_context *context,
mirror_lifetime--;
if (!mirror_lifetime) {
fprintf(stderr, "closing mirror session\n");
lwsl_info("closing mirror session\n");
return -1;
} else
/* get notified as soon as we can write again */
libwebsocket_callback_on_writable(context, wsi);
}
/* get notified as soon as we can write again */
lws_callback_on_writable(context, wsi);
break;
default:
@ -215,7 +214,7 @@ callback_lws_mirror(struct libwebsocket_context *context,
/* list of supported protocols and callbacks */
static struct libwebsocket_protocols protocols[] = {
static struct lws_protocols protocols[] = {
{
"dumb-increment-protocol,fake-nonexistant-protocol",
callback_dumb_increment,
@ -248,24 +247,33 @@ static struct option options[] = {
{ NULL, 0, 0, 0 }
};
static int ratelimit_connects(unsigned int *last, int secs)
{
struct timeval tv;
gettimeofday(&tv, NULL);
if (tv.tv_sec - (*last) < secs)
return 0;
*last = tv.tv_sec;
return 1;
}
int main(int argc, char **argv)
{
int n = 0;
int ret = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
const char *address;
struct libwebsocket *wsi_dumb;
int ietf_version = -1; /* latest */
int n = 0, ret = 0, port = 7681, use_ssl = 0;
unsigned int rl_dumb = 0, rl_mirror = 0;
struct lws_context_creation_info info;
struct lws_context *context;
int ietf_version = -1; /* latest */
const char *address;
memset(&info, 0, sizeof info);
fprintf(stderr, "libwebsockets test client\n"
"(C) Copyright 2010-2015 Andy Green <andy@warmcat.com> "
"licensed under LGPL2.1\n");
"licensed under LGPL2.1\n");
if (argc < 2)
goto usage;
@ -319,67 +327,51 @@ int main(int argc, char **argv)
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
info.extensions = lws_get_internal_extensions();
#endif
info.gid = -1;
info.uid = -1;
context = libwebsocket_create_context(&info);
context = lws_create_context(&info);
if (context == NULL) {
fprintf(stderr, "Creating libwebsocket context failed\n");
return 1;
}
/* create a client websocket using dumb increment protocol */
wsi_dumb = libwebsocket_client_connect(context, address, port, use_ssl,
"/", argv[optind], argv[optind],
protocols[PROTOCOL_DUMB_INCREMENT].name, ietf_version);
if (wsi_dumb == NULL) {
fprintf(stderr, "libwebsocket connect failed\n");
ret = 1;
goto bail;
}
fprintf(stderr, "Waiting for connect...\n");
/*
* sit there servicing the websocket context to handle incoming
* packets, and drawing random circles on the mirror protocol websocket
*
* nothing happens until the client websocket connection is
* asynchronously established
* asynchronously established... calling lws_client_connect() only
* instantiates the connection logically, lws_service() progresses it
* asynchronously.
*/
n = 0;
while (n >= 0 && !was_closed && !force_exit) {
n = libwebsocket_service(context, 10);
while (!force_exit) {
if (n < 0)
continue;
if (wsi_mirror)
continue;
/* create a client websocket using mirror protocol */
wsi_mirror = libwebsocket_client_connect(context,
address, port, use_ssl, "/",
argv[optind], argv[optind],
protocols[PROTOCOL_LWS_MIRROR].name, ietf_version);
if (wsi_mirror == NULL) {
fprintf(stderr, "libwebsocket "
"mirror connect failed\n");
ret = 1;
goto bail;
if (!wsi_dumb && ratelimit_connects(&rl_dumb, 2)) {
lwsl_notice("dumb: connecting\n");
wsi_dumb = lws_client_connect(context, address, port,
use_ssl, "/", argv[optind], argv[optind],
protocols[PROTOCOL_DUMB_INCREMENT].name,
ietf_version);
}
if (!wsi_mirror && ratelimit_connects(&rl_mirror, 2)) {
lwsl_notice("mirror: connecting\n");
wsi_mirror = lws_client_connect(context,
address, port, use_ssl, "/",
argv[optind], argv[optind],
protocols[PROTOCOL_LWS_MIRROR].name,
ietf_version);
}
lws_service(context, 500);
}
bail:
fprintf(stderr, "Exiting\n");
libwebsocket_context_destroy(context);
lwsl_err("Exiting\n");
lws_context_destroy(context);
return ret;

30
test-server/test-echo.c
View file

@ -53,9 +53,9 @@ struct per_session_data__echo {
};
static int
callback_echo(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason, void *user,
callback_echo(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason, void *user,
void *in, size_t len)
{
struct per_session_data__echo *pss = (struct per_session_data__echo *)user;
@ -68,7 +68,7 @@ callback_echo(struct libwebsocket_context *context,
case LWS_CALLBACK_SERVER_WRITEABLE:
do_tx:
n = libwebsocket_write(wsi, &pss->buf[LWS_SEND_BUFFER_PRE_PADDING], pss->len, LWS_WRITE_TEXT);
n = lws_write(wsi, &pss->buf[LWS_SEND_BUFFER_PRE_PADDING], pss->len, LWS_WRITE_TEXT);
if (n < 0) {
lwsl_err("ERROR %d writing to socket, hanging up\n", n);
return 1;
@ -87,7 +87,7 @@ do_rx:
}
memcpy(&pss->buf[LWS_SEND_BUFFER_PRE_PADDING], in, len);
pss->len = (unsigned int)len;
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
#endif
@ -122,7 +122,7 @@ do_rx:
/* we will send our packet... */
pss->len = sprintf((char *)&pss->buf[LWS_SEND_BUFFER_PRE_PADDING], "hello from libwebsockets-test-echo client pid %d index %d\n", getpid(), pss->index++);
lwsl_notice("Client TX: %s", &pss->buf[LWS_SEND_BUFFER_PRE_PADDING]);
n = libwebsocket_write(wsi, &pss->buf[LWS_SEND_BUFFER_PRE_PADDING], pss->len, LWS_WRITE_TEXT);
n = lws_write(wsi, &pss->buf[LWS_SEND_BUFFER_PRE_PADDING], pss->len, LWS_WRITE_TEXT);
if (n < 0) {
lwsl_err("ERROR %d writing to socket, hanging up\n", n);
return -1;
@ -145,7 +145,7 @@ do_rx:
static struct libwebsocket_protocols protocols[] = {
static struct lws_protocols protocols[] = {
/* first protocol must always be HTTP handler */
{
@ -189,7 +189,7 @@ int main(int argc, char **argv)
int n = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
struct lws_context *context;
int opts = 0;
char interface_name[128] = "";
const char *_interface = NULL;
@ -207,7 +207,7 @@ int main(int argc, char **argv)
char address[256], ads_port[256 + 30];
int rate_us = 250000;
unsigned long long oldus;
struct libwebsocket *wsi;
struct lws *wsi;
int disallow_selfsigned = 0;
struct timeval tv;
#endif
@ -364,7 +364,7 @@ int main(int argc, char **argv)
info.iface = _interface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
info.extensions = lws_get_internal_extensions();
#endif
if (use_ssl && !client) {
info.ssl_cert_filepath = ssl_cert;
@ -378,7 +378,7 @@ int main(int argc, char **argv)
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
context = lws_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
@ -403,7 +403,7 @@ int main(int argc, char **argv)
address[sizeof(address) - 1] = '\0';
sprintf(ads_port, "%s:%u", address, port & 65535);
wsi = libwebsocket_client_connect(context, address,
wsi = lws_client_connect(context, address,
port, use_ssl, uri, ads_port,
ads_port, NULL, -1);
if (!wsi) {
@ -416,17 +416,17 @@ int main(int argc, char **argv)
gettimeofday(&tv, NULL);
if (((((unsigned long long)tv.tv_sec * 1000000) + tv.tv_usec) - oldus) > rate_us) {
libwebsocket_callback_on_writable_all_protocol(&protocols[0]);
lws_callback_on_writable_all_protocol(&protocols[0]);
oldus = ((unsigned long long)tv.tv_sec * 1000000) + tv.tv_usec;
}
}
#endif
n = libwebsocket_service(context, 10);
n = lws_service(context, 10);
}
#ifndef LWS_NO_CLIENT
bail:
#endif
libwebsocket_context_destroy(context);
lws_context_destroy(context);
lwsl_notice("libwebsockets-test-echo exited cleanly\n");
#ifndef _WIN32

40
test-server/test-fraggle.c
View file

@ -53,9 +53,9 @@ struct per_session_data__fraggle {
};
static int
callback_fraggle(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
callback_fraggle(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
int n;
@ -76,7 +76,7 @@ callback_fraggle(struct libwebsocket_context *context,
fprintf(stderr, "server sees client connect\n");
psf->state = FRAGSTATE_START_MESSAGE;
/* start the ball rolling */
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
case LWS_CALLBACK_CLIENT_ESTABLISHED:
@ -106,7 +106,7 @@ callback_fraggle(struct libwebsocket_context *context,
psf->total_message += len;
psf->packets_left++;
if (libwebsocket_is_final_fragment(wsi))
if (lws_is_final_fragment(wsi))
psf->state = FRAGSTATE_POST_PAYLOAD_SUM;
break;
@ -136,7 +136,7 @@ callback_fraggle(struct libwebsocket_context *context,
switch (psf->state) {
case FRAGSTATE_START_MESSAGE:
libwebsockets_get_random(context, &ran, sizeof(ran));
lws_get_random(context, &ran, sizeof(ran));
psf->packets_left = (ran % 1024) + 1;
fprintf(stderr, "Spamming %d random fragments\n",
psf->packets_left);
@ -155,11 +155,11 @@ callback_fraggle(struct libwebsocket_context *context,
* code for rx spill because the rx buffer is full
*/
libwebsockets_get_random(context, &ran, sizeof(ran));
lws_get_random(context, &ran, sizeof(ran));
chunk = (ran % 8000) + 1;
psf->total_message += chunk;
libwebsockets_get_random(context, bp, chunk);
lws_get_random(context, bp, chunk);
for (n = 0; n < chunk; n++)
psf->sum += bp[n];
@ -169,7 +169,7 @@ callback_fraggle(struct libwebsocket_context *context,
else
psf->state = FRAGSTATE_POST_PAYLOAD_SUM;
n = libwebsocket_write(wsi, bp, chunk, write_mode);
n = lws_write(wsi, bp, chunk, write_mode);
if (n < 0)
return -1;
if (n < chunk) {
@ -177,7 +177,7 @@ callback_fraggle(struct libwebsocket_context *context,
return -1;
}
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
case FRAGSTATE_POST_PAYLOAD_SUM:
@ -191,7 +191,7 @@ callback_fraggle(struct libwebsocket_context *context,
bp[2] = psf->sum >> 8;
bp[3] = psf->sum;
n = libwebsocket_write(wsi, (unsigned char *)bp,
n = lws_write(wsi, (unsigned char *)bp,
4, LWS_WRITE_BINARY);
if (n < 0)
return -1;
@ -202,7 +202,7 @@ callback_fraggle(struct libwebsocket_context *context,
psf->state = FRAGSTATE_START_MESSAGE;
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
}
break;
@ -232,7 +232,7 @@ callback_fraggle(struct libwebsocket_context *context,
/* list of supported protocols and callbacks */
static struct libwebsocket_protocols protocols[] = {
static struct lws_protocols protocols[] = {
{
"fraggle-protocol",
callback_fraggle,
@ -258,11 +258,11 @@ int main(int argc, char **argv)
int n = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
struct lws_context *context;
int opts = 0;
char interface_name[128] = "";
const char *iface = NULL;
struct libwebsocket *wsi;
struct lws *wsi;
const char *address;
int server_port = port;
struct lws_context_creation_info info;
@ -318,7 +318,7 @@ int main(int argc, char **argv)
info.iface = iface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
info.extensions = lws_get_internal_extensions();
#endif
if (use_ssl) {
info.ssl_cert_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
@ -328,7 +328,7 @@ int main(int argc, char **argv)
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
context = lws_create_context(&info);
if (context == NULL) {
fprintf(stderr, "libwebsocket init failed\n");
return -1;
@ -337,7 +337,7 @@ int main(int argc, char **argv)
if (client) {
address = argv[optind];
fprintf(stderr, "Connecting to %s:%u\n", address, port);
wsi = libwebsocket_client_connect(context, address,
wsi = lws_client_connect(context, address,
port, use_ssl, "/", address,
"origin", protocols[PROTOCOL_FRAGGLE].name,
-1);
@ -349,12 +349,12 @@ int main(int argc, char **argv)
n = 0;
while (!n && !terminate)
n = libwebsocket_service(context, 50);
n = lws_service(context, 50);
fprintf(stderr, "Terminating...\n");
bail:
libwebsocket_context_destroy(context);
lws_context_destroy(context);
return 0;
}

36
test-server/test-ping.c
View file

@ -48,7 +48,7 @@
#define MAX_PING_CLIENTS 256
#define PING_RINGBUFFER_SIZE 256
static struct libwebsocket *ping_wsi[MAX_PING_CLIENTS];
static struct lws *ping_wsi[MAX_PING_CLIENTS];
static unsigned int interval_us = 1000000;
static unsigned int size = 64;
static int flood;
@ -100,9 +100,9 @@ enum demo_protocols {
static int
callback_lws_mirror(struct libwebsocket_context * this,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
callback_lws_mirror(struct lws_context * this,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
struct timeval tv;
@ -144,7 +144,7 @@ callback_lws_mirror(struct libwebsocket_context * this,
* LWS_CALLBACK_CLIENT_WRITEABLE will come next service
*/
libwebsocket_callback_on_writable(this, wsi);
lws_callback_on_writable(this, wsi);
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
@ -256,11 +256,11 @@ callback_lws_mirror(struct libwebsocket_context * this,
global_tx_count++;
if (use_mirror)
n = libwebsocket_write(wsi,
n = lws_write(wsi,
&pingbuf[LWS_SEND_BUFFER_PRE_PADDING],
size, write_options | LWS_WRITE_BINARY);
else
n = libwebsocket_write(wsi,
n = lws_write(wsi,
&pingbuf[LWS_SEND_BUFFER_PRE_PADDING],
size, write_options | LWS_WRITE_PING);
@ -286,7 +286,7 @@ callback_lws_mirror(struct libwebsocket_context * this,
/* list of supported protocols and callbacks */
static struct libwebsocket_protocols protocols[] = {
static struct lws_protocols protocols[] = {
{
"lws-mirror-protocol",
@ -330,7 +330,7 @@ int main(int argc, char **argv)
int n = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
struct lws_context *context;
char protocol_name[256];
char ip[30];
#ifndef _WIN32
@ -426,12 +426,12 @@ int main(int argc, char **argv)
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
info.extensions = lws_get_internal_extensions();
#endif
info.gid = -1;
info.uid = -1;
context = libwebsocket_create_context(&info);
context = lws_create_context(&info);
if (context == NULL) {
fprintf(stderr, "Creating libwebsocket context failed\n");
return 1;
@ -440,7 +440,7 @@ int main(int argc, char **argv)
/* create client websockets using dumb increment protocol */
for (n = 0; n < clients; n++) {
ping_wsi[n] = libwebsocket_client_connect(context, address,
ping_wsi[n] = lws_client_connect(context, address,
port, use_ssl, "/", address,
"origin", protocols[PROTOCOL_LWS_MIRROR].name,
ietf_version);
@ -451,8 +451,8 @@ int main(int argc, char **argv)
}
}
libwebsockets_get_peer_addresses(context, ping_wsi[0],
libwebsocket_get_socket_fd(ping_wsi[0]),
lws_get_peer_addresses(context, ping_wsi[0],
lws_get_socket_fd(ping_wsi[0]),
peer_name, sizeof peer_name, ip, sizeof ip);
fprintf(stderr, "Websocket PING %s (%s) %d bytes of data.\n",
@ -487,7 +487,7 @@ int main(int argc, char **argv)
if (!interrupted_time) {
if ((l - oldus) > interval_us) {
for (n = 0; n < clients; n++)
libwebsocket_callback_on_writable(
lws_callback_on_writable(
context, ping_wsi[n]);
oldus = l;
}
@ -501,9 +501,9 @@ int main(int argc, char **argv)
}
if (!interval_us)
n = libwebsocket_service(context, 0);
n = lws_service(context, 0);
else
n = libwebsocket_service(context, 1);
n = lws_service(context, 1);
}
/* stats */
@ -523,7 +523,7 @@ int main(int argc, char **argv)
((double)global_rx_count * (double)size) /
((double)(l - started) / 1000000.0) / 1024.0);
libwebsocket_context_destroy(context);
lws_context_destroy(context);
return 0;

8
test-server/test-server-dumb-increment.c
View file

@ -23,9 +23,9 @@
/* dumb_increment protocol */
int
callback_dumb_increment(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
callback_dumb_increment(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 512 +
@ -43,7 +43,7 @@ callback_dumb_increment(struct libwebsocket_context *context,
case LWS_CALLBACK_SERVER_WRITEABLE:
n = sprintf((char *)p, "%d", pss->number++);
m = libwebsocket_write(wsi, p, n, LWS_WRITE_TEXT);
m = lws_write(wsi, p, n, LWS_WRITE_TEXT);
if (m < n) {
lwsl_err("ERROR %d writing to di socket\n", n);
return -1;

51
test-server/test-server-http.c
View file

@ -60,7 +60,7 @@ struct serveable {
* content
*/
void
dump_handshake_info(struct libwebsocket *wsi)
dump_handshake_info(struct lws *wsi)
{
int n = 0;
char buf[256];
@ -110,10 +110,9 @@ const char * get_mimetype(const char *file)
* here on the first protocol server.
*/
int callback_http(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason, void *user,
void *in, size_t len)
int callback_http(struct lws_context *context, struct lws *wsi,
enum lws_callback_reasons reason, void *user,
void *in, size_t len)
{
struct per_session_data__http *pss =
(struct per_session_data__http *)user;
@ -130,7 +129,7 @@ int callback_http(struct libwebsocket_context *context,
int n, m;
#ifdef EXTERNAL_POLL
struct libwebsocket_pollargs *pa = (struct libwebsocket_pollargs *)in;
struct lws_pollargs *pa = (struct lws_pollargs *)in;
#endif
switch (reason) {
@ -139,14 +138,14 @@ int callback_http(struct libwebsocket_context *context,
dump_handshake_info(wsi);
if (len < 1) {
libwebsockets_return_http_status(context, wsi,
lws_return_http_status(context, wsi,
HTTP_STATUS_BAD_REQUEST, NULL);
goto try_to_reuse;
}
/* this example server has no concept of directories */
if (strchr((const char *)in + 1, '/')) {
libwebsockets_return_http_status(context, wsi,
lws_return_http_status(context, wsi,
HTTP_STATUS_FORBIDDEN, NULL);
goto try_to_reuse;
}
@ -217,7 +216,7 @@ int callback_http(struct libwebsocket_context *context,
* this is mandated by changes in HTTP2
*/
n = libwebsocket_write(wsi,
n = lws_write(wsi,
buffer + LWS_SEND_BUFFER_PRE_PADDING,
p - (buffer + LWS_SEND_BUFFER_PRE_PADDING),
LWS_WRITE_HTTP_HEADERS);
@ -229,7 +228,7 @@ int callback_http(struct libwebsocket_context *context,
/*
* book us a LWS_CALLBACK_HTTP_WRITEABLE callback
*/
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
}
@ -247,7 +246,7 @@ int callback_http(struct libwebsocket_context *context,
mimetype = get_mimetype(buf);
if (!mimetype) {
lwsl_err("Unknown mimetype for %s\n", buf);
libwebsockets_return_http_status(context, wsi,
lws_return_http_status(context, wsi,
HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, NULL);
return -1;
}
@ -275,7 +274,7 @@ int callback_http(struct libwebsocket_context *context,
other_headers = leaf_path;
}
n = libwebsockets_serve_http_file(context, wsi, buf,
n = lws_serve_http_file(context, wsi, buf,
mimetype, other_headers, n);
if (n < 0 || ((n > 0) && lws_http_transaction_completed(wsi)))
return -1; /* error or can't reuse connection: close the socket */
@ -302,7 +301,7 @@ int callback_http(struct libwebsocket_context *context,
case LWS_CALLBACK_HTTP_BODY_COMPLETION:
lwsl_notice("LWS_CALLBACK_HTTP_BODY_COMPLETION\n");
/* the whole of the sent body arrived, close or reuse the connection */
libwebsockets_return_http_status(context, wsi,
lws_return_http_status(context, wsi,
HTTP_STATUS_OK, NULL);
goto try_to_reuse;
@ -330,7 +329,7 @@ int callback_http(struct libwebsocket_context *context,
n = m;
n = read(pss->fd, buffer + LWS_SEND_BUFFER_PRE_PADDING,
n);
n);
/* problem reading, close conn */
if (n < 0)
goto bail;
@ -344,9 +343,8 @@ int callback_http(struct libwebsocket_context *context,
* is handled by the library itself if you sent a
* content-length header
*/
m = libwebsocket_write(wsi,
buffer + LWS_SEND_BUFFER_PRE_PADDING,
n, LWS_WRITE_HTTP);
m = lws_write(wsi, buffer + LWS_SEND_BUFFER_PRE_PADDING,
n, LWS_WRITE_HTTP);
if (m < 0)
/* write failed, close conn */
goto bail;
@ -360,22 +358,23 @@ int callback_http(struct libwebsocket_context *context,
goto bail;
if (m) /* while still active, extend timeout */
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_HTTP_CONTENT, 5);
lws_set_timeout(wsi,
PENDING_TIMEOUT_HTTP_CONTENT, 5);
/* if we have indigestion, let him clear it before eating more */
/* if we have indigestion, let him clear it
* before eating more */
if (lws_partial_buffered(wsi))
break;
} while (!lws_send_pipe_choked(wsi));
later:
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
flush_bail:
/* true if still partial pending */
if (lws_partial_buffered(wsi)) {
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
}
close(pss->fd);
@ -397,7 +396,6 @@ bail:
/* if we returned non-zero from here, we kill the connection */
break;
#ifdef EXTERNAL_POLL
/*
* callbacks for managing the external poll() array appear in
* protocol 0 callback
@ -407,16 +405,21 @@ bail:
/*
* lock mutex to protect pollfd state
* called before any other POLL related callback
* if protecting wsi lifecycle change, len == 1
*/
test_server_lock(len);
break;
case LWS_CALLBACK_UNLOCK_POLL:
/*
* unlock mutex to protect pollfd state when
* called after any other POLL related callback
* if protecting wsi lifecycle change, len == 1
*/
test_server_unlock(len);
break;
#ifdef EXTERNAL_POLL
case LWS_CALLBACK_ADD_POLL_FD:
if (count_pollfds >= max_poll_elements) {
@ -446,7 +449,7 @@ bail:
case LWS_CALLBACK_GET_THREAD_ID:
/*
* if you will call "libwebsocket_callback_on_writable"
* if you will call "lws_callback_on_writable"
* from a different thread, return the caller thread ID
* here so lws can use this information to work out if it
* should signal the poll() loop to exit and restart early

20
test-server/test-server-mirror.c
View file

@ -33,9 +33,9 @@ static struct a_message ringbuffer[MAX_MESSAGE_QUEUE];
static int ringbuffer_head;
int
callback_lws_mirror(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
callback_lws_mirror(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
struct per_session_data__lws_mirror *pss =
@ -62,7 +62,7 @@ callback_lws_mirror(struct libwebsocket_context *context,
break;
while (pss->ringbuffer_tail != ringbuffer_head) {
n = libwebsocket_write(wsi, (unsigned char *)
n = lws_write(wsi, (unsigned char *)
ringbuffer[pss->ringbuffer_tail].payload +
LWS_SEND_BUFFER_PRE_PADDING,
ringbuffer[pss->ringbuffer_tail].len,
@ -82,11 +82,11 @@ callback_lws_mirror(struct libwebsocket_context *context,
if (((ringbuffer_head - pss->ringbuffer_tail) &
(MAX_MESSAGE_QUEUE - 1)) == (MAX_MESSAGE_QUEUE - 15))
libwebsocket_rx_flow_allow_all_protocol(
libwebsockets_get_protocol(wsi));
lws_rx_flow_allow_all_protocol(
lws_get_protocol(wsi));
if (lws_partial_buffered(wsi) || lws_send_pipe_choked(wsi)) {
libwebsocket_callback_on_writable(context, wsi);
lws_callback_on_writable(context, wsi);
break;
}
/*
@ -128,11 +128,11 @@ callback_lws_mirror(struct libwebsocket_context *context,
choke:
lwsl_debug("LWS_CALLBACK_RECEIVE: throttling %p\n", wsi);
libwebsocket_rx_flow_control(wsi, 0);
lws_rx_flow_control(wsi, 0);
done:
libwebsocket_callback_on_writable_all_protocol(
libwebsockets_get_protocol(wsi));
lws_callback_on_writable_all_protocol(
lws_get_protocol(wsi));
break;
/*

342
test-server/test-server-pthreads.c Normal file
View file

@ -0,0 +1,342 @@
/*
* libwebsockets-test-server - libwebsockets test implementation
*
* Copyright (C) 2010-2015 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
* License as published by the Free Software Foundation:
* version 2.1 of the License.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
#include "test-server.h"
#include <pthread.h>
int close_testing;
int max_poll_elements;
#ifdef EXTERNAL_POLL
struct lws_pollfd *pollfds;
int *fd_lookup;
int count_pollfds;
#endif
volatile int force_exit = 0;
struct lws_context *context;
/*
* This mutex lock protects code that changes or relies on wsi list outside of
* the service thread. The service thread will acquire it when changing the
* wsi list and other threads should acquire it while dereferencing wsis or
* calling apis like lws_callback_on_writable_all_protocol() which
* use the wsi list and wsis from a different thread context.
*/
pthread_mutex_t lock_established_conns;
/* http server gets files from this path */
#define LOCAL_RESOURCE_PATH INSTALL_DATADIR"/libwebsockets-test-server"
char *resource_path = LOCAL_RESOURCE_PATH;
/*
* multithreaded version - protect wsi lifecycle changes in the library
* these are called from protocol 0 callbacks
*/
void test_server_lock(int care)
{
if (care)
pthread_mutex_lock(&lock_established_conns);
}
void test_server_unlock(int care)
{
if (care)
pthread_mutex_unlock(&lock_established_conns);
}
/*
* This demo server shows how to use libwebsockets for one or more
* websocket protocols in the same server
*
* It defines the following websocket protocols:
*
* dumb-increment-protocol: once the socket is opened, an incrementing
* ascii string is sent down it every 50ms.
* If you send "reset\n" on the websocket, then
* the incrementing number is reset to 0.
*
* lws-mirror-protocol: copies any received packet to every connection also
* using this protocol, including the sender
*/
enum demo_protocols {
/* always first */
PROTOCOL_HTTP = 0,
PROTOCOL_DUMB_INCREMENT,
PROTOCOL_LWS_MIRROR,
/* always last */
DEMO_PROTOCOL_COUNT
};
/* list of supported protocols and callbacks */
static struct lws_protocols protocols[] = {
/* first protocol must always be HTTP handler */
{
"http-only", /* name */
callback_http, /* callback */
sizeof (struct per_session_data__http), /* per_session_data_size */
0, /* max frame size / rx buffer */
},
{
"dumb-increment-protocol",
callback_dumb_increment,
sizeof(struct per_session_data__dumb_increment),
10,
},
{
"lws-mirror-protocol",
callback_lws_mirror,
sizeof(struct per_session_data__lws_mirror),
128,
},
{ NULL, NULL, 0, 0 } /* terminator */
};
void *thread_dumb_increment(void *threadid)
{
while (!force_exit) {
/*
* this lock means wsi in the active list cannot
* disappear underneath us, because the code to add and remove
* them is protected by the same lock
*/
pthread_mutex_lock(&lock_established_conns);
lws_callback_on_writable_all_protocol(
&protocols[PROTOCOL_DUMB_INCREMENT]);
pthread_mutex_unlock(&lock_established_conns);
usleep(100000);
}
pthread_exit(NULL);
}
void sighandler(int sig)
{
force_exit = 1;
lws_cancel_service(context);
}
static struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "debug", required_argument, NULL, 'd' },
{ "port", required_argument, NULL, 'p' },
{ "ssl", no_argument, NULL, 's' },
{ "allow-non-ssl", no_argument, NULL, 'a' },
{ "interface", required_argument, NULL, 'i' },
{ "closetest", no_argument, NULL, 'c' },
{ "libev", no_argument, NULL, 'e' },
#ifndef LWS_NO_DAEMONIZE
{ "daemonize", no_argument, NULL, 'D' },
#endif
{ "resource_path", required_argument, NULL, 'r' },
{ NULL, 0, 0, 0 }
};
int main(int argc, char **argv)
{
struct lws_context_creation_info info;
char interface_name[128] = "";
const char *iface = NULL;
pthread_t pthread_dumb;
char cert_path[1024];
char key_path[1024];
int debug_level = 7;
int use_ssl = 0;
void *retval;
int opts = 0;
int n = 0;
#ifndef _WIN32
int syslog_options = LOG_PID | LOG_PERROR;
#endif
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
/*
* take care to zero down the info struct, he contains random garbaage
* from the stack otherwise
*/
memset(&info, 0, sizeof info);
info.port = 7681;
pthread_mutex_init(&lock_established_conns, NULL);
while (n >= 0) {
n = getopt_long(argc, argv, "eci:hsap:d:Dr:", options, NULL);
if (n < 0)
continue;
switch (n) {
case 'e':
opts |= LWS_SERVER_OPTION_LIBEV;
break;
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
#ifndef _WIN32
syslog_options &= ~LOG_PERROR;
#endif
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1;
break;
case 'a':
opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT;
break;
case 'p':
info.port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
iface = interface_name;
break;
case 'c':
close_testing = 1;
fprintf(stderr, " Close testing mode -- closes on "
"client after 50 dumb increments"
"and suppresses lws_mirror spam\n");
break;
case 'r':
resource_path = optarg;
printf("Setting resource path to \"%s\"\n", resource_path);
break;
case 'h':
fprintf(stderr, "Usage: test-server "
"[--port=<p>] [--ssl] "
"[-d <log bitfield>] "
"[--resource_path <path>]\n");
exit(1);
}
}
#if !defined(LWS_NO_DAEMONIZE) && !defined(WIN32)
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
if (daemonize && lws_daemonize("/tmp/.lwsts-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
signal(SIGINT, sighandler);
#ifndef _WIN32
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
#endif
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets test server - "
"(C) Copyright 2010-2015 Andy Green <andy@warmcat.com> - "
"licensed under LGPL2.1\n");
printf("Using resource path \"%s\"\n", resource_path);
#ifdef EXTERNAL_POLL
max_poll_elements = getdtablesize();
pollfds = malloc(max_poll_elements * sizeof (struct lws_pollfd));
fd_lookup = malloc(max_poll_elements * sizeof (int));
if (pollfds == NULL || fd_lookup == NULL) {
lwsl_err("Out of memory pollfds=%d\n", max_poll_elements);
return -1;
}
#endif
info.iface = iface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = lws_get_internal_extensions();
#endif
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
if (use_ssl) {
if (strlen(resource_path) > sizeof(cert_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(cert_path, "%s/libwebsockets-test-server.pem",
resource_path);
if (strlen(resource_path) > sizeof(key_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(key_path, "%s/libwebsockets-test-server.key.pem",
resource_path);
info.ssl_cert_filepath = cert_path;
info.ssl_private_key_filepath = key_path;
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = lws_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
/* start the dumb increment thread */
n = pthread_create(&pthread_dumb, NULL, thread_dumb_increment, 0);
if (n) {
lwsl_err("Unable to create dumb thread\n");
goto done;
}
/* this is our service thread */
n = 0;
while (n >= 0 && !force_exit) {
n = lws_service(context, 50);
}
/* wait for pthread_dumb to exit */
pthread_join(pthread_dumb, &retval);
done:
lws_context_destroy(context);
pthread_mutex_destroy(&lock_established_conns);
lwsl_notice("libwebsockets-test-server exited cleanly\n");
#ifndef _WIN32
closelog();
#endif
return 0;
}

33
test-server/test-server.c
View file

@ -25,17 +25,26 @@ int close_testing;
int max_poll_elements;
#ifdef EXTERNAL_POLL
struct libwebsocket_pollfd *pollfds;
struct lws_pollfd *pollfds;
int *fd_lookup;
int count_pollfds;
#endif
volatile int force_exit = 0;
struct libwebsocket_context *context;
struct lws_context *context;
/* http server gets files from this path */
#define LOCAL_RESOURCE_PATH INSTALL_DATADIR"/libwebsockets-test-server"
char *resource_path = LOCAL_RESOURCE_PATH;
/* singlethreaded version --> no locks */
void test_server_lock(int care)
{
}
void test_server_unlock(int care)
{
}
/*
* This demo server shows how to use libwebsockets for one or more
* websocket protocols in the same server
@ -64,7 +73,7 @@ enum demo_protocols {
/* list of supported protocols and callbacks */
static struct libwebsocket_protocols protocols[] = {
static struct lws_protocols protocols[] = {
/* first protocol must always be HTTP handler */
{
@ -91,7 +100,7 @@ static struct libwebsocket_protocols protocols[] = {
void sighandler(int sig)
{
force_exit = 1;
libwebsocket_cancel_service(context);
lws_cancel_service(context);
}
static struct option options[] = {
@ -126,7 +135,7 @@ int main(int argc, char **argv)
int syslog_options = LOG_PID | LOG_PERROR;
#endif
#ifndef LWS_NO_DAEMONIZE
// int daemonize = 0;
int daemonize = 0;
#endif
/*
@ -218,7 +227,7 @@ int main(int argc, char **argv)
printf("Using resource path \"%s\"\n", resource_path);
#ifdef EXTERNAL_POLL
max_poll_elements = getdtablesize();
pollfds = malloc(max_poll_elements * sizeof (struct libwebsocket_pollfd));
pollfds = malloc(max_poll_elements * sizeof (struct lws_pollfd));
fd_lookup = malloc(max_poll_elements * sizeof (int));
if (pollfds == NULL || fd_lookup == NULL) {
lwsl_err("Out of memory pollfds=%d\n", max_poll_elements);
@ -229,7 +238,7 @@ int main(int argc, char **argv)
info.iface = iface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
info.extensions = lws_get_internal_extensions();
#endif
info.ssl_cert_filepath = NULL;
@ -256,7 +265,7 @@ int main(int argc, char **argv)
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
context = lws_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
@ -276,7 +285,7 @@ int main(int argc, char **argv)
ms = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
if ((ms - oldms) > 50) {
libwebsocket_callback_on_writable_all_protocol(
lws_callback_on_writable_all_protocol(
&protocols[PROTOCOL_DUMB_INCREMENT]);
oldms = ms;
}
@ -301,7 +310,7 @@ int main(int argc, char **argv)
* match anything under libwebsockets
* control
*/
if (libwebsocket_service_fd(context,
if (lws_service_fd(context,
&pollfds[n]) < 0)
goto done;
#else
@ -314,7 +323,7 @@ int main(int argc, char **argv)
* the number of ms in the second argument.
*/
n = libwebsocket_service(context, 50);
n = lws_service(context, 50);
#endif
}
@ -322,7 +331,7 @@ int main(int argc, char **argv)
done:
#endif
libwebsocket_context_destroy(context);
lws_context_destroy(context);
lwsl_notice("libwebsockets-test-server exited cleanly\n");

29
test-server/test-server.h
View file

@ -27,14 +27,17 @@ extern int close_testing;
extern int max_poll_elements;
#ifdef EXTERNAL_POLL
extern struct libwebsocket_pollfd *pollfds;
extern struct lws_pollfd *pollfds;
extern int *fd_lookup;
extern int count_pollfds;
#endif
extern volatile int force_exit;
extern struct libwebsocket_context *context;
extern struct lws_context *context;
extern char *resource_path;
extern void test_server_lock(int care);
extern void test_server_unlock(int care);
#ifndef __func__
#define __func__ __FUNCTION__
#endif
@ -56,22 +59,22 @@ struct per_session_data__dumb_increment {
};
struct per_session_data__lws_mirror {
struct libwebsocket *wsi;
struct lws *wsi;
int ringbuffer_tail;
};
extern int callback_http(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
extern int callback_http(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len);
extern int callback_lws_mirror(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
extern int callback_lws_mirror(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len);
extern int callback_dumb_increment(struct libwebsocket_context *context,
struct libwebsocket *wsi,
enum libwebsocket_callback_reasons reason,
extern int callback_dumb_increment(struct lws_context *context,
struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len);
extern void
dump_handshake_info(struct libwebsocket *wsi);
dump_handshake_info(struct lws *wsi);