static int handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi) { static const char *websocket_magic_guid_04 = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; static const char *websocket_magic_guid_04_masking = "61AC5F19-FBBA-4540-B96F-6561F1AB40A8"; char accept_buf[MAX_WEBSOCKET_04_KEY_LEN + 37]; char nonce_buf[256]; char mask_summing_buf[256 + MAX_WEBSOCKET_04_KEY_LEN + 37]; unsigned char hash[20]; int n; char *response; char *p; char *m = mask_summing_buf; int nonce_len = 0; int accept_len; char *c; char ext_name[128]; struct libwebsocket_extension * ext; int ext_count = 0; int more = 1; if (!wsi->utf8_token[WSI_TOKEN_HOST].token_len || !wsi->utf8_token[WSI_TOKEN_KEY].token_len) { debug("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 " "than max supported %d\n", MAX_WEBSOCKET_04_KEY_LEN); goto bail; } strcpy(accept_buf, wsi->utf8_token[WSI_TOKEN_KEY].token); strcpy(accept_buf + wsi->utf8_token[WSI_TOKEN_KEY].token_len, websocket_magic_guid_04); SHA1((unsigned char *)accept_buf, wsi->utf8_token[WSI_TOKEN_KEY].token_len + strlen(websocket_magic_guid_04), hash); 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"); goto bail; } /* allocate the per-connection user memory (if any) */ if (wsi->protocol->per_session_data_size) { 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"); goto bail; } } else wsi->user_space = NULL; /* create the response packet */ /* make a buffer big enough for everything */ response = malloc(256 + wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len + 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"); goto bail; } p = response; strcpy(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a"); p += strlen("HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a"); strcpy(p, "Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); p += strlen("Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); strcpy(p, accept_buf); p += accept_len; if (wsi->ietf_spec_revision == 4) { strcpy(p, "\x0d\x0aSec-WebSocket-Nonce: "); p += strlen("\x0d\x0aSec-WebSocket-Nonce: "); /* select the nonce */ n = libwebsockets_get_random(wsi->protocol->owning_server, hash, 16); if (n != 16) { fprintf(stderr, "Unable to read random device %s %d\n", SYSTEM_RANDOM_FILEPATH, n); if (wsi->user_space) free(wsi->user_space); goto bail; } /* encode the nonce */ 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"); if (wsi->user_space) free(wsi->user_space); goto bail; } /* apply the nonce */ strcpy(p, nonce_buf); p += nonce_len; } if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token) { strcpy(p, "\x0d\x0aSec-WebSocket-Protocol: "); p += strlen("\x0d\x0aSec-WebSocket-Protocol: "); strcpy(p, wsi->utf8_token[WSI_TOKEN_PROTOCOL].token); p += wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len; } /* * Figure out which extensions the client has that we want to * enable on this connection, and give him back the list */ if (wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len) { strcpy(p, "\x0d\x0aSec-WebSocket-Extensions: "); p += strlen("\x0d\x0aSec-WebSocket-Extensions: "); /* * break down the list of client extensions * and go through them */ c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token; fprintf(stderr, "wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token = %s\n", wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token); wsi->count_active_extensions = 0; n = 0; while (more) { if (*c && (*c != ',' && *c != ' ' && *c != '\t')) { ext_name[n] = *c++; if (n < sizeof(ext_name) - 1) n++; continue; } ext_name[n] = '\0'; if (!*c) more = 0; else { c++; if (!n) continue; } /* check a client's extension against our support */ ext = wsi->protocol->owning_server->extensions; while (ext && ext->callback) { if (strcmp(ext_name, ext->name)) { ext++; continue; } /* * oh, we do support this one he * asked for... but let's ask user * code if it's OK to apply it on this * particular connection + protocol */ n = wsi->protocol->owning_server-> protocols[0].callback( wsi->protocol->owning_server, wsi, LWS_CALLBACK_CONFIRM_EXTENSION_OKAY, wsi->user_space, ext_name, 0); /* * zero return from callback means * go ahead and allow the extension, * it's what we get if the callback is * unhandled */ if (n) { ext++; continue; } /* apply it */ if (ext_count) *p++ = ','; p += sprintf(p, "%s", ext_name); ext_count++; /* instantiate the extension on this conn */ wsi->active_extensions_user[ wsi->count_active_extensions] = malloc(ext->per_session_data_size); memset(wsi->active_extensions_user[ wsi->count_active_extensions], 0, ext->per_session_data_size); wsi->active_extensions[ wsi->count_active_extensions] = ext; /* allow him to construct his context */ ext->callback(wsi->protocol->owning_server, ext, wsi, LWS_EXT_CALLBACK_CONSTRUCT, wsi->active_extensions_user[ wsi->count_active_extensions], NULL, 0); wsi->count_active_extensions++; fprintf(stderr, "wsi->count_active_extensions <- %d", wsi->count_active_extensions); ext++; } n = 0; } } /* end of response packet */ strcpy(p, "\x0d\x0a\x0d\x0a"); p += strlen("\x0d\x0a\x0d\x0a"); if (wsi->ietf_spec_revision == 4) { /* * precompute the masking key the client will use from the SHA1 * hash of ( base 64 client key we were sent, concatenated with * the bse 64 nonce we sent, concatenated with a magic constant * guid specified by the 04 standard ) * * We store the hash in the connection's wsi ready to use with * undoing the masking the client has done on framed data it * sends (we send our data to the client in clear). */ strcpy(mask_summing_buf, wsi->utf8_token[WSI_TOKEN_KEY].token); m += wsi->utf8_token[WSI_TOKEN_KEY].token_len; strcpy(m, nonce_buf); m += nonce_len; strcpy(m, websocket_magic_guid_04_masking); m += strlen(websocket_magic_guid_04_masking); SHA1((unsigned char *)mask_summing_buf, m - mask_summing_buf, wsi->masking_key_04); } if (!lws_any_extension_handled(context, wsi, LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX, response, p - response)) { /* okay send the handshake response accepting the connection */ debug("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"); goto bail; } } /* alright clean up and set ourselves into established state */ free(response); wsi->state = WSI_STATE_ESTABLISHED; wsi->lws_rx_parse_state = LWS_RXPS_NEW; wsi->rx_packet_length = 0; /* notify user code that we're ready to roll */ if (wsi->protocol->callback) wsi->protocol->callback(wsi->protocol->owning_server, wsi, LWS_CALLBACK_ESTABLISHED, wsi->user_space, NULL, 0); return 0; bail: return -1; }
int handshake_0405(struct lws_context *context, struct lws *wsi) { unsigned char hash[20]; int n; char *response; char *p; int accept_len; if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST) || !lws_hdr_total_length(wsi, WSI_TOKEN_KEY)) { lwsl_parser("handshake_04 missing pieces\n"); /* completed header processing, but missing some bits */ goto bail; } if (lws_hdr_total_length(wsi, WSI_TOKEN_KEY) >= MAX_WEBSOCKET_04_KEY_LEN) { lwsl_warn("Client key too long %d\n", MAX_WEBSOCKET_04_KEY_LEN); goto bail; } /* * since key length is restricted above (currently 128), cannot * overflow */ n = sprintf((char *)context->serv_buf, "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", lws_hdr_simple_ptr(wsi, WSI_TOKEN_KEY)); lws_SHA1(context->serv_buf, n, hash); accept_len = lws_b64_encode_string((char *)hash, 20, (char *)context->serv_buf, sizeof(context->serv_buf)); if (accept_len < 0) { lwsl_warn("Base64 encoded hash too long\n"); goto bail; } /* allocate the per-connection user memory (if any) */ if (lws_ensure_user_space(wsi)) goto bail; /* create the response packet */ /* make a buffer big enough for everything */ response = (char *)context->serv_buf + MAX_WEBSOCKET_04_KEY_LEN + LWS_SEND_BUFFER_PRE_PADDING; p = response; LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a" "Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); strcpy(p, (char *)context->serv_buf); p += accept_len; if (lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL)) { LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: "); n = lws_hdr_copy(wsi, p, 128, WSI_TOKEN_PROTOCOL); if (n < 0) goto bail; p += n; } #ifndef LWS_NO_EXTENSIONS /* * Figure out which extensions the client has that we want to * enable on this connection, and give him back the list */ if (lws_extension_server_handshake(wsi, &p)) goto bail; #endif //LWS_CPYAPP(p, "\x0d\x0a""An-unknown-header: blah"); /* end of response packet */ LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a"); if (!lws_any_extension_handled(wsi, LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX, response, p - response)) { /* okay send the handshake response accepting the connection */ lwsl_parser("issuing resp pkt %d len\n", (int)(p - response)); #ifdef DEBUG fwrite(response, 1, p - response, stderr); #endif 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"); goto bail; } } /* alright clean up and set ourselves into established state */ wsi->state = LWSS_ESTABLISHED; wsi->lws_rx_parse_state = LWS_RXPS_NEW; /* notify user code that we're ready to roll */ if (wsi->protocol->callback) if (wsi->protocol->callback(wsi, LWS_CALLBACK_ESTABLISHED, wsi->user_space, #ifdef LWS_OPENSSL_SUPPORT wsi->ssl, #else NULL, #endif 0)) goto bail; return 0; bail: /* free up his parsing allocations */ lws_free_header_table(wsi); return -1; }
int handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi) { unsigned char hash[20]; int n; char *response; char *p; int accept_len; #ifndef LWS_NO_EXTENSIONS char *c; char ext_name[128]; struct libwebsocket_extension *ext; int ext_count = 0; int more = 1; #endif if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST) || !lws_hdr_total_length(wsi, WSI_TOKEN_KEY)) { lwsl_parser("handshake_04 missing pieces\n"); /* completed header processing, but missing some bits */ goto bail; } if (lws_hdr_total_length(wsi, WSI_TOKEN_KEY) >= MAX_WEBSOCKET_04_KEY_LEN) { lwsl_warn("Client key too long %d\n", MAX_WEBSOCKET_04_KEY_LEN); goto bail; } /* * since key length is restricted above (currently 128), cannot * overflow */ n = sprintf((char *)context->service_buffer, "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", lws_hdr_simple_ptr(wsi, WSI_TOKEN_KEY)); SHA1(context->service_buffer, n, hash); accept_len = lws_b64_encode_string((char *)hash, 20, (char *)context->service_buffer, sizeof(context->service_buffer)); if (accept_len < 0) { lwsl_warn("Base64 encoded hash too long\n"); goto bail; } /* allocate the per-connection user memory (if any) */ if (libwebsocket_ensure_user_space(wsi)) goto bail; /* create the response packet */ /* make a buffer big enough for everything */ response = (char *)context->service_buffer + MAX_WEBSOCKET_04_KEY_LEN; p = response; LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a" "Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); strcpy(p, (char *)context->service_buffer); p += accept_len; if (lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL)) { LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: "); n = lws_hdr_copy(wsi, p, 128, WSI_TOKEN_PROTOCOL); if (n < 0) goto bail; p += n; } #ifndef LWS_NO_EXTENSIONS /* * Figure out which extensions the client has that we want to * enable on this connection, and give him back the list */ if (lws_hdr_total_length(wsi, WSI_TOKEN_EXTENSIONS)) { /* * break down the list of client extensions * and go through them */ if (lws_hdr_copy(wsi, (char *)context->service_buffer, sizeof(context->service_buffer), WSI_TOKEN_EXTENSIONS) < 0) goto bail; c = (char *)context->service_buffer; lwsl_parser("WSI_TOKEN_EXTENSIONS = '%s'\n", c); wsi->count_active_extensions = 0; n = 0; while (more) { if (*c && (*c != ',' && *c != ' ' && *c != '\t')) { ext_name[n] = *c++; if (n < sizeof(ext_name) - 1) n++; continue; } ext_name[n] = '\0'; if (!*c) more = 0; else { c++; if (!n) continue; } /* check a client's extension against our support */ ext = wsi->protocol->owning_server->extensions; while (ext && ext->callback) { if (strcmp(ext_name, ext->name)) { ext++; continue; } /* * oh, we do support this one he * asked for... but let's ask user * code if it's OK to apply it on this * particular connection + protocol */ n = wsi->protocol->owning_server-> protocols[0].callback( wsi->protocol->owning_server, wsi, LWS_CALLBACK_CONFIRM_EXTENSION_OKAY, wsi->user_space, ext_name, 0); /* * zero return from callback means * go ahead and allow the extension, * it's what we get if the callback is * unhandled */ if (n) { ext++; continue; } /* apply it */ if (ext_count) *p++ = ','; else LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Extensions: "); p += sprintf(p, "%s", ext_name); ext_count++; /* instantiate the extension on this conn */ wsi->active_extensions_user[ wsi->count_active_extensions] = malloc(ext->per_session_data_size); if (wsi->active_extensions_user[ wsi->count_active_extensions] == NULL) { lwsl_err("Out of mem\n"); free(response); goto bail; } memset(wsi->active_extensions_user[ wsi->count_active_extensions], 0, ext->per_session_data_size); wsi->active_extensions[ wsi->count_active_extensions] = ext; /* allow him to construct his context */ ext->callback(wsi->protocol->owning_server, ext, wsi, LWS_EXT_CALLBACK_CONSTRUCT, wsi->active_extensions_user[ wsi->count_active_extensions], NULL, 0); wsi->count_active_extensions++; lwsl_parser("count_active_extensions <- %d\n", wsi->count_active_extensions); ext++; } n = 0; } } #endif /* end of response packet */ LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a"); if (!lws_any_extension_handled(context, wsi, LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX, response, p - response)) { /* okay send the handshake response accepting the connection */ lwsl_parser("issuing resp pkt %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 != (p - response)) { lwsl_debug("handshake_0405: ERROR writing to socket\n"); goto bail; } } /* alright clean up and set ourselves into established state */ wsi->state = WSI_STATE_ESTABLISHED; wsi->lws_rx_parse_state = LWS_RXPS_NEW; /* notify user code that we're ready to roll */ if (wsi->protocol->callback) wsi->protocol->callback(wsi->protocol->owning_server, wsi, LWS_CALLBACK_ESTABLISHED, wsi->user_space, NULL, 0); return 0; bail: /* free up his parsing allocations */ if (wsi->u.hdr.ah) free(wsi->u.hdr.ah); return -1; }
int handshake_0405(struct lws_context *context, struct lws *wsi) { struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi]; unsigned char hash[20]; int n, accept_len; char *response; char *p; if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST) || !lws_hdr_total_length(wsi, WSI_TOKEN_KEY)) { lwsl_parser("handshake_04 missing pieces\n"); /* completed header processing, but missing some bits */ goto bail; } if (lws_hdr_total_length(wsi, WSI_TOKEN_KEY) >= MAX_WEBSOCKET_04_KEY_LEN) { lwsl_warn("Client key too long %d\n", MAX_WEBSOCKET_04_KEY_LEN); goto bail; } /* * since key length is restricted above (currently 128), cannot * overflow */ n = sprintf((char *)pt->serv_buf, "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", lws_hdr_simple_ptr(wsi, WSI_TOKEN_KEY)); lws_SHA1(pt->serv_buf, n, hash); accept_len = lws_b64_encode_string((char *)hash, 20, (char *)pt->serv_buf, context->pt_serv_buf_size); if (accept_len < 0) { lwsl_warn("Base64 encoded hash too long\n"); goto bail; } /* allocate the per-connection user memory (if any) */ if (lws_ensure_user_space(wsi)) goto bail; /* create the response packet */ /* make a buffer big enough for everything */ response = (char *)pt->serv_buf + MAX_WEBSOCKET_04_KEY_LEN + LWS_PRE; p = response; LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a" "Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); strcpy(p, (char *)pt->serv_buf); p += accept_len; /* we can only return the protocol header if: * - one came in, and ... */ if (lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL) && /* - it is not an empty string */ wsi->protocol->name && wsi->protocol->name[0]) { LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: "); p += lws_snprintf(p, 128, "%s", wsi->protocol->name); } #ifndef LWS_NO_EXTENSIONS /* * Figure out which extensions the client has that we want to * enable on this connection, and give him back the list. * * Give him a limited write bugdet */ if (lws_extension_server_handshake(wsi, &p, 192)) goto bail; #endif //LWS_CPYAPP(p, "\x0d\x0a""An-unknown-header: blah"); /* end of response packet */ LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a"); if (!lws_any_extension_handled(wsi, LWS_EXT_CB_HANDSHAKE_REPLY_TX, response, p - response)) { /* okay send the handshake response accepting the connection */ lwsl_parser("issuing resp pkt %d len\n", (int)(p - response)); #if defined(DEBUG) && ! defined(LWS_WITH_ESP8266) fwrite(response, 1, p - response, stderr); #endif 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"); goto bail; } } /* alright clean up and set ourselves into established state */ wsi->state = LWSS_ESTABLISHED; wsi->lws_rx_parse_state = LWS_RXPS_NEW; { const char * uri_ptr = lws_hdr_simple_ptr(wsi, WSI_TOKEN_GET_URI); int uri_len = lws_hdr_total_length(wsi, WSI_TOKEN_GET_URI); const struct lws_http_mount *hit = lws_find_mount(wsi, uri_ptr, uri_len); if (hit && hit->cgienv && wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP_PMO, wsi->user_space, (void *)hit->cgienv, 0)) return 1; } return 0; bail: /* caller will free up his parsing allocations */ return -1; }
int handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi) { static const char *websocket_magic_guid_04 = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; char accept_buf[MAX_WEBSOCKET_04_KEY_LEN + 37]; unsigned char hash[20]; int n; char *response; char *p; int accept_len; #ifndef LWS_NO_EXTENSIONS char *c; char ext_name[128]; struct libwebsocket_extension *ext; int ext_count = 0; int more = 1; #endif if (!wsi->utf8_token[WSI_TOKEN_HOST].token_len || !wsi->utf8_token[WSI_TOKEN_KEY].token_len) { 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) { lwsl_warn("Client sent handshake key longer " "than max supported %d\n", MAX_WEBSOCKET_04_KEY_LEN); goto bail; } strcpy(accept_buf, wsi->utf8_token[WSI_TOKEN_KEY].token); strcpy(accept_buf + wsi->utf8_token[WSI_TOKEN_KEY].token_len, websocket_magic_guid_04); SHA1((unsigned char *)accept_buf, wsi->utf8_token[WSI_TOKEN_KEY].token_len + strlen(websocket_magic_guid_04), hash); accept_len = lws_b64_encode_string((char *)hash, 20, accept_buf, sizeof accept_buf); if (accept_len < 0) { lwsl_warn("Base64 encoded hash too long\n"); goto bail; } /* allocate the per-connection user memory (if any) */ if (wsi->protocol->per_session_data_size && !libwebsocket_ensure_user_space(wsi)) goto bail; /* create the response packet */ /* make a buffer big enough for everything */ response = (char *)malloc(256 + wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len + wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len + wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len); if (!response) { lwsl_err("Out of memory for response buffer\n"); goto bail; } p = response; LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a" "Upgrade: WebSocket\x0d\x0a" "Connection: Upgrade\x0d\x0a" "Sec-WebSocket-Accept: "); strcpy(p, accept_buf); p += accept_len; if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token) { LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: "); LWS_CPYAPP_TOKEN(p, WSI_TOKEN_PROTOCOL); } #ifndef LWS_NO_EXTENSIONS /* * Figure out which extensions the client has that we want to * enable on this connection, and give him back the list */ if (wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len) { /* * break down the list of client extensions * and go through them */ c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token; 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; while (more) { if (*c && (*c != ',' && *c != ' ' && *c != '\t')) { ext_name[n] = *c++; if (n < sizeof(ext_name) - 1) n++; continue; } ext_name[n] = '\0'; if (!*c) more = 0; else { c++; if (!n) continue; } /* check a client's extension against our support */ ext = wsi->protocol->owning_server->extensions; while (ext && ext->callback) { if (strcmp(ext_name, ext->name)) { ext++; continue; } /* * oh, we do support this one he * asked for... but let's ask user * code if it's OK to apply it on this * particular connection + protocol */ n = wsi->protocol->owning_server-> protocols[0].callback( wsi->protocol->owning_server, wsi, LWS_CALLBACK_CONFIRM_EXTENSION_OKAY, wsi->user_space, ext_name, 0); /* * zero return from callback means * go ahead and allow the extension, * it's what we get if the callback is * unhandled */ if (n) { ext++; continue; } /* apply it */ if (ext_count) *p++ = ','; else LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Extensions: "); p += sprintf(p, "%s", ext_name); ext_count++; /* instantiate the extension on this conn */ wsi->active_extensions_user[ wsi->count_active_extensions] = malloc(ext->per_session_data_size); if (wsi->active_extensions_user[ wsi->count_active_extensions] == NULL) { lwsl_err("Out of mem\n"); free(response); goto bail; } memset(wsi->active_extensions_user[ wsi->count_active_extensions], 0, ext->per_session_data_size); wsi->active_extensions[ wsi->count_active_extensions] = ext; /* allow him to construct his context */ ext->callback(wsi->protocol->owning_server, ext, wsi, LWS_EXT_CALLBACK_CONSTRUCT, wsi->active_extensions_user[ wsi->count_active_extensions], NULL, 0); wsi->count_active_extensions++; lwsl_parser("wsi->count_active_extensions <- %d\n", wsi->count_active_extensions); ext++; } n = 0; } } #endif /* end of response packet */ LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a"); #ifndef LWS_NO_EXTENSIONS if (!lws_any_extension_handled(context, wsi, LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX, response, p - response)) #endif { /* okay send the handshake response accepting the connection */ 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) { lwsl_debug("handshake_0405: ERROR writing to socket\n"); goto bail; } } /* alright clean up and set ourselves into established state */ free(response); wsi->state = WSI_STATE_ESTABLISHED; wsi->lws_rx_parse_state = LWS_RXPS_NEW; wsi->u.ws.rx_packet_length = 0; /* notify user code that we're ready to roll */ if (wsi->protocol->callback) wsi->protocol->callback(wsi->protocol->owning_server, wsi, LWS_CALLBACK_ESTABLISHED, wsi->user_space, NULL, 0); return 0; bail: return -1; }