mirror of
https://github.com/bjc/prosody.git
synced 2025-04-01 20:27:39 +03:00
274 lines
8.4 KiB
Lua
274 lines
8.4 KiB
Lua
-- Prosody IM
|
|
-- Copyright (C) 2012 Florian Zeitz
|
|
-- Copyright (C) 2014 Daurnimator
|
|
--
|
|
-- This project is MIT/X11 licensed. Please see the
|
|
-- COPYING file in the source package for more information.
|
|
--
|
|
|
|
local t_concat = table.concat;
|
|
|
|
local http = require "prosody.net.http";
|
|
local frames = require "prosody.net.websocket.frames";
|
|
local base64 = require "prosody.util.encodings".base64;
|
|
local sha1 = require "prosody.util.hashes".sha1;
|
|
local random_bytes = require "prosody.util.random".bytes;
|
|
local timer = require "prosody.util.timer";
|
|
local log = require "prosody.util.logger".init "websocket";
|
|
|
|
local close_timeout = 3; -- Seconds to wait after sending close frame until closing connection.
|
|
|
|
local websockets = {};
|
|
|
|
local websocket_listeners = {};
|
|
function websocket_listeners.ondisconnect(conn, err)
|
|
local s = websockets[conn];
|
|
if not s then return; end
|
|
websockets[conn] = nil;
|
|
if s.close_timer then
|
|
timer.stop(s.close_timer);
|
|
s.close_timer = nil;
|
|
end
|
|
s.readyState = 3;
|
|
if s.close_code == nil and s.onerror then s:onerror(err); end
|
|
if s.onclose then s:onclose(s.close_code, s.close_message or err); end
|
|
end
|
|
|
|
function websocket_listeners.ondetach(conn)
|
|
websockets[conn] = nil;
|
|
end
|
|
|
|
local function fail(s, code, reason)
|
|
log("warn", "WebSocket connection failed, closing. %d %s", code, reason);
|
|
s:close(code, reason);
|
|
s.conn:close();
|
|
return false
|
|
end
|
|
|
|
function websocket_listeners.onincoming(conn, buffer, err) -- luacheck: ignore 212/err
|
|
local s = websockets[conn];
|
|
s.readbuffer = s.readbuffer..buffer;
|
|
while true do
|
|
local frame, len = frames.parse(s.readbuffer);
|
|
if frame == nil then break end
|
|
s.readbuffer = s.readbuffer:sub(len+1);
|
|
|
|
log("debug", "Websocket received frame: opcode=%0x, %i bytes", frame.opcode, #frame.data);
|
|
|
|
-- Error cases
|
|
if frame.RSV1 or frame.RSV2 or frame.RSV3 then -- Reserved bits non zero
|
|
return fail(s, 1002, "Reserved bits not zero");
|
|
end
|
|
|
|
if frame.opcode < 0x8 then
|
|
local databuffer = s.databuffer;
|
|
if frame.opcode == 0x0 then -- Continuation frames
|
|
if not databuffer then
|
|
return fail(s, 1002, "Unexpected continuation frame");
|
|
end
|
|
databuffer[#databuffer+1] = frame.data;
|
|
elseif frame.opcode == 0x1 or frame.opcode == 0x2 then -- Text or Binary frame
|
|
if databuffer then
|
|
return fail(s, 1002, "Continuation frame expected");
|
|
end
|
|
databuffer = {type=frame.opcode, frame.data};
|
|
s.databuffer = databuffer;
|
|
else
|
|
return fail(s, 1002, "Reserved opcode");
|
|
end
|
|
if frame.FIN then
|
|
s.databuffer = nil;
|
|
if s.onmessage then
|
|
s:onmessage(t_concat(databuffer), databuffer.type);
|
|
end
|
|
end
|
|
else -- Control frame
|
|
if frame.length > 125 then -- Control frame with too much payload
|
|
return fail(s, 1002, "Payload too large");
|
|
elseif not frame.FIN then -- Fragmented control frame
|
|
return fail(s, 1002, "Fragmented control frame");
|
|
end
|
|
if frame.opcode == 0x8 then -- Close request
|
|
if frame.length == 1 then
|
|
return fail(s, 1002, "Close frame with payload, but too short for status code");
|
|
end
|
|
local status_code, message = frames.parse_close(frame.data);
|
|
if status_code == nil then
|
|
--[[ RFC 6455 7.4.1
|
|
1005 is a reserved value and MUST NOT be set as a status code in a
|
|
Close control frame by an endpoint. It is designated for use in
|
|
applications expecting a status code to indicate that no status
|
|
code was actually present.
|
|
]]
|
|
status_code = 1005
|
|
elseif status_code < 1000 then
|
|
return fail(s, 1002, "Closed with invalid status code");
|
|
elseif ((status_code > 1003 and status_code < 1007) or status_code > 1011) and status_code < 3000 then
|
|
return fail(s, 1002, "Closed with reserved status code");
|
|
end
|
|
s.close_code, s.close_message = status_code, message;
|
|
s:close(1000);
|
|
return true;
|
|
elseif frame.opcode == 0x9 then -- Ping frame
|
|
frame.opcode = 0xA;
|
|
frame.MASK = true; -- RFC 6455 6.1.5: If the data is being sent by the client, the frame(s) MUST be masked
|
|
conn:write(frames.build(frame));
|
|
elseif frame.opcode == 0xA then -- Pong frame
|
|
log("debug", "Received unexpected pong frame: %s", frame.data);
|
|
else
|
|
return fail(s, 1002, "Reserved opcode");
|
|
end
|
|
end
|
|
end
|
|
return true;
|
|
end
|
|
|
|
local websocket_methods = {};
|
|
local function close_timeout_cb(now, timerid, s) -- luacheck: ignore 212/now 212/timerid
|
|
s.close_timer = nil;
|
|
log("warn", "Close timeout waiting for server to close, closing manually.");
|
|
s.conn:close();
|
|
end
|
|
function websocket_methods:close(code, reason)
|
|
if self.readyState < 2 then
|
|
code = code or 1000;
|
|
log("debug", "closing WebSocket with code %i: %s" , code , reason);
|
|
self.readyState = 2;
|
|
local conn = self.conn;
|
|
conn:write(frames.build_close(code, reason, true));
|
|
-- Do not close socket straight away, wait for acknowledgement from server.
|
|
self.close_timer = timer.add_task(close_timeout, close_timeout_cb, self);
|
|
elseif self.readyState == 2 then
|
|
log("debug", "tried to close a closing WebSocket, closing the raw socket.");
|
|
-- Stop timer
|
|
if self.close_timer then
|
|
timer.stop(self.close_timer);
|
|
self.close_timer = nil;
|
|
end
|
|
local conn = self.conn;
|
|
conn:close();
|
|
else
|
|
log("debug", "tried to close a closed WebSocket, ignoring.");
|
|
end
|
|
end
|
|
function websocket_methods:send(data, opcode)
|
|
if self.readyState < 1 then
|
|
return nil, "WebSocket not open yet, unable to send data.";
|
|
elseif self.readyState >= 2 then
|
|
return nil, "WebSocket closed, unable to send data.";
|
|
end
|
|
if opcode == "text" or opcode == nil then
|
|
opcode = 0x1;
|
|
elseif opcode == "binary" then
|
|
opcode = 0x2;
|
|
end
|
|
local frame = {
|
|
FIN = true;
|
|
MASK = true; -- RFC 6455 6.1.5: If the data is being sent by the client, the frame(s) MUST be masked
|
|
opcode = opcode;
|
|
data = tostring(data);
|
|
};
|
|
log("debug", "WebSocket sending frame: opcode=%0x, %i bytes", frame.opcode, #frame.data);
|
|
return self.conn:write(frames.build(frame));
|
|
end
|
|
|
|
local websocket_metatable = {
|
|
__index = websocket_methods;
|
|
};
|
|
|
|
local function connect(url, ex, listeners)
|
|
ex = ex or {};
|
|
|
|
--[[RFC 6455 4.1.7:
|
|
The request MUST include a header field with the name
|
|
|Sec-WebSocket-Key|. The value of this header field MUST be a
|
|
nonce consisting of a randomly selected 16-byte value that has
|
|
been base64-encoded (see Section 4 of [RFC4648]). The nonce
|
|
MUST be selected randomly for each connection.
|
|
]]
|
|
local key = base64.encode(random_bytes(16));
|
|
|
|
-- Either a single protocol string or an array of protocol strings.
|
|
local protocol = ex.protocol;
|
|
if type(protocol) == "string" then
|
|
protocol = { protocol, [protocol] = true };
|
|
elseif type(protocol) == "table" and protocol[1] then
|
|
for _, v in ipairs(protocol) do
|
|
protocol[v] = true;
|
|
end
|
|
else
|
|
protocol = nil;
|
|
end
|
|
|
|
local headers = {
|
|
["Upgrade"] = "websocket";
|
|
["Connection"] = "Upgrade";
|
|
["Sec-WebSocket-Key"] = key;
|
|
["Sec-WebSocket-Protocol"] = protocol and t_concat(protocol, ", ");
|
|
["Sec-WebSocket-Version"] = "13";
|
|
["Sec-WebSocket-Extensions"] = ex.extensions;
|
|
}
|
|
if ex.headers then
|
|
for k,v in pairs(ex.headers) do
|
|
headers[k] = v;
|
|
end
|
|
end
|
|
|
|
local s = setmetatable({
|
|
readbuffer = "";
|
|
databuffer = nil;
|
|
conn = nil;
|
|
close_code = nil;
|
|
close_message = nil;
|
|
close_timer = nil;
|
|
readyState = 0;
|
|
protocol = nil;
|
|
|
|
url = url;
|
|
|
|
onopen = listeners.onopen;
|
|
onclose = listeners.onclose;
|
|
onmessage = listeners.onmessage;
|
|
onerror = listeners.onerror;
|
|
}, websocket_metatable);
|
|
|
|
local http_url = url:gsub("^(ws)", "http");
|
|
local http_req = http.request(http_url, { -- luacheck: ignore 211/http_req
|
|
method = "GET";
|
|
headers = headers;
|
|
sslctx = ex.sslctx;
|
|
insecure = ex.insecure;
|
|
}, function(b, c, r, http_req)
|
|
if c ~= 101
|
|
or r.headers["connection"]:lower() ~= "upgrade"
|
|
or r.headers["upgrade"] ~= "websocket"
|
|
or r.headers["sec-websocket-accept"] ~= base64.encode(sha1(key .. "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
|
|
or (protocol and not protocol[r.headers["sec-websocket-protocol"]])
|
|
then
|
|
s.readyState = 3;
|
|
log("warn", "WebSocket connection to %s failed: %s", url, b);
|
|
if s.onerror then s:onerror("connecting-failed"); end
|
|
return;
|
|
end
|
|
|
|
s.protocol = r.headers["sec-websocket-protocol"];
|
|
|
|
-- Take possession of socket from http
|
|
local conn = http_req.conn;
|
|
http_req.conn = nil;
|
|
s.conn = conn;
|
|
websockets[conn] = s;
|
|
conn:setlistener(websocket_listeners);
|
|
|
|
log("debug", "WebSocket connected successfully to %s", url);
|
|
s.readyState = 1;
|
|
if s.onopen then s:onopen(); end
|
|
websocket_listeners.onincoming(conn, b);
|
|
end);
|
|
|
|
return s;
|
|
end
|
|
|
|
return {
|
|
connect = connect;
|
|
};
|