AM_CONDITIONAL(NOPING, test x$noping = xyes)
+#
+#
+#
+AC_ARG_ENABLE(debug,
+ [ --disable-debug Stops debug-related code from even being compiled in, useful for best speed],
+ [ disable_debug=yes
+ ])
+
+if test "x$disable_debug" != "xyes" ; then
+CFLAGS="$CFLAGS -D_DEBUG"
+fi
+AM_CONDITIONAL(DISABLE_DEBUG, test x$disable_debug = xyes)
# Checks for header files.
#include <stdio.h>
#include <string.h>
+#include <private-libwebsockets.h>
static const char encode[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz0123456789+/";
n = lws_b64_encode_string(plaintext[test],
strlen(plaintext[test]), buf, sizeof buf);
if (n != strlen(coded[test]) || strcmp(buf, coded[test])) {
- fprintf(stderr, "Failed lws_b64 encode selftest "
+ lwsl_err("Failed lws_b64 encode selftest "
"%d result '%s' %d\n", test, buf, n);
return -1;
}
n = lws_b64_decode_string(coded[test], buf, sizeof buf);
if (n != strlen(plaintext[test]) ||
strcmp(buf, plaintext[test])) {
- fprintf(stderr, "Failed lws_b64 decode selftest "
+ lwsl_err("Failed lws_b64 decode selftest "
"%d result '%s' %d\n", test, buf, n);
return -1;
}
struct protoent *tcp_proto;
#endif
- debug("__libwebsocket_client_connect_2\n");
+ lwsl_client("__libwebsocket_client_connect_2\n");
wsi->candidate_children_list = NULL;
* prepare the actual connection (to the proxy, if any)
*/
- debug("__libwebsocket_client_connect_2: address %s", wsi->c_address);
+ lwsl_client("__libwebsocket_client_connect_2: address %s", wsi->c_address);
server_hostent = gethostbyname(wsi->c_address);
if (server_hostent == NULL) {
- fprintf(stderr, "Unable to get host name from %s\n",
- wsi->c_address);
+ lwsl_err("Unable to get host name from %s\n", wsi->c_address);
goto oom4;
}
wsi->sock = socket(AF_INET, SOCK_STREAM, 0);
if (wsi->sock < 0) {
- fprintf(stderr, "Unable to open socket\n");
+ lwsl_warn("Unable to open socket\n");
goto oom4;
}
if (connect(wsi->sock, (struct sockaddr *)&server_addr,
sizeof(struct sockaddr)) == -1) {
- fprintf(stderr, "Connect failed\n");
+ lwsl_debug("Connect failed\n");
#ifdef WIN32
closesocket(wsi->sock);
#else
goto oom4;
}
- debug("connected\n");
+ lwsl_client("connected\n");
/* into fd -> wsi hashtable */
#else
close(wsi->sock);
#endif
- fprintf(stderr, "ERROR writing to proxy socket\n");
+ lwsl_debug("ERROR writing to proxy socket\n");
goto bail1;
}
int handled;
#ifndef LWS_OPENSSL_SUPPORT
if (ssl_connection) {
- fprintf(stderr, "libwebsockets not configured for ssl\n");
+ lwsl_err("libwebsockets not configured for ssl\n");
return NULL;
}
#endif
wsi->xor_mask = xor_mask_05;
break;
default:
- fprintf(stderr,
- "Client ietf version %d not supported\n",
+ lwsl_parser("Client ietf version %d not supported\n",
wsi->ietf_spec_revision);
goto oom4;
}
}
if (handled) {
- debug("libwebsocket_client_connect: ext handling conn\n");
+ lwsl_client("libwebsocket_client_connect: ext handling conn\n");
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_AWAITING_EXTENSION_CONNECT_RESPONSE, AWAITING_TIMEOUT);
return wsi;
}
- debug("libwebsocket_client_connect: direct conn\n");
+ lwsl_client("libwebsocket_client_connect: direct conn\n");
return __libwebsocket_client_connect_2(context, wsi);
conn->zs_in.opaque = conn->zs_out.opaque = Z_NULL;
n = inflateInit2(&conn->zs_in, -LWS_ZLIB_WINDOW_BITS);
if (n != Z_OK) {
- fprintf(stderr, "deflateInit returned %d", n);
+ lwsl_ext("deflateInit returned %d", n);
return 1;
}
n = deflateInit2(&conn->zs_out,
-LWS_ZLIB_WINDOW_BITS, LWS_ZLIB_MEMLEVEL,
Z_DEFAULT_STRATEGY);
if (n != Z_OK) {
- fprintf(stderr, "deflateInit2 returned %d", n);
+ lwsl_ext("deflateInit2 returned %d", n);
return 1;
}
conn->buf_pre_used = 0;
LWS_SEND_BUFFER_POST_PADDING);
if (!conn->buf_out)
goto bail;
- fprintf(stderr, "zlibs constructed\n");
+ lwsl_ext("zlibs constructed\n");
break;
bail:
- fprintf(stderr, "Out of mem\n");
+ lwsl_err("Out of mem\n");
(void)inflateEnd(&conn->zs_in);
(void)deflateEnd(&conn->zs_out);
return -1;
conn->compressed_out = 0;
(void)inflateEnd(&conn->zs_in);
(void)deflateEnd(&conn->zs_out);
- fprintf(stderr, "zlibs destructed\n");
+ lwsl_ext("zlibs destructed\n");
break;
case LWS_EXT_CALLBACK_PAYLOAD_RX:
conn->buf_pre =
(unsigned char *)malloc(total_payload + 4);
if (!conn->buf_pre) {
- fprintf(stderr, "Out of memory\n");
+ lwsl_err("Out of memory\n");
return -1;
}
}
* screwed.. close the connection... we will get a
* destroy callback to take care of closing nicely
*/
- fprintf(stderr, "zlib error inflate %d: %s",
+ lwsl_ext("zlib error inflate %d: %s",
n, conn->zs_in.msg);
return -1;
}
* screwed.. close the connection... we will get a
* destroy callback to take care of closing nicely
*/
- fprintf(stderr, "zlib error deflate");
+ lwsl_ext("zlib error deflate");
return -1;
}
conn->buf_out_length +
LWS_SEND_BUFFER_POST_PADDING);
if (!new_buf) {
- fprintf(stderr, "Out of memory\n");
+ lwsl_err("Out of memory\n");
return -1;
}
memcpy(new_buf + LWS_SEND_BUFFER_PRE_PADDING,
conn->zs_in.opaque = conn->zs_out.opaque = Z_NULL;
n = inflateInit2(&conn->zs_in, -LWS_ZLIB_WINDOW_BITS);
if (n != Z_OK) {
- fprintf(stderr, "deflateInit returned %d\n", n);
+ lwsl_err("deflateInit returned %d\n", n);
return 1;
}
n = deflateInit2(&conn->zs_out,
-LWS_ZLIB_WINDOW_BITS, LWS_ZLIB_MEMLEVEL,
Z_DEFAULT_STRATEGY);
if (n != Z_OK) {
- fprintf(stderr, "deflateInit returned %d\n", n);
+ lwsl_err("deflateInit returned %d\n", n);
return 1;
}
- debug("zlibs constructed\n");
+ lwsl_ext("zlibs constructed\n");
conn->remaining_in = 0;
break;
case LWS_EXT_CALLBACK_DESTROY:
(void)inflateEnd(&conn->zs_in);
(void)deflateEnd(&conn->zs_out);
- debug("zlibs destructed\n");
+ lwsl_ext("zlibs destructed\n");
break;
case LWS_EXT_CALLBACK_PACKET_RX_PREPARSE:
* screwed.. close the connection... we will get a
* destroy callback to take care of closing nicely
*/
- fprintf(stderr, "zlib error inflate %d\n", n);
+ lwsl_err("zlib error inflate %d\n", n);
return -1;
}
* screwed.. close the connection... we will get a
* destroy callback to take care of closing nicely
*/
- fprintf(stderr, "zlib error deflate\n");
+ lwsl_ext("zlib error deflate\n");
return -1;
}
int n;
void *v;
-// fprintf(stderr, "XRX: %02X %d %d\n", c, conn->state, conn->length);
+// lwsl_debug("XRX: %02X %d %d\n", c, conn->state, conn->length);
/*
* [ <Channel ID b12.. b8> <Mux Opcode b2..b0> ]
switch (conn->state) {
case LWS_EXT_XGM_STATE__MUX_BLOCK_1:
-// fprintf(stderr, "LWS_EXT_XGM_STATE__MUX_BLOCK_1: opc=%d channel=%d\n", c & 7, c >> 3);
+// lwsl_ext("LWS_EXT_XGM_STATE__MUX_BLOCK_1: opc=%d channel=%d\n", c & 7, c >> 3);
conn->block_subopcode = (enum lws_ext_x_goole_mux__mux_opcodes)(c & 7);
conn->block_subchannel = (c >> 3) & 0x1f;
conn->ignore_cmd = 0;
conn->block_subchannel |= c;
interpret:
-// fprintf(stderr, "LWS_EXT_XGM_STATE__MUX_BLOCK_3: subchannel=%d\n", conn->block_subchannel);
+// lwsl_ext("LWS_EXT_XGM_STATE__MUX_BLOCK_3: subchannel=%d\n", conn->block_subchannel);
ongoing_subchannel = conn->block_subchannel;
/*
conn->state = LWS_EXT_XGM_STATE__FLOWCONTROL_1;
break;
default:
- fprintf(stderr, "xgm: unknown subopcode\n");
+ lwsl_ext("xgm: unknown subopcode\n");
return -1;
}
break;
if (conn->block_subchannel == 0 || conn->block_subchannel >=
(sizeof(conn->wsi_children) /
sizeof(conn->wsi_children[0]))) {
- fprintf(stderr, "Illegal subchannel %d in "
+ lwsl_ext("Illegal subchannel %d in "
"LWS_EXT_XGM_STATE__ADDCHANNEL_HEADERS, ignoring",
conn->block_subchannel);
conn->ignore_cmd = 1;
}
if (conn->block_subchannel == 1 && !conn->original_ch1_closed) {
- fprintf(stderr, "illegal request to add ch1 when it's still live, ignoring\n");
+ lwsl_ext("illegal request to add ch1 when it's still live, ignoring\n");
conn->ignore_cmd = 1;
}
wsi_child->user_space = malloc(
wsi_child->protocol->per_session_data_size);
if (wsi_child->user_space == NULL) {
- fprintf(stderr, "Out of memory for "
+ lwsl_ext("Out of memory for "
"conn user space\n");
goto bail2;
}
child_conn = (struct lws_ext_x_google_mux_conn *)lws_get_extension_user_matching_ext(wsi_child,
this_ext);
if (!child_conn) {
- fprintf(stderr, "wsi_child %p has no child conn!", (void *)wsi_child);
+ lwsl_ext("wsi_child %p has no child conn!", (void *)wsi_child);
break;
}
child_conn->wsi_parent = wsi;
wsi_child->user_space = malloc(
wsi_child->protocol->per_session_data_size);
if (wsi_child->user_space == NULL) {
- fprintf(stderr, "Out of memory for "
+ lwsl_err("Out of memory for "
"conn user space\n");
break;
}
case LWS_EXT_XGM_STATE__DATA:
-// fprintf(stderr, "LWS_EXT_XGM_STATE__DATA in\n");
+// lwsl_debug("LWS_EXT_XGM_STATE__DATA in\n");
/*
* we have cooked websocket frame content following just like
* afterwards
*/
if (conn->block_subchannel - MUX_REAL_CHILD_INDEX_OFFSET >= conn->highest_child_subchannel) {
- fprintf(stderr, "Illegal subchannel %d\n", conn->block_subchannel);
+ lwsl_ext("Illegal subchannel %d\n", conn->block_subchannel);
return -1;
}
- // fprintf(stderr, "LWS_EXT_XGM_STATE__DATA: ch %d\n", conn->block_subchannel);
+ // lwsl_debug("LWS_EXT_XGM_STATE__DATA: ch %d\n", conn->block_subchannel);
if (conn->block_subchannel == 1) {
if (conn->original_ch1_closed) {
- fprintf(stderr, "data sent to closed ch1\n");
+ lwsl_debug("data sent to closed ch1\n");
return -1;
}
wsi_child = wsi;
wsi_child = conn->wsi_children[conn->block_subchannel - MUX_REAL_CHILD_INDEX_OFFSET];
if (!wsi_child) {
- fprintf(stderr, "Bad subchannel %d\n", conn->block_subchannel);
+ lwsl_ext("Bad subchannel %d\n", conn->block_subchannel);
return -1;
}
case LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE:
case LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY:
case LWS_CONNMODE_WS_CLIENT:
-// fprintf(stderr, " client\n");
+// lwsl_ext(" client\n");
if (libwebsocket_client_rx_sm(wsi_child, c) < 0) {
libwebsocket_close_and_free_session(
context,
/* server is receiving from client */
default:
-// fprintf(stderr, " server\n");
+// lwsl_ext(" server\n");
if (libwebsocket_rx_sm(wsi_child, c) < 0) {
muxdebug("probs\n");
libwebsocket_close_and_free_session(
if (parent_conn->highest_child_subchannel >=
(sizeof(parent_conn->wsi_children) /
sizeof(parent_conn->wsi_children[0]))) {
- fprintf(stderr, "Can't add any more children\n");
+ lwsl_ext("Can't add any more children\n");
continue;
}
/*
conn->original_ch1_closed = 1;
- fprintf(stderr, "original mux parent channel closing\n");
+ lwsl_ext("original mux parent channel closing\n");
parent_conn = conn;
} else {
/* if he has children, don't let him close for real! */
if (done) {
- fprintf(stderr, "VETO closure\n");
+ lwsl_ext("VETO closure\n");
return 1;
}
/* no children, ch1 is closed, let him destroy himself */
if (conn->subchannel == 1)
- fprintf(stderr, "ALLOW closure of mux parent\n");
+ lwsl_ext("ALLOW closure of mux parent\n");
break;
conn->original_ch1_closed = 1;
- fprintf(stderr, "original mux parent channel closing\n");
+ lwsl_ext("original mux parent channel closing\n");
parent_conn = conn;
wsi_parent = wsi;
*/
if (conn->original_ch1_closed) {
- fprintf(stderr, "Trying to send on dead original ch1\n");
+ lwsl_ext("Trying to send on dead original ch1\n");
return 0;
}
*/
if (!conn->wsi_parent) {
- // fprintf(stderr, "conn %p has no parent\n", (void *)conn);
+ // lwsl_ext("conn %p has no parent\n", (void *)conn);
return 0;
}
*/
if (!parent_conn->sticky_mux_used) {
- // fprintf(stderr, "parent in singular mode\n");
+ // lwsl_ext("parent in singular mode\n");
return 0;
}
}
}
if (rem) {
- fprintf(stderr, "nonzero handshake remainder\n");
+ lwsl_warn("nonzero handshake remainder\n");
return -1;
}
wsi->utf8_token[WSI_TOKEN_GET_URI].token_len +
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
if (!response) {
- fprintf(stderr, "Out of memory for response buffer\n");
+ lwsl_err("Out of memory for response buffer\n");
goto bail;
}
/* it's complete: go ahead and send it */
- _debug("issuing response packet %d len\n", (int)(p - response));
+ lwsl_parser("issuing response packet %d len\n", (int)(p - response));
#ifdef _DEBUG
fwrite(response, 1, p - response, stderr);
#endif
n = libwebsocket_write(wsi, (unsigned char *)response,
p - response, LWS_WRITE_HTTP);
if (n < 0) {
- fprintf(stderr, "ERROR writing to socket");
+ lwsl_debug("ERROR writing to socket");
goto bail;
}
if (!wsi->utf8_token[WSI_TOKEN_HOST].token_len ||
!wsi->utf8_token[WSI_TOKEN_KEY].token_len) {
- _debug("handshake_04 missing pieces\n");
+ lwsl_parser("handshake_04 missing pieces\n");
/* completed header processing, but missing some bits */
goto bail;
}
if (wsi->utf8_token[WSI_TOKEN_KEY].token_len >=
MAX_WEBSOCKET_04_KEY_LEN) {
- fprintf(stderr, "Client sent handshake key longer "
+ lwsl_warn("Client sent handshake key longer "
"than max supported %d\n", MAX_WEBSOCKET_04_KEY_LEN);
goto bail;
}
accept_len = lws_b64_encode_string((char *)hash, 20, accept_buf,
sizeof accept_buf);
if (accept_len < 0) {
- fprintf(stderr, "Base64 encoded hash too long\n");
+ lwsl_warn("Base64 encoded hash too long\n");
goto bail;
}
wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len +
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
if (!response) {
- fprintf(stderr, "Out of memory for response buffer\n");
+ lwsl_err("Out of memory for response buffer\n");
goto bail;
}
n = libwebsockets_get_random(wsi->protocol->owning_server,
hash, 16);
if (n != 16) {
- fprintf(stderr, "Unable to read random device %s %d\n",
+ lwsl_err("Unable to read random device %s %d\n",
SYSTEM_RANDOM_FILEPATH, n);
if (wsi->user_space)
free(wsi->user_space);
nonce_len = lws_b64_encode_string((const char *)hash, 16,
nonce_buf, sizeof nonce_buf);
if (nonce_len < 0) {
- fprintf(stderr, "Failed to base 64 encode the nonce\n");
+ lwsl_err("Failed to base 64 encode the nonce\n");
if (wsi->user_space)
free(wsi->user_space);
goto bail;
*/
c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token;
- debug("wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token = %s\n",
+ lwsl_parser("wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token = %s\n",
wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token);
wsi->count_active_extensions = 0;
n = 0;
wsi->count_active_extensions], NULL, 0);
wsi->count_active_extensions++;
- debug("wsi->count_active_extensions <- %d",
+ lwsl_parser("wsi->count_active_extensions <- %d",
wsi->count_active_extensions);
ext++;
/* okay send the handshake response accepting the connection */
- _debug("issuing response packet %d len\n", (int)(p - response));
+ lwsl_parser("issuing response packet %d len\n", (int)(p - response));
#ifdef DEBUG
fwrite(response, 1, p - response, stderr);
#endif
n = libwebsocket_write(wsi, (unsigned char *)response,
p - response, LWS_WRITE_HTTP);
if (n < 0) {
- fprintf(stderr, "ERROR writing to socket");
+ lwsl_debug("ERROR writing to socket");
goto bail;
}
/* fallthru */
case WSI_STATE_HTTP_HEADERS:
- _debug("issuing %d bytes to parser\n", (int)len);
+ lwsl_parser("issuing %d bytes to parser\n", (int)len);
#ifdef _DEBUG
- fwrite(buf, 1, len, stderr);
+ //fwrite(buf, 1, len, stderr);
#endif
switch (wsi->mode) {
if (wsi->parser_state != WSI_PARSING_COMPLETE)
break;
- debug("seem to be serving, mode is %d\n", wsi->mode);
+ lwsl_parser("seem to be serving, mode is %d\n", wsi->mode);
- debug("libwebsocket_parse sees parsing complete\n");
+ lwsl_parser("libwebsocket_parse sees parsing complete\n");
/* is this websocket protocol or normal http 1.0? */
}
if (!wsi->protocol)
- fprintf(stderr, "NULL protocol at libwebsocket_read\n");
+ lwsl_err("NULL protocol at libwebsocket_read\n");
/*
* It's websocket
if (wsi->protocol->callback == NULL) {
if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token == NULL)
- fprintf(stderr, "[no protocol] "
+ lwsl_err("[no protocol] "
"not supported (use NULL .name)\n");
else
- fprintf(stderr, "Requested protocol %s "
+ lwsl_err("Requested protocol %s "
"not supported\n",
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
goto bail;
if ((wsi->protocol->callback)(wsi->protocol->owning_server, wsi,
LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION,
&wsi->utf8_token[0], NULL, 0)) {
- fprintf(stderr, "User code denied connection\n");
+ lwsl_warn("User code denied connection\n");
goto bail;
}
break;
case 4: /* 04 */
wsi->xor_mask = xor_mask_04;
- _debug("libwebsocket_parse calling handshake_04\n");
+ lwsl_parser("libwebsocket_parse calling handshake_04\n");
if (handshake_0405(context, wsi))
goto bail;
break;
case 8:
case 13:
wsi->xor_mask = xor_mask_05;
- _debug("libwebsocket_parse calling handshake_04\n");
+ lwsl_parser("libwebsocket_parse calling handshake_04\n");
if (handshake_0405(context, wsi))
goto bail;
break;
default:
- fprintf(stderr, "Unknown client spec version %d\n",
+ lwsl_warn("Unknown client spec version %d\n",
wsi->ietf_spec_revision);
goto bail;
}
- debug("accepted v%02d connection\n",
+ lwsl_parser("accepted v%02d connection\n",
wsi->ietf_spec_revision);
break;
#endif
#endif
+static int log_level = LLL_ERR | LLL_WARN;
+static const char *log_level_names[] = {
+ "ERR",
+ "WARN",
+ "INFO",
+ "DEBUG",
+ "PARSER",
+ "HEADER",
+ "EXTENSION",
+ "CLIENT",
+};
+
/*
* In-place str to lower case
*/
int h = LWS_FD_HASH(wsi->sock);
if (context->fd_hashtable[h].length == MAX_CLIENTS - 1) {
- fprintf(stderr, "hash table overflow\n");
+ lwsl_err("hash table overflow\n");
return 1;
}
return 0;
}
- fprintf(stderr, "Failed to find fd %d requested for "
+ lwsl_err("Failed to find fd %d requested for "
"delete in hashtable\n", fd);
return 1;
}
while ((err = ERR_get_error()) != 0) {
ERR_error_string_n(err, buf, sizeof(buf));
- fprintf(stderr, "*** %s\n", buf);
+ lwsl_err("*** %s\n", buf);
}
}
#endif
*/
if (m) {
- debug("extension vetoed close\n");
+ lwsl_ext("extension vetoed close\n");
return;
}
}
LWS_EXT_CALLBACK_FLUSH_PENDING_TX,
wsi->active_extensions_user[n], &eff_buf, 0);
if (m < 0) {
- fprintf(stderr, "Extension reports "
- "fatal error\n");
+ lwsl_ext("Extension reports fatal error\n");
goto just_kill_connection;
}
if (m)
if (old_state == WSI_STATE_ESTABLISHED &&
reason != LWS_CLOSE_STATUS_NOSTATUS) {
- debug("sending close indication...\n");
+ lwsl_debug("sending close indication...\n");
n = libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING],
0, LWS_WRITE_CLOSE);
libwebsocket_set_timeout(wsi,
PENDING_TIMEOUT_CLOSE_ACK, AWAITING_TIMEOUT);
- debug("sent close indication, awaiting ack\n");
+ lwsl_debug("sent close indication, awaiting ack\n");
return;
}
just_kill_connection:
- debug("libwebsocket_close_and_free_session: just_kill_connection\n");
+ lwsl_debug("libwebsocket_close_and_free_session: just_kill_connection\n");
/*
* we won't be servicing or receiving anything further from this guy
((old_state == WSI_STATE_ESTABLISHED) ||
(old_state == WSI_STATE_RETURNED_CLOSE_ALREADY) ||
(old_state == WSI_STATE_AWAITING_CLOSE_ACK))) {
- debug("calling back CLOSED\n");
+ lwsl_debug("calling back CLOSED\n");
wsi->protocol->callback(context, wsi, LWS_CALLBACK_CLOSED,
wsi->user_space, NULL, 0);
} else
- debug("not calling back closed, old_state=%d\n", old_state);
+ lwsl_debug("not calling back closed, old_state=%d\n", old_state);
/* deallocate any active extension contexts */
if (wsi->c_address)
free(wsi->c_address);
-/* fprintf(stderr, "closing fd=%d\n", wsi->sock); */
+/* lwsl_info("closing fd=%d\n", wsi->sock); */
#ifdef LWS_OPENSSL_SUPPORT
if (wsi->ssl) {
LWS_EXT_CALLBACK_PACKET_TX_PRESEND,
wsi->active_extensions_user[n], &eff_buf, 0);
if (m < 0) {
- fprintf(stderr, "ext reports fatal error\n");
+ lwsl_err("ext reports fatal error\n");
return -1;
}
if (m)
/* no we could add more */
continue;
- debug("choked in POLLOUT service\n");
+ lwsl_info("choked in POLLOUT service\n");
/*
* Yes, he's choked. Leave the POLLOUT masked on so we will
*/
if (sec > wsi->pending_timeout_limit) {
- debug("TIMEDOUT WAITING\n");
+ lwsl_info("TIMEDOUT WAITING\n");
libwebsocket_close_and_free_session(context,
wsi, LWS_CLOSE_STATUS_NOSTATUS);
}
new_wsi = (struct libwebsocket *)malloc(sizeof(struct libwebsocket));
if (new_wsi == NULL) {
- fprintf(stderr, "Out of memory for new connection\n");
+ lwsl_err("Out of memory for new connection\n");
return NULL;
}
n = libwebsockets_get_random(context, hash, 16);
if (n != 16) {
- fprintf(stderr, "Unable to read from random dev %s\n",
+ lwsl_err("Unable to read from random dev %s\n",
SYSTEM_RANDOM_FILEPATH);
free(wsi->c_path);
free(wsi->c_host);
}
if (n) { /* an extension vetos us */
- debug("ext %s vetoed\n", (char *)ext->name);
+ lwsl_ext("ext %s vetoed\n", (char *)ext->name);
ext++;
continue;
}
!wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len ||
(!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len &&
wsi->c_protocol != NULL)) {
- debug("libwebsocket_client_handshake "
+ lwsl_parser("libwebsocket_client_handshake "
"missing required header(s)\n");
pkt[len] = '\0';
- debug("%s", pkt);
+ lwsl_parser("%s", pkt);
goto bail3;
}
strtolower(wsi->utf8_token[WSI_TOKEN_HTTP].token);
if (strncmp(wsi->utf8_token[WSI_TOKEN_HTTP].token, "101", 3)) {
- fprintf(stderr, "libwebsocket_client_handshake "
+ lwsl_warn("libwebsocket_client_handshake "
"server sent bad HTTP response '%s'\n",
wsi->utf8_token[WSI_TOKEN_HTTP].token);
goto bail3;
}
if (wsi->utf8_token[WSI_TOKEN_CHALLENGE].token_len < 16) {
- fprintf(stderr, "libwebsocket_client_handshake "
+ lwsl_parser("libwebsocket_client_handshake "
"challenge reply too short %d\n",
wsi->utf8_token[
WSI_TOKEN_CHALLENGE].token_len);
pkt[len] = '\0';
- debug("%s", pkt);
+ lwsl_parser("%s", pkt);
goto bail3;
}
* Now let's confirm it sent all the necessary headers
*/
#if 0
- fprintf(stderr, "WSI_TOKEN_HTTP: %d\n",
+ lwsl_parser("WSI_TOKEN_HTTP: %d\n",
wsi->utf8_token[WSI_TOKEN_HTTP].token_len);
- fprintf(stderr, "WSI_TOKEN_UPGRADE: %d\n",
+ lwsl_parser("WSI_TOKEN_UPGRADE: %d\n",
wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len);
- fprintf(stderr, "WSI_TOKEN_CONNECTION: %d\n",
+ lwsl_parser("WSI_TOKEN_CONNECTION: %d\n",
wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len);
- fprintf(stderr, "WSI_TOKEN_ACCEPT: %d\n",
+ lwsl_parser("WSI_TOKEN_ACCEPT: %d\n",
wsi->utf8_token[WSI_TOKEN_ACCEPT].token_len);
- fprintf(stderr, "WSI_TOKEN_NONCE: %d\n",
+ lwsl_parser("WSI_TOKEN_NONCE: %d\n",
wsi->utf8_token[WSI_TOKEN_NONCE].token_len);
- fprintf(stderr, "WSI_TOKEN_PROTOCOL: %d\n",
+ lwsl_parser("WSI_TOKEN_PROTOCOL: %d\n",
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
#endif
if (!wsi->utf8_token[WSI_TOKEN_HTTP].token_len ||
wsi->ietf_spec_revision == 4) ||
(!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len &&
wsi->c_protocol != NULL)) {
- debug("libwebsocket_client_handshake "
+ lwsl_parser("libwebsocket_client_handshake "
"missing required header(s)\n");
pkt[len] = '\0';
- debug("%s", pkt);
+ lwsl_parser("%s", pkt);
goto bail3;
}
strtolower(wsi->utf8_token[WSI_TOKEN_HTTP].token);
if (strncmp(wsi->utf8_token[WSI_TOKEN_HTTP].token, "101", 3)) {
- fprintf(stderr, "libwebsocket_client_handshake "
+ lwsl_warn("libwebsocket_client_handshake "
"server sent bad HTTP response '%s'\n",
wsi->utf8_token[WSI_TOKEN_HTTP].token);
goto bail3;
strtolower(wsi->utf8_token[WSI_TOKEN_UPGRADE].token);
if (strcmp(wsi->utf8_token[WSI_TOKEN_UPGRADE].token,
"websocket")) {
- fprintf(stderr, "libwebsocket_client_handshake server "
+ lwsl_warn("libwebsocket_client_handshake server "
"sent bad Upgrade header '%s'\n",
wsi->utf8_token[WSI_TOKEN_UPGRADE].token);
goto bail3;
strtolower(wsi->utf8_token[WSI_TOKEN_CONNECTION].token);
if (strcmp(wsi->utf8_token[WSI_TOKEN_CONNECTION].token,
"upgrade")) {
- fprintf(stderr, "libwebsocket_client_handshake server "
+ lwsl_warn("libwebsocket_client_handshake server "
"sent bad Connection hdr '%s'\n",
wsi->utf8_token[WSI_TOKEN_CONNECTION].token);
goto bail3;
select_protocol:
pc = wsi->c_protocol;
if (pc == NULL)
- fprintf(stderr, "lws_client_interpret_server_handshake: "
+ lwsl_parser("lws_client_interpret_server_handshake: "
"NULL c_protocol\n");
else
- debug("lws_client_interpret_server_handshake: "
+ lwsl_parser("lws_client_interpret_server_handshake: "
"cPprotocol='%s'\n", pc);
/*
if (!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len) {
- fprintf(stderr, "lws_client_interpret_server_handshake "
+ lwsl_warn("lws_client_interpret_server_handshake "
"WSI_TOKEN_PROTOCOL is null\n");
/*
* no protocol name to work from,
free(wsi->c_protocol);
if (!okay) {
- fprintf(stderr, "libwebsocket_client_handshake server "
+ lwsl_err("libwebsocket_client_handshake server "
"sent bad protocol '%s'\n",
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
goto bail2;
}
if (wsi->protocol == NULL) {
- fprintf(stderr, "libwebsocket_client_handshake server "
+ lwsl_err("libwebsocket_client_handshake server "
"requested protocol '%s', which we "
"said we supported but we don't!\n",
wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
/* instantiate the accepted extensions */
if (!wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len) {
- debug("no client extenstions allowed by server\n");
+ lwsl_ext("no client extenstions allowed by server\n");
goto check_accept;
}
/* check we actually support it */
- debug("checking client ext %s\n", ext_name);
+ lwsl_ext("checking client ext %s\n", ext_name);
n = 0;
ext = wsi->protocol->owning_server->extensions;
n = 1;
- debug("instantiating client ext %s\n", ext_name);
+ lwsl_ext("instantiating client ext %s\n", ext_name);
/* instantiate the extension on this conn */
}
if (n == 0) {
- fprintf(stderr, "Server said we should use"
+ lwsl_warn("Server said we should use"
"an unknown extension '%s'!\n", ext_name);
goto bail2;
}
if (memcmp(wsi->initial_handshake_hash_base64,
wsi->utf8_token[WSI_TOKEN_CHALLENGE].token, 16)) {
- fprintf(stderr, "libwebsocket_client_handshake "
+ lwsl_warn("libwebsocket_client_handshake "
"failed 00 challenge compare\n");
pkt[len] = '\0';
- fprintf(stderr, "%s", pkt);
+ lwsl_warn("%s", pkt);
goto bail2;
}
if (strcmp(wsi->utf8_token[WSI_TOKEN_ACCEPT].token,
wsi->initial_handshake_hash_base64)) {
- fprintf(stderr, "libwebsocket_client_handshake server "
+ lwsl_warn("libwebsocket_client_handshake server "
"sent bad ACCEPT '%s' vs computed '%s'\n",
wsi->utf8_token[WSI_TOKEN_ACCEPT].token,
wsi->initial_handshake_hash_base64);
wsi->state = WSI_STATE_ESTABLISHED;
wsi->mode = LWS_CONNMODE_WS_CLIENT;
- _debug("handshake OK for protocol %s\n", wsi->protocol->name);
+ lwsl_debug("handshake OK for protocol %s\n", wsi->protocol->name);
/* call him back to inform him he is up */
break;
if (context->fds_count >= MAX_CLIENTS) {
- fprintf(stderr, "too busy to accept new client\n");
+ lwsl_warn("too busy to accept new client\n");
break;
}
accept_fd = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
&clilen);
if (accept_fd < 0) {
- debug("ERROR on accept: %d\n", strerror(errno));
+ lwsl_warn("ERROR on accept: %d\n", strerror(errno));
return -1;
}
if ((context->protocols[0].callback)(context, wsi,
LWS_CALLBACK_FILTER_NETWORK_CONNECTION,
(void *)(long)accept_fd, NULL, 0)) {
- debug("Callback denied network connection\n");
+ lwsl_debug("Callback denied network connection\n");
#ifdef WIN32
closesocket(accept_fd);
#else
new_wsi->ssl = SSL_new(context->ssl_ctx);
if (new_wsi->ssl == NULL) {
- fprintf(stderr, "SSL_new failed: %s\n",
+ lwsl_err("SSL_new failed: %s\n",
ERR_error_string(SSL_get_error(
new_wsi->ssl, 0), NULL));
libwebsockets_decode_ssl_error();
* ssl params which fail then retry
* and succeed
*/
- _debug("SSL_accept failed skt %u: %s\n",
+ lwsl_debug("SSL_accept failed skt %u: %s\n",
pollfd->fd,
ERR_error_string(SSL_get_error(
new_wsi->ssl, n), NULL));
break;
}
- _debug("accepted new SSL conn "
+ lwsl_debug("accepted new SSL conn "
"port %u on fd=%d SSL ver %s\n",
ntohs(cli_addr.sin_port), accept_fd,
SSL_get_version(new_wsi->ssl));
} else
#endif
- _debug("accepted new conn port %u on fd=%d\n",
+ lwsl_debug("accepted new conn port %u on fd=%d\n",
ntohs(cli_addr.sin_port), accept_fd);
insert_wsi(context, new_wsi);
accept_fd = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
&clilen);
if (accept_fd < 0) {
- debug("ERROR on accept\n");
+ lwsl_warn("ERROR on accept %d\n", accept_fd);
return -1;
}
if (context->fds_count >= MAX_CLIENTS) {
- fprintf(stderr, "too busy to accept new broadcast "
+ lwsl_err("too busy to accept new broadcast "
"proxy client\n");
#ifdef WIN32
closesocket(accept_fd);
if (pollfd->revents & (POLLERR | POLLHUP)) {
- _debug("Session Socket %p (fd=%d) dead\n",
+ lwsl_debug("Session Socket %p (fd=%d) dead\n",
(void *)wsi, pollfd->fd);
libwebsocket_close_and_free_session(context, wsi,
len = read(pollfd->fd, buf + LWS_SEND_BUFFER_PRE_PADDING,
MAX_BROADCAST_PAYLOAD);
if (len < 0) {
- fprintf(stderr, "Error reading broadcast payload\n");
+ lwsl_err("Error reading broadcast payload\n");
break;
}
if (pollfd->revents & (POLLERR | POLLHUP)) {
- fprintf(stderr, "Proxy connection %p (fd=%d) dead\n",
+ lwsl_warn("Proxy connection %p (fd=%d) dead\n",
(void *)wsi, pollfd->fd);
libwebsocket_close_and_free_session(context, wsi,
if (n < 0) {
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
- fprintf(stderr, "ERROR reading from proxy socket\n");
+ lwsl_err("ERROR reading from proxy socket\n");
return 1;
}
if (strcmp(pkt, "HTTP/1.0 200 ") != 0) {
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
- fprintf(stderr, "ERROR from proxy: %s\n", pkt);
+ lwsl_err("ERROR from proxy: %s\n", pkt);
return 1;
}
* run into the connection timeout or win
*/
- fprintf(stderr, "SSL connect error %s\n",
+ lwsl_err("SSL connect error %s\n",
ERR_error_string(ERR_get_error(),
ssl_err_buf));
return 0;
n != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT ||
wsi->use_ssl != 2)) {
- fprintf(stderr, "server's cert didn't "
+ lwsl_err("server's cert didn't "
"look good %d\n", n);
libwebsocket_close_and_free_session(context,
wsi, LWS_CLOSE_STATUS_NOSTATUS);
n = send(wsi->sock, pkt, p - pkt, 0);
if (n < 0) {
- fprintf(stderr, "ERROR writing to client socket\n");
+ lwsl_debug("ERROR writing to client socket\n");
libwebsocket_close_and_free_session(context, wsi,
LWS_CLOSE_STATUS_NOSTATUS);
return 1;
if (pollfd->revents & (POLLERR | POLLHUP)) {
- fprintf(stderr, "Server connection %p (fd=%d) dead\n",
+ lwsl_debug("Server connection %p (fd=%d) dead\n",
(void *)wsi, pollfd->fd);
goto bail3;
return 1;
case LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT:
- fprintf(stderr,
- "LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT\n");
+ lwsl_ext("LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT\n");
break;
case LWS_CONNMODE_WS_CLIENT_PENDING_CANDIDATE_CHILD:
- fprintf(stderr,
- "LWS_CONNMODE_WS_CLIENT_PENDING_CANDIDATE_CHILD\n");
+ lwsl_ext("LWS_CONNMODE_WS_CLIENT_PENDING_CANDIDATE_CHILD\n");
break;
if (pollfd->revents & (POLLERR | POLLHUP)) {
- fprintf(stderr, "Session Socket %p (fd=%d) dead\n",
+ lwsl_debug("Session Socket %p (fd=%d) dead\n",
(void *)wsi, pollfd->fd);
libwebsocket_close_and_free_session(context, wsi,
recv(pollfd->fd, buf, sizeof buf, 0);
if (eff_buf.token_len < 0) {
- fprintf(stderr, "Socket read returned %d\n",
+ lwsl_debug("Socket read returned %d\n",
eff_buf.token_len);
if (errno != EINTR && errno != EAGAIN)
libwebsocket_close_and_free_session(context,
wsi->active_extensions_user[n],
&eff_buf, 0);
if (m < 0) {
- fprintf(stderr,
+ lwsl_ext(
"Extension reports fatal error\n");
libwebsocket_close_and_free_session(
context, wsi,
if (n < 0) {
/*
- fprintf(stderr, "Listen Socket dead\n");
+ lwsl_err("Listen Socket dead\n");
*/
return -1;
}
}
if (n == context->fds_count)
- fprintf(stderr, "libwebsocket_callback_on_writable: "
+ lwsl_err("libwebsocket_callback_on_writable: "
"failed to find socket %d\n", wsi->sock);
/* external POLL support via protocol 0 */
(void *)(long)wsi->sock, NULL, POLLIN);
#if 0
- fprintf(stderr, "libwebsocket_rx_flow_control "
- "unable to find socket\n");
+ lwsl_err("libwebsocket_rx_flow_control unable to find socket\n");
#endif
return 1;
}
char ssl_err_buf[512];
#endif
+ lwsl_info("Initial logging level %d\n", log_level);
+
#ifdef _WIN32
{
WORD wVersionRequested;
if (err != 0) {
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
- fprintf(stderr, "WSAStartup failed with error: %d\n",
- err);
+ lwsl_err("WSAStartup failed with error: %d\n", err);
return NULL;
}
context = (struct libwebsocket_context *) malloc(sizeof(struct libwebsocket_context));
if (!context) {
- fprintf(stderr, "No memory for websocket context\n");
+ lwsl_err("No memory for websocket context\n");
return NULL;
}
context->protocols = protocols;
#else
context->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
if (context->fd_random < 0) {
- fprintf(stderr, "Unable to open random device %s %d\n",
+ lwsl_err("Unable to open random device %s %d\n",
SYSTEM_RANDOM_FILEPATH, context->fd_random);
return NULL;
}
if (strlen(hostname) < sizeof(sa.sa_data) - 1) {
strcpy(sa.sa_data, hostname);
- // fprintf(stderr, "my host name is %s\n", sa.sa_data);
+ // lwsl_debug("my host name is %s\n", sa.sa_data);
n = getnameinfo(&sa, sizeof(sa), hostname,
(sizeof hostname) - 1, NULL, 0, 0);
}
strncpy(context->canonical_hostname, hostname,
sizeof context->canonical_hostname - 1);
- // fprintf(stderr, "context->canonical_hostname = %s\n",
+ // lwsl_debug("context->canonical_hostname = %s\n",
// context->canonical_hostname);
}
p = strchr(context->http_proxy_address, ':');
if (p == NULL) {
- fprintf(stderr, "http_proxy needs to be ads:port\n");
+ lwsl_err("http_proxy needs to be ads:port\n");
return NULL;
}
*p = '\0';
context->http_proxy_port = atoi(p + 1);
- fprintf(stderr, "Using proxy %s:%u\n",
+ lwsl_debug("Using proxy %s:%u\n",
context->http_proxy_address,
context->http_proxy_port);
}
context->use_ssl = ssl_cert_filepath != NULL &&
ssl_private_key_filepath != NULL;
if (context->use_ssl)
- fprintf(stderr, " Compiled with SSL support, "
- "using it\n");
+ lwsl_info(" Compiled with SSL support, using it\n");
else
- fprintf(stderr, " Compiled with SSL support, "
- "not using it\n");
+ lwsl_info(" Compiled with SSL support, not using it\n");
#else
if (ssl_cert_filepath != NULL &&
ssl_private_key_filepath != NULL) {
- fprintf(stderr, " Not compiled for OpenSSl support!\n");
+ lwsl_info(" Not compiled for OpenSSl support!\n");
return NULL;
}
- fprintf(stderr, " Compiled without SSL support, "
+ lwsl_info(" Compiled without SSL support, "
"serving unencrypted\n");
#endif
}
method = (SSL_METHOD *)SSLv23_server_method();
if (!method) {
- fprintf(stderr, "problem creating ssl method: %s\n",
+ lwsl_err("problem creating ssl method: %s\n",
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
}
context->ssl_ctx = SSL_CTX_new(method); /* create context */
if (!context->ssl_ctx) {
- fprintf(stderr, "problem creating ssl context: %s\n",
+ lwsl_err("problem creating ssl context: %s\n",
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
}
if (port == CONTEXT_PORT_NO_LISTEN) {
method = (SSL_METHOD *)SSLv23_client_method();
if (!method) {
- fprintf(stderr, "problem creating ssl method: %s\n",
+ lwsl_err("problem creating ssl method: %s\n",
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
}
/* create context */
context->ssl_client_ctx = SSL_CTX_new(method);
if (!context->ssl_client_ctx) {
- fprintf(stderr, "problem creating ssl context: %s\n",
+ lwsl_err("problem creating ssl context: %s\n",
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
}
if (!SSL_CTX_load_verify_locations(
context->ssl_client_ctx, NULL,
LWS_OPENSSL_CLIENT_CERTS))
- fprintf(stderr,
+ lwsl_err(
"Unable to load SSL Client certs from %s "
"(set by --with-client-cert-dir= in configure) -- "
" client ssl isn't going to work",
if (!SSL_CTX_load_verify_locations(
context->ssl_client_ctx, ssl_ca_filepath,
NULL))
- fprintf(stderr,
+ lwsl_err(
"Unable to load SSL Client certs "
"file from %s -- client ssl isn't "
"going to work", ssl_ca_filepath);
n = SSL_CTX_use_certificate_chain_file(context->ssl_ctx,
ssl_cert_filepath);
if (n != 1) {
- fprintf(stderr, "problem getting cert '%s': %s\n",
+ lwsl_err("problem getting cert '%s': %s\n",
ssl_cert_filepath,
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
/* set the private key from KeyFile */
if (SSL_CTX_use_PrivateKey_file(context->ssl_ctx,
ssl_private_key_filepath, SSL_FILETYPE_PEM) != 1) {
- fprintf(stderr, "ssl problem getting key '%s': %s\n",
+ lwsl_err("ssl problem getting key '%s': %s\n",
ssl_private_key_filepath,
ERR_error_string(ERR_get_error(), ssl_err_buf));
return NULL;
}
/* verify private key */
if (!SSL_CTX_check_private_key(context->ssl_ctx)) {
- fprintf(stderr, "Private SSL key doesn't match cert\n");
+ lwsl_err("Private SSL key doesn't match cert\n");
return NULL;
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
- fprintf(stderr, "ERROR opening socket");
+ lwsl_err("ERROR opening socket");
return NULL;
}
n = bind(sockfd, (struct sockaddr *) &serv_addr,
sizeof(serv_addr));
if (n < 0) {
- fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
+ lwsl_err("ERROR on binding to port %d (%d %d)\n",
port, n, errno);
return NULL;
}
insert_wsi(context, wsi);
listen(sockfd, SOMAXCONN);
- fprintf(stderr, " Listening on port %d\n", port);
+ lwsl_info(" Listening on port %d\n", port);
/* list in the internal poll array */
#else
if (gid != -1)
if (setgid(gid))
- fprintf(stderr, "setgid: %s\n", strerror(errno));
+ lwsl_warn("setgid: %s\n", strerror(errno));
if (uid != -1)
if (setuid(uid))
- fprintf(stderr, "setuid: %s\n", strerror(errno));
+ lwsl_warn("setuid: %s\n", strerror(errno));
#endif
/* set up our internal broadcast trigger sockets per-protocol */
protocols[context->count_protocols].callback;
context->count_protocols++) {
- _debug(" Protocol: %s\n", protocols[context->count_protocols].name);
+ lwsl_parser(" Protocol: %s\n",
+ protocols[context->count_protocols].name);
protocols[context->count_protocols].owning_server = context;
protocols[context->count_protocols].protocol_index =
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
- fprintf(stderr, "ERROR opening socket");
+ lwsl_err("ERROR opening socket");
return NULL;
}
n = bind(fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
if (n < 0) {
- fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
+ lwsl_err("ERROR on binding to port %d (%d %d)\n",
port, n, errno);
return NULL;
}
slen = sizeof cli_addr;
n = getsockname(fd, (struct sockaddr *)&cli_addr, &slen);
if (n < 0) {
- fprintf(stderr, "getsockname failed\n");
+ lwsl_err("getsockname failed\n");
return NULL;
}
protocols[context->count_protocols].broadcast_socket_port =
ntohs(cli_addr.sin_port);
listen(fd, 5);
- _debug(" Protocol %s broadcast socket %d\n",
+ lwsl_debug(" Protocol %s broadcast socket %d\n",
protocols[context->count_protocols].name,
ntohs(cli_addr.sin_port));
if (extensions) {
while (extensions->callback) {
- debug(" Extension: %s\n", extensions->name);
+ lwsl_ext(" Extension: %s\n", extensions->name);
extensions->callback(context, extensions, NULL,
(enum libwebsocket_extension_callback_reasons)m,
NULL, NULL, 0);
for (p = 0; p < context->count_protocols; p++) {
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
- fprintf(stderr, "Unable to create socket\n");
+ lwsl_err("Unable to create socket\n");
return -1;
}
cli_addr.sin_family = AF_INET;
n = connect(fd, (struct sockaddr *)&cli_addr,
sizeof cli_addr);
if (n < 0) {
- fprintf(stderr, "Unable to connect to "
+ lwsl_err("Unable to connect to "
"broadcast socket %d, %s\n",
n, strerror(errno));
return -1;
wsi->user_space = malloc(
wsi->protocol->per_session_data_size);
if (wsi->user_space == NULL) {
- fprintf(stderr, "Out of memory for "
- "conn user space\n");
+ lwsl_err("Out of memory for conn user space\n");
return NULL;
}
memset(wsi->user_space, 0,
}
return wsi->user_space;
}
+
+void _lws_log(int filter, const char *format, ...)
+{
+ va_list ap;
+ int n;
+
+ if (!(log_level & filter))
+ return;
+
+ for (n = 0; n < LLL_COUNT; n++)
+ if (filter == (1 << n)) {
+ fprintf(stderr, "%s: ", log_level_names[n]);
+ break;
+ }
+
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+}
+
+/**
+ * lws_set_log_level() - Set the logging bitfield
+ * @level: OR together the LLL_ debug contexts you want output from
+ *
+ *
+ * defaults to err and warn contexts enabled
+ */
+
+void lws_set_log_level(int level)
+{
+ log_level = level;
+}
+
#define CONTEXT_PORT_NO_LISTEN 0
#define MAX_MUX_RECURSION 2
+enum lws_log_levels {
+ LLL_ERR = 1 << 0,
+ LLL_WARN = 1 << 1,
+ LLL_INFO = 1 << 2,
+ LLL_DEBUG = 1 << 3,
+ LLL_PARSER = 1 << 4,
+ LLL_HEADER = 1 << 5,
+ LLL_EXT = 1 << 6,
+ LLL_CLIENT = 1 << 7,
+
+ LLL_COUNT = 8 /* set to count of valid flags */
+};
+
enum libwebsocket_context_options {
LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK = 1,
LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT = 2,
void * per_context_private_data;
};
-
+LWS_EXTERN
+void lws_set_log_level(int level);
LWS_EXTERN struct libwebsocket_context *
libwebsocket_create_context(int port, const char * interf,
case WSI_TOKEN_HTTP:
case WSI_TOKEN_MUXURL:
- _debug("WSI_TOKEN_(%d) '%c'\n", wsi->parser_state, c);
+ lwsl_parser("WSI_TOKEN_(%d) '%c'\n", wsi->parser_state, c);
/* collect into malloc'd buffers */
/* optional space swallow */
if (wsi->parser_state == WSI_TOKEN_GET_URI && c == ' ') {
wsi->utf8_token[wsi->parser_state].token[
wsi->utf8_token[wsi->parser_state].token_len] = '\0';
-// debug("uri '%s'\n", wsi->utf8_token[wsi->parser_state].token);
+// lwsl_parser("uri '%s'\n", wsi->utf8_token[wsi->parser_state].token);
wsi->parser_state = WSI_TOKEN_SKIPPING;
break;
}
wsi->utf8_token[wsi->parser_state].token[
wsi->utf8_token[wsi->parser_state].token_len] = '\0';
wsi->parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
- _debug("*\n");
+ lwsl_parser("*\n");
break;
}
/* For any supported protocol we have enough payload */
- _debug("Setting WSI_PARSING_COMPLETE\n");
+ lwsl_parser("Setting WSI_PARSING_COMPLETE\n");
wsi->parser_state = WSI_PARSING_COMPLETE;
break;
/* collecting and checking a name part */
case WSI_TOKEN_NAME_PART:
- _debug("WSI_TOKEN_NAME_PART '%c'\n", c);
+ lwsl_parser("WSI_TOKEN_NAME_PART '%c'\n", c);
if (wsi->name_buffer_pos == sizeof(wsi->name_buffer) - 1) {
/* name bigger than we can handle, skip until next */
continue;
if (strcasecmp(lws_tokens[n].token, wsi->name_buffer))
continue;
- _debug("known hdr '%s'\n", wsi->name_buffer);
+ lwsl_parser("known hdr '%s'\n", wsi->name_buffer);
/*
* WSORIGIN is protocol equiv to ORIGIN,
if (wsi->parser_state == WSI_TOKEN_NAME_PART) {
if (c == ':') {
- debug("skipping unknown header '%s'\n",
+ lwsl_parser("skipping unknown header '%s'\n",
wsi->name_buffer);
wsi->parser_state = WSI_TOKEN_SKIPPING;
break;
if (c == ' ' &&
!wsi->utf8_token[WSI_TOKEN_GET_URI].token_len) {
- debug("unknown method '%s'\n",
+ lwsl_parser("unknown method '%s'\n",
wsi->name_buffer);
wsi->parser_state = WSI_TOKEN_GET_URI;
wsi->current_alloc_len = LWS_INITIAL_HDR_ALLOC;
if (!wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len) {
/* they're HTTP headers, not websocket upgrade! */
- _debug("Setting WSI_PARSING_COMPLETE "
+ lwsl_parser("Setting WSI_PARSING_COMPLETE "
"from http headers\n");
wsi->parser_state = WSI_PARSING_COMPLETE;
}
if (wsi->utf8_token[WSI_TOKEN_VERSION].token_len &&
atoi(wsi->utf8_token[WSI_TOKEN_VERSION].token) >= 4) {
- _debug("04 header completed\n");
+ lwsl_parser("04 header completed\n");
wsi->parser_state = WSI_PARSING_COMPLETE;
wsi->utf8_token[WSI_TOKEN_CHALLENGE].token_len = 0;
free(wsi->utf8_token[WSI_TOKEN_CHALLENGE].token);
/* client parser? */
if (wsi->ietf_spec_revision >= 4) {
- _debug("04 header completed\n");
+ lwsl_parser("04 header completed\n");
wsi->parser_state = WSI_PARSING_COMPLETE;
}
/* skipping arg part of a name we didn't recognize */
case WSI_TOKEN_SKIPPING:
- _debug("WSI_TOKEN_SKIPPING '%c'\n", c);
+ lwsl_parser("WSI_TOKEN_SKIPPING '%c'\n", c);
if (c == '\x0d')
wsi->parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
break;
case WSI_TOKEN_SKIPPING_SAW_CR:
- _debug("WSI_TOKEN_SKIPPING_SAW_CR '%c'\n", c);
+ lwsl_parser("WSI_TOKEN_SKIPPING_SAW_CR '%c'\n", c);
if (c == '\x0a')
wsi->parser_state = WSI_TOKEN_NAME_PART;
else
break;
/* we're done, ignore anything else */
case WSI_PARSING_COMPLETE:
- _debug("WSI_PARSING_COMPLETE '%c'\n", c);
+ lwsl_parser("WSI_PARSING_COMPLETE '%c'\n", c);
break;
default: /* keep gcc happy */
int m;
#if 0
- fprintf(stderr, "RX: %02X ", c);
+ lwsl_debug("RX: %02X ", c);
#endif
switch (wsi->lws_rx_parse_state) {
goto handle_first;
default:
- fprintf(stderr, "libwebsocket_rx_sm doesn't know "
+ lwsl_warn("libwebsocket_rx_sm doesn't know "
"about spec version %d\n", wsi->ietf_spec_revision);
break;
}
wsi->opcode = LWS_WS_OPCODE_07__BINARY_FRAME;
break;
default:
- fprintf(stderr, "reserved opcodes not "
+ lwsl_warn("reserved opcodes not "
"usable pre v7 protocol\n");
return -1;
}
c = wsi->xor_mask(wsi, c);
if ((c & 0x80) && wsi->ietf_spec_revision < 7) {
- fprintf(stderr, "Frame has extensions "
- "set illegally 2\n");
+ lwsl_warn("Frame has extensions set illegally 2\n");
/* kill the connection */
return -1;
}
if (wsi->ietf_spec_revision < 7)
c = wsi->xor_mask(wsi, c);
if (c & 0x80) {
- fprintf(stderr, "b63 of length must be zero\n");
+ lwsl_warn("b63 of length must be zero\n");
/* kill the connection */
return -1;
}
if (c)
break;
- _debug("Seen that client is requesting "
+ lwsl_parser("Seen that client is requesting "
"a v76 close, sending ack\n");
buf[0] = 0xff;
buf[1] = 0;
n = libwebsocket_write(wsi, buf, 2, LWS_WRITE_HTTP);
if (n < 0) {
- fprintf(stderr, "ERROR writing to socket");
+ lwsl_warn("ERROR writing to socket");
return -1;
}
- _debug(" v76 close ack sent, server closing skt\n");
+ lwsl_parser(" v76 close ack sent, server closing skt\n");
/* returning < 0 will get it closed in parent */
return -1;
* layer? If so service it and hide it from the user callback
*/
- _debug("spill on %s\n", wsi->protocol->name);
+ lwsl_parser("spill on %s\n", wsi->protocol->name);
switch (wsi->opcode) {
case LWS_WS_OPCODE_07__CLOSE:
* fine he has told us he is closing too, let's
* finish our close
*/
- _debug("seen client close ack\n");
+ lwsl_parser("seen client close ack\n");
return -1;
}
- debug("server sees client close packet\n");
+ lwsl_parser("server sees client close packet\n");
/* parrot the close packet payload back */
n = libwebsocket_write(wsi, (unsigned char *)
&wsi->rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
default:
- _debug("passing opcode %x up to exts\n", wsi->opcode);
+ lwsl_parser("passing opcode %x up to exts\n", wsi->opcode);
/*
* It's something special we can't understand here.
}
if (!handled)
- fprintf(stderr, "Unhandled extended opcode "
+ lwsl_ext("Unhandled extended opcode "
"0x%x - ignoring frame\n", wsi->opcode);
wsi->rx_user_buffer_head = 0;
wsi->active_extensions_user[n],
&eff_buf, 0);
if (m < 0) {
- fprintf(stderr,
+ lwsl_ext(
"Extension '%s' failed to handle payload!",
wsi->active_extensions[n]->name);
return -1;
eff_buf.token,
eff_buf.token_len);
else
- fprintf(stderr, "No callback on payload spill!");
+ lwsl_err("No callback on payload spill!");
}
wsi->rx_user_buffer_head = 0;
illegal_ctl_length:
- fprintf(stderr, "Control frame asking for "
+ lwsl_warn("Control frame asking for "
"extended length is illegal\n");
/* kill the connection */
return -1;
struct lws_tokens eff_buf;
int m;
- _debug(" CRX: %02X %d\n", c, wsi->lws_rx_parse_state);
+ lwsl_parser(" CRX: %02X %d\n", c, wsi->lws_rx_parse_state);
switch (wsi->lws_rx_parse_state) {
case LWS_RXPS_NEW:
LWS_WS_OPCODE_07__BINARY_FRAME;
break;
default:
- fprintf(stderr, "reserved opcodes not "
+ lwsl_warn("reserved opcodes not "
"usable pre v7 protocol\n");
return -1;
}
break;
default:
- fprintf(stderr, "client_rx_sm doesn't know how "
+ lwsl_err("client_rx_sm doesn't know how "
"to handle spec version %02d\n",
wsi->ietf_spec_revision);
break;
case LWS_RXPS_04_FRAME_HDR_LEN:
if ((c & 0x80) && wsi->ietf_spec_revision < 7) {
- fprintf(stderr,
- "Frame has extensions set illegally 4\n");
+ lwsl_warn("Frame has extensions set illegally 4\n");
/* kill the connection */
return -1;
}
case LWS_RXPS_04_FRAME_HDR_LEN64_8:
if (c & 0x80) {
- fprintf(stderr, "b63 of length must be zero\n");
+ lwsl_warn("b63 of length must be zero\n");
/* kill the connection */
return -1;
}
if (c)
break;
- _debug("Seen that client is requesting "
+ lwsl_parser("Seen that client is requesting "
"a v76 close, sending ack\n");
buf[0] = 0xff;
buf[1] = 0;
n = libwebsocket_write(wsi, buf, 2, LWS_WRITE_HTTP);
if (n < 0) {
- fprintf(stderr, "ERROR writing to socket");
+ lwsl_warn("ERROR writing to socket");
return -1;
}
- _debug(" v76 close ack sent, server closing skt\n");
+ lwsl_parser(" v76 close ack sent, server closing skt\n");
/* returning < 0 will get it closed in parent */
return -1;
* fine he has told us he is closing too, let's
* finish our close
*/
- debug("seen server's close ack\n");
+ lwsl_parser("seen server's close ack\n");
return -1;
}
- _debug("client sees server close packet len = %d\n", wsi->rx_user_buffer_head);
+ lwsl_parser("client sees server close packet len = %d\n", wsi->rx_user_buffer_head);
/* parrot the close packet payload back */
n = libwebsocket_write(wsi, (unsigned char *)
&wsi->rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
wsi->rx_user_buffer_head, LWS_WRITE_CLOSE);
- _debug("client writing close ack returned %d\n", n);
+ lwsl_parser("client writing close ack returned %d\n", n);
wsi->state = WSI_STATE_RETURNED_CLOSE_ALREADY;
/* close the connection */
return -1;
default:
- debug("Reserved opcode 0x%2X\n", wsi->opcode);
+ lwsl_parser("Reserved opcode 0x%2X\n", wsi->opcode);
/*
* It's something special we can't understand here.
* Pass the payload up to the extension's parsing
}
if (!handled) {
- fprintf(stderr, "Unhandled extended opcode "
+ lwsl_ext("Unhandled extended opcode "
"0x%x - ignoring frame\n", wsi->opcode);
wsi->rx_user_buffer_head = 0;
wsi->active_extensions_user[n],
&eff_buf, 0);
if (m < 0) {
- fprintf(stderr,
+ lwsl_ext(
"Extension '%s' failed to handle payload!",
wsi->active_extensions[n]->name);
return -1;
wsi->rx_user_buffer_head = 0;
break;
default:
- fprintf(stderr, "client rx illegal state\n");
+ lwsl_err("client rx illegal state\n");
return 1;
}
illegal_ctl_length:
- fprintf(stderr, "Control frame asking for "
+ lwsl_warn("Control frame asking for "
"extended length is illegal\n");
/* kill the connection */
return -1;
size_t n;
#ifdef DEBUG
- fprintf(stderr, "received %d byte packet\n", (int)len);
+ lwsl_parser("received %d byte packet\n", (int)len);
for (n = 0; n < len; n++)
- fprintf(stderr, "%02X ", buf[n]);
- fprintf(stderr, "\n");
+ lwsl_parser("%02X ", buf[n]);
+ lwsl_parser("\n");
#endif
/* let the rx protocol state machine have as much as it needs */
n = libwebsockets_get_random(wsi->protocol->owning_server,
wsi->frame_masking_nonce_04, 4);
if (n != 4) {
- fprintf(stderr, "Unable to read from random device %s %d\n",
+ lwsl_parser("Unable to read from random device %s %d\n",
SYSTEM_RANDOM_FILEPATH, n);
return 1;
}
int m;
int start;
- fprintf(stderr, "\n");
+ lwsl_parser("\n");
for (n = 0; n < len;) {
start = n;
- fprintf(stderr, "%04X: ", start);
+ lwsl_debug("%04X: ", start);
for (m = 0; m < 16 && n < len; m++)
- fprintf(stderr, "%02X ", buf[n++]);
+ lwsl_debug("%02X ", buf[n++]);
while (m++ < 16)
- fprintf(stderr, " ");
+ lwsl_debug(" ");
- fprintf(stderr, " ");
+ lwsl_debug(" ");
for (m = 0; m < 16 && (start + m) < len; m++) {
if (buf[start + m] >= ' ' && buf[start + m] <= 127)
- fprintf(stderr, "%c", buf[start + m]);
+ lwsl_debug("%c", buf[start + m]);
else
- fprintf(stderr, ".");
+ lwsl_debug(".");
}
while (m++ < 16)
- fprintf(stderr, " ");
+ lwsl_debug(" ");
- fprintf(stderr, "\n");
+ lwsl_debug("\n");
}
- fprintf(stderr, "\n");
+ lwsl_debug("\n");
}
int lws_issue_raw(struct libwebsocket *wsi, unsigned char *buf, size_t len)
LWS_EXT_CALLBACK_PACKET_TX_DO_SEND,
wsi->active_extensions_user[n], &buf, len);
if (m < 0) {
- fprintf(stderr, "Extension reports fatal error\n");
+ lwsl_ext("Extension reports fatal error\n");
return -1;
}
if (m) /* handled */ {
-/* fprintf(stderr, "ext sent it\n"); */
+/* lwsl_ext("ext sent it\n"); */
return 0;
}
}
if (!wsi->sock)
- fprintf(stderr, "** error 0 sock but expected to send\n");
+ lwsl_warn("** error 0 sock but expected to send\n");
/*
* nope, send it on the socket directly
*/
#if 0
- fprintf(stderr, " TX: ");
+ lwsl_debug(" TX: ");
lws_stderr_hexdump(buf, len);
#endif
if (wsi->ssl) {
n = SSL_write(wsi->ssl, buf, len);
if (n < 0) {
- fprintf(stderr,
- "ERROR writing to socket\n");
+ lwsl_debug("ERROR writing to socket\n");
return -1;
}
} else {
#endif
n = send(wsi->sock, buf, len, MSG_NOSIGNAL);
if (n < 0) {
- fprintf(stderr,
- "ERROR writing to socket\n");
+ lwsl_debug("ERROR writing to socket\n");
return -1;
}
#ifdef LWS_OPENSSL_SUPPORT
LWS_EXT_CALLBACK_PACKET_TX_PRESEND,
wsi->active_extensions_user[n], &eff_buf, 0);
if (m < 0) {
- fprintf(stderr, "Extension: fatal error\n");
+ lwsl_ext("Extension: fatal error\n");
return -1;
}
if (m)
eff_buf.token_len))
return -1;
- _debug("written %d bytes to client\n", eff_buf.token_len);
+ lwsl_parser("written %d bytes to client\n", eff_buf.token_len);
/* no extension has more to spill */
/* no we could add more */
continue;
- debug("choked\n");
+ lwsl_debug("choked\n");
/*
* Yes, he's choked. Don't spill the rest now get a callback
int m;
if (len == 0 && protocol != LWS_WRITE_CLOSE) {
- fprintf(stderr, "zero length libwebsocket_write attempt\n");
+ lwsl_warn("zero length libwebsocket_write attempt\n");
return 0;
}
switch (wsi->mode) {
case LWS_CONNMODE_WS_SERVING:
/*
- fprintf(stderr, "LWS_WRITE_CLOSE S\n");
+ lwsl_debug("LWS_WRITE_CLOSE S\n");
*/
buf[0] = 'S';
break;
case LWS_CONNMODE_WS_CLIENT:
/*
- fprintf(stderr, "LWS_WRITE_CLOSE C\n");
+ lwsl_debug("LWS_WRITE_CLOSE C\n");
*/
buf[0] = 'C';
break;
n = LWS_WS_OPCODE_07__PONG;
break;
default:
- fprintf(stderr, "libwebsocket_write: unknown write "
+ lwsl_warn("libwebsocket_write: unknown write "
"opcode / protocol\n");
return -1;
}
wsi->xor_mask != xor_no_mask) {
if (libwebsocket_0405_frame_mask_generate(wsi)) {
- fprintf(stderr, "libwebsocket_write: "
+ lwsl_err("libwebsocket_write: "
"frame mask generation failed\n");
return 1;
}
send_raw:
#if 0
- fprintf(stderr, "send %ld: ", len + post);
+ lwsl_debug("send %ld: ", len + post);
for (n = -pre; n < ((int)len + post); n++)
- fprintf(stderr, "%02X ", buf[n]);
+ lwsl_debug("%02X ", buf[n]);
- fprintf(stderr, "\n");
+ lwsl_debug("\n");
#endif
if (protocol == LWS_WRITE_HTTP) {
#include <openssl/sha.h>
#endif
-
#include "libwebsockets.h"
-#if 0
-#define _DEBUG
-#endif
+extern void _lws_log(int filter, const char *format, ...);
+/* warn and log are always compiled in */
+#define lwsl_warn(...) _lws_log(LLL_WARN, __VA_ARGS__)
+#define lwsl_err(...) _lws_log(LLL_ERR, __VA_ARGS__)
+
+/*
+ * weaker logging can be deselected at configure time using disable_debug
+ * that gets rid of the overhead of checking while keeping _warn and _err
+ * active
+ */
#ifdef _DEBUG
-#ifdef WIN32
-#define _debug(...) lws_log(LWS_LOG_DEBUG, __VA_ARGS__)
-#else
-static inline
+#define lwsl_info(...) _lws_log(LLL_INFO, __VA_ARGS__)
+#define lwsl_debug(...) _lws_log(LLL_DEBUG, __VA_ARGS__)
+#define lwsl_parser(...) _lws_log(LLL_PARSER, __VA_ARGS__)
+#define lwsl_header(...) _lws_log(LLL_HEADER, __VA_ARGS__)
+#define lwsl_ext(...) _lws_log(LLL_HEADER, __VA_ARGS__)
+#define lwsl_client(...) _lws_log(LLL_CLIENT, __VA_ARGS__)
+#else /* no debug */
+#define lwsl_info(...)
+#define lwsl_debug(...)
+#define lwsl_parser(...)
+#define lwsl_header(...)
+#define lwsl_ext(...)
+#define lwsl_client(...)
#endif
-void debug(const char *format, ...)
-{
- va_list ap;
- va_start(ap, format); vfprintf(stderr, format, ap); va_end(ap);
-}
-#else
-#ifdef WIN32
-#define _debug(...)
-#else
-static inline
-void _debug(const char *format, ...)
-{
-}
-#endif
-#endif
-
/*
* Mac OSX as well as iOS do not define the MSG_NOSIGNAL flag,
"just work".
</blockquote>
<hr>
+<h2>lws_set_log_level - Set the logging bitfield</h2>
+<i>void</i>
+<b>lws_set_log_level</b>
+(<i>int</i> <b>level</b>)
+<h3>Arguments</h3>
+<dl>
+<dt><b>level</b>
+<dd>OR together the LLL_ debug contexts you want output from
+</dl>
+<h3>Description</h3>
+<blockquote>
+<p>
+defaults to err and warn contexts enabled
+</blockquote>
+<hr>
<h2>libwebsocket_write - Apply protocol then write data to client</h2>
<i>int</i>
<b>libwebsocket_write</b>
projects / platform / upstream / libwebsockets.git / commitdiff