net/server_select.lua

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