2 * Copyright (C) 2016, 2017 "IoT.bzh"
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * This work is a far adaptation of apache-websocket:
19 * origin: https://github.com/disconnect/apache-websocket
20 * commit: cfaef071223f11ba016bff7e1e4b7c9e5df45b50
21 * Copyright 2010-2012 self.disconnect (APACHE-2)
32 #if !defined(WEBSOCKET_DEFAULT_MAXLENGTH)
33 # define WEBSOCKET_DEFAULT_MAXLENGTH 1048500 /* 76 less than 1M, probably enougth for headers */
36 #define FRAME_GET_FIN(BYTE) (((BYTE) >> 7) & 0x01)
37 #define FRAME_GET_RSV1(BYTE) (((BYTE) >> 6) & 0x01)
38 #define FRAME_GET_RSV2(BYTE) (((BYTE) >> 5) & 0x01)
39 #define FRAME_GET_RSV3(BYTE) (((BYTE) >> 4) & 0x01)
40 #define FRAME_GET_OPCODE(BYTE) ( (BYTE) & 0x0F)
41 #define FRAME_GET_MASK(BYTE) (((BYTE) >> 7) & 0x01)
42 #define FRAME_GET_PAYLOAD_LEN(BYTE) ( (BYTE) & 0x7F)
44 #define FRAME_SET_FIN(BYTE) (((BYTE) & 0x01) << 7)
45 #define FRAME_SET_RSV1(BYTE) (((BYTE) & 0x01) << 6)
46 #define FRAME_SET_RSV2(BYTE) (((BYTE) & 0x01) << 5)
47 #define FRAME_SET_RSV3(BYTE) (((BYTE) & 0x01) << 4)
48 #define FRAME_SET_OPCODE(BYTE) ((BYTE) & 0x0F)
49 #define FRAME_SET_MASK(BYTE) (((BYTE) & 0x01) << 7)
50 #define FRAME_SET_LENGTH(X64, IDX) (unsigned char)((sizeof(X64)) <= (IDX) ? 0 : (((X64) >> ((IDX)*8)) & 0xFF))
52 #define OPCODE_CONTINUATION 0x0
53 #define OPCODE_TEXT 0x1
54 #define OPCODE_BINARY 0x2
55 #define OPCODE_CLOSE 0x8
56 #define OPCODE_PING 0x9
57 #define OPCODE_PONG 0xA
61 #define STATE_LENGTH 2
64 static size_t default_maxlength = WEBSOCKET_DEFAULT_MAXLENGTH;
72 unsigned char header[14]; /* 2 + 8 + 4 */
73 const struct websock_itf *itf;
77 static ssize_t ws_writev(struct websock *ws, const struct iovec *iov, int iovcnt)
79 return ws->itf->writev(ws->closure, iov, iovcnt);
82 static ssize_t ws_readv(struct websock *ws, const struct iovec *iov, int iovcnt)
84 return ws->itf->readv(ws->closure, iov, iovcnt);
88 static ssize_t ws_write(struct websock *ws, const void *buffer, size_t buffer_size)
91 iov.iov_base = (void *)buffer; /* const cast */
92 iov.iov_len = buffer_size;
93 return ws_writev(ws, &iov, 1);
97 static ssize_t ws_read(struct websock *ws, void *buffer, size_t buffer_size)
100 iov.iov_base = buffer;
101 iov.iov_len = buffer_size;
102 return ws_readv(ws, &iov, 1);
105 static int websock_send_internal_v(struct websock *ws, unsigned char first, const struct iovec *iovec, int count)
107 struct iovec iov[32];
109 size_t pos, size, len;
111 unsigned char header[32];
114 if (count < 0 || (count + 1) > (int)(sizeof iov / sizeof * iov)) {
119 /* computes the size */
122 for (j = 0 ; j < count ; j++) {
123 iov[i].iov_base = iovec[j].iov_base;
124 len = iovec[j].iov_len;
126 iov[i].iov_len = len;
132 /* makes the header */
134 header[pos++] = first;
135 size = (uint64_t) size;
137 header[pos++] = FRAME_SET_MASK(0) | FRAME_SET_LENGTH(size, 0);
140 header[pos++] = FRAME_SET_MASK(0) | 126;
142 header[pos++] = FRAME_SET_MASK(0) | 127;
143 header[pos++] = FRAME_SET_LENGTH(size, 7);
144 header[pos++] = FRAME_SET_LENGTH(size, 6);
145 header[pos++] = FRAME_SET_LENGTH(size, 5);
146 header[pos++] = FRAME_SET_LENGTH(size, 4);
147 header[pos++] = FRAME_SET_LENGTH(size, 3);
148 header[pos++] = FRAME_SET_LENGTH(size, 2);
150 header[pos++] = FRAME_SET_LENGTH(size, 1);
151 header[pos++] = FRAME_SET_LENGTH(size, 0);
154 /* allocates the vec */
155 iov[0].iov_base = header;
156 iov[0].iov_len = pos;
157 rc = ws_writev(ws, iov, i);
159 return rc < 0 ? -1 : 0;
162 static int websock_send_internal(struct websock *ws, unsigned char first, const void *buffer, size_t size)
166 iov.iov_base = (void *)buffer;
168 return websock_send_internal_v(ws, first, &iov, 1);
171 static inline int websock_send_v(struct websock *ws, int last, int rsv1, int rsv2, int rsv3, int opcode, const struct iovec *iovec, int count)
173 unsigned char first = (unsigned char)(FRAME_SET_FIN(last)
174 | FRAME_SET_RSV1(rsv1)
175 | FRAME_SET_RSV1(rsv2)
176 | FRAME_SET_RSV1(rsv3)
177 | FRAME_SET_OPCODE(opcode));
178 return websock_send_internal_v(ws, first, iovec, count);
181 static inline int websock_send(struct websock *ws, int last, int rsv1, int rsv2, int rsv3, int opcode, const void *buffer, size_t size)
183 unsigned char first = (unsigned char)(FRAME_SET_FIN(last)
184 | FRAME_SET_RSV1(rsv1)
185 | FRAME_SET_RSV1(rsv2)
186 | FRAME_SET_RSV1(rsv3)
187 | FRAME_SET_OPCODE(opcode));
188 return websock_send_internal(ws, first, buffer, size);
191 int websock_close_empty(struct websock *ws)
193 return websock_close(ws, WEBSOCKET_CODE_NOT_SET, NULL, 0);
196 int websock_close(struct websock *ws, uint16_t code, const void *data, size_t length)
198 unsigned char buffer[2];
201 if (code == WEBSOCKET_CODE_NOT_SET && length == 0)
202 return websock_send(ws, 1, 0, 0, 0, OPCODE_CLOSE, NULL, 0);
204 /* checks the length */
210 /* prepare the buffer */
211 buffer[0] = (unsigned char)((code >> 8) & 0xFF);
212 buffer[1] = (unsigned char)(code & 0xFF);
214 /* Send server-side closing handshake */
215 iov[0].iov_base = (void *)buffer;
217 iov[1].iov_base = (void *)data;
218 iov[1].iov_len = length;
219 return websock_send_v(ws, 1, 0, 0, 0, OPCODE_CLOSE, iov, 2);
222 int websock_ping(struct websock *ws, const void *data, size_t length)
224 /* checks the length */
230 return websock_send(ws, 1, 0, 0, 0, OPCODE_PING, data, length);
233 int websock_pong(struct websock *ws, const void *data, size_t length)
235 /* checks the length */
241 return websock_send(ws, 1, 0, 0, 0, OPCODE_PONG, data, length);
244 int websock_text(struct websock *ws, int last, const void *text, size_t length)
246 return websock_send(ws, last, 0, 0, 0, OPCODE_TEXT, text, length);
249 int websock_text_v(struct websock *ws, int last, const struct iovec *iovec, int count)
251 return websock_send_v(ws, last, 0, 0, 0, OPCODE_TEXT, iovec, count);
254 int websock_binary(struct websock *ws, int last, const void *data, size_t length)
256 return websock_send(ws, last, 0, 0, 0, OPCODE_BINARY, data, length);
259 int websock_binary_v(struct websock *ws, int last, const struct iovec *iovec, int count)
261 return websock_send_v(ws, last, 0, 0, 0, OPCODE_BINARY, iovec, count);
264 int websock_continue(struct websock *ws, int last, const void *data, size_t length)
266 return websock_send(ws, last, 0, 0, 0, OPCODE_CONTINUATION, data, length);
269 int websock_continue_v(struct websock *ws, int last, const struct iovec *iovec, int count)
271 return websock_send_v(ws, last, 0, 0, 0, OPCODE_CONTINUATION, iovec, count);
274 int websock_error(struct websock *ws, uint16_t code, const void *data, size_t size)
276 int rc = websock_close(ws, code, data, size);
277 if (ws->itf->on_error != NULL)
278 ws->itf->on_error(ws->closure, code, data, size);
282 static int read_header(struct websock *ws)
284 if (ws->lenhead < ws->szhead) {
286 ws_read(ws, &ws->header[ws->lenhead], (size_t)(ws->szhead - ws->lenhead));
289 ws->lenhead += (int)rbc;
294 static int check_control_header(struct websock *ws)
297 if (FRAME_GET_RSV1(ws->header[0]) != 0)
299 if (FRAME_GET_RSV2(ws->header[0]) != 0)
301 if (FRAME_GET_RSV3(ws->header[0]) != 0)
303 if (FRAME_GET_PAYLOAD_LEN(ws->header[1]) > 125)
305 if (FRAME_GET_OPCODE(ws->header[0]) == OPCODE_CLOSE)
306 return FRAME_GET_PAYLOAD_LEN(ws->header[1]) != 1;
310 int websock_dispatch(struct websock *ws, int loop)
318 ws->state = STATE_START;
322 /* read the header */
325 else if (ws->lenhead < ws->szhead)
328 switch (FRAME_GET_OPCODE(ws->header[0])) {
329 case OPCODE_CONTINUATION:
334 if (!check_control_header(ws))
336 if (FRAME_GET_PAYLOAD_LEN(ws->header[1]))
341 if (!check_control_header(ws))
346 /* update heading size */
347 switch (FRAME_GET_PAYLOAD_LEN(ws->header[1])) {
355 ws->szhead += 4 * FRAME_GET_MASK(ws->header[1]);
357 ws->state = STATE_LENGTH;
361 /* continue to read the header */
364 else if (ws->lenhead < ws->szhead)
368 switch (FRAME_GET_PAYLOAD_LEN(ws->header[1])) {
370 ws->length = (((uint64_t) ws->header[2]) << 56)
371 | (((uint64_t) ws->header[3]) << 48)
372 | (((uint64_t) ws->header[4]) << 40)
373 | (((uint64_t) ws->header[5]) << 32)
374 | (((uint64_t) ws->header[6]) << 24)
375 | (((uint64_t) ws->header[7]) << 16)
376 | (((uint64_t) ws->header[8]) << 8)
377 | (uint64_t) ws->header[9];
380 ws->length = (((uint64_t) ws->header[2]) << 8)
381 | (uint64_t) ws->header[3];
384 ws->length = FRAME_GET_PAYLOAD_LEN(ws->header[1]);
387 if (FRAME_GET_OPCODE(ws->header[0]) == OPCODE_CLOSE && ws->length != 0)
389 if (ws->length > ws->maxlength)
393 if (FRAME_GET_MASK(ws->header[1])) {
394 ((unsigned char *)&ws->mask)[0] = ws->header[ws->szhead - 4];
395 ((unsigned char *)&ws->mask)[1] = ws->header[ws->szhead - 3];
396 ((unsigned char *)&ws->mask)[2] = ws->header[ws->szhead - 2];
397 ((unsigned char *)&ws->mask)[3] = ws->header[ws->szhead - 1];
401 /* all heading fields are known, process */
402 ws->state = STATE_DATA;
403 if (ws->itf->on_extension != NULL) {
404 if (ws->itf->on_extension(ws->closure,
405 FRAME_GET_FIN(ws->header[0]),
406 FRAME_GET_RSV1(ws->header[0]),
407 FRAME_GET_RSV2(ws->header[0]),
408 FRAME_GET_RSV3(ws->header[0]),
409 FRAME_GET_OPCODE(ws->header[0]),
410 (size_t) ws->length)) {
415 /* not an extension case */
416 if (FRAME_GET_RSV1(ws->header[0]) != 0)
418 if (FRAME_GET_RSV2(ws->header[0]) != 0)
420 if (FRAME_GET_RSV3(ws->header[0]) != 0)
424 switch (FRAME_GET_OPCODE(ws->header[0])) {
425 case OPCODE_CONTINUATION:
426 ws->itf->on_continue(ws->closure,
427 FRAME_GET_FIN(ws->header[0]),
428 (size_t) ws->length);
433 ws->itf->on_text(ws->closure,
434 FRAME_GET_FIN(ws->header[0]),
435 (size_t) ws->length);
440 ws->itf->on_binary(ws->closure,
441 FRAME_GET_FIN(ws->header[0]),
442 (size_t) ws->length);
448 code = WEBSOCKET_CODE_NOT_SET;
450 code = (uint16_t)(ws->header[ws->szhead - 2] & 0xff);
451 code = (uint16_t)(code << 8);
452 code = (uint16_t)(code | (uint16_t)(ws->header[ws->szhead - 1] & 0xff));
454 ws->itf->on_close(ws->closure, code, (size_t) ws->length);
457 if (ws->itf->on_ping)
458 ws->itf->on_ping(ws->closure, ws->length);
461 websock_pong(ws, NULL, 0);
463 ws->state = STATE_INIT;
468 if (ws->itf->on_pong)
469 ws->itf->on_pong(ws->closure, ws->length);
472 ws->state = STATE_INIT;
484 ws->state = STATE_INIT;
490 websock_error(ws, WEBSOCKET_CODE_MESSAGE_TOO_LARGE, NULL, 0);
494 websock_error(ws, WEBSOCKET_CODE_PROTOCOL_ERROR, NULL, 0);
498 static void unmask(struct websock * ws, void *buffer, size_t size)
505 while (size && ((sizeof(uint32_t) - 1) & (uintptr_t) b8)) {
506 m = ((uint8_t *) & mask)[0];
507 ((uint8_t *) & mask)[0] = ((uint8_t *) & mask)[1];
508 ((uint8_t *) & mask)[1] = ((uint8_t *) & mask)[2];
509 ((uint8_t *) & mask)[2] = ((uint8_t *) & mask)[3];
510 ((uint8_t *) & mask)[3] = m;
514 b32 = (uint32_t *) b8;
515 while (size >= sizeof(uint32_t)) {
517 size -= sizeof(uint32_t);
519 b8 = (uint8_t *) b32;
521 m = ((uint8_t *) & mask)[0];
522 ((uint8_t *) & mask)[0] = ((uint8_t *) & mask)[1];
523 ((uint8_t *) & mask)[1] = ((uint8_t *) & mask)[2];
524 ((uint8_t *) & mask)[2] = ((uint8_t *) & mask)[3];
525 ((uint8_t *) & mask)[3] = m;
532 ssize_t websock_read(struct websock * ws, void *buffer, size_t size)
536 if (ws->state != STATE_DATA)
539 if (size > ws->length)
540 size = (size_t) ws->length;
542 rc = ws_read(ws, buffer, size);
548 unmask(ws, buffer, size);
553 int websock_drop(struct websock *ws)
558 if (websock_read(ws, buffer, sizeof buffer) < 0)
563 struct websock *websock_create_v13(const struct websock_itf *itf, void *closure)
565 struct websock *result = calloc(1, sizeof *result);
568 result->closure = closure;
569 result->maxlength = default_maxlength;
574 void websock_destroy(struct websock *ws)
579 void websock_set_default_max_length(size_t maxlen)
581 default_maxlength = maxlen;
584 void websock_set_max_length(struct websock *ws, size_t maxlen)
586 ws->maxlength = (uint64_t)maxlen;
589 const char *websocket_explain_error(uint16_t code)
591 static const char *msgs[] = {
593 "GOING_AWAY", /* 1001 */
594 "PROTOCOL_ERROR", /* 1002 */
595 "CANT_ACCEPT", /* 1003 */
596 "RESERVED", /* 1004 */
597 "NOT_SET", /* 1005 */
598 "ABNORMAL", /* 1006 */
599 "INVALID_UTF8", /* 1007 */
600 "POLICY_VIOLATION", /* 1008 */
601 "MESSAGE_TOO_LARGE", /* 1009 */
602 "EXPECT_EXTENSION", /* 1010 */
603 "INTERNAL_ERROR", /* 1011 */
605 if (code < 1000 || (code - 1000) >= (sizeof msgs / sizeof *msgs))
607 return msgs[code - 1000];