3 server.lua by blastbeat of the luadch project
\r
5 re-used here under the MIT/X Consortium License
\r
7 - this script contains the server loop of the program
\r
8 - other scripts can reg a server here
\r
12 ----------------------------------// DECLARATION //--
\r
16 local STAT_UNIT = 1 / ( 1024 * 1024 ) -- mb
\r
18 --// lua functions //--
\r
20 local function use( what ) return _G[ what ] end
\r
22 local type = use "type"
\r
23 local pairs = use "pairs"
\r
24 local ipairs = use "ipairs"
\r
25 local tostring = use "tostring"
\r
26 local collectgarbage = use "collectgarbage"
\r
30 local table = use "table"
\r
31 local coroutine = use "coroutine"
\r
33 --// lua lib methods //--
\r
35 local table_concat = table.concat
\r
36 local table_remove = table.remove
\r
37 local string_sub = use'string'.sub
\r
38 local coroutine_wrap = coroutine.wrap
\r
39 local coroutine_yield = coroutine.yield
\r
40 local print = print;
\r
41 local out_put = function () end --print;
\r
42 local out_error = print;
\r
44 --// extern libs //--
\r
46 local luasec = select(2, pcall(require, "ssl"))
\r
47 local luasocket = require "socket"
\r
49 --// extern lib methods //--
\r
51 local ssl_wrap = ( luasec and luasec.wrap )
\r
52 local socket_bind = luasocket.bind
\r
53 local socket_select = luasocket.select
\r
54 local ssl_newcontext = ( luasec and luasec.newcontext )
\r
78 --// simple data types //--
\r
81 local readlen = 0 -- length of readlist
\r
82 local writelen = 0 -- lenght of writelist
\r
85 local receivestat = 0
\r
87 ----------------------------------// DEFINITION //--
\r
89 listener = { } -- key = port, value = table
\r
90 readlist = { } -- array with sockets to read from
\r
91 writelist = { } -- arrary with sockets to write to
\r
92 socketlist = { } -- key = socket, value = wrapped socket
\r
96 return receivestat, sendstat
\r
99 wrapserver = function( listener, socket, ip, serverport, mode, sslctx ) -- this function wraps a server
\r
101 local dispatch, disconnect = listener.listener, listener.disconnect -- dangerous
\r
103 local wrapclient, err
\r
106 if not ssl_newcontext then
\r
107 return nil, "luasec not found"
\r
109 if type( sslctx ) ~= "table" then
\r
110 out_error "server.lua: wrong server sslctx"
\r
111 return nil, "wrong server sslctx"
\r
113 sslctx, err = ssl_newcontext( sslctx )
\r
115 err = err or "wrong sslctx parameters"
\r
116 out_error( "server.lua: ", err )
\r
119 wrapclient = wrapsslclient
\r
120 wrapclient = wraptlsclient
\r
122 wrapclient = wraptcpclient
\r
125 local accept = socket.accept
\r
126 local close = socket.close
\r
128 --// public methods of the object //--
\r
130 local handler = { }
\r
132 handler.shutdown = function( ) end
\r
134 --[[handler.listener = function( data, err )
\r
135 return ondata( handler, data, err )
\r
137 handler.ssl = function( )
\r
138 return sslctx and true or false
\r
140 handler.close = function( closed )
\r
141 _ = not closed and close( socket )
\r
142 writelen = removesocket( writelist, socket, writelen )
\r
143 readlen = removesocket( readlist, socket, readlen )
\r
144 socketlist[ socket ] = nil
\r
147 handler.ip = function( )
\r
150 handler.serverport = function( )
\r
153 handler.socket = function( )
\r
156 handler.receivedata = function( )
\r
157 local client, err = accept( socket ) -- try to accept
\r
159 local ip, clientport = client:getpeername( )
\r
160 client:settimeout( 0 )
\r
161 local handler, client, err = wrapclient( listener, client, ip, serverport, clientport, mode, sslctx ) -- wrap new client socket
\r
162 if err then -- error while wrapping ssl socket
\r
165 out_put( "server.lua: accepted new client connection from ", ip, ":", clientport )
\r
166 return dispatch( handler )
\r
167 elseif err then -- maybe timeout or something else
\r
168 out_put( "server.lua: error with new client connection: ", err )
\r
175 wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, sslctx ) -- this function wraps a ssl cleint
\r
177 local dispatch, disconnect = listener.listener, listener.disconnect
\r
179 --// transform socket to ssl object //--
\r
182 socket, err = ssl_wrap( socket, sslctx ) -- wrap socket
\r
184 out_put( "server.lua: ssl error: ", err )
\r
185 return nil, nil, err -- fatal error
\r
187 socket:settimeout( 0 )
\r
189 --// private closures of the object //--
\r
191 local writequeue = { } -- buffer for messages to send
\r
193 local eol -- end of buffer
\r
195 local sstat, rstat = 0, 0
\r
197 --// local import of socket methods //--
\r
199 local send = socket.send
\r
200 local receive = socket.receive
\r
201 local close = socket.close
\r
202 --local shutdown = socket.shutdown
\r
204 --// public methods of the object //--
\r
206 local handler = { }
\r
208 handler.getstats = function( )
\r
209 return rstat, sstat
\r
212 handler.listener = function( data, err )
\r
213 return listener( handler, data, err )
\r
215 handler.ssl = function( )
\r
218 handler.send = function( _, data, i, j )
\r
219 return send( socket, data, i, j )
\r
221 handler.receive = function( pattern, prefix )
\r
222 return receive( socket, pattern, prefix )
\r
224 handler.shutdown = function( pattern )
\r
225 --return shutdown( socket, pattern )
\r
227 handler.close = function( closed )
\r
229 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen
\r
230 readlen = removesocket( readlist, socket, readlen )
\r
231 socketlist[ socket ] = nil
\r
232 out_put "server.lua: closed handler and removed socket from list"
\r
234 handler.ip = function( )
\r
237 handler.serverport = function( )
\r
240 handler.clientport = function( )
\r
244 handler.write = function( data )
\r
246 writelen = writelen + 1
\r
247 writelist[ writelen ] = socket
\r
251 writequeue[ eol ] = data
\r
253 handler.writequeue = function( )
\r
256 handler.socket = function( )
\r
259 handler.mode = function( )
\r
262 handler._receivedata = function( )
\r
263 local data, err, part = receive( socket, mode ) -- receive data in "mode"
\r
264 if not err or ( err == "timeout" or err == "wantread" ) then -- received something
\r
265 local data = data or part or ""
\r
266 local count = #data * STAT_UNIT
\r
267 rstat = rstat + count
\r
268 receivestat = receivestat + count
\r
269 out_put( "server.lua: read data '", data, "', error: ", err )
\r
270 return dispatch( handler, data, err )
\r
271 else -- connections was closed or fatal error
\r
272 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
274 disconnect( handler, err )
\r
280 handler._dispatchdata = function( ) -- this function writes data to handlers
\r
281 local buffer = table_concat( writequeue, "", 1, eol )
\r
282 local succ, err, byte = send( socket, buffer )
\r
283 local count = ( succ or 0 ) * STAT_UNIT
\r
284 sstat = sstat + count
\r
285 sendstat = sendstat + count
\r
286 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )
\r
287 if succ then -- sending succesful
\r
290 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist
\r
292 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write
\r
293 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer
\r
294 writequeue[ 1 ] = buffer -- insert new buffer in queue
\r
297 else -- connection was closed during sending or fatal error
\r
298 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
300 disconnect( handler, err )
\r
309 handler.getIp = handler.ip
\r
310 handler.getPort = handler.clientport
\r
312 --// handshake //--
\r
316 handler.handshake = coroutine_wrap( function( client )
\r
318 for i = 1, 10 do -- 10 handshake attemps
\r
319 _, err = client:dohandshake( )
\r
321 out_put( "server.lua: ssl handshake done" )
\r
322 writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen
\r
323 handler.receivedata = handler._receivedata -- when handshake is done, replace the handshake function with regular functions
\r
324 handler.dispatchdata = handler._dispatchdata
\r
325 return dispatch( handler )
\r
327 out_put( "server.lua: error during ssl handshake: ", err )
\r
328 if err == "wantwrite" then
\r
329 if wrote == nil then
\r
330 writelen = writelen + 1
\r
331 writelist[ writelen ] = client
\r
335 coroutine_yield( handler, nil, err ) -- handshake not finished
\r
338 _ = err ~= "closed" and close( socket )
\r
340 disconnect( handler, err )
\r
343 return false -- handshake failed
\r
346 handler.receivedata = handler.handshake
\r
347 handler.dispatchdata = handler.handshake
\r
349 handler.handshake( socket ) -- do handshake
\r
351 socketlist[ socket ] = handler
\r
352 readlen = readlen + 1
\r
353 readlist[ readlen ] = socket
\r
355 return handler, socket
\r
358 wraptlsclient = function( listener, socket, ip, serverport, clientport, mode, sslctx ) -- this function wraps a tls cleint
\r
360 local dispatch, disconnect = listener.listener, listener.disconnect
\r
362 --// transform socket to ssl object //--
\r
366 socket:settimeout( 0 )
\r
368 --// private closures of the object //--
\r
370 local writequeue = { } -- buffer for messages to send
\r
372 local eol -- end of buffer
\r
374 local sstat, rstat = 0, 0
\r
376 --// local import of socket methods //--
\r
378 local send = socket.send
\r
379 local receive = socket.receive
\r
380 local close = socket.close
\r
381 --local shutdown = socket.shutdown
\r
383 --// public methods of the object //--
\r
385 local handler = { }
\r
387 handler.getstats = function( )
\r
388 return rstat, sstat
\r
391 handler.listener = function( data, err )
\r
392 return listener( handler, data, err )
\r
394 handler.ssl = function( )
\r
397 handler.send = function( _, data, i, j )
\r
398 return send( socket, data, i, j )
\r
400 handler.receive = function( pattern, prefix )
\r
401 return receive( socket, pattern, prefix )
\r
403 handler.shutdown = function( pattern )
\r
404 --return shutdown( socket, pattern )
\r
406 handler.close = function( closed )
\r
408 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen
\r
409 readlen = removesocket( readlist, socket, readlen )
\r
410 socketlist[ socket ] = nil
\r
411 out_put "server.lua: closed handler and removed socket from list"
\r
413 handler.ip = function( )
\r
416 handler.serverport = function( )
\r
419 handler.clientport = function( )
\r
423 handler.write = function( data )
\r
425 writelen = writelen + 1
\r
426 writelist[ writelen ] = socket
\r
430 writequeue[ eol ] = data
\r
432 handler.writequeue = function( )
\r
435 handler.socket = function( )
\r
438 handler.mode = function( )
\r
441 handler._receivedata = function( )
\r
442 local data, err, part = receive( socket, mode ) -- receive data in "mode"
\r
443 if not err or ( err == "timeout" or err == "wantread" ) then -- received something
\r
444 local data = data or part or ""
\r
445 local count = #data * STAT_UNIT
\r
446 rstat = rstat + count
\r
447 receivestat = receivestat + count
\r
448 --out_put( "server.lua: read data '", data, "', error: ", err )
\r
449 return dispatch( handler, data, err )
\r
450 else -- connections was closed or fatal error
\r
451 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
453 disconnect( handler, err )
\r
459 handler._dispatchdata = function( ) -- this function writes data to handlers
\r
460 local buffer = table_concat( writequeue, "", 1, eol )
\r
461 local succ, err, byte = send( socket, buffer )
\r
462 local count = ( succ or 0 ) * STAT_UNIT
\r
463 sstat = sstat + count
\r
464 sendstat = sendstat + count
\r
465 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )
\r
466 if succ then -- sending succesful
\r
469 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist
\r
470 if handler.need_tls then
\r
471 out_put("server.lua: connection is ready for tls handshake");
\r
472 handler.starttls(true);
\r
473 if handler.need_tls then
\r
474 out_put("server.lua: uh-oh... we still want tls, something must be wrong");
\r
478 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write
\r
479 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer
\r
480 writequeue[ 1 ] = buffer -- insert new buffer in queue
\r
483 else -- connection was closed during sending or fatal error
\r
484 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
486 disconnect( handler, err )
\r
493 handler.receivedata, handler.dispatchdata = handler._receivedata, handler._dispatchdata;
\r
496 handler.getIp = handler.ip
\r
497 handler.getPort = handler.clientport
\r
499 --// handshake //--
\r
503 handler.starttls = function (now)
\r
504 if not now then out_put("server.lua: we need to do tls, but delaying until later"); handler.need_tls = true; return; end
\r
505 out_put( "server.lua: attempting to start tls on "..tostring(socket) )
\r
506 socket, err = ssl_wrap( socket, sslctx ) -- wrap socket
\r
507 out_put("sslwrapped socket is "..tostring(socket));
\r
509 out_put( "server.lua: ssl error: ", err )
\r
510 return nil, nil, err -- fatal error
\r
512 socket:settimeout( 1 )
\r
514 receive = socket.receive
\r
515 close = socket.close
\r
516 handler.ssl = function( )
\r
519 handler.send = function( _, data, i, j )
\r
520 return send( socket, data, i, j )
\r
522 handler.receive = function( pattern, prefix )
\r
523 return receive( socket, pattern, prefix )
\r
526 handler.handshake = coroutine_wrap( function( client )
\r
528 for i = 1, 10 do -- 10 handshake attemps
\r
529 _, err = client:dohandshake( )
\r
531 out_put( "server.lua: ssl handshake done" )
\r
532 writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen
\r
533 handler.receivedata = handler._receivedata -- when handshake is done, replace the handshake function with regular functions
\r
534 handler.dispatchdata = handler._dispatchdata
\r
535 handler.need_tls = nil
\r
536 socketlist[ client ] = handler
\r
537 readlen = readlen + 1
\r
538 readlist[ readlen ] = client
\r
541 out_put( "server.lua: error during ssl handshake: ", err )
\r
542 if err == "wantwrite" then
\r
543 if wrote == nil then
\r
544 writelen = writelen + 1
\r
545 writelist[ writelen ] = client
\r
549 coroutine_yield( handler, nil, err ) -- handshake not finished
\r
552 _ = err ~= "closed" and close( socket )
\r
554 disconnect( handler, err )
\r
557 return false -- handshake failed
\r
560 handler.receivedata = handler.handshake
\r
561 handler.dispatchdata = handler.handshake
\r
563 handler.handshake( socket ) -- do handshake
\r
565 socketlist[ socket ] = handler
\r
566 readlen = readlen + 1
\r
567 readlist[ readlen ] = socket
\r
569 return handler, socket
\r
572 wraptcpclient = function( listener, socket, ip, serverport, clientport, mode ) -- this function wraps a socket
\r
574 local dispatch, disconnect = listener.listener, listener.disconnect
\r
576 --// private closures of the object //--
\r
578 local writequeue = { } -- list for messages to send
\r
582 local rstat, sstat = 0, 0
\r
584 --// local import of socket methods //--
\r
586 local send = socket.send
\r
587 local receive = socket.receive
\r
588 local close = socket.close
\r
589 local shutdown = socket.shutdown
\r
591 --// public methods of the object //--
\r
593 local handler = { }
\r
595 handler.getstats = function( )
\r
596 return rstat, sstat
\r
599 handler.listener = function( data, err )
\r
600 return listener( handler, data, err )
\r
602 handler.ssl = function( )
\r
605 handler.send = function( _, data, i, j )
\r
606 return send( socket, data, i, j )
\r
608 handler.receive = function( pattern, prefix )
\r
609 return receive( socket, pattern, prefix )
\r
611 handler.shutdown = function( pattern )
\r
612 return shutdown( socket, pattern )
\r
614 handler.close = function( closed )
\r
615 _ = not closed and shutdown( socket )
\r
616 _ = not closed and close( socket )
\r
617 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen
\r
618 readlen = removesocket( readlist, socket, readlen )
\r
619 socketlist[ socket ] = nil
\r
620 out_put "server.lua: closed handler and removed socket from list"
\r
622 handler.ip = function( )
\r
625 handler.serverport = function( )
\r
628 handler.clientport = function( )
\r
631 handler.write = function( data )
\r
633 writelen = writelen + 1
\r
634 writelist[ writelen ] = socket
\r
638 writequeue[ eol ] = data
\r
640 handler.writequeue = function( )
\r
643 handler.socket = function( )
\r
646 handler.mode = function( )
\r
650 handler.receivedata = function( )
\r
651 local data, err, part = receive( socket, mode ) -- receive data in "mode"
\r
652 if not err or ( err == "timeout" or err == "wantread" ) then -- received something
\r
653 local data = data or part or ""
\r
654 local count = #data * STAT_UNIT
\r
655 rstat = rstat + count
\r
656 receivestat = receivestat + count
\r
657 out_put( "server.lua: read data '", data, "', error: ", err )
\r
658 return dispatch( handler, data, err )
\r
659 else -- connections was closed or fatal error
\r
660 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
662 disconnect( handler, err )
\r
669 handler.dispatchdata = function( ) -- this function writes data to handlers
\r
670 local buffer = table_concat( writequeue, "", 1, eol )
\r
671 local succ, err, byte = send( socket, buffer )
\r
672 local count = ( succ or 0 ) * STAT_UNIT
\r
673 sstat = sstat + count
\r
674 sendstat = sendstat + count
\r
675 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )
\r
676 if succ then -- sending succesful
\r
679 writelen = removesocket( writelist, socket, writelen ) -- delete socket from writelist
\r
681 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write
\r
682 buffer = string_sub( buffer, byte + 1, -1 ) -- new buffer
\r
683 writequeue[ 1 ] = buffer -- insert new buffer in queue
\r
686 else -- connection was closed during sending or fatal error
\r
687 out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )
\r
689 disconnect( handler, err )
\r
698 handler.getIp = handler.ip
\r
699 handler.getPort = handler.clientport
\r
701 socketlist[ socket ] = handler
\r
702 readlen = readlen + 1
\r
703 readlist[ readlen ] = socket
\r
705 return handler, socket
\r
708 addtimer = function( listener )
\r
709 timelistener[ #timelistener + 1 ] = listener
\r
712 firetimer = function( listener )
\r
713 for i, listener in ipairs( timelistener ) do
\r
718 addserver = function( listeners, port, addr, mode, sslctx ) -- this function provides a way for other scripts to reg a server
\r
720 if type( listeners ) ~= "table" then
\r
721 err = "invalid listener table"
\r
723 for name, func in pairs( listeners ) do
\r
724 if type( func ) ~= "function" then
\r
725 --err = "invalid listener function"
\r
730 if not type( port ) == "number" or not ( port >= 0 and port <= 65535 ) then
\r
731 err = "invalid port"
\r
732 elseif listener[ port ] then
\r
733 err= "listeners on port '" .. port .. "' already exist"
\r
734 elseif sslctx and not luasec then
\r
735 err = "luasec not found"
\r
738 out_error( "server.lua: ", err )
\r
742 local server, err = socket_bind( addr, port )
\r
744 out_error( "server.lua: ", err )
\r
747 local handler, err = wrapserver( listeners, server, addr, port, mode, sslctx ) -- wrap new server socket
\r
748 if not handler then
\r
752 server:settimeout( 0 )
\r
753 readlen = readlen + 1
\r
754 readlist[ readlen ] = server
\r
755 listener[ port ] = listeners
\r
756 socketlist[ server ] = handler
\r
757 out_put( "server.lua: new server listener on ", addr, ":", port )
\r
761 removesocket = function( tbl, socket, len ) -- this function removes sockets from a list
\r
762 for i, target in ipairs( tbl ) do
\r
763 if target == socket then
\r
765 table_remove( tbl, i )
\r
772 closeall = function( )
\r
773 for sock, handler in pairs( socketlist ) do
\r
774 handler.shutdown( )
\r
776 socketlist[ sock ] = nil
\r
778 writelist, readlist, socketlist = { }, { }, { }
\r
781 closesocket = function( socket )
\r
782 writelen = removesocket( writelist, socket, writelen )
\r
783 readlen = removesocket( readlist, socket, readlen )
\r
784 socketlist[ socket ] = nil
\r
788 loop = function( ) -- this is the main loop of the program
\r
789 --signal_set( "hub", "run" )
\r
791 --[[print(readlen, writelen)
\r
792 for _, s in ipairs(readlist) do print("R:", tostring(s)) end
\r
793 for _, s in ipairs(writelist) do print("W:", tostring(s)) end
\r
794 out_put("select()"..os.time())]]
\r
795 local read, write, err = socket_select( readlist, writelist, 1 ) -- 1 sec timeout, nice for timers
\r
796 for i, socket in ipairs( write ) do -- send data waiting in writequeues
\r
797 local handler = socketlist[ socket ]
\r
799 handler.dispatchdata( )
\r
801 closesocket( socket )
\r
802 out_put "server.lua: found no handler and closed socket (writelist)" -- this should not happen
\r
805 for i, socket in ipairs( read ) do -- receive data
\r
806 local handler = socketlist[ socket ]
\r
808 handler.receivedata( )
\r
810 closesocket( socket )
\r
811 out_put "server.lua: found no handler and closed socket (readlist)" -- this can happen
\r
819 ----------------------------------// BEGIN //--
\r
821 ----------------------------------// PUBLIC INTERFACE //--
\r
828 closeall = closeall,
\r
829 addtimer = addtimer,
\r
830 wraptlsclient = wraptlsclient,
\r