Software /
code /
prosody
Annotate
net/server.lua @ 122:21f8d2175393
No s2s yet :)
author | Matthew Wild <mwild1@gmail.com> |
---|---|
date | Thu, 23 Oct 2008 14:39:42 +0100 |
parent | 98:3a2d327c4856 |
child | 127:93f3c6b94c75 |
rev | line source |
---|---|
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
1 --[[ |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
2 |
64 | 3 server.lua by blastbeat of the luadch project |
4 | |
5 re-used here under the MIT/X Consortium License | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
6 |
64 | 7 - this script contains the server loop of the program |
8 - other scripts can reg a server here | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
9 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
10 ]]-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
11 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
12 ----------------------------------// DECLARATION //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
13 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
14 --// constants //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
15 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
16 local STAT_UNIT = 1 / ( 1024 * 1024 ) -- mb |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
17 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
18 --// lua functions //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
19 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
20 local function use( what ) return _G[ what ] end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
21 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
22 local type = use "type" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
23 local pairs = use "pairs" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
24 local ipairs = use "ipairs" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
25 local tostring = use "tostring" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
26 local collectgarbage = use "collectgarbage" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
27 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
28 --// lua libs //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
29 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
30 local table = use "table" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
31 local coroutine = use "coroutine" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
32 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
33 --// lua lib methods //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
34 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
35 local table_concat = table.concat |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
36 local table_remove = table.remove |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
37 local string_sub = use'string'.sub |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
38 local coroutine_wrap = coroutine.wrap |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
39 local coroutine_yield = coroutine.yield |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
40 local print = print; |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
41 local out_put = function () end --print; |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
42 local out_error = print; |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
43 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
44 --// extern libs //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
45 |
98
3a2d327c4856
server.lua should degrade gracefully when LuaSec not present
Matthew Wild <mwild1@gmail.com>
parents:
74
diff
changeset
|
46 local luasec = select(2, pcall(require, "ssl")) |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
47 local luasocket = require "socket" |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
48 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
49 --// extern lib methods //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
50 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
51 local ssl_wrap = ( luasec and luasec.wrap ) |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
52 local socket_bind = luasocket.bind |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
53 local socket_select = luasocket.select |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
54 local ssl_newcontext = ( luasec and luasec.newcontext ) |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
55 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
56 --// functions //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
57 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
58 local loop |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
59 local stats |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
60 local addtimer |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
61 local closeall |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
62 local addserver |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
63 local firetimer |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
64 local closesocket |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
65 local removesocket |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
66 local wrapserver |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
67 local wraptcpclient |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
68 local wrapsslclient |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
69 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
70 --// tables //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
71 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
72 local listener |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
73 local readlist |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
74 local writelist |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
75 local socketlist |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
76 local timelistener |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
77 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
78 --// simple data types //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
79 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
80 local _ |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
81 local readlen = 0 -- length of readlist |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
82 local writelen = 0 -- lenght of writelist |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
83 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
84 local sendstat= 0 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
85 local receivestat = 0 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
86 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
87 ----------------------------------// DEFINITION //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
88 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
89 listener = { } -- key = port, value = table |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
90 readlist = { } -- array with sockets to read from |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
91 writelist = { } -- arrary with sockets to write to |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
92 socketlist = { } -- key = socket, value = wrapped socket |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
93 timelistener = { } |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
94 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
95 stats = function( ) |
64 | 96 return receivestat, sendstat |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
97 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
98 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
99 wrapserver = function( listener, socket, ip, serverport, mode, sslctx ) -- this function wraps a server |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
100 |
64 | 101 local dispatch, disconnect = listener.listener, listener.disconnect -- dangerous |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
102 |
64 | 103 local wrapclient, err |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
104 |
64 | 105 if sslctx then |
106 if not ssl_newcontext then | |
107 return nil, "luasec not found" | |
108 end | |
109 if type( sslctx ) ~= "table" then | |
110 out_error "server.lua: wrong server sslctx" | |
111 return nil, "wrong server sslctx" | |
112 end | |
113 sslctx, err = ssl_newcontext( sslctx ) | |
114 if not sslctx then | |
115 err = err or "wrong sslctx parameters" | |
116 out_error( "server.lua: ", err ) | |
117 return nil, err | |
118 end | |
119 wrapclient = wrapsslclient | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
120 wrapclient = wraptlsclient |
64 | 121 else |
122 wrapclient = wraptcpclient | |
123 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
124 |
64 | 125 local accept = socket.accept |
126 local close = socket.close | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
127 |
64 | 128 --// public methods of the object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
129 |
64 | 130 local handler = { } |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
131 |
64 | 132 handler.shutdown = function( ) end |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
133 |
64 | 134 --[[handler.listener = function( data, err ) |
135 return ondata( handler, data, err ) | |
136 end]] | |
137 handler.ssl = function( ) | |
138 return sslctx and true or false | |
139 end | |
140 handler.close = function( closed ) | |
141 _ = not closed and close( socket ) | |
142 writelen = removesocket( writelist, socket, writelen ) | |
143 readlen = removesocket( readlist, socket, readlen ) | |
144 socketlist[ socket ] = nil | |
145 handler = nil | |
146 end | |
147 handler.ip = function( ) | |
148 return ip | |
149 end | |
150 handler.serverport = function( ) | |
151 return serverport | |
152 end | |
153 handler.socket = function( ) | |
154 return socket | |
155 end | |
156 handler.receivedata = function( ) | |
157 local client, err = accept( socket ) -- try to accept | |
158 if client then | |
159 local ip, clientport = client:getpeername( ) | |
160 client:settimeout( 0 ) | |
161 local handler, client, err = wrapclient( listener, client, ip, serverport, clientport, mode, sslctx ) -- wrap new client socket | |
162 if err then -- error while wrapping ssl socket | |
163 return false | |
164 end | |
165 out_put( "server.lua: accepted new client connection from ", ip, ":", clientport ) | |
166 return dispatch( handler ) | |
167 elseif err then -- maybe timeout or something else | |
168 out_put( "server.lua: error with new client connection: ", err ) | |
169 return false | |
170 end | |
171 end | |
172 return handler | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
173 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
174 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
175 wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, sslctx ) -- this function wraps a ssl cleint |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
176 |
64 | 177 local dispatch, disconnect = listener.listener, listener.disconnect |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
178 |
64 | 179 --// transform socket to ssl object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
180 |
64 | 181 local err |
182 socket, err = ssl_wrap( socket, sslctx ) -- wrap socket | |
183 if err then | |
184 out_put( "server.lua: ssl error: ", err ) | |
185 return nil, nil, err -- fatal error | |
186 end | |
187 socket:settimeout( 0 ) | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
188 |
64 | 189 --// private closures of the object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
190 |
64 | 191 local writequeue = { } -- buffer for messages to send |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
192 |
64 | 193 local eol -- end of buffer |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
194 |
64 | 195 local sstat, rstat = 0, 0 |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
196 |
64 | 197 --// local import of socket methods //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
198 |
64 | 199 local send = socket.send |
200 local receive = socket.receive | |
201 local close = socket.close | |
202 --local shutdown = socket.shutdown | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
203 |
64 | 204 --// public methods of the object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
205 |
64 | 206 local handler = { } |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
207 |
64 | 208 handler.getstats = function( ) |
209 return rstat, sstat | |
210 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
211 |
64 | 212 handler.listener = function( data, err ) |
213 return listener( handler, data, err ) | |
214 end | |
215 handler.ssl = function( ) | |
216 return true | |
217 end | |
218 handler.send = function( _, data, i, j ) | |
219 return send( socket, data, i, j ) | |
220 end | |
221 handler.receive = function( pattern, prefix ) | |
222 return receive( socket, pattern, prefix ) | |
223 end | |
224 handler.shutdown = function( pattern ) | |
225 --return shutdown( socket, pattern ) | |
226 end | |
227 handler.close = function( closed ) | |
228 close( socket ) | |
229 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen | |
230 readlen = removesocket( readlist, socket, readlen ) | |
231 socketlist[ socket ] = nil | |
232 out_put "server.lua: closed handler and removed socket from list" | |
233 end | |
234 handler.ip = function( ) | |
235 return ip | |
236 end | |
237 handler.serverport = function( ) | |
238 return serverport | |
239 end | |
240 handler.clientport = function( ) | |
241 return clientport | |
242 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
243 |
64 | 244 handler.write = function( data ) |
245 if not eol then | |
246 writelen = writelen + 1 | |
247 writelist[ writelen ] = socket | |
248 eol = 0 | |
249 end | |
250 eol = eol + 1 | |
251 writequeue[ eol ] = data | |
252 end | |
253 handler.writequeue = function( ) | |
254 return writequeue | |
255 end | |
256 handler.socket = function( ) | |
257 return socket | |
258 end | |
259 handler.mode = function( ) | |
260 return mode | |
261 end | |
262 handler._receivedata = function( ) | |
263 local data, err, part = receive( socket, mode ) -- receive data in "mode" | |
264 if not err or ( err == "timeout" or err == "wantread" ) then -- received something | |
265 local data = data or part or "" | |
266 local count = #data * STAT_UNIT | |
267 rstat = rstat + count | |
268 receivestat = receivestat + count | |
269 out_put( "server.lua: read data '", data, "', error: ", err ) | |
270 return dispatch( handler, data, err ) | |
271 else -- connections was closed or fatal error | |
272 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) | |
273 handler.close( ) | |
274 disconnect( handler, err ) | |
275 writequeue = nil | |
276 handler = nil | |
277 return false | |
278 end | |
279 end | |
280 handler._dispatchdata = function( ) -- this function writes data to handlers | |
281 local buffer = table_concat( writequeue, "", 1, eol ) | |
282 local succ, err, byte = send( socket, buffer ) | |
283 local count = ( succ or 0 ) * STAT_UNIT | |
284 sstat = sstat + count | |
285 sendstat = sendstat + count | |
286 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport ) | |
287 if succ then -- sending succesful | |
288 --writequeue = { } | |
289 eol = nil | |
290 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist | |
291 return true | |
292 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write | |
293 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer | |
294 writequeue[ 1 ] = buffer -- insert new buffer in queue | |
295 eol = 1 | |
296 return true | |
297 else -- connection was closed during sending or fatal error | |
298 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) | |
299 handler.close( ) | |
300 disconnect( handler, err ) | |
301 writequeue = nil | |
302 handler = nil | |
303 return false | |
304 end | |
305 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
306 |
64 | 307 -- // COMPAT // -- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
308 |
64 | 309 handler.getIp = handler.ip |
310 handler.getPort = handler.clientport | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
311 |
64 | 312 --// handshake //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
313 |
64 | 314 local wrote |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
315 |
64 | 316 handler.handshake = coroutine_wrap( function( client ) |
317 local err | |
318 for i = 1, 10 do -- 10 handshake attemps | |
319 _, err = client:dohandshake( ) | |
320 if not err then | |
321 out_put( "server.lua: ssl handshake done" ) | |
322 writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen | |
323 handler.receivedata = handler._receivedata -- when handshake is done, replace the handshake function with regular functions | |
324 handler.dispatchdata = handler._dispatchdata | |
325 return dispatch( handler ) | |
326 else | |
327 out_put( "server.lua: error during ssl handshake: ", err ) | |
328 if err == "wantwrite" then | |
329 if wrote == nil then | |
330 writelen = writelen + 1 | |
331 writelist[ writelen ] = client | |
332 wrote = true | |
333 end | |
334 end | |
335 coroutine_yield( handler, nil, err ) -- handshake not finished | |
336 end | |
337 end | |
338 _ = err ~= "closed" and close( socket ) | |
339 handler.close( ) | |
340 disconnect( handler, err ) | |
341 writequeue = nil | |
342 handler = nil | |
343 return false -- handshake failed | |
344 end | |
345 ) | |
346 handler.receivedata = handler.handshake | |
347 handler.dispatchdata = handler.handshake | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
348 |
64 | 349 handler.handshake( socket ) -- do handshake |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
350 |
64 | 351 socketlist[ socket ] = handler |
352 readlen = readlen + 1 | |
353 readlist[ readlen ] = socket | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
354 |
64 | 355 return handler, socket |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
356 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
357 |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
358 wraptlsclient = function( listener, socket, ip, serverport, clientport, mode, sslctx ) -- this function wraps a tls cleint |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
359 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
360 local dispatch, disconnect = listener.listener, listener.disconnect |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
361 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
362 --// transform socket to ssl object //-- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
363 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
364 local err |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
365 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
366 socket:settimeout( 0 ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
367 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
368 --// private closures of the object //-- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
369 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
370 local writequeue = { } -- buffer for messages to send |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
371 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
372 local eol -- end of buffer |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
373 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
374 local sstat, rstat = 0, 0 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
375 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
376 --// local import of socket methods //-- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
377 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
378 local send = socket.send |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
379 local receive = socket.receive |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
380 local close = socket.close |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
381 --local shutdown = socket.shutdown |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
382 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
383 --// public methods of the object //-- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
384 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
385 local handler = { } |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
386 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
387 handler.getstats = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
388 return rstat, sstat |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
389 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
390 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
391 handler.listener = function( data, err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
392 return listener( handler, data, err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
393 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
394 handler.ssl = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
395 return false |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
396 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
397 handler.send = function( _, data, i, j ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
398 return send( socket, data, i, j ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
399 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
400 handler.receive = function( pattern, prefix ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
401 return receive( socket, pattern, prefix ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
402 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
403 handler.shutdown = function( pattern ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
404 --return shutdown( socket, pattern ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
405 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
406 handler.close = function( closed ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
407 close( socket ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
408 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
409 readlen = removesocket( readlist, socket, readlen ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
410 socketlist[ socket ] = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
411 out_put "server.lua: closed handler and removed socket from list" |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
412 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
413 handler.ip = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
414 return ip |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
415 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
416 handler.serverport = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
417 return serverport |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
418 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
419 handler.clientport = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
420 return clientport |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
421 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
422 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
423 handler.write = function( data ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
424 if not eol then |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
425 writelen = writelen + 1 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
426 writelist[ writelen ] = socket |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
427 eol = 0 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
428 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
429 eol = eol + 1 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
430 writequeue[ eol ] = data |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
431 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
432 handler.writequeue = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
433 return writequeue |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
434 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
435 handler.socket = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
436 return socket |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
437 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
438 handler.mode = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
439 return mode |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
440 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
441 handler._receivedata = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
442 local data, err, part = receive( socket, mode ) -- receive data in "mode" |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
443 if not err or ( err == "timeout" or err == "wantread" ) then -- received something |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
444 local data = data or part or "" |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
445 local count = #data * STAT_UNIT |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
446 rstat = rstat + count |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
447 receivestat = receivestat + count |
66 | 448 --out_put( "server.lua: read data '", data, "', error: ", err ) |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
449 return dispatch( handler, data, err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
450 else -- connections was closed or fatal error |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
451 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
452 handler.close( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
453 disconnect( handler, err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
454 writequeue = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
455 handler = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
456 return false |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
457 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
458 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
459 handler._dispatchdata = function( ) -- this function writes data to handlers |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
460 local buffer = table_concat( writequeue, "", 1, eol ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
461 local succ, err, byte = send( socket, buffer ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
462 local count = ( succ or 0 ) * STAT_UNIT |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
463 sstat = sstat + count |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
464 sendstat = sendstat + count |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
465 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
466 if succ then -- sending succesful |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
467 --writequeue = { } |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
468 eol = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
469 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
470 if handler.need_tls then |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
471 out_put("server.lua: connection is ready for tls handshake"); |
66 | 472 handler.starttls(true); |
473 if handler.need_tls then | |
474 out_put("server.lua: uh-oh... we still want tls, something must be wrong"); | |
475 end | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
476 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
477 return true |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
478 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
479 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
480 writequeue[ 1 ] = buffer -- insert new buffer in queue |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
481 eol = 1 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
482 return true |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
483 else -- connection was closed during sending or fatal error |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
484 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
485 handler.close( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
486 disconnect( handler, err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
487 writequeue = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
488 handler = nil |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
489 return false |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
490 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
491 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
492 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
493 handler.receivedata, handler.dispatchdata = handler._receivedata, handler._dispatchdata; |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
494 -- // COMPAT // -- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
495 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
496 handler.getIp = handler.ip |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
497 handler.getPort = handler.clientport |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
498 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
499 --// handshake //-- |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
500 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
501 local wrote, read |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
502 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
503 handler.starttls = function (now) |
66 | 504 if not now then out_put("server.lua: we need to do tls, but delaying until later"); handler.need_tls = true; return; end |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
505 out_put( "server.lua: attempting to start tls on "..tostring(socket) ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
506 socket, err = ssl_wrap( socket, sslctx ) -- wrap socket |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
507 out_put("sslwrapped socket is "..tostring(socket)); |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
508 if err then |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
509 out_put( "server.lua: ssl error: ", err ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
510 return nil, nil, err -- fatal error |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
511 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
512 socket:settimeout( 1 ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
513 send = socket.send |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
514 receive = socket.receive |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
515 close = socket.close |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
516 handler.ssl = function( ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
517 return true |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
518 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
519 handler.send = function( _, data, i, j ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
520 return send( socket, data, i, j ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
521 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
522 handler.receive = function( pattern, prefix ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
523 return receive( socket, pattern, prefix ) |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
524 end |
66 | 525 |
526 handler.handshake = coroutine_wrap( function( client ) | |
527 local err | |
528 for i = 1, 10 do -- 10 handshake attemps | |
529 _, err = client:dohandshake( ) | |
530 if not err then | |
531 out_put( "server.lua: ssl handshake done" ) | |
532 writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen | |
533 handler.receivedata = handler._receivedata -- when handshake is done, replace the handshake function with regular functions | |
534 handler.dispatchdata = handler._dispatchdata | |
535 handler.need_tls = nil | |
536 socketlist[ client ] = handler | |
537 readlen = readlen + 1 | |
538 readlist[ readlen ] = client | |
539 return true; | |
540 else | |
541 out_put( "server.lua: error during ssl handshake: ", err ) | |
542 if err == "wantwrite" then | |
543 if wrote == nil then | |
544 writelen = writelen + 1 | |
545 writelist[ writelen ] = client | |
546 wrote = true | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
547 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
548 end |
66 | 549 coroutine_yield( handler, nil, err ) -- handshake not finished |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
550 end |
66 | 551 end |
552 _ = err ~= "closed" and close( socket ) | |
553 handler.close( ) | |
554 disconnect( handler, err ) | |
555 writequeue = nil | |
556 handler = nil | |
557 return false -- handshake failed | |
558 end | |
559 ) | |
560 handler.receivedata = handler.handshake | |
561 handler.dispatchdata = handler.handshake | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
562 |
66 | 563 handler.handshake( socket ) -- do handshake |
564 end | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
565 socketlist[ socket ] = handler |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
566 readlen = readlen + 1 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
567 readlist[ readlen ] = socket |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
568 |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
569 return handler, socket |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
570 end |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
571 |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
572 wraptcpclient = function( listener, socket, ip, serverport, clientport, mode ) -- this function wraps a socket |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
573 |
64 | 574 local dispatch, disconnect = listener.listener, listener.disconnect |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
575 |
64 | 576 --// private closures of the object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
577 |
64 | 578 local writequeue = { } -- list for messages to send |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
579 |
64 | 580 local eol |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
581 |
64 | 582 local rstat, sstat = 0, 0 |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
583 |
64 | 584 --// local import of socket methods //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
585 |
64 | 586 local send = socket.send |
587 local receive = socket.receive | |
588 local close = socket.close | |
589 local shutdown = socket.shutdown | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
590 |
64 | 591 --// public methods of the object //-- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
592 |
64 | 593 local handler = { } |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
594 |
64 | 595 handler.getstats = function( ) |
596 return rstat, sstat | |
597 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
598 |
64 | 599 handler.listener = function( data, err ) |
600 return listener( handler, data, err ) | |
601 end | |
602 handler.ssl = function( ) | |
603 return false | |
604 end | |
605 handler.send = function( _, data, i, j ) | |
606 return send( socket, data, i, j ) | |
607 end | |
608 handler.receive = function( pattern, prefix ) | |
609 return receive( socket, pattern, prefix ) | |
610 end | |
611 handler.shutdown = function( pattern ) | |
612 return shutdown( socket, pattern ) | |
613 end | |
614 handler.close = function( closed ) | |
615 _ = not closed and shutdown( socket ) | |
616 _ = not closed and close( socket ) | |
617 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen | |
618 readlen = removesocket( readlist, socket, readlen ) | |
619 socketlist[ socket ] = nil | |
620 out_put "server.lua: closed handler and removed socket from list" | |
621 end | |
622 handler.ip = function( ) | |
623 return ip | |
624 end | |
625 handler.serverport = function( ) | |
626 return serverport | |
627 end | |
628 handler.clientport = function( ) | |
629 return clientport | |
630 end | |
631 handler.write = function( data ) | |
632 if not eol then | |
633 writelen = writelen + 1 | |
634 writelist[ writelen ] = socket | |
635 eol = 0 | |
636 end | |
637 eol = eol + 1 | |
638 writequeue[ eol ] = data | |
639 end | |
640 handler.writequeue = function( ) | |
641 return writequeue | |
642 end | |
643 handler.socket = function( ) | |
644 return socket | |
645 end | |
646 handler.mode = function( ) | |
647 return mode | |
648 end | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
649 |
64 | 650 handler.receivedata = function( ) |
651 local data, err, part = receive( socket, mode ) -- receive data in "mode" | |
652 if not err or ( err == "timeout" or err == "wantread" ) then -- received something | |
653 local data = data or part or "" | |
654 local count = #data * STAT_UNIT | |
655 rstat = rstat + count | |
656 receivestat = receivestat + count | |
657 out_put( "server.lua: read data '", data, "', error: ", err ) | |
658 return dispatch( handler, data, err ) | |
659 else -- connections was closed or fatal error | |
660 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) | |
661 handler.close( ) | |
662 disconnect( handler, err ) | |
663 writequeue = nil | |
664 handler = nil | |
665 return false | |
666 end | |
667 end | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
668 |
64 | 669 handler.dispatchdata = function( ) -- this function writes data to handlers |
670 local buffer = table_concat( writequeue, "", 1, eol ) | |
671 local succ, err, byte = send( socket, buffer ) | |
672 local count = ( succ or 0 ) * STAT_UNIT | |
673 sstat = sstat + count | |
674 sendstat = sendstat + count | |
675 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport ) | |
676 if succ then -- sending succesful | |
677 --writequeue = { } | |
678 eol = nil | |
679 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist | |
680 return true | |
681 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write | |
682 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer | |
683 writequeue[ 1 ] = buffer -- insert new buffer in queue | |
684 eol = 1 | |
685 return true | |
686 else -- connection was closed during sending or fatal error | |
687 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err ) | |
688 handler.close( ) | |
689 disconnect( handler, err ) | |
690 writequeue = nil | |
691 handler = nil | |
692 return false | |
693 end | |
694 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
695 |
64 | 696 -- // COMPAT // -- |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
697 |
64 | 698 handler.getIp = handler.ip |
699 handler.getPort = handler.clientport | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
700 |
64 | 701 socketlist[ socket ] = handler |
702 readlen = readlen + 1 | |
703 readlist[ readlen ] = socket | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
704 |
64 | 705 return handler, socket |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
706 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
707 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
708 addtimer = function( listener ) |
64 | 709 timelistener[ #timelistener + 1 ] = listener |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
710 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
711 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
712 firetimer = function( listener ) |
64 | 713 for i, listener in ipairs( timelistener ) do |
714 listener( ) | |
715 end | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
716 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
717 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
718 addserver = function( listeners, port, addr, mode, sslctx ) -- this function provides a way for other scripts to reg a server |
64 | 719 local err |
720 if type( listeners ) ~= "table" then | |
721 err = "invalid listener table" | |
722 else | |
723 for name, func in pairs( listeners ) do | |
724 if type( func ) ~= "function" then | |
98
3a2d327c4856
server.lua should degrade gracefully when LuaSec not present
Matthew Wild <mwild1@gmail.com>
parents:
74
diff
changeset
|
725 --err = "invalid listener function" |
64 | 726 break |
727 end | |
728 end | |
729 end | |
730 if not type( port ) == "number" or not ( port >= 0 and port <= 65535 ) then | |
731 err = "invalid port" | |
732 elseif listener[ port ] then | |
733 err= "listeners on port '" .. port .. "' already exist" | |
734 elseif sslctx and not luasec then | |
735 err = "luasec not found" | |
736 end | |
737 if err then | |
738 out_error( "server.lua: ", err ) | |
739 return nil, err | |
740 end | |
741 addr = addr or "*" | |
742 local server, err = socket_bind( addr, port ) | |
743 if err then | |
744 out_error( "server.lua: ", err ) | |
745 return nil, err | |
746 end | |
747 local handler, err = wrapserver( listeners, server, addr, port, mode, sslctx ) -- wrap new server socket | |
748 if not handler then | |
749 server:close( ) | |
750 return nil, err | |
751 end | |
752 server:settimeout( 0 ) | |
753 readlen = readlen + 1 | |
754 readlist[ readlen ] = server | |
755 listener[ port ] = listeners | |
756 socketlist[ server ] = handler | |
757 out_put( "server.lua: new server listener on ", addr, ":", port ) | |
758 return true | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
759 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
760 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
761 removesocket = function( tbl, socket, len ) -- this function removes sockets from a list |
64 | 762 for i, target in ipairs( tbl ) do |
763 if target == socket then | |
764 len = len - 1 | |
765 table_remove( tbl, i ) | |
766 return len | |
767 end | |
768 end | |
769 return len | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
770 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
771 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
772 closeall = function( ) |
64 | 773 for sock, handler in pairs( socketlist ) do |
774 handler.shutdown( ) | |
775 handler.close( ) | |
776 socketlist[ sock ] = nil | |
777 end | |
778 writelist, readlist, socketlist = { }, { }, { } | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
779 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
780 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
781 closesocket = function( socket ) |
64 | 782 writelen = removesocket( writelist, socket, writelen ) |
783 readlen = removesocket( readlist, socket, readlen ) | |
784 socketlist[ socket ] = nil | |
785 socket:close( ) | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
786 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
787 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
788 loop = function( ) -- this is the main loop of the program |
64 | 789 --signal_set( "hub", "run" ) |
790 repeat | |
66 | 791 --[[print(readlen, writelen) |
792 for _, s in ipairs(readlist) do print("R:", tostring(s)) end | |
793 for _, s in ipairs(writelist) do print("W:", tostring(s)) end | |
794 out_put("select()"..os.time())]] | |
64 | 795 local read, write, err = socket_select( readlist, writelist, 1 ) -- 1 sec timeout, nice for timers |
796 for i, socket in ipairs( write ) do -- send data waiting in writequeues | |
797 local handler = socketlist[ socket ] | |
798 if handler then | |
799 handler.dispatchdata( ) | |
800 else | |
801 closesocket( socket ) | |
802 out_put "server.lua: found no handler and closed socket (writelist)" -- this should not happen | |
803 end | |
804 end | |
805 for i, socket in ipairs( read ) do -- receive data | |
806 local handler = socketlist[ socket ] | |
807 if handler then | |
808 handler.receivedata( ) | |
809 else | |
810 closesocket( socket ) | |
811 out_put "server.lua: found no handler and closed socket (readlist)" -- this can happen | |
812 end | |
813 end | |
814 firetimer( ) | |
65
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
815 until false |
9c471840acb9
TLS: Handshake works, no data after that
Matthew Wild <mwild1@gmail.com>
parents:
64
diff
changeset
|
816 return |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
817 end |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
818 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
819 ----------------------------------// BEGIN //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
820 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
821 ----------------------------------// PUBLIC INTERFACE //-- |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
822 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
823 return { |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
824 |
64 | 825 add = addserver, |
826 loop = loop, | |
827 stats = stats, | |
828 closeall = closeall, | |
829 addtimer = addtimer, | |
1
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
830 |
b8787e859fd2
Switched to new connection framework, courtesy of the luadch project
matthew
parents:
diff
changeset
|
831 } |