2 -- Copyright (C) 2012 Florian Zeitz
3 -- Copyright (C) 2014 Daurnimator
5 -- This project is MIT/X11 licensed. Please see the
6 -- COPYING file in the source package for more information.
9 local softreq = require "util.dependencies".softreq;
10 local log = require "util.logger".init "websocket.frames";
11 local random_bytes = require "util.random".bytes;
13 local bit = assert(softreq"bit" or softreq"bit32",
14 "No bit module found. See https://prosody.im/doc/depends#bitop");
15 local band = bit.band;
17 local bxor = bit.bxor;
18 local lshift = bit.lshift;
19 local rshift = bit.rshift;
21 local t_concat = table.concat;
22 local s_byte = string.byte;
23 local s_char= string.char;
24 local s_sub = string.sub;
25 local s_pack = string.pack;
26 local s_unpack = string.unpack;
28 if not s_pack and softreq"struct" then
29 s_pack = softreq"struct".pack;
30 s_unpack = softreq"struct".unpack;
33 local function read_uint16be(str, pos)
34 local l1, l2 = s_byte(str, pos, pos+1);
37 -- FIXME: this may lose precision
38 local function read_uint64be(str, pos)
39 local l1, l2, l3, l4, l5, l6, l7, l8 = s_byte(str, pos, pos+7);
40 local h = lshift(l1, 24) + lshift(l2, 16) + lshift(l3, 8) + l4;
41 local l = lshift(l5, 24) + lshift(l6, 16) + lshift(l7, 8) + l8;
44 local function pack_uint16be(x)
45 return s_char(rshift(x, 8), band(x, 0xFF));
47 local function get_byte(x, n)
48 return band(rshift(x, n), 0xFF);
50 local function pack_uint64be(x)
51 local h = band(x / 2^32, 2^32-1);
52 return s_char(get_byte(h, 24), get_byte(h, 16), get_byte(h, 8), band(h, 0xFF),
53 get_byte(x, 24), get_byte(x, 16), get_byte(x, 8), band(x, 0xFF));
57 function pack_uint16be(x)
58 return s_pack(">I2", x);
60 function pack_uint64be(x)
61 return s_pack(">I8", x);
66 function read_uint16be(str, pos)
67 return s_unpack(">I2", str, pos);
69 function read_uint64be(str, pos)
70 return s_unpack(">I8", str, pos);
74 local function parse_frame_header(frame)
75 if #frame < 2 then return; end
77 local byte1, byte2 = s_byte(frame, 1, 2);
79 FIN = band(byte1, 0x80) > 0;
80 RSV1 = band(byte1, 0x40) > 0;
81 RSV2 = band(byte1, 0x20) > 0;
82 RSV3 = band(byte1, 0x10) > 0;
83 opcode = band(byte1, 0x0F);
85 MASK = band(byte2, 0x80) > 0;
86 length = band(byte2, 0x7F);
89 local length_bytes = 0;
90 if result.length == 126 then
92 elseif result.length == 127 then
96 local header_length = 2 + length_bytes + (result.MASK and 4 or 0);
97 if #frame < header_length then return; end
99 if length_bytes == 2 then
100 result.length = read_uint16be(frame, 3);
101 elseif length_bytes == 8 then
102 result.length = read_uint64be(frame, 3);
106 result.key = { s_byte(frame, length_bytes+3, length_bytes+6) };
109 return result, header_length;
112 -- XORs the string `str` with the array of bytes `key`
114 local function apply_mask(str, key, from, to)
116 if from < 0 then from = #str + from + 1 end -- negative indicies
118 if to < 0 then to = #str + to + 1 end -- negative indicies
123 local key_index = counter%key_len + 1;
124 counter = counter + 1;
125 data[counter] = s_char(bxor(key[key_index], s_byte(str, i)));
127 return t_concat(data);
130 local function parse_frame_body(frame, header, pos)
132 return apply_mask(frame, header.key, pos, pos + header.length - 1);
134 return frame:sub(pos, pos + header.length - 1);
138 local function parse_frame(frame)
139 local result, pos = parse_frame_header(frame);
140 if result == nil or #frame < (pos + result.length) then return; end
141 result.data = parse_frame_body(frame, result, pos+1);
142 return result, pos + result.length;
145 local function build_frame(desc)
146 local data = desc.data or "";
148 assert(desc.opcode and desc.opcode >= 0 and desc.opcode <= 0xF, "Invalid WebSocket opcode");
149 if desc.opcode >= 0x8 then
151 assert(#data <= 125, "WebSocket control frames MUST have a payload length of 125 bytes or less.");
154 local b1 = bor(desc.opcode,
155 desc.FIN and 0x80 or 0,
156 desc.RSV1 and 0x40 or 0,
157 desc.RSV2 and 0x20 or 0,
158 desc.RSV3 and 0x10 or 0);
162 if b2 <= 125 then -- 7-bit length
164 elseif b2 <= 0xFFFF then -- 2-byte length
166 length_extra = pack_uint16be(#data);
167 else -- 8-byte length
169 length_extra = pack_uint64be(#data);
174 local key_a = desc.key
176 key = s_char(unpack(key_a, 1, 4));
178 key = random_bytes(4);
179 key_a = {key:byte(1,4)};
182 data = apply_mask(data, key_a);
185 return s_char(b1, b2) .. length_extra .. key .. data
188 local function parse_close(data)
191 code = read_uint16be(data, 1);
193 message = s_sub(data, 3);
199 local function build_close(code, message, mask)
200 local data = pack_uint16be(code);
202 assert(#message<=123, "Close reason must be <=123 bytes");
203 data = data .. message;
214 parse_header = parse_frame_header;
215 parse_body = parse_frame_body;
218 parse_close = parse_close;
219 build_close = build_close;