1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
-- Prosody IM
-- Copyright (C) 2009 Tobias Markmann
--
-- This project is MIT/X11 licensed. Please see the
-- COPYING file in the source package for more information.
--
local st = require "util.stanza";
local zlib = require "zlib";
local pcall = pcall;
local xmlns_compression_feature = "http://jabber.org/features/compress"
local xmlns_compression_protocol = "http://jabber.org/protocol/compress"
local xmlns_stream = "http://etherx.jabber.org/streams";
local compression_stream_feature = st.stanza("compression", {xmlns=xmlns_compression_feature}):tag("method"):text("zlib"):up();
local compression_level = module:get_option("compression_level");
-- if not defined assume admin wants best compression
if compression_level == nil then compression_level = 9 end;
compression_level = tonumber(compression_level);
if not compression_level or compression_level < 1 or compression_level > 9 then
module:log("warn", "Invalid compression level in config: %s", tostring(compression_level));
module:log("warn", "Module loading aborted. Compression won't be available.");
return;
end
module:add_event_hook("stream-features",
function (session, features)
if not session.compressed then
-- FIXME only advertise compression support when TLS layer has no compression enabled
features:add_child(compression_stream_feature);
end
end
);
module:hook("s2s-stream-features",
function (data)
local session, features = data.session, data.features;
-- FIXME only advertise compression support when TLS layer has no compression enabled
features:add_child(compression_stream_feature);
end
);
-- S2Sout handling aka the client perspective in the S2S connection
module:hook_stanza(xmlns_stream, "features",
function (session, stanza)
if not session.compressed then
module:log("debug", "FEATURES: "..stanza:pretty_print())
-- does remote server support compression?
local comp_st = stanza:child_with_name("compression");
if comp_st then
-- do we support the mechanism
for a in comp_st:children() do
local algorithm = a[1]
if algorithm == "zlib" then
session.sends2s(st.stanza("compress", {xmlns=xmlns_compression_protocol}):tag("method"):text("zlib"))
session.log("info", "Enabled compression using zlib.")
return true;
end
end
session.log("debug", "Remote server supports no compression algorithm we support.")
end
end
end
, 250);
-- returns either nil or a fully functional ready to use inflate stream
local function get_deflate_stream(session)
local status, deflate_stream = pcall(zlib.deflate, compression_level);
if status == false then
local error_st = st.stanza("failure", {xmlns=xmlns_compression_protocol}):tag("setup-failed");
(session.sends2s or session.send)(error_st);
session.log("error", "Failed to create zlib.deflate filter.");
module:log("error", deflate_stream);
return
end
return deflate_stream
end
-- returns either nil or a fully functional ready to use inflate stream
local function get_inflate_stream(session)
local status, inflate_stream = pcall(zlib.inflate);
if status == false then
local error_st = st.stanza("failure", {xmlns=xmlns_compression_protocol}):tag("setup-failed");
(session.sends2s or session.send)(error_st);
session.log("error", "Failed to create zlib.deflate filter.");
module:log("error", inflate_stream);
return
end
return inflate_stream
end
-- setup compression for a stream
local function setup_compression(session, deflate_stream)
local old_send = (session.sends2s or session.send);
local new_send = function(t)
local status, compressed, eof = pcall(deflate_stream, tostring(t), 'sync');
if status == false then
session:close({
condition = "undefined-condition";
text = compressed;
extra = st.stanza("failure", {xmlns="http://jabber.org/protocol/compress"}):tag("processing-failed");
});
module:log("warn", compressed);
return;
end
old_send(compressed);
end;
if session.sends2s then session.sends2s = new_send
elseif session.send then session.send = new_send end
end
-- setup decompression for a stream
local function setup_decompression(session, inflate_stream)
local old_data = session.data
session.data = function(conn, data)
local status, decompressed, eof = pcall(inflate_stream, data);
if status == false then
session:close({
condition = "undefined-condition";
text = decompressed;
extra = st.stanza("failure", {xmlns="http://jabber.org/protocol/compress"}):tag("processing-failed");
});
module:log("warn", decompressed);
return;
end
old_data(conn, decompressed);
end;
end
-- TODO Support compression on S2S level too.
module:add_handler({"s2sout_unauthed", "s2sout"}, "compressed", xmlns_compression_protocol,
function(session ,stanza)
session.log("debug", "Activating compression...")
end
);
module:add_handler({"c2s_unauthed", "c2s", "s2sin_unauthed", "s2sin"}, "compress", xmlns_compression_protocol,
function(session, stanza)
-- fail if we are already compressed
if session.compressed then
local error_st = st.stanza("failure", {xmlns=xmlns_compression_protocol}):tag("unsupported-method");
session.send(error_st);
session.log("warn", "Tried to establish another compression layer.");
end
-- checking if the compression method is supported
local method = stanza:child_with_name("method")[1];
if method == "zlib" then
session.log("info", method.." compression selected.");
(session.sends2s or session.send)(st.stanza("compressed", {xmlns=xmlns_compression_protocol}));
session:reset_stream();
-- create deflate and inflate streams
deflate_stream = get_deflate_stream(session);
if not deflate_stream then return end
inflate_stream = get_inflate_stream(session);
if not inflate_stream then return end
-- setup compression for session.w
setup_compression(session, deflate_stream);
-- setup decompression for session.data
setup_decompression(session, inflate_stream);
local session_reset_stream = session.reset_stream;
session.reset_stream = function(session)
session_reset_stream(session);
setup_decompression(session, inflate_stream);
return true;
end;
session.compressed = true;
else
session.log("info", method.." compression selected. But we don't support it.");
local error_st = st.stanza("failure", {xmlns=xmlns_compression_protocol}):tag("unsupported-method");
(session.sends2s or session.send)(error_st);
end
end
);
|
