Skip to content

Commit 46e4b7e

Browse files
bzickbzick
committed
port from php-ion
0 parents  commit 46e4b7e

7 files changed

Lines changed: 368 additions & 0 deletions

File tree

‎.gitignore‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
*.o
2+
*.loT

‎AUTHORS‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
Ivan Shalganov <a.cobest@gmail.com>

‎Makefile‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
CFLAGS?=-std=gnu99 -ansi -pedantic -O4 -Wall -fPIC
2+
3+
default: websocket_parser.o
4+
5+
websocket_parser.o: websocket_parser.c websocket_parser.h
6+
7+
solib: websocket_parser.o
8+
$(CC) -shared -Wl,-soname,libwebsocket_parser.so -o libwebsocket_parser.so websocket_parser.o
9+
10+
clean:
11+
rm -f *.o *.so

‎README.md‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
WebSocket frame parser
2+
======================
3+
4+
5+
### Features
6+
* No dependencies
7+
* Works with chunks of a data - no need to buffer the whole request
8+
9+
This is a parser for WebSocket frame-messages written in C (by [RFC6455](https://tools.ietf.org/html/rfc6455)).
10+
It does not make any syscalls nor allocations, it does not
11+
buffer data, it can be interrupted at anytime.
12+
13+
Tested as part of [PHP-ION](https://github.com/php-ion/php-ion) extension.
14+
15+
Inspired by [http-parser](https://github.com/joyent/http-parser) by [Ryan Dahl](https://github.com/ry)
16+
and [multipart-parser](https://github.com/iafonov/multipart-parser-c) by [Igor Afonov](https://github.com/iafonov).
17+
18+
### Usage
19+
20+
This parser library works with several callbacks, which the user may set up at application initialization time.
21+
22+
```c
23+
websocket_parser_settings settings;
24+
25+
websocket_parser_settings_init(&settings);
26+
27+
settings.on_frame_header = websocket_frame_header;
28+
settings.on_frame_body = websocket_frame_body;
29+
settings.on_frame_end = websocket_frame_end;
30+
```
31+
32+
These functions must match the signatures defined in the websocket-parser header file.
33+
34+
Returning a value other than 0 from the callbacks will abort message processing.
35+
36+
Initialize the `struct` using `http_parser_init()` and set the callbacks. That might look something
37+
like this for a request parser:
38+
```c
39+
websocket_parser_settings settings;
40+
41+
websocket_parser_settings_init(&settings);
42+
43+
settings.on_frame_header = websocket_frame_header;
44+
settings.on_frame_body = websocket_frame_body;
45+
settings.on_frame_end = websocket_frame_end;
46+
47+
parser = malloc(sizeof(websocket_parser));
48+
websocket_parser_init(parser);
49+
parser->data = my_frame_struct; // set your custom data after websocket_parser_init() function
50+
```
51+
52+
Basically, callback looks like that:
53+
54+
```c
55+
int websocket_frame_header(websocket_parser * parser) {
56+
parser->data->opcode = parser->flags & WS_OP_MASK; // gets opcode
57+
parser->data->is_final = parser->flags & WS_FIN; // checks is final frame
58+
if(parser->length) {
59+
parser->data->body = malloc(parser->length); // allocate memory for frame body, if body exists
60+
}
61+
return 0;
62+
}
63+
64+
int ion_websocket_frame_body(websocket_parser * parser, const char *at, size_t size) {
65+
if(parser->flags & WS_HAS_MASK) {
66+
// if frame has mask, we have to copy and decode data via websocket_parser_copy_masked function
67+
websocket_parser_copy_masked(&parser->data[parser->offset], at, size, parser);
68+
} else {
69+
memcpy(&parser->data[parser->offset], at, size);
70+
}
71+
return 0;
72+
}
73+
```
74+
75+
When data is received execute the parser and check for errors.
76+
77+
```c
78+
websocket_parser_execute(parser, &settings, data, data_len);
79+
if(parser->error) {
80+
// e.g. log error
81+
}
82+
// ...
83+
free(parser);
84+
```

‎websocket_parser.c‎

Lines changed: 173 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,173 @@
1+
#include "websocket_parser.h"
2+
#include <assert.h>
3+
#include <stddef.h>
4+
#include <stdlib.h>
5+
#include <string.h>
6+
#include <limits.h>
7+
8+
9+
#ifdef __GNUC__
10+
# define EXPECTED(X) __builtin_expect(!!(X), 1)
11+
# define UNEXPECTED(X) __builtin_expect(!!(X), 0)
12+
#else
13+
# define EXPECTED(X) (X)
14+
# define UNEXPECTED(X) (X)
15+
#endif
16+
17+
#define OPCODE_MASK 0xF
18+
19+
#define NOTIFY_CB(FOR) \
20+
do { \
21+
if (settings->on_##FOR) { \
22+
if (settings->on_##FOR(parser) != 0) { \
23+
return i; \
24+
} \
25+
} \
26+
} while (0)
27+
28+
#define EMIT_DATA_CB(FOR, ptr, len) \
29+
do { \
30+
if (settings->on_##FOR) { \
31+
if (settings->on_##FOR(parser, ptr, len) != 0) { \
32+
return i; \
33+
} \
34+
} \
35+
} while (0)
36+
37+
enum state {
38+
s_start,
39+
s_head,
40+
s_length,
41+
s_mask,
42+
s_body,
43+
};
44+
45+
void websocket_parser_init(websocket_parser * parser) {
46+
void *data = parser->data; /* preserve application data */
47+
memset(parser, 0, sizeof(*parser));
48+
parser->data = data;
49+
parser->state = s_start;
50+
parser->error = 0;
51+
}
52+
53+
void websocket_parser_settings_init(websocket_parser_settings *settings) {
54+
memset(settings, 0, sizeof(*settings));
55+
}
56+
57+
size_t websocket_parser_execute(websocket_parser *parser, const websocket_parser_settings *settings, const char *data, size_t len) {
58+
size_t i = 0;
59+
size_t r = 0;
60+
char c;
61+
62+
while(i < len) {
63+
c = data[i];
64+
switch(parser->state) {
65+
case s_start:
66+
parser->length = 0;
67+
parser->flags = (uint32_t) (c & WS_OP_MASK);
68+
c >>= 7;
69+
if(c & 1) {
70+
parser->flags |= WS_FIN;
71+
}
72+
parser->state = s_head;
73+
break;
74+
case s_head:
75+
parser->length = (size_t)c & 0x7F;
76+
if(c & 0x80) {
77+
parser->flags |= WS_HAS_MASK;
78+
}
79+
if(EXPECTED(parser->length >= 126)) {
80+
if(EXPECTED(parser->length == 127)) {
81+
if(EXPECTED(len - i > 8)) {
82+
parser->length = (uint16_t)data[i+1];
83+
i += 8;
84+
} else {
85+
parser->require = 8;
86+
parser->state = s_length;
87+
}
88+
} else {
89+
if(EXPECTED(len - i >= 2)) {
90+
parser->length = (uint16_t)data[i+1];
91+
i += 2;
92+
} else {
93+
parser->require = 2;
94+
}
95+
}
96+
} else {
97+
}
98+
if(EXPECTED(parser->require)) {
99+
parser->state = s_length;
100+
} else {
101+
if(EXPECTED(parser->flags & WS_HAS_MASK)) {
102+
parser->state = s_mask;
103+
parser->require = 4;
104+
} else if(parser->length) {
105+
parser->require = parser->length;
106+
NOTIFY_CB(frame_header);
107+
parser->state = s_body;
108+
} else {
109+
NOTIFY_CB(frame_header);
110+
NOTIFY_CB(frame_end);
111+
parser->state = s_start;
112+
}
113+
}
114+
break;
115+
case s_length:
116+
for(; i < len, parser->require; i++, parser->require--) {
117+
parser->length <<= 8;
118+
parser->length |= (unsigned char)data[i];
119+
}
120+
if(!UNEXPECTED(parser->require)) {
121+
parser->require = parser->length;
122+
NOTIFY_CB(frame_header);
123+
parser->state = s_body;
124+
}
125+
break;
126+
case s_mask:
127+
for(; i < len, parser->require; i++, parser->require--) {
128+
parser->mask[4 - parser->require] = data[i];
129+
}
130+
i--;
131+
if(!UNEXPECTED(parser->require)) {
132+
if(parser->length) {
133+
parser->require = parser->length;
134+
NOTIFY_CB(frame_header);
135+
parser->state = s_body;
136+
} else {
137+
NOTIFY_CB(frame_header);
138+
NOTIFY_CB(frame_end);
139+
parser->state = s_start;
140+
}
141+
}
142+
break;
143+
case s_body:
144+
if(parser->require) {
145+
r = parser->require;
146+
parser->require -= len - i;
147+
EMIT_DATA_CB(frame_body, &data[i], len - i);
148+
parser->offset = len - parser->require;
149+
i+=r;
150+
}
151+
if(!UNEXPECTED(parser->require)) {
152+
NOTIFY_CB(frame_end);
153+
parser->state = s_start;
154+
}
155+
break;
156+
default:
157+
parser->error = ERR_UNKNOWN_STATE;
158+
return i;
159+
}
160+
i++;
161+
}
162+
163+
return i;
164+
}
165+
166+
void websocket_parser_copy_masked(char * dst, const char * src, size_t len, websocket_parser * parser) {
167+
size_t i = 0;
168+
for(; i < len; i++) {
169+
dst[i] = src[i] ^ parser->mask[(i + parser->mask_offset) % 4];
170+
}
171+
172+
parser->mask_offset = (uint8_t) ((i + parser->mask_offset + 1) % 4);
173+
}

‎websocket_parser.h‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
#ifndef WEBSOCKET_PARSER_H
2+
#define WEBSOCKET_PARSER_H
3+
4+
#ifdef __cplusplus
5+
extern "C" {
6+
#endif
7+
8+
9+
#include <sys/types.h>
10+
#if defined(_WIN32) && !defined(__MINGW32__) && \
11+
(!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__)
12+
#include <BaseTsd.h>
13+
#include <stddef.h>
14+
typedef __int8 int8_t;
15+
typedef unsigned __int8 uint8_t;
16+
typedef __int16 int16_t;
17+
typedef unsigned __int16 uint16_t;
18+
typedef __int32 int32_t;
19+
typedef unsigned __int32 uint32_t;
20+
typedef __int64 int64_t;
21+
typedef unsigned __int64 uint64_t;
22+
#else
23+
#include <stdint.h>
24+
#endif
25+
26+
typedef struct websocket_parser websocket_parser;
27+
typedef struct websocket_parser_settings websocket_parser_settings;
28+
29+
enum websocket_ops {
30+
WS_OP_CONTINUE = 0x0,
31+
WS_OP_TEXT = 0x1,
32+
WS_OP_BINARY = 0x2,
33+
WS_OP_CLOSE = 0x8,
34+
WS_OP_PING = 0x9,
35+
WS_OP_PONG = 0xA,
36+
};
37+
38+
#define WS_OP_MASK 0xF
39+
40+
enum websocket_errors {
41+
ERR_OK,
42+
ERR_UNKNOWN_STATE,
43+
};
44+
45+
enum websocket_flags {
46+
WS_FIN = 0x10,
47+
WS_HAS_MASK = 0x20,
48+
};
49+
50+
typedef int (*websocket_data_cb) (websocket_parser*, const char *at, size_t length);
51+
typedef int (*websocket_cb) (websocket_parser*);
52+
53+
struct websocket_parser {
54+
uint32_t state;
55+
uint32_t flags;
56+
uint32_t error;
57+
char mask[4];
58+
uint8_t mask_offset;
59+
60+
uint32_t nread;
61+
size_t length;
62+
size_t require;
63+
size_t offset;
64+
65+
void * data;
66+
};
67+
68+
struct websocket_parser_settings {
69+
uint64_t max_frame_size;
70+
websocket_cb on_frame_header;
71+
websocket_data_cb on_frame_body;
72+
websocket_cb on_frame_end;
73+
};
74+
75+
void websocket_parser_init(websocket_parser *parser);
76+
void websocket_parser_settings_init(websocket_parser_settings *settings);
77+
size_t websocket_parser_execute(websocket_parser *parser,
78+
const websocket_parser_settings *settings,
79+
const char *data,
80+
size_t len);
81+
void websocket_parser_copy_masked(char * dst, const char * src, size_t len, websocket_parser * parser);
82+
#ifdef __cplusplus
83+
}
84+
#endif
85+
#endif //WEBSOCKET_PARSER_H

‎websocket_parser.lo‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
# external/websocket-parser/websocket_parser.lo - a libtool object file
2+
# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.492 2008/01/30 06:40:56)
3+
#
4+
# Please DO NOT delete this file!
5+
# It is necessary for linking the library.
6+
7+
# Name of the PIC object.
8+
pic_object='.libs/websocket_parser.o'
9+
10+
# Name of the non-PIC object.
11+
non_pic_object=none
12+

0 commit comments

Comments
 (0)