#include "ws.h"
-#include <pthread.h>
#ifndef _MSC_VER
#include <fcntl.h>
#endif
-#ifndef _MSC_VER
-#define ms_sleep(x) usleep( x * 1000);
-#else
-#define ms_sleep(x) Sleep( x );
-#endif
-
#define SHA1_HASH_SIZE 20
-struct ws_globals_s ws_globals;
+struct globals_s globals;
#ifndef WSS_STANDALONE
OpenSSL_add_all_algorithms(); /* load & register cryptos */
SSL_load_error_strings(); /* load all error messages */
- ws_globals.ssl_method = TLSv1_server_method(); /* create server instance */
- ws_globals.ssl_ctx = SSL_CTX_new(ws_globals.ssl_method); /* create context */
- assert(ws_globals.ssl_ctx);
+ globals.ssl_method = TLSv1_server_method(); /* create server instance */
+ globals.ssl_ctx = SSL_CTX_new(globals.ssl_method); /* create context */
+ assert(globals.ssl_ctx);
/* set the local certificate from CertFile */
- SSL_CTX_use_certificate_file(ws_globals.ssl_ctx, ws_globals.cert, SSL_FILETYPE_PEM);
+ SSL_CTX_use_certificate_file(globals.ssl_ctx, globals.cert, SSL_FILETYPE_PEM);
/* set the private key from KeyFile */
- SSL_CTX_use_PrivateKey_file(ws_globals.ssl_ctx, ws_globals.key, SSL_FILETYPE_PEM);
+ SSL_CTX_use_PrivateKey_file(globals.ssl_ctx, globals.key, SSL_FILETYPE_PEM);
/* verify private key */
- if ( !SSL_CTX_check_private_key(ws_globals.ssl_ctx) ) {
+ if ( !SSL_CTX_check_private_key(globals.ssl_ctx) ) {
abort();
- }
+ }
- SSL_CTX_set_cipher_list(ws_globals.ssl_ctx, "HIGH:!DSS:!aNULL@STRENGTH");
+ SSL_CTX_set_cipher_list(globals.ssl_ctx, "HIGH:!DSS:!aNULL@STRENGTH");
thread_setup();
}
*/
do {
- if(!strncmp(p,name,strlen(name)) && *(p+strlen(name))==':') break;
+ if(!strncmp(p,name,strlen(name)) && *(p+strlen(name))==':') break;
} while((p = (strstr(p,"\n")+1))!=(char *)1);
if (p != (char *)1 && *p!='\0') {
- char *v, *e = 0;
+ char *v, *e = 0;
- v = strchr(p, ':');
- if (v) {
- v++;
- while(v && *v == ' ') {
+ v = strchr(p, ':');
+ if (v) {
+ v++;
+ while(v && *v == ' ') {
v++;
- }
- if (v) {
+ }
+ if (v) {
e = strchr(v, '\r');
if (!e) {
e = strchr(v, '\n');
}
- }
+ }
- if (v && e) {
- int cplen;
+ if (v && e) {
+ size_t cplen;
size_t len = e - v;
if (len > buflen - 1) {
strncpy(buf, v, cplen);
*(buf+cplen) = '\0';
return 1;
- }
-
- }
+ }
+
+ }
}
return 0;
}
#endif
-int ws_handshake(wsh_t *wsh)
+int ws_handshake_kvp(wsh_t *wsh, char *key, char *version, char *proto)
{
- char key[256] = "";
- char version[5] = "";
- char proto[256] = "";
- char proto_buf[384] = "";
- char uri[256] = "";
char input[256] = "";
unsigned char output[SHA1_HASH_SIZE] = "";
char b64[256] = "";
char respond[512] = "";
- ssize_t bytes;
- char *p, *e = 0;
- if (wsh->sock == ws_sock_invalid) {
+ if (!wsh->tsession) {
return -3;
}
- while((bytes = ws_raw_read(wsh, wsh->buffer + wsh->datalen, wsh->buflen - wsh->datalen)) > 0) {
- wsh->datalen += bytes;
- if (strstr(wsh->buffer, "\r\n\r\n") || strstr(wsh->buffer, "\n\n")) {
- break;
- }
- }
-
- if (bytes > sizeof(wsh->buffer) -1) {
+ if (!*key || !*version || !*proto) {
goto err;
}
- *(wsh->buffer+bytes) = '\0';
-
- if (strncasecmp(wsh->buffer, "GET ", 4)) {
- goto err;
- }
-
- p = wsh->buffer + 4;
-
- e = strchr(p, ' ');
- if (!e) {
- goto err;
- }
-
- strncpy(uri, p, e-p);
-
- cheezy_get_var(wsh->buffer, "Sec-WebSocket-Key", key, sizeof(key));
- cheezy_get_var(wsh->buffer, "Sec-WebSocket-Version", version, sizeof(version));
- cheezy_get_var(wsh->buffer, "Sec-WebSocket-Protocol", proto, sizeof(proto));
-
- if (!*key) {
- goto err;
- }
-
snprintf(input, sizeof(input), "%s%s", key, WEBSOCKET_GUID);
sha1_digest(output, input);
b64encode((unsigned char *)output, SHA1_HASH_SIZE, (unsigned char *)b64, sizeof(b64));
- if (*proto) {
- snprintf(proto_buf, sizeof(proto_buf), "Sec-WebSocket-Protocol: %s\r\n", proto);
- }
-
snprintf(respond, sizeof(respond),
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n"
- "%s\r\n",
+ "Sec-WebSocket-Protocol: %s\r\n\r\n",
b64,
- proto_buf);
+ proto);
-
- ws_raw_write(wsh, respond, strlen(respond));
- wsh->handshake = 1;
-
- return 0;
+ if (ws_raw_write(wsh, respond, strlen(respond))) {
+ wsh->handshake = 1;
+ return 0;
+ }
err:
snprintf(respond, sizeof(respond), "HTTP/1.1 400 Bad Request\r\n"
"Sec-WebSocket-Version: 13\r\n\r\n");
- //printf("ERR:\n%s\n", respond);
-
-
ws_raw_write(wsh, respond, strlen(respond));
ws_close(wsh, WS_NONE);
}
-ssize_t ws_raw_read(wsh_t *wsh, void *data, size_t bytes)
+issize_t ws_raw_read(wsh_t *wsh, void *data, size_t bytes)
{
- ssize_t r;
- int err = 0;
+ issize_t r;
+ TConn *conn = wsh->tsession->connP;
- if (wsh->ssl) {
- do {
- r = SSL_read(wsh->ssl, data, bytes);
-#ifndef _MSC_VER
- if (wsh->x++) usleep(10000);
-#else
- if (wsh->x++) Sleep(10);
-#endif
- if (r == -1) {
- err = SSL_get_error(wsh->ssl, r);
+ if (!wsh->handshake) {
+ r = wsh->tsession->connP->buffersize;
+ memcpy(data, conn->buffer.b, r);
+ printf("%s\n", conn->buffer.t);
+ ConnReadInit(conn);
+ return r;
+ } else {
+ const char *readError = NULL;
- if (wsh->handshake && err == SSL_ERROR_WANT_READ) {
- r = -2;
- goto end;
- }
- }
+ // printf(" pos=%d size=%d need=%d\n", conn->bufferpos, conn->buffersize, bytes);
- } while (r == -1 && err == SSL_ERROR_WANT_READ && wsh->x < 100);
+ r = conn->buffersize - conn->bufferpos;
- goto end;
- }
+ if (r < 0) {
+ printf("286 Read Error %d!\n", r);
+ return 0;
+ } else if (r == 0) {
+ ConnRead(conn, 2, NULL, NULL, &readError);
+
+ if (readError) {
+ // printf("292 Read Error %s\n", readError);
+ free((void *)readError);
+ return 0;
+ }
- do {
- r = recv(wsh->sock, data, bytes, 0);
-#ifndef _MSC_VER
- if (wsh->x++) usleep(10000);
-#else
- if (wsh->x++) Sleep(10);
-#endif
- } while (r == -1 && xp_is_blocking(xp_errno()) && wsh->x < 100);
-
- if (wsh->x >= 100) {
- r = -1;
- }
+ r = conn->buffersize - conn->bufferpos;
+ }
- end:
+ if (r <= (issize_t)bytes) {
+ memcpy(data, conn->buffer.b + conn->bufferpos, r);
+ // ConnReadInit(conn);
+ conn->bufferpos = conn->buffersize;
+ ConnReadInit(conn);
+ return r;
+ } else {
+ memcpy(data, conn->buffer.b + conn->bufferpos, bytes);
+ conn->bufferpos += (uint32_t)bytes;
+ return (issize_t)bytes;
+ }
- if (r > 0) {
- *((char *)data + r) = '\0';
}
- if (r >= 0) {
- wsh->x = 0;
- }
-
- return r;
}
-ssize_t ws_raw_write(wsh_t *wsh, void *data, size_t bytes)
+issize_t ws_raw_write(wsh_t *wsh, void *data, size_t bytes)
{
size_t r;
if (wsh->ssl) {
do {
- r = SSL_write(wsh->ssl, data, bytes);
- } while (r == -1 && SSL_get_error(wsh->ssl, r) == SSL_ERROR_WANT_WRITE);
-
- return r;
- }
-
- do {
- r = send(wsh->sock, data, bytes, 0);
- } while (r == -1 && xp_is_blocking(xp_errno()));
+ r = SSL_write(wsh->ssl, data, (int)bytes);
+ } while (r == -1 && SSL_get_error(wsh->ssl, (int)r) == SSL_ERROR_WANT_WRITE);
- //if (r<0) {
- //printf("wRITE FAIL: %s\n", strerror(errno));
- //}
-
- return r;
-}
-
-#ifdef _MSC_VER
-static int setup_socket(ws_socket_t sock)
-{
- unsigned long v = 1;
-
- if (ioctlsocket(sock, FIONBIO, &v) == SOCKET_ERROR) {
- return -1;
+ return (issize_t)r;
}
- return 0;
-
-}
-
-static int restore_socket(ws_socket_t sock)
-{
- unsigned long v = 0;
-
- if (ioctlsocket(sock, FIONBIO, &v) == SOCKET_ERROR) {
- return -1;
- }
-
- return 0;
-
-}
-
-#else
-
-static int setup_socket(ws_socket_t sock)
-{
- int flags = fcntl(sock, F_GETFL, 0);
- return fcntl(sock, F_SETFL, flags | O_NONBLOCK);
-}
-
-static int restore_socket(ws_socket_t sock)
-{
- int flags = fcntl(sock, F_GETFL, 0);
-
- flags &= ~O_NONBLOCK;
-
- return fcntl(sock, F_SETFL, flags);
-
-}
-
-#endif
-
-
-static int establish_logical_layer(wsh_t *wsh)
-{
-
- if (!wsh->sanity) {
- return -1;
- }
-
- if (wsh->logical_established) {
+ if (ConnWrite(wsh->tsession->connP, data, (uint32_t)bytes)) {
+ return (issize_t)bytes;
+ } else {
return 0;
}
-
- if (wsh->secure && !wsh->secure_established) {
- int code;
-
- if (!wsh->ssl) {
- wsh->ssl = SSL_new(wsh->ssl_ctx);
- assert(wsh->ssl);
-
- SSL_set_fd(wsh->ssl, wsh->sock);
- }
-
- do {
- code = SSL_accept(wsh->ssl);
-
- if (code == 1) {
- wsh->secure_established = 1;
- break;
- }
-
- if (code == 0) {
- return -1;
- }
-
- if (code < 0) {
- if (code == -1 && SSL_get_error(wsh->ssl, code) != SSL_ERROR_WANT_READ) {
- return -1;
- }
- }
-
- if (wsh->block) {
- ms_sleep(10);
- } else {
- ms_sleep(1);
- }
-
- wsh->sanity--;
-
- if (!wsh->block) {
- return -2;
- }
-
- } while (wsh->sanity > 0);
-
- if (!wsh->sanity) {
- return -1;
- }
-
- }
-
- while (!wsh->down && !wsh->handshake) {
- int r = ws_handshake(wsh);
-
- if (r < 0) {
- wsh->down = 1;
- return -1;
- }
-
- if (!wsh->handshake && !wsh->block) {
- return -2;
- }
-
- }
-
- wsh->logical_established = 1;
-
- return 0;
}
-
-int ws_init(wsh_t *wsh, ws_socket_t sock, SSL_CTX *ssl_ctx, int close_sock, int block)
+wsh_t * ws_init(ws_tsession_t *tsession)
{
- memset(wsh, 0, sizeof(*wsh));
+ wsh_t *wsh = (wsh_t *)malloc(sizeof(*wsh));
- wsh->sock = sock;
- wsh->block = block;
- wsh->sanity = 5000;
- wsh->ssl_ctx = ssl_ctx;
-
- if (!ssl_ctx) {
- ssl_ctx = ws_globals.ssl_ctx;
- }
-
- if (close_sock) {
- wsh->close_sock = 1;
- }
+ if (!wsh) return NULL;
+ memset(wsh, 0, sizeof(*wsh));
+ wsh->tsession = tsession;
wsh->buflen = sizeof(wsh->buffer);
- wsh->secure = ssl_ctx ? 1 : 0;
- setup_socket(sock);
-
- if (establish_logical_layer(wsh) == -1) {
- return -1;
- }
-
- if (wsh->down) {
- return -1;
- }
-
- return 0;
+ return wsh;
}
void ws_destroy(wsh_t *wsh)
}
}
-ssize_t ws_close(wsh_t *wsh, int16_t reason)
+issize_t ws_close(wsh_t *wsh, int16_t reason)
{
if (wsh->down) {
}
wsh->down = 1;
-
- if (reason && wsh->sock != ws_sock_invalid) {
- uint16_t *u16;
- uint8_t fr[4] = {WSOC_CLOSE | 0x80, 2, 0};
-
- u16 = (uint16_t *) &fr[2];
- *u16 = htons((int16_t)reason);
- ws_raw_write(wsh, fr, 4);
- }
-
- restore_socket(wsh->sock);
-
- if (wsh->close_sock && wsh->sock != ws_sock_invalid) {
- close(wsh->sock);
- }
-
- wsh->sock = ws_sock_invalid;
return reason * -1;
-
}
-ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
+issize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
{
- ssize_t need = 2;
+ issize_t need = 2;
char *maskp;
- int ll = 0;
again:
need = 2;
maskp = NULL;
*data = NULL;
- ll = establish_logical_layer(wsh);
-
- if (ll < 0) {
- return ll;
- }
-
if (wsh->down) {
return -1;
}
return ws_close(wsh, WS_PROTO_ERR);
}
- if ((wsh->datalen = ws_raw_read(wsh, wsh->buffer, 9)) < 0) {
- if (wsh->datalen == -2) {
- return -2;
- }
- return ws_close(wsh, WS_PROTO_ERR);
- }
-
- if (wsh->datalen < need) {
- if ((wsh->datalen += ws_raw_read(wsh, wsh->buffer + wsh->datalen, 9 - wsh->datalen)) < need) {
- /* too small - protocol err */
+ if ((wsh->datalen = ws_raw_read(wsh, wsh->buffer, 14)) < need) {
+ while (!wsh->down && (wsh->datalen += ws_raw_read(wsh, wsh->buffer + wsh->datalen, 14 - wsh->datalen)) < need) ;
+
+ if (0 && (wsh->datalen += ws_raw_read(wsh, wsh->buffer + wsh->datalen, 14 - wsh->datalen)) < need) {
+ /* too small - protocol err */
return ws_close(wsh, WS_PROTO_ERR);
}
}
wsh->plen = wsh->buffer[1] & 0x7f;
wsh->payload = &wsh->buffer[2];
-
+
if (wsh->plen == 127) {
uint64_t *u64;
need = (wsh->plen - (wsh->datalen - need));
- if (need < 0) {
- /* invalid read - protocol err .. */
- *oc = WSOC_CLOSE;
- return ws_close(wsh, WS_PROTO_ERR);
- }
-
- if ((need + wsh->datalen) > (ssize_t)wsh->buflen) {
+ if ((need + wsh->datalen) > (issize_t)wsh->buflen) {
/* too big - Ain't nobody got time fo' dat */
*oc = WSOC_CLOSE;
return ws_close(wsh, WS_DATA_TOO_BIG);
wsh->rplen = wsh->plen - need;
while(need) {
- ssize_t r = ws_raw_read(wsh, wsh->payload + wsh->rplen, need);
+ issize_t r = ws_raw_read(wsh, wsh->payload + wsh->rplen, need);
if (r < 1) {
/* invalid read - protocol err .. */
}
if (mask && maskp) {
- ssize_t i;
+ issize_t i;
for (i = 0; i < wsh->datalen; i++) {
wsh->payload[i] ^= maskp[i % 4];
}
}
-ssize_t ws_feed_buf(wsh_t *wsh, void *data, size_t bytes)
+issize_t ws_feed_buf(wsh_t *wsh, void *data, size_t bytes)
{
if (bytes + wsh->wdatalen > wsh->buflen) {
memcpy(wsh->wbuffer + wsh->wdatalen, data, bytes);
- wsh->wdatalen += bytes;
+ wsh->wdatalen += (issize_t)bytes;
- return bytes;
+ return (issize_t)bytes;
}
-ssize_t ws_send_buf(wsh_t *wsh, ws_opcode_t oc)
+issize_t ws_send_buf(wsh_t *wsh, ws_opcode_t oc)
{
- ssize_t r = 0;
+ issize_t r = 0;
if (!wsh->wdatalen) {
return -1;
}
-ssize_t ws_write_frame(wsh_t *wsh, ws_opcode_t oc, void *data, size_t bytes)
+issize_t ws_write_frame(wsh_t *wsh, ws_opcode_t oc, void *data, size_t bytes)
{
uint8_t hdr[14] = { 0 };
size_t hlen = 2;
*u64 = htonl(bytes);
}
- if (ws_raw_write(wsh, (void *) &hdr[0], hlen) != (ssize_t)hlen) {
+ if (ws_raw_write(wsh, (void *) &hdr[0], hlen) != (issize_t)hlen) {
return -1;
}
- if (ws_raw_write(wsh, data, bytes) != (ssize_t)bytes) {
+ if (ws_raw_write(wsh, data, bytes) != (issize_t)bytes) {
return -2;
}
- return bytes;
+ return (issize_t)bytes;
}
-#ifdef _MSC_VER
-
-int xp_errno(void)
-{
- return WSAGetLastError();
-}
-int xp_is_blocking(int errcode)
-{
- return errcode == WSAEWOULDBLOCK || errcode == WSAEINPROGRESS;
-}
-
-#else
-
-int xp_errno(void)
-{
- return errno;
-}
-
-int xp_is_blocking(int errcode)
-{
- return errcode == EAGAIN || errcode == EWOULDBLOCK || errcode == EINPROGRESS || errcode == EINTR || errcode == ETIMEDOUT;
-}
-
-#endif
projects / thirdparty / freeswitch.git / commitdiff
