--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/components/websocket/websocket.c Sat Oct 20 13:23:15 2018 +0200
@@ -0,0 +1,318 @@
+/**
+ * @file websocket.c
+ * @brief Websocket functions.
+ * @author Blake Felt - blake.w.felt@gmail.com`
+ */
+
+#include "websocket.h"
+#include "lwip/tcp.h" // for the netconn structure
+#include "esp_system.h" // for esp_random
+#include "esp_log.h"
+#include "mbedtls/base64.h"
+#include "mbedtls/sha1.h"
+#include <string.h>
+
+static const char *TAG = "websoket";
+
+ws_client_t ws_connect_client(struct netconn* conn,
+ char* url,
+ void (*ccallback)(WEBSOCKET_TYPE_t type,char* msg,uint64_t len),
+ void (*scallback)(uint8_t num,WEBSOCKET_TYPE_t type,char* msg,uint64_t len)
+ ) {
+ ws_client_t client;
+ client.conn = conn;
+ client.connected = true;
+ client.url = url;
+ client.ping = 0;
+ client.last_opcode = 0;
+ client.contin = NULL;
+ client.len = 0;
+ client.unfinished = 0;
+ client.ccallback = ccallback;
+ client.scallback = scallback;
+ return client;
+}
+
+void ws_disconnect_client(ws_client_t* client) {
+ ws_send(client,WEBSOCKET_OPCODE_CLOSE,NULL,0,1); // tell the client to close
+ if(client->conn) {
+ client->conn->callback = NULL; // shut off the callback
+ netconn_close(client->conn);
+ netconn_delete(client->conn);
+ client->conn = NULL;
+ }
+ client->connected = false;
+ client->url = NULL;
+ client->last_opcode = 0;
+ if(client->len) {
+ if(client->contin)
+ free(client->contin);
+ client->len = 0;
+ }
+ client->ccallback = NULL;
+ client->scallback = NULL;
+}
+
+bool ws_is_connected(ws_client_t client) {
+ if (client.conn && client.connected)
+ return 1;
+ return 0;
+}
+
+static void ws_generate_mask(ws_header_t* header) {
+ header->param.bit.MASK = 1;
+ header->key.full = esp_random(); // generate a random 32 bit number
+}
+
+static void ws_encrypt_decrypt(char* msg,ws_header_t header) {
+ if(header.param.bit.MASK) {
+ for(uint64_t i=0; i<header.length; i++) {
+ msg[i] ^= header.key.part[i%4];
+ }
+ }
+}
+
+
+
+err_t ws_send(ws_client_t* client,WEBSOCKET_OPCODES_t opcode,char* msg,uint64_t len,bool mask)
+{
+ static char *out;
+ static char *encrypt;
+ static uint64_t pos;
+ static uint64_t true_len;
+ ws_header_t header;
+ static err_t err;
+
+ header.param.pos.ZERO = 0; // reset the whole header
+ header.param.pos.ONE = 0;
+
+ header.param.bit.FIN = 1; // all pieces are done (you don't need a huge message anyway...)
+ header.param.bit.OPCODE = opcode;
+ // populate LEN field
+ pos = 2;
+ header.length = len;
+ if (len<125) {
+ header.param.bit.LEN = len;
+ } else if (len < 65536) {
+ header.param.bit.LEN = 126;
+ pos += 2;
+ } else {
+ header.param.bit.LEN = 127;
+ pos += 8;
+ }
+
+ if (mask) {
+ ws_generate_mask(&header); // get a key
+ encrypt = malloc(len); // allocate memory for the encryption
+ memcpy(encrypt,msg,len);
+ ws_encrypt_decrypt(encrypt,header); // encrypt it!
+ pos += 4; // add the position
+ }
+
+ true_len = pos+len; // get the length of the entire message
+ pos = 2;
+ out = malloc(true_len); // allocate dat memory
+
+ if (out == NULL) {
+ ESP_LOGE(TAG, "ws_send malloc error for %llu bytes", true_len);
+ return ERR_MEM;
+ }
+
+ out[0] = header.param.pos.ZERO; // save header
+ out[1] = header.param.pos.ONE;
+
+ // put in the length, if necessary
+ if(header.param.bit.LEN == 126) {
+ out[2] = (len >> 8) & 0xFF;
+ out[3] = (len ) & 0xFF;
+ pos = 4;
+ }
+ if(header.param.bit.LEN == 127) {
+ //memcpy(&out[2],&len,8);
+ out[2] = (len >> 56) & 0xFF;
+ out[3] = (len >> 48) & 0xFF;
+ out[4] = (len >> 40) & 0xFF;
+ out[5] = (len >> 32) & 0xFF;
+ out[6] = (len >> 24) & 0xFF;
+ out[7] = (len >> 16) & 0xFF;
+ out[8] = (len >> 8) & 0xFF;
+ out[9] = (len) & 0xFF;
+ pos = 10;
+ }
+
+ if(mask) {
+ out[pos] = header.key.part[0]; pos++;
+ out[pos] = header.key.part[1]; pos++;
+ out[pos] = header.key.part[2]; pos++;
+ out[pos] = header.key.part[3]; pos++;
+ memcpy(&out[pos],encrypt,len); // put in the encrypted message
+ free(encrypt);
+ } else {
+ memcpy(&out[pos],msg,len);
+ }
+
+ err = netconn_write(client->conn,out,true_len,NETCONN_COPY); // finally! send it.
+ if (err != ERR_OK) {
+ client->connected = false;
+ ESP_LOGE(TAG, "ws_send netconn_write error %d", err);
+ }
+ free(out); // free the entire message
+ return err;
+}
+
+
+
+char* ws_read(ws_client_t* client,ws_header_t* header)
+{
+ char *ret, *append;
+ err_t err;
+ struct netbuf *inbuf, *inbuf2;
+ char *buf, *buf2;
+ uint16_t len, len2;
+ uint64_t pos, cont_len, cont_pos;
+
+ // if we read from this previously (not cont frames), stop reading
+ if(client->unfinished) {
+ client->unfinished--;
+ return NULL;
+ }
+
+ err = netconn_recv(client->conn,&inbuf);
+ if (err != ERR_OK) {
+ client->connected = false;
+ ESP_LOGE(TAG, "ws_read netconn_recv error %d", err);
+ return NULL;
+ }
+ netbuf_data(inbuf,(void**)&buf, &len);
+ if(!buf) return NULL;
+
+ // get the header
+ header->param.pos.ZERO = buf[0];
+ header->param.pos.ONE = buf[1];
+
+ // get the message length
+ pos = 2;
+ if(header->param.bit.LEN < 125) {
+ header->length = header->param.bit.LEN;
+ } else if(header->param.bit.LEN == 126) {
+ header->length = buf[2] << 8 | buf[3];
+ pos = 4;
+ } else { // LEN = 127
+ header->length = (uint64_t)buf[2] << 56 | (uint64_t)buf[3] << 48
+ | (uint64_t)buf[4] << 40 | (uint64_t)buf[5] << 32
+ | (uint64_t)buf[6] << 24 | (uint64_t)buf[7] << 16
+ | (uint64_t)buf[8] << 8 | (uint64_t)buf[9];
+ pos = 10;
+ }
+
+ if(header->param.bit.MASK) {
+ memcpy(&(header->key.full),&buf[pos],4); // extract the key
+ pos += 4;
+ }
+
+ ret = malloc(header->length+1); // allocate memory, plus a byte
+ if(!ret) {
+ ESP_LOGE(TAG, "ws_read malloc error for %llu bytes", header->length+1);
+ netbuf_delete(inbuf);
+ header->received = 0;
+ return NULL;
+ }
+
+ cont_len = len-pos; // get the actual length
+ memcpy(ret,&buf[pos],header->length); // allocate the total memory
+ cont_pos = cont_len; // get the initial position
+
+ // netconn gives messages in pieces, so we need to get those (different than OPCODE_CONT)
+ while(cont_len < header->length) { // while the actual length is less than the header stated
+ err = netconn_recv(client->conn,&inbuf2);
+ if (err != ERR_OK) {
+ ESP_LOGE(TAG, "ws_read netconn_recv error %d", err);
+ netbuf_delete(inbuf2);
+ free(ret);
+ client->unfinished = 0;
+ client->connected = false;
+ header->received = 0;
+ return NULL;
+ }
+
+ netbuf_data(inbuf2,(void**)&buf2, &len2);
+ memcpy(&ret[cont_pos],buf2,len2);
+ cont_pos += len2;
+ if (!buf2) {
+ client->unfinished = 0;
+ header->received = 0;
+ }
+ netbuf_delete(inbuf2);
+ client->unfinished++;
+ cont_len += len2;
+ }
+
+ ret[header->length] = '\0'; // end string
+ ws_encrypt_decrypt(ret,*header); // unencrypt, if necessary
+
+ if(header->param.bit.FIN == 0) { // if the message isn't done
+ if((header->param.bit.OPCODE == WEBSOCKET_OPCODE_CONT) &&
+ ((client->last_opcode==WEBSOCKET_OPCODE_BIN) || (client->last_opcode==WEBSOCKET_OPCODE_TEXT))) {
+ cont_len = header->length + client->len;
+ append = malloc(cont_len);
+ memcpy(append,client->contin,client->len);
+ memcpy(&append[client->len],ret,header->length);
+ free(client->contin);
+ client->contin = malloc(cont_len);
+ client->len = cont_len;
+
+ free(append);
+ free(ret);
+ netbuf_delete(inbuf);
+ //free(buf);
+ return NULL;
+ }
+ else if((header->param.bit.OPCODE==WEBSOCKET_OPCODE_BIN) || (header->param.bit.OPCODE==WEBSOCKET_OPCODE_TEXT)) {
+ if(client->len) {
+ free(client->contin);
+ }
+ client->contin = malloc(header->length);
+ memcpy(client->contin,ret,header->length);
+ client->len = header->length;
+ client->last_opcode = header->param.bit.OPCODE;
+
+ free(ret);
+ netbuf_delete(inbuf);
+ //free(buf);
+ return NULL;
+ }
+ else { // there shouldn't be another FIN code....
+ free(ret);
+ netbuf_delete(inbuf);
+ //free(buf);
+ return NULL;
+ }
+ }
+ client->last_opcode = header->param.bit.OPCODE;
+ if(inbuf) netbuf_delete(inbuf);
+ header->received = 1;
+ return ret;
+}
+
+char* ws_hash_handshake(char* handshake,uint8_t len) {
+ const char hash[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+ const uint8_t hash_len = sizeof(hash);
+ char* ret;
+ char key[64];
+ unsigned char sha1sum[20];
+ unsigned int ret_len;
+
+ if(!len) return NULL;
+ ret = malloc(32);
+
+ memcpy(key,handshake,len);
+ strlcpy(&key[len],hash,sizeof(key));
+ mbedtls_sha1((unsigned char*)key,len+hash_len-1,sha1sum);
+ mbedtls_base64_encode(NULL, 0, &ret_len, sha1sum, 20);
+ if(!mbedtls_base64_encode((unsigned char*)ret,32,&ret_len,sha1sum,20)) {
+ ret[ret_len] = '\0';
+ return ret;
+ }
+ free(ret);
+ return NULL;
+}