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.ip = function( )
 402                 return ip
 403         end
 404         handler.serverport = function( )
 405                 return serverport
 406         end
 407         handler.clientport = function( )
 408                 return clientport
 409         end
 410         handler.port = handler.clientport -- COMPAT server_event
 411         local write = function( self, data )
 412                 bufferlen = bufferlen + #data
 413                 if bufferlen > maxsendlen then
 414                         _closelist[ handler ] = "send buffer exceeded"   -- cannot close the client at the moment, have to wait to the end of the cycle
 415                         handler.write = idfalse -- dont write anymore
 416                         return false
 417                 elseif socket and not _sendlist[ socket ] then
 418                         _sendlistlen = addsocket(_sendlist, socket, _sendlistlen)
 419                 end
 420                 bufferqueuelen = bufferqueuelen + 1
 421                 bufferqueue[ bufferqueuelen ] = data
 422                 if handler then
 423                         _writetimes[ handler ] = _writetimes[ handler ] or _currenttime
 424                 end
 425                 return true
 426         end
 427         handler.write = write
 428         handler.bufferqueue = function( self )
 429                 return bufferqueue
 430         end
 431         handler.socket = function( self )
 432                 return socket
 433         end
 434         handler.set_mode = function( self, new )
 435                 pattern = new or pattern
 436                 return pattern
 437         end
 438         handler.set_send = function ( self, newsend )
 439                 send = newsend or send
 440                 return send
 441         end
 442         handler.bufferlen = function( self, readlen, sendlen )
 443                 maxsendlen = sendlen or maxsendlen
 444                 maxreadlen = readlen or maxreadlen
 445                 return bufferlen, maxreadlen, maxsendlen
 446         end
 447         --TODO: Deprecate
 448         handler.lock_read = function (self, switch)
 449                 if switch == true then
 450                         local tmp = _readlistlen
 451                         _readlistlen = removesocket( _readlist, socket, _readlistlen )
 452                         _readtimes[ handler ] = nil
 453                         if _readlistlen ~= tmp then
 454                                 noread = true
 455                         end
 456                 elseif switch == false then
 457                         if noread then
 458                                 noread = false
 459                                 _readlistlen = addsocket(_readlist, socket, _readlistlen)
 460                                 _readtimes[ handler ] = _currenttime
 461                         end
 462                 end
 463                 return noread
 464         end
 465         handler.pause = function (self)
 466                 return self:lock_read(true);
 467         end
 468         handler.resume = function (self)
 469                 return self:lock_read(false);
 470         end
 471         handler.lock = function( self, switch )
 472                 handler.lock_read (switch)
 473                 if switch == true then
 474                         handler.write = idfalse
 475                         local tmp = _sendlistlen
 476                         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
 477                         _writetimes[ handler ] = nil
 478                         if _sendlistlen ~= tmp then
 479                                 nosend = true
 480                         end
 481                 elseif switch == false then
 482                         handler.write = write
 483                         if nosend then
 484                                 nosend = false
 485                                 write( "" )
 486                         end
 487                 end
 488                 return noread, nosend
 489         end
 490         local _readbuffer = function( ) -- this function reads data
 491                 local buffer, err, part = receive( socket, pattern )    -- receive buffer with "pattern"
 492                 if not err or (err == "wantread" or err == "timeout") then -- received something
 493                         local buffer = buffer or part or ""
 494                         local len = #buffer
 495                         if len > maxreadlen then
 496                                 handler:close( "receive buffer exceeded" )
 497                                 return false
 498                         end
 499                         local count = len * STAT_UNIT
 500                         readtraffic = readtraffic + count
 501                         _readtraffic = _readtraffic + count
 502                         _readtimes[ handler ] = _currenttime
 503                         --out_put( "server.lua: read data '", buffer:gsub("[^%w%p ]", "."), "', error: ", err )
 504                         return dispatch( handler, buffer, err )
 505                 else    -- connections was closed or fatal error
 506                         out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " read error: ", tostring(err) )
 507                         fatalerror = true
 508                         _ = handler and handler:force_close( err )
 509                         return false
 510                 end
 511         end
 512         local _sendbuffer = function( ) -- this function sends data
 513                 local succ, err, byte, buffer, count;
 514                 if socket then
 515                         buffer = table_concat( bufferqueue, "", 1, bufferqueuelen )
 516                         succ, err, byte = send( socket, buffer, 1, bufferlen )
 517                         count = ( succ or byte or 0 ) * STAT_UNIT
 518                         sendtraffic = sendtraffic + count
 519                         _sendtraffic = _sendtraffic + count
 520                         for i = bufferqueuelen,1,-1 do
 521                                 bufferqueue[ i ] = nil
 522                         end
 523                         --out_put( "server.lua: sended '", buffer, "', bytes: ", tostring(succ), ", error: ", tostring(err), ", part: ", tostring(byte), ", to: ", tostring(ip), ":", tostring(clientport) )
 524                 else
 525                         succ, err, count = false, "unexpected close", 0;
 526                 end
 527                 if succ then    -- sending succesful
 528                         bufferqueuelen = 0
 529                         bufferlen = 0
 530                         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen ) -- delete socket from writelist
 531                         _writetimes[ handler ] = nil
 532                         if drain then
 533                                 drain(handler)
 534                         end
 535                         _ = needtls and handler:starttls(nil)
 536                         _ = toclose and handler:force_close( )
 537                         return true
 538                 elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write
 539                         buffer = string_sub( buffer, byte + 1, bufferlen ) -- new buffer
 540                         bufferqueue[ 1 ] = buffer        -- insert new buffer in queue
 541                         bufferqueuelen = 1
 542                         bufferlen = bufferlen - byte
 543                         _writetimes[ handler ] = _currenttime
 544                         return true
 545                 else    -- connection was closed during sending or fatal error
 546                         out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " write error: ", tostring(err) )
 547                         fatalerror = true
 548                         _ = handler and handler:force_close( err )
 549                         return false
 550                 end
 551         end
 552
 553         -- Set the sslctx
 554         local handshake;
 555         function handler.set_sslctx(self, new_sslctx)
 556                 sslctx = new_sslctx;
 557                 local read, wrote
 558                 handshake = coroutine_wrap( function( client ) -- create handshake coroutine
 559                                 local err
 560                                 for i = 1, _maxsslhandshake do
 561                                         _sendlistlen = ( wrote and removesocket( _sendlist, client, _sendlistlen ) ) or _sendlistlen
 562                                         _readlistlen = ( read and removesocket( _readlist, client, _readlistlen ) ) or _readlistlen
 563                                         read, wrote = nil, nil
 564                                         _, err = client:dohandshake( )
 565                                         if not err then
 566                                                 out_put( "server.lua: ssl handshake done" )
 567                                                 handler.readbuffer = _readbuffer        -- when handshake is done, replace the handshake function with regular functions
 568                                                 handler.sendbuffer = _sendbuffer
 569                                                 _ = status and status( handler, "ssl-handshake-complete" )
 570                                                 if self.autostart_ssl and listeners.onconnect then
 571                                                         listeners.onconnect(self);
 572                                                         if bufferqueuelen ~= 0 then
 573                                                                 _sendlistlen = addsocket(_sendlist, client, _sendlistlen)
 574                                                         end
 575                                                 end
 576                                                 _readlistlen = addsocket(_readlist, client, _readlistlen)
 577                                                 return true
 578                                         else
 579                                                 if err == "wantwrite" then
 580                                                         _sendlistlen = addsocket(_sendlist, client, _sendlistlen)
 581                                                         wrote = true
 582                                                 elseif err == "wantread" then
 583                                                         _readlistlen = addsocket(_readlist, client, _readlistlen)
 584                                                         read = true
 585                                                 else
 586                                                         break;
 587                                                 end
 588                                                 err = nil;
 589                                                 coroutine_yield( ) -- handshake not finished
 590                                         end
 591                                 end
 592                                 err = "ssl handshake error: " .. ( err or "handshake too long" );
 593                                 out_put( "server.lua: ", err );
 594                                 _ = handler and handler:force_close(err)
 595                                 return false, err -- handshake failed
 596                         end
 597                 )
 598         end
 599         if has_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 has_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         addr = addr or "*"
 729         local err
 730         if type( listeners ) ~= "table" then
 731                 err = "invalid listener table"
 732         elseif type ( addr ) ~= "string" then
 733                 err = "invalid address"
 734         elseif type( port ) ~= "number" or not ( port >= 0 and port <= 65535 ) then
 735                 err = "invalid port"
 736         elseif _server[ addr..":"..port ] then
 737                 err = "listeners on '[" .. addr .. "]:" .. port .. "' already exist"
 738         elseif sslctx and not has_luasec then
 739                 err = "luasec not found"
 740         end
 741         if err then
 742                 out_error( "server.lua, [", addr, "]:", port, ": ", err )
 743                 return nil, err
 744         end
 745         local server, err = socket_bind( addr, port, _tcpbacklog )
 746         if err then
 747                 out_error( "server.lua, [", addr, "]:", port, ": ", err )
 748                 return nil, err
 749         end
 750         local handler, err = wrapserver( listeners, server, addr, port, pattern, sslctx ) -- wrap new server socket
 751         if not handler then
 752                 server:close( )
 753                 return nil, err
 754         end
 755         server:settimeout( 0 )
 756         _readlistlen = addsocket(_readlist, server, _readlistlen)
 757         _server[ addr..":"..port ] = handler
 758         _socketlist[ server ] = handler
 759         out_put( "server.lua: new "..(sslctx and "ssl " or "").."server listener on '[", addr, "]:", port, "'" )
 760         return handler
 761 end
 762
 763 getserver = function ( addr, port )
 764         return _server[ addr..":"..port ];
 765 end
 766
 767 removeserver = function( addr, port )
 768         local handler = _server[ addr..":"..port ]
 769         if not handler then
 770                 return nil, "no server found on '[" .. addr .. "]:" .. tostring( port ) .. "'"
 771         end
 772         handler:close( )
 773         _server[ addr..":"..port ] = nil
 774         return true
 775 end
 776
 777 closeall = function( )
 778         for _, handler in pairs( _socketlist ) do
 779                 handler:close( )
 780                 _socketlist[ _ ] = nil
 781         end
 782         _readlistlen = 0
 783         _sendlistlen = 0
 784         _timerlistlen = 0
 785         _server = { }
 786         _readlist = { }
 787         _sendlist = { }
 788         _timerlist = { }
 789         _socketlist = { }
 790         --mem_free( )
 791 end
 792
 793 getsettings = function( )
 794         return {
 795                 select_timeout = _selecttimeout;
 796                 select_sleep_time = _sleeptime;
 797                 tcp_backlog = _tcpbacklog;
 798                 max_send_buffer_size = _maxsendlen;
 799                 max_receive_buffer_size = _maxreadlen;
 800                 select_idle_check_interval = _checkinterval;
 801                 send_timeout = _sendtimeout;
 802                 read_timeout = _readtimeout;
 803                 max_connections = _maxselectlen;
 804                 max_ssl_handshake_roundtrips = _maxsslhandshake;
 805                 highest_allowed_fd = _maxfd;
 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         _maxselectlen = new.max_connections or _maxselectlen
 822         _maxsslhandshake = new.max_ssl_handshake_roundtrips or _maxsslhandshake
 823         _maxfd = new.highest_allowed_fd or _maxfd
 824         return true
 825 end
 826
 827 addtimer = function( listener )
 828         if type( listener ) ~= "function" then
 829                 return nil, "invalid listener function"
 830         end
 831         _timerlistlen = _timerlistlen + 1
 832         _timerlist[ _timerlistlen ] = listener
 833         return true
 834 end
 835
 836 stats = function( )
 837         return _readtraffic, _sendtraffic, _readlistlen, _sendlistlen, _timerlistlen
 838 end
 839
 840 local quitting;
 841
 842 local function setquitting(quit)
 843         quitting = not not quit;
 844 end
 845
 846 loop = function(once) -- this is the main loop of the program
 847         if quitting then return "quitting"; end
 848         if once then quitting = "once"; end
 849         local next_timer_time = math_huge;
 850         repeat
 851                 local read, write, err = socket_select( _readlist, _sendlist, math_min(_selecttimeout, next_timer_time) )
 852                 for i, socket in ipairs( write ) do -- send data waiting in writequeues
 853                         local handler = _socketlist[ socket ]
 854                         if handler then
 855                                 handler.sendbuffer( )
 856                         else
 857                                 closesocket( socket )
 858                                 out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen
 859                         end
 860                 end
 861                 for i, socket in ipairs( read ) do -- receive data
 862                         local handler = _socketlist[ socket ]
 863                         if handler then
 864                                 handler.readbuffer( )
 865                         else
 866                                 closesocket( socket )
 867                                 out_put "server.lua: found no handler and closed socket (readlist)" -- this can happen
 868                         end
 869                 end
 870                 for handler, err in pairs( _closelist ) do
 871                         handler.disconnect( )( handler, err )
 872                         handler:force_close()    -- forced disconnect
 873                         _closelist[ handler ] = nil;
 874                 end
 875                 _currenttime = luasocket_gettime( )
 876
 877                 -- Check for socket timeouts
 878                 local difftime = os_difftime( _currenttime - _starttime )
 879                 if difftime > _checkinterval then
 880                         _starttime = _currenttime
 881                         for handler, timestamp in pairs( _writetimes ) do
 882                                 if os_difftime( _currenttime - timestamp ) > _sendtimeout then
 883                                         handler.disconnect( )( handler, "send timeout" )
 884                                         handler:force_close()    -- forced disconnect
 885                                 end
 886                         end
 887                         for handler, timestamp in pairs( _readtimes ) do
 888                                 if os_difftime( _currenttime - timestamp ) > _readtimeout then
 889                                         if not(handler.onreadtimeout) or handler:onreadtimeout() ~= true then
 890                                                 handler.disconnect( )( handler, "read timeout" )
 891                                                 handler:close( )        -- forced disconnect?
 892                                         else
 893                                                 _readtimes[ handler ] = _currenttime -- reset timer
 894                                         end
 895                                 end
 896                         end
 897                 end
 898
 899                 -- Fire timers
 900                 if _currenttime - _timer >= math_min(next_timer_time, 1) then
 901                         next_timer_time = math_huge;
 902                         for i = 1, _timerlistlen do
 903                                 local t = _timerlist[ i ]( _currenttime ) -- fire timers
 904                                 if t then next_timer_time = math_min(next_timer_time, t); end
 905                         end
 906                         _timer = _currenttime
 907                 else
 908                         next_timer_time = next_timer_time - (_currenttime - _timer);
 909                 end
 910
 911                 -- wait some time (0 by default)
 912                 socket_sleep( _sleeptime )
 913         until quitting;
 914         if once and quitting == "once" then quitting = nil; return; end
 915         closeall();
 916         return "quitting"
 917 end
 918
 919 local function step()
 920         return loop(true);
 921 end
 922
 923 local function get_backend()
 924         return "select";
 925 end
 926
 927 --// EXPERIMENTAL //--
 928
 929 local wrapclient = function( socket, ip, serverport, listeners, pattern, sslctx )
 930         local handler, socket, err = wrapconnection( nil, listeners, socket, ip, serverport, "clientport", pattern, sslctx )
 931         if not handler then return nil, err end
 932         _socketlist[ socket ] = handler
 933         if not sslctx then
 934                 _sendlistlen = addsocket(_sendlist, socket, _sendlistlen)
 935                 if listeners.onconnect then
 936                         -- When socket is writeable, call onconnect
 937                         local _sendbuffer = handler.sendbuffer;
 938                         handler.sendbuffer = function ()
 939                                 handler.sendbuffer = _sendbuffer;
 940                                 listeners.onconnect(handler);
 941                                 return _sendbuffer(); -- Send any queued outgoing data
 942                         end
 943                 end
 944         end
 945         return handler, socket
 946 end
 947
 948 local addclient = function( address, port, listeners, pattern, sslctx, typ )
 949         local err
 950         if type( listeners ) ~= "table" then
 951                 err = "invalid listener table"
 952         elseif type ( address ) ~= "string" then
 953                 err = "invalid address"
 954         elseif type( port ) ~= "number" or not ( port >= 0 and port <= 65535 ) then
 955                 err = "invalid port"
 956         elseif sslctx and not has_luasec then
 957                 err = "luasec not found"
 958         end
 959         if not typ then
 960                 local addrinfo, err = getaddrinfo(address)
 961                 if not addrinfo then return nil, err end
 962                 if addrinfo[1] and addrinfo[1].family == "inet6" then
 963                         typ = "tcp6"
 964                 else
 965                         typ = "tcp"
 966                 end
 967         end
 968         local create = luasocket[typ]
 969         if type( create ) ~= "function"  then
 970                 err = "invalid socket type"
 971         end
 972
 973         if err then
 974                 out_error( "server.lua, addclient: ", err )
 975                 return nil, err
 976         end
 977
 978         local client, err = create( )
 979         if err then
 980                 return nil, err
 981         end
 982         client:settimeout( 0 )
 983         local ok, err = client:connect( address, port )
 984         if ok or err == "timeout" then
 985                 return wrapclient( client, address, port, listeners, pattern, sslctx )
 986         else
 987                 return nil, err
 988         end
 989 end
 990
 991 --// EXPERIMENTAL //--
 992
 993 ----------------------------------// BEGIN //--
 994
 995 use "setmetatable" ( _socketlist, { __mode = "k" } )
 996 use "setmetatable" ( _readtimes, { __mode = "k" } )
 997 use "setmetatable" ( _writetimes, { __mode = "k" } )
 998
 999 _timer = luasocket_gettime( )
1000 _starttime = luasocket_gettime( )
1001
1002 local function setlogger(new_logger)
1003         local old_logger = log;
1004         if new_logger then
1005                 log = new_logger;
1006         end
1007         return old_logger;
1008 end
1009
1010 ----------------------------------// PUBLIC INTERFACE //--
1011
1012 return {
1013         _addtimer = addtimer,
1014
1015         addclient = addclient,
1016         wrapclient = wrapclient,
1017
1018         loop = loop,
1019         link = link,
1020         step = step,
1021         stats = stats,
1022         closeall = closeall,
1023         addserver = addserver,
1024         getserver = getserver,
1025         setlogger = setlogger,
1026         getsettings = getsettings,
1027         setquitting = setquitting,
1028         removeserver = removeserver,
1029         get_backend = get_backend,
1030         changesettings = changesettings,
1031 }