Merge 0.9->0.10
[prosody.git] / net / server_select.lua
1 --
2 -- server.lua by blastbeat of the luadch project
3 -- Re-used here under the MIT/X Consortium License
4 --
5 -- Modifications (C) 2008-2010 Matthew Wild, Waqas Hussain
6 --
7
8 -- // wrapping luadch stuff // --
9
10 local use = function( what )
11         return _G[ what ]
12 end
13
14 local log, table_concat = require ("util.logger").init("socket"), table.concat;
15 local out_put = function (...) return log("debug", table_concat{...}); end
16 local out_error = function (...) return log("warn", table_concat{...}); end
17
18 ----------------------------------// DECLARATION //--
19
20 --// constants //--
21
22 local STAT_UNIT = 1 -- byte
23
24 --// lua functions //--
25
26 local type = use "type"
27 local pairs = use "pairs"
28 local ipairs = use "ipairs"
29 local tonumber = use "tonumber"
30 local tostring = use "tostring"
31
32 --// lua libs //--
33
34 local os = use "os"
35 local table = use "table"
36 local string = use "string"
37 local coroutine = use "coroutine"
38
39 --// lua lib methods //--
40
41 local os_difftime = os.difftime
42 local math_min = math.min
43 local math_huge = math.huge
44 local table_concat = table.concat
45 local string_sub = string.sub
46 local coroutine_wrap = coroutine.wrap
47 local coroutine_yield = coroutine.yield
48
49 --// extern libs //--
50
51 local has_luasec, luasec = pcall ( require , "ssl" )
52 local luasocket = use "socket" or require "socket"
53 local luasocket_gettime = luasocket.gettime
54
55 --// extern lib methods //--
56
57 local ssl_wrap = ( has_luasec and luasec.wrap )
58 local socket_bind = luasocket.bind
59 local socket_sleep = luasocket.sleep
60 local socket_select = luasocket.select
61
62 --// functions //--
63
64 local id
65 local loop
66 local stats
67 local idfalse
68 local closeall
69 local addsocket
70 local addserver
71 local addtimer
72 local getserver
73 local wrapserver
74 local getsettings
75 local closesocket
76 local removesocket
77 local removeserver
78 local wrapconnection
79 local changesettings
80
81 --// tables //--
82
83 local _server
84 local _readlist
85 local _timerlist
86 local _sendlist
87 local _socketlist
88 local _closelist
89 local _readtimes
90 local _writetimes
91
92 --// simple data types //--
93
94 local _
95 local _readlistlen
96 local _sendlistlen
97 local _timerlistlen
98
99 local _sendtraffic
100 local _readtraffic
101
102 local _selecttimeout
103 local _sleeptime
104 local _tcpbacklog
105
106 local _starttime
107 local _currenttime
108
109 local _maxsendlen
110 local _maxreadlen
111
112 local _checkinterval
113 local _sendtimeout
114 local _readtimeout
115
116 local _timer
117
118 local _maxselectlen
119 local _maxfd
120
121 local _maxsslhandshake
122
123 ----------------------------------// DEFINITION //--
124
125 _server = { } -- key = port, value = table; list of listening servers
126 _readlist = { } -- array with sockets to read from
127 _sendlist = { } -- arrary with sockets to write to
128 _timerlist = { } -- array of timer functions
129 _socketlist = { } -- key = socket, value = wrapped socket (handlers)
130 _readtimes = { } -- key = handler, value = timestamp of last data reading
131 _writetimes = { } -- key = handler, value = timestamp of last data writing/sending
132 _closelist = { } -- handlers to close
133
134 _readlistlen = 0 -- length of readlist
135 _sendlistlen = 0 -- length of sendlist
136 _timerlistlen = 0 -- lenght of timerlist
137
138 _sendtraffic = 0 -- some stats
139 _readtraffic = 0
140
141 _selecttimeout = 1 -- timeout of socket.select
142 _sleeptime = 0 -- time to wait at the end of every loop
143 _tcpbacklog = 128 -- some kind of hint to the OS
144
145 _maxsendlen = 51000 * 1024 -- max len of send buffer
146 _maxreadlen = 25000 * 1024 -- max len of read buffer
147
148 _checkinterval = 30 -- interval in secs to check idle clients
149 _sendtimeout = 60000 -- allowed send idle time in secs
150 _readtimeout = 6 * 60 * 60 -- allowed read idle time in secs
151
152 local is_windows = package.config:sub(1,1) == "\\" -- check the directory separator, to detemine whether this is Windows
153 _maxfd = (is_windows and math.huge) or luasocket._SETSIZE or 1024 -- max fd number, limit to 1024 by default to prevent glibc buffer overflow, but not on Windows
154 _maxselectlen = luasocket._SETSIZE or 1024 -- But this still applies on Windows
155
156 _maxsslhandshake = 30 -- max handshake round-trips
157
158 ----------------------------------// PRIVATE //--
159
160 wrapserver = function( listeners, socket, ip, serverport, pattern, sslctx ) -- this function wraps a server -- FIXME Make sure FD < _maxfd
161
162         if socket:getfd() >= _maxfd then
163                 out_error("server.lua: Disallowed FD number: "..socket:getfd())
164                 socket:close()
165                 return nil, "fd-too-large"
166         end
167
168         local connections = 0
169
170         local dispatch, disconnect = listeners.onconnect, listeners.ondisconnect
171
172         local accept = socket.accept
173
174         --// public methods of the object //--
175
176         local handler = { }
177
178         handler.shutdown = function( ) end
179
180         handler.ssl = function( )
181                 return sslctx ~= nil
182         end
183         handler.sslctx = function( )
184                 return sslctx
185         end
186         handler.remove = function( )
187                 connections = connections - 1
188                 if handler then
189                         handler.resume( )
190                 end
191         end
192         handler.close = function()
193                 socket:close( )
194                 _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
195                 _readlistlen = removesocket( _readlist, socket, _readlistlen )
196                 _server[ip..":"..serverport] = nil;
197                 _socketlist[ socket ] = nil
198                 handler = nil
199                 socket = nil
200                 --mem_free( )
201                 out_put "server.lua: closed server handler and removed sockets from list"
202         end
203         handler.pause = function( hard )
204                 if not handler.paused then
205                         _readlistlen = removesocket( _readlist, socket, _readlistlen )
206                         if hard then
207                                 _socketlist[ socket ] = nil
208                                 socket:close( )
209                                 socket = nil;
210                         end
211                         handler.paused = true;
212                 end
213         end
214         handler.resume = function( )
215                 if handler.paused then
216                         if not socket then
217                                 socket = socket_bind( ip, serverport, _tcpbacklog );
218                                 socket:settimeout( 0 )
219                         end
220                         _readlistlen = addsocket(_readlist, socket, _readlistlen)
221                         _socketlist[ socket ] = handler
222                         handler.paused = false;
223                 end
224         end
225         handler.ip = function( )
226                 return ip
227         end
228         handler.serverport = function( )
229                 return serverport
230         end
231         handler.socket = function( )
232                 return socket
233         end
234         handler.readbuffer = function( )
235                 if _readlistlen >= _maxselectlen or _sendlistlen >= _maxselectlen then
236                         handler.pause( )
237                         out_put( "server.lua: refused new client connection: server full" )
238                         return false
239                 end
240                 local client, err = accept( socket )    -- try to accept
241                 if client then
242                         local ip, clientport = client:getpeername( )
243                         local handler, client, err = wrapconnection( handler, listeners, client, ip, serverport, clientport, pattern, sslctx ) -- wrap new client socket
244                         if err then -- error while wrapping ssl socket
245                                 return false
246                         end
247                         connections = connections + 1
248                         out_put( "server.lua: accepted new client connection from ", tostring(ip), ":", tostring(clientport), " to ", tostring(serverport))
249                         if dispatch and not sslctx then -- SSL connections will notify onconnect when handshake completes
250                                 return dispatch( handler );
251                         end
252                         return;
253                 elseif err then -- maybe timeout or something else
254                         out_put( "server.lua: error with new client connection: ", tostring(err) )
255                         return false
256                 end
257         end
258         return handler
259 end
260
261 wrapconnection = function( server, listeners, socket, ip, serverport, clientport, pattern, sslctx ) -- this function wraps a client to a handler object
262
263         if socket:getfd() >= _maxfd then
264                 out_error("server.lua: Disallowed FD number: "..socket:getfd()) -- PROTIP: Switch to libevent
265                 socket:close( ) -- Should we send some kind of error here?
266                 if server then
267                         server.pause( )
268                 end
269                 return nil, nil, "fd-too-large"
270         end
271         socket:settimeout( 0 )
272
273         --// local import of socket methods //--
274
275         local send
276         local receive
277         local shutdown
278
279         --// private closures of the object //--
280
281         local ssl
282
283         local dispatch = listeners.onincoming
284         local status = listeners.onstatus
285         local disconnect = listeners.ondisconnect
286         local drain = listeners.ondrain
287         local onreadtimeout = listeners.onreadtimeout;
288         local detach = listeners.ondetach
289
290         local bufferqueue = { } -- buffer array
291         local bufferqueuelen = 0        -- end of buffer array
292
293         local toclose
294         local fatalerror
295         local needtls
296
297         local bufferlen = 0
298
299         local noread = false
300         local nosend = false
301
302         local sendtraffic, readtraffic = 0, 0
303
304         local maxsendlen = _maxsendlen
305         local maxreadlen = _maxreadlen
306
307         --// public methods of the object //--
308
309         local handler = bufferqueue -- saves a table ^_^
310
311         handler.dispatch = function( )
312                 return dispatch
313         end
314         handler.disconnect = function( )
315                 return disconnect
316         end
317         handler.onreadtimeout = onreadtimeout;
318
319         handler.setlistener = function( self, listeners )
320                 if detach then
321                         detach(self) -- Notify listener that it is no longer responsible for this connection
322                 end
323                 dispatch = listeners.onincoming
324                 disconnect = listeners.ondisconnect
325                 status = listeners.onstatus
326                 drain = listeners.ondrain
327                 handler.onreadtimeout = listeners.onreadtimeout
328                 detach = listeners.ondetach
329         end
330         handler.getstats = function( )
331                 return readtraffic, sendtraffic
332         end
333         handler.ssl = function( )
334                 return ssl
335         end
336         handler.sslctx = function ( )
337                 return sslctx
338         end
339         handler.send = function( _, data, i, j )
340                 return send( socket, data, i, j )
341         end
342         handler.receive = function( pattern, prefix )
343                 return receive( socket, pattern, prefix )
344         end
345         handler.shutdown = function( pattern )
346                 return shutdown( socket, pattern )
347         end
348         handler.setoption = function (self, option, value)
349                 if socket.setoption then
350                         return socket:setoption(option, value);
351                 end
352                 return false, "setoption not implemented";
353         end
354         handler.force_close = function ( self, err )
355                 if bufferqueuelen ~= 0 then
356                         out_put("server.lua: discarding unwritten data for ", tostring(ip), ":", tostring(clientport))
357                         bufferqueuelen = 0;
358                 end
359                 return self:close(err);
360         end
361         handler.close = function( self, err )
362                 if not handler then return true; end
363                 _readlistlen = removesocket( _readlist, socket, _readlistlen )
364                 _readtimes[ handler ] = nil
365                 if bufferqueuelen ~= 0 then
366                         handler.sendbuffer() -- Try now to send any outstanding data
367                         if bufferqueuelen ~= 0 then -- Still not empty, so we'll try again later
368                                 if handler then
369                                         handler.write = nil -- ... but no further writing allowed
370                                 end
371                                 toclose = true
372                                 return false
373                         end
374                 end
375                 if socket then
376                         _ = shutdown and shutdown( socket )
377                         socket:close( )
378                         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
379                         _socketlist[ socket ] = nil
380                         socket = nil
381                 else
382                         out_put "server.lua: socket already closed"
383                 end
384                 if handler then
385                         _writetimes[ handler ] = nil
386                         _closelist[ handler ] = nil
387                         local _handler = handler;
388                         handler = nil
389                         if disconnect then
390                                 disconnect(_handler, err or false);
391                                 disconnect = nil
392                         end
393                 end
394                 if server then
395                         server.remove( )
396                 end
397                 out_put "server.lua: closed client handler and removed socket from list"
398                 return true
399         end
400         handler.ip = function( )
401                 return ip
402         end
403         handler.serverport = function( )
404                 return serverport
405         end
406         handler.clientport = function( )
407                 return clientport
408         end
409         handler.port = handler.clientport -- COMPAT server_event
410         local write = function( self, data )
411                 bufferlen = bufferlen + #data
412                 if bufferlen > maxsendlen then
413                         _closelist[ handler ] = "send buffer exceeded"   -- cannot close the client at the moment, have to wait to the end of the cycle
414                         handler.write = idfalse -- dont write anymore
415                         return false
416                 elseif socket and not _sendlist[ socket ] then
417                         _sendlistlen = addsocket(_sendlist, socket, _sendlistlen)
418                 end
419                 bufferqueuelen = bufferqueuelen + 1
420                 bufferqueue[ bufferqueuelen ] = data
421                 if handler then
422                         _writetimes[ handler ] = _writetimes[ handler ] or _currenttime
423                 end
424                 return true
425         end
426         handler.write = write
427         handler.bufferqueue = function( self )
428                 return bufferqueue
429         end
430         handler.socket = function( self )
431                 return socket
432         end
433         handler.set_mode = function( self, new )
434                 pattern = new or pattern
435                 return pattern
436         end
437         handler.set_send = function ( self, newsend )
438                 send = newsend or send
439                 return send
440         end
441         handler.bufferlen = function( self, readlen, sendlen )
442                 maxsendlen = sendlen or maxsendlen
443                 maxreadlen = readlen or maxreadlen
444                 return bufferlen, maxreadlen, maxsendlen
445         end
446         --TODO: Deprecate
447         handler.lock_read = function (self, switch)
448                 if switch == true then
449                         local tmp = _readlistlen
450                         _readlistlen = removesocket( _readlist, socket, _readlistlen )
451                         _readtimes[ handler ] = nil
452                         if _readlistlen ~= tmp then
453                                 noread = true
454                         end
455                 elseif switch == false then
456                         if noread then
457                                 noread = false
458                                 _readlistlen = addsocket(_readlist, socket, _readlistlen)
459                                 _readtimes[ handler ] = _currenttime
460                         end
461                 end
462                 return noread
463         end
464         handler.pause = function (self)
465                 return self:lock_read(true);
466         end
467         handler.resume = function (self)
468                 return self:lock_read(false);
469         end
470         handler.lock = function( self, switch )
471                 handler.lock_read (switch)
472                 if switch == true then
473                         handler.write = idfalse
474                         local tmp = _sendlistlen
475                         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
476                         _writetimes[ handler ] = nil
477                         if _sendlistlen ~= tmp then
478                                 nosend = true
479                         end
480                 elseif switch == false then
481                         handler.write = write
482                         if nosend then
483                                 nosend = false
484                                 write( "" )
485                         end
486                 end
487                 return noread, nosend
488         end
489         local _readbuffer = function( ) -- this function reads data
490                 local buffer, err, part = receive( socket, pattern )    -- receive buffer with "pattern"
491                 if not err or (err == "wantread" or err == "timeout") then -- received something
492                         local buffer = buffer or part or ""
493                         local len = #buffer
494                         if len > maxreadlen then
495                                 handler:close( "receive buffer exceeded" )
496                                 return false
497                         end
498                         local count = len * STAT_UNIT
499                         readtraffic = readtraffic + count
500                         _readtraffic = _readtraffic + count
501                         _readtimes[ handler ] = _currenttime
502                         --out_put( "server.lua: read data '", buffer:gsub("[^%w%p ]", "."), "', error: ", err )
503                         return dispatch( handler, buffer, err )
504                 else    -- connections was closed or fatal error
505                         out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " read error: ", tostring(err) )
506                         fatalerror = true
507                         _ = handler and handler:force_close( err )
508                         return false
509                 end
510         end
511         local _sendbuffer = function( ) -- this function sends data
512                 local succ, err, byte, buffer, count;
513                 if socket then
514                         buffer = table_concat( bufferqueue, "", 1, bufferqueuelen )
515                         succ, err, byte = send( socket, buffer, 1, bufferlen )
516                         count = ( succ or byte or 0 ) * STAT_UNIT
517                         sendtraffic = sendtraffic + count
518                         _sendtraffic = _sendtraffic + count
519                         for i = bufferqueuelen,1,-1 do
520                                 bufferqueue[ i ] = nil
521                         end
522                         --out_put( "server.lua: sended '", buffer, "', bytes: ", tostring(succ), ", error: ", tostring(err), ", part: ", tostring(byte), ", to: ", tostring(ip), ":", tostring(clientport) )
523                 else
524                         succ, err, count = false, "unexpected close", 0;
525                 end
526                 if succ then    -- sending succesful
527                         bufferqueuelen = 0
528                         bufferlen = 0
529                         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen ) -- delete socket from writelist
530                         _writetimes[ handler ] = nil
531                         if drain then
532                                 drain(handler)
533                         end
534                         _ = needtls and handler:starttls(nil)
535                         _ = toclose and handler:force_close( )
536                         return true
537                 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write
538                         buffer = string_sub( buffer, byte + 1, bufferlen ) -- new buffer
539                         bufferqueue[ 1 ] = buffer        -- insert new buffer in queue
540                         bufferqueuelen = 1
541                         bufferlen = bufferlen - byte
542                         _writetimes[ handler ] = _currenttime
543                         return true
544                 else    -- connection was closed during sending or fatal error
545                         out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " write error: ", tostring(err) )
546                         fatalerror = true
547                         _ = handler and handler:force_close( err )
548                         return false
549                 end
550         end
551
552         -- Set the sslctx
553         local handshake;
554         function handler.set_sslctx(self, new_sslctx)
555                 sslctx = new_sslctx;
556                 local read, wrote
557                 handshake = coroutine_wrap( function( client ) -- create handshake coroutine
558                                 local err
559                                 for i = 1, _maxsslhandshake do
560                                         _sendlistlen = ( wrote and removesocket( _sendlist, client, _sendlistlen ) ) or _sendlistlen
561                                         _readlistlen = ( read and removesocket( _readlist, client, _readlistlen ) ) or _readlistlen
562                                         read, wrote = nil, nil
563                                         _, err = client:dohandshake( )
564                                         if not err then
565                                                 out_put( "server.lua: ssl handshake done" )
566                                                 handler.readbuffer = _readbuffer        -- when handshake is done, replace the handshake function with regular functions
567                                                 handler.sendbuffer = _sendbuffer
568                                                 _ = status and status( handler, "ssl-handshake-complete" )
569                                                 if self.autostart_ssl and listeners.onconnect then
570                                                         listeners.onconnect(self);
571                                                         if bufferqueuelen ~= 0 then
572                                                                 _sendlistlen = addsocket(_sendlist, client, _sendlistlen)
573                                                         end
574                                                 end
575                                                 _readlistlen = addsocket(_readlist, client, _readlistlen)
576                                                 return true
577                                         else
578                                                 if err == "wantwrite" then
579                                                         _sendlistlen = addsocket(_sendlist, client, _sendlistlen)
580                                                         wrote = true
581                                                 elseif err == "wantread" then
582                                                         _readlistlen = addsocket(_readlist, client, _readlistlen)
583                                                         read = true
584                                                 else
585                                                         break;
586                                                 end
587                                                 err = nil;
588                                                 coroutine_yield( ) -- handshake not finished
589                                         end
590                                 end
591                                 out_put( "server.lua: ssl handshake error: ", tostring(err or "handshake too long") )
592                                 _ = handler and handler:force_close("ssl handshake failed")
593                                 return false, err -- handshake failed
594                         end
595                 )
596         end
597         if has_luasec then
598                 handler.starttls = function( self, _sslctx)
599                         if _sslctx then
600                                 handler:set_sslctx(_sslctx);
601                         end
602                         if bufferqueuelen > 0 then
603                                 out_put "server.lua: we need to do tls, but delaying until send buffer empty"
604                                 needtls = true
605                                 return
606                         end
607                         out_put( "server.lua: attempting to start tls on " .. tostring( socket ) )
608                         local oldsocket, err = socket
609                         socket, err = ssl_wrap( socket, sslctx )        -- wrap socket
610                         if not socket then
611                                 out_put( "server.lua: error while starting tls on client: ", tostring(err or "unknown error") )
612                                 return nil, err -- fatal error
613                         end
614
615                         socket:settimeout( 0 )
616
617                         -- add the new socket to our system
618                         send = socket.send
619                         receive = socket.receive
620                         shutdown = id
621                         _socketlist[ socket ] = handler
622                         _readlistlen = addsocket(_readlist, socket, _readlistlen)
623
624                         -- remove traces of the old socket
625                         _readlistlen = removesocket( _readlist, oldsocket, _readlistlen )
626                         _sendlistlen = removesocket( _sendlist, oldsocket, _sendlistlen )
627                         _socketlist[ oldsocket ] = nil
628
629                         handler.starttls = nil
630                         needtls = nil
631
632                         -- Secure now (if handshake fails connection will close)
633                         ssl = true
634
635                         handler.readbuffer = handshake
636                         handler.sendbuffer = handshake
637                         return handshake( socket ) -- do handshake
638                 end
639         end
640
641         handler.readbuffer = _readbuffer
642         handler.sendbuffer = _sendbuffer
643         send = socket.send
644         receive = socket.receive
645         shutdown = ( ssl and id ) or socket.shutdown
646
647         _socketlist[ socket ] = handler
648         _readlistlen = addsocket(_readlist, socket, _readlistlen)
649
650         if sslctx and has_luasec then
651                 out_put "server.lua: auto-starting ssl negotiation..."
652                 handler.autostart_ssl = true;
653                 local ok, err = handler:starttls(sslctx);
654                 if ok == false then
655                         return nil, nil, err
656                 end
657         end
658
659         return handler, socket
660 end
661
662 id = function( )
663 end
664
665 idfalse = function( )
666         return false
667 end
668
669 addsocket = function( list, socket, len )
670         if not list[ socket ] then
671                 len = len + 1
672                 list[ len ] = socket
673                 list[ socket ] = len
674         end
675         return len;
676 end
677
678 removesocket = function( list, socket, len )    -- this function removes sockets from a list ( copied from copas )
679         local pos = list[ socket ]
680         if pos then
681                 list[ socket ] = nil
682                 local last = list[ len ]
683                 list[ len ] = nil
684                 if last ~= socket then
685                         list[ last ] = pos
686                         list[ pos ] = last
687                 end
688                 return len - 1
689         end
690         return len
691 end
692
693 closesocket = function( socket )
694         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
695         _readlistlen = removesocket( _readlist, socket, _readlistlen )
696         _socketlist[ socket ] = nil
697         socket:close( )
698         --mem_free( )
699 end
700
701 local function link(sender, receiver, buffersize)
702         local sender_locked;
703         local _sendbuffer = receiver.sendbuffer;
704         function receiver.sendbuffer()
705                 _sendbuffer();
706                 if sender_locked and receiver.bufferlen() < buffersize then
707                         sender:lock_read(false); -- Unlock now
708                         sender_locked = nil;
709                 end
710         end
711
712         local _readbuffer = sender.readbuffer;
713         function sender.readbuffer()
714                 _readbuffer();
715                 if not sender_locked and receiver.bufferlen() >= buffersize then
716                         sender_locked = true;
717                         sender:lock_read(true);
718                 end
719         end
720         sender:set_mode("*a");
721 end
722
723 ----------------------------------// PUBLIC //--
724
725 addserver = function( addr, port, listeners, pattern, sslctx ) -- this function provides a way for other scripts to reg a server
726         local err
727         if type( listeners ) ~= "table" then
728                 err = "invalid listener table"
729         end
730         if type( port ) ~= "number" or not ( port >= 0 and port <= 65535 ) then
731                 err = "invalid port"
732         elseif _server[ addr..":"..port ] then
733                 err = "listeners on '[" .. addr .. "]:" .. port .. "' already exist"
734         elseif sslctx and not has_luasec then
735                 err = "luasec not found"
736         end
737         if err then
738                 out_error( "server.lua, [", addr, "]:", port, ": ", err )
739                 return nil, err
740         end
741         addr = addr or "*"
742         local server, err = socket_bind( addr, port, _tcpbacklog )
743         if err then
744                 out_error( "server.lua, [", addr, "]:", port, ": ", err )
745                 return nil, err
746         end
747         local handler, err = wrapserver( listeners, server, addr, port, pattern, sslctx ) -- wrap new server socket
748         if not handler then
749                 server:close( )
750                 return nil, err
751         end
752         server:settimeout( 0 )
753         _readlistlen = addsocket(_readlist, server, _readlistlen)
754         _server[ addr..":"..port ] = handler
755         _socketlist[ server ] = handler
756         out_put( "server.lua: new "..(sslctx and "ssl " or "").."server listener on '[", addr, "]:", port, "'" )
757         return handler
758 end
759
760 getserver = function ( addr, port )
761         return _server[ addr..":"..port ];
762 end
763
764 removeserver = function( addr, port )
765         local handler = _server[ addr..":"..port ]
766         if not handler then
767                 return nil, "no server found on '[" .. addr .. "]:" .. tostring( port ) .. "'"
768         end
769         handler:close( )
770         _server[ addr..":"..port ] = nil
771         return true
772 end
773
774 closeall = function( )
775         for _, handler in pairs( _socketlist ) do
776                 handler:close( )
777                 _socketlist[ _ ] = nil
778         end
779         _readlistlen = 0
780         _sendlistlen = 0
781         _timerlistlen = 0
782         _server = { }
783         _readlist = { }
784         _sendlist = { }
785         _timerlist = { }
786         _socketlist = { }
787         --mem_free( )
788 end
789
790 getsettings = function( )
791         return {
792                 select_timeout = _selecttimeout;
793                 select_sleep_time = _sleeptime;
794                 tcp_backlog = _tcpbacklog;
795                 max_send_buffer_size = _maxsendlen;
796                 max_receive_buffer_size = _maxreadlen;
797                 select_idle_check_interval = _checkinterval;
798                 send_timeout = _sendtimeout;
799                 read_timeout = _readtimeout;
800                 max_connections = _maxselectlen;
801                 max_ssl_handshake_roundtrips = _maxsslhandshake;
802                 highest_allowed_fd = _maxfd;
803         }
804 end
805
806 changesettings = function( new )
807         if type( new ) ~= "table" then
808                 return nil, "invalid settings table"
809         end
810         _selecttimeout = tonumber( new.select_timeout ) or _selecttimeout
811         _sleeptime = tonumber( new.select_sleep_time ) or _sleeptime
812         _maxsendlen = tonumber( new.max_send_buffer_size ) or _maxsendlen
813         _maxreadlen = tonumber( new.max_receive_buffer_size ) or _maxreadlen
814         _checkinterval = tonumber( new.select_idle_check_interval ) or _checkinterval
815         _tcpbacklog = tonumber( new.tcp_backlog ) or _tcpbacklog
816         _sendtimeout = tonumber( new.send_timeout ) or _sendtimeout
817         _readtimeout = tonumber( new.read_timeout ) or _readtimeout
818         _maxselectlen = new.max_connections or _maxselectlen
819         _maxsslhandshake = new.max_ssl_handshake_roundtrips or _maxsslhandshake
820         _maxfd = new.highest_allowed_fd or _maxfd
821         return true
822 end
823
824 addtimer = function( listener )
825         if type( listener ) ~= "function" then
826                 return nil, "invalid listener function"
827         end
828         _timerlistlen = _timerlistlen + 1
829         _timerlist[ _timerlistlen ] = listener
830         return true
831 end
832
833 stats = function( )
834         return _readtraffic, _sendtraffic, _readlistlen, _sendlistlen, _timerlistlen
835 end
836
837 local quitting;
838
839 local function setquitting(quit)
840         quitting = not not quit;
841 end
842
843 loop = function(once) -- this is the main loop of the program
844         if quitting then return "quitting"; end
845         if once then quitting = "once"; end
846         local next_timer_time = math_huge;
847         repeat
848                 local read, write, err = socket_select( _readlist, _sendlist, math_min(_selecttimeout, next_timer_time) )
849                 for i, socket in ipairs( write ) do -- send data waiting in writequeues
850                         local handler = _socketlist[ socket ]
851                         if handler then
852                                 handler.sendbuffer( )
853                         else
854                                 closesocket( socket )
855                                 out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen
856                         end
857                 end
858                 for i, socket in ipairs( read ) do -- receive data
859                         local handler = _socketlist[ socket ]
860                         if handler then
861                                 handler.readbuffer( )
862                         else
863                                 closesocket( socket )
864                                 out_put "server.lua: found no handler and closed socket (readlist)" -- this can happen
865                         end
866                 end
867                 for handler, err in pairs( _closelist ) do
868                         handler.disconnect( )( handler, err )
869                         handler:force_close()    -- forced disconnect
870                         _closelist[ handler ] = nil;
871                 end
872                 _currenttime = luasocket_gettime( )
873
874                 -- Check for socket timeouts
875                 local difftime = os_difftime( _currenttime - _starttime )
876                 if difftime > _checkinterval then
877                         _starttime = _currenttime
878                         for handler, timestamp in pairs( _writetimes ) do
879                                 if os_difftime( _currenttime - timestamp ) > _sendtimeout then
880                                         handler.disconnect( )( handler, "send timeout" )
881                                         handler:force_close()    -- forced disconnect
882                                 end
883                         end
884                         for handler, timestamp in pairs( _readtimes ) do
885                                 if os_difftime( _currenttime - timestamp ) > _readtimeout then
886                                         if not(handler.onreadtimeout) or handler:onreadtimeout() ~= true then
887                                                 handler.disconnect( )( handler, "read timeout" )
888                                                 handler:close( )        -- forced disconnect?
889                                         else
890                                                 _readtimes[ handler ] = _currenttime -- reset timer
891                                         end
892                                 end
893                         end
894                 end
895
896                 -- Fire timers
897                 if _currenttime - _timer >= math_min(next_timer_time, 1) then
898                         next_timer_time = math_huge;
899                         for i = 1, _timerlistlen do
900                                 local t = _timerlist[ i ]( _currenttime ) -- fire timers
901                                 if t then next_timer_time = math_min(next_timer_time, t); end
902                         end
903                         _timer = _currenttime
904                 else
905                         next_timer_time = next_timer_time - (_currenttime - _timer);
906                 end
907
908                 -- wait some time (0 by default)
909                 socket_sleep( _sleeptime )
910         until quitting;
911         if once and quitting == "once" then quitting = nil; return; end
912         return "quitting"
913 end
914
915 local function step()
916         return loop(true);
917 end
918
919 local function get_backend()
920         return "select";
921 end
922
923 --// EXPERIMENTAL //--
924
925 local wrapclient = function( socket, ip, serverport, listeners, pattern, sslctx )
926         local handler, socket, err = wrapconnection( nil, listeners, socket, ip, serverport, "clientport", pattern, sslctx )
927         if not handler then return nil, err end
928         _socketlist[ socket ] = handler
929         if not sslctx then
930                 _sendlistlen = addsocket(_sendlist, socket, _sendlistlen)
931                 if listeners.onconnect then
932                         -- When socket is writeable, call onconnect
933                         local _sendbuffer = handler.sendbuffer;
934                         handler.sendbuffer = function ()
935                                 handler.sendbuffer = _sendbuffer;
936                                 listeners.onconnect(handler);
937                                 return _sendbuffer(); -- Send any queued outgoing data
938                         end
939                 end
940         end
941         return handler, socket
942 end
943
944 local addclient = function( address, port, listeners, pattern, sslctx )
945         local client, err = luasocket.tcp( )
946         if err then
947                 return nil, err
948         end
949         client:settimeout( 0 )
950         _, err = client:connect( address, port )
951         if err then -- try again
952                 return wrapclient( client, address, port, listeners, pattern, sslctx )
953         else
954                 return wrapconnection( nil, listeners, client, address, port, "clientport", pattern, sslctx )
955         end
956 end
957
958 --// EXPERIMENTAL //--
959
960 ----------------------------------// BEGIN //--
961
962 use "setmetatable" ( _socketlist, { __mode = "k" } )
963 use "setmetatable" ( _readtimes, { __mode = "k" } )
964 use "setmetatable" ( _writetimes, { __mode = "k" } )
965
966 _timer = luasocket_gettime( )
967 _starttime = luasocket_gettime( )
968
969 local function setlogger(new_logger)
970         local old_logger = log;
971         if new_logger then
972                 log = new_logger;
973         end
974         return old_logger;
975 end
976
977 ----------------------------------// PUBLIC INTERFACE //--
978
979 return {
980         _addtimer = addtimer,
981
982         addclient = addclient,
983         wrapclient = wrapclient,
984
985         loop = loop,
986         link = link,
987         step = step,
988         stats = stats,
989         closeall = closeall,
990         addserver = addserver,
991         getserver = getserver,
992         setlogger = setlogger,
993         getsettings = getsettings,
994         setquitting = setquitting,
995         removeserver = removeserver,
996         get_backend = get_backend,
997         changesettings = changesettings,
998 }