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