net/server_select.lua

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