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