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                                 out_put( "server.lua: ssl handshake error: ", tostring(err or "handshake too long") )
 593                                 _ = handler and handler:force_close("ssl handshake failed")
 594                                 return false, err -- handshake failed
 595                         end
 596                 )
 597         end
 598         if has_luasec then
 599                 handler.starttls = function( self, _sslctx)
 600                         if _sslctx then
 601                                 handler:set_sslctx(_sslctx);
 602                         end
 603                         if bufferqueuelen > 0 then
 604                                 out_put "server.lua: we need to do tls, but delaying until send buffer empty"
 605                                 needtls = true
 606                                 return
 607                         end
 608                         out_put( "server.lua: attempting to start tls on " .. tostring( socket ) )
 609                         local oldsocket, err = socket
 610                         socket, err = ssl_wrap( socket, sslctx )        -- wrap socket
 611                         if not socket then
 612                                 out_put( "server.lua: error while starting tls on client: ", tostring(err or "unknown error") )
 613                                 return nil, err -- fatal error
 614                         end
 615
 616                         socket:settimeout( 0 )
 617
 618                         -- add the new socket to our system
 619                         send = socket.send
 620                         receive = socket.receive
 621                         shutdown = id
 622                         _socketlist[ socket ] = handler
 623                         _readlistlen = addsocket(_readlist, socket, _readlistlen)
 624
 625                         -- remove traces of the old socket
 626                         _readlistlen = removesocket( _readlist, oldsocket, _readlistlen )
 627                         _sendlistlen = removesocket( _sendlist, oldsocket, _sendlistlen )
 628                         _socketlist[ oldsocket ] = nil
 629
 630                         handler.starttls = nil
 631                         needtls = nil
 632
 633                         -- Secure now (if handshake fails connection will close)
 634                         ssl = true
 635
 636                         handler.readbuffer = handshake
 637                         handler.sendbuffer = handshake
 638                         return handshake( socket ) -- do handshake
 639                 end
 640         end
 641
 642         handler.readbuffer = _readbuffer
 643         handler.sendbuffer = _sendbuffer
 644         send = socket.send
 645         receive = socket.receive
 646         shutdown = ( ssl and id ) or socket.shutdown
 647
 648         _socketlist[ socket ] = handler
 649         _readlistlen = addsocket(_readlist, socket, _readlistlen)
 650
 651         if sslctx and has_luasec then
 652                 out_put "server.lua: auto-starting ssl negotiation..."
 653                 handler.autostart_ssl = true;
 654                 local ok, err = handler:starttls(sslctx);
 655                 if ok == false then
 656                         return nil, nil, err
 657                 end
 658         end
 659
 660         return handler, socket
 661 end
 662
 663 id = function( )
 664 end
 665
 666 idfalse = function( )
 667         return false
 668 end
 669
 670 addsocket = function( list, socket, len )
 671         if not list[ socket ] then
 672                 len = len + 1
 673                 list[ len ] = socket
 674                 list[ socket ] = len
 675         end
 676         return len;
 677 end
 678
 679 removesocket = function( list, socket, len )    -- this function removes sockets from a list ( copied from copas )
 680         local pos = list[ socket ]
 681         if pos then
 682                 list[ socket ] = nil
 683                 local last = list[ len ]
 684                 list[ len ] = nil
 685                 if last ~= socket then
 686                         list[ last ] = pos
 687                         list[ pos ] = last
 688                 end
 689                 return len - 1
 690         end
 691         return len
 692 end
 693
 694 closesocket = function( socket )
 695         _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
 696         _readlistlen = removesocket( _readlist, socket, _readlistlen )
 697         _socketlist[ socket ] = nil
 698         socket:close( )
 699         --mem_free( )
 700 end
 701
 702 local function link(sender, receiver, buffersize)
 703         local sender_locked;
 704         local _sendbuffer = receiver.sendbuffer;
 705         function receiver.sendbuffer()
 706                 _sendbuffer();
 707                 if sender_locked and receiver.bufferlen() < buffersize then
 708                         sender:lock_read(false); -- Unlock now
 709                         sender_locked = nil;
 710                 end
 711         end
 712
 713         local _readbuffer = sender.readbuffer;
 714         function sender.readbuffer()
 715                 _readbuffer();
 716                 if not sender_locked and receiver.bufferlen() >= buffersize then
 717                         sender_locked = true;
 718                         sender:lock_read(true);
 719                 end
 720         end
 721         sender:set_mode("*a");
 722 end
 723
 724 ----------------------------------// PUBLIC //--
 725
 726 addserver = function( addr, port, listeners, pattern, sslctx ) -- this function provides a way for other scripts to reg a server
 727         addr = addr or "*"
 728         local err
 729         if type( listeners ) ~= "table" then
 730                 err = "invalid listener table"
 731         elseif type ( addr ) ~= "string" then
 732                 err = "invalid address"
 733         elseif type( port ) ~= "number" or not ( port >= 0 and port <= 65535 ) then
 734                 err = "invalid port"
 735         elseif _server[ addr..":"..port ] then
 736                 err = "listeners on '[" .. addr .. "]:" .. port .. "' already exist"
 737         elseif sslctx and not has_luasec then
 738                 err = "luasec not found"
 739         end
 740         if err then
 741                 out_error( "server.lua, [", addr, "]:", port, ": ", err )
 742                 return nil, err
 743         end
 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         }
 806 end
 807
 808 changesettings = function( new )
 809         if type( new ) ~= "table" then
 810                 return nil, "invalid settings table"
 811         end
 812         _selecttimeout = tonumber( new.select_timeout ) or _selecttimeout
 813         _sleeptime = tonumber( new.select_sleep_time ) or _sleeptime
 814         _maxsendlen = tonumber( new.max_send_buffer_size ) or _maxsendlen
 815         _maxreadlen = tonumber( new.max_receive_buffer_size ) or _maxreadlen
 816         _checkinterval = tonumber( new.select_idle_check_interval ) or _checkinterval
 817         _tcpbacklog = tonumber( new.tcp_backlog ) or _tcpbacklog
 818         _sendtimeout = tonumber( new.send_timeout ) or _sendtimeout
 819         _readtimeout = tonumber( new.read_timeout ) or _readtimeout
 820         _maxselectlen = new.max_connections or _maxselectlen
 821         _maxsslhandshake = new.max_ssl_handshake_roundtrips or _maxsslhandshake
 822         _maxfd = new.highest_allowed_fd or _maxfd
 823         return true
 824 end
 825
 826 addtimer = function( listener )
 827         if type( listener ) ~= "function" then
 828                 return nil, "invalid listener function"
 829         end
 830         _timerlistlen = _timerlistlen + 1
 831         _timerlist[ _timerlistlen ] = listener
 832         return true
 833 end
 834
 835 stats = function( )
 836         return _readtraffic, _sendtraffic, _readlistlen, _sendlistlen, _timerlistlen
 837 end
 838
 839 local quitting;
 840
 841 local function setquitting(quit)
 842         quitting = not not quit;
 843 end
 844
 845 loop = function(once) -- this is the main loop of the program
 846         if quitting then return "quitting"; end
 847         if once then quitting = "once"; end
 848         local next_timer_time = math_huge;
 849         repeat
 850                 local read, write, err = socket_select( _readlist, _sendlist, math_min(_selecttimeout, next_timer_time) )
 851                 for i, socket in ipairs( write ) do -- send data waiting in writequeues
 852                         local handler = _socketlist[ socket ]
 853                         if handler then
 854                                 handler.sendbuffer( )
 855                         else
 856                                 closesocket( socket )
 857                                 out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen
 858                         end
 859                 end
 860                 for i, socket in ipairs( read ) do -- receive data
 861                         local handler = _socketlist[ socket ]
 862                         if handler then
 863                                 handler.readbuffer( )
 864                         else
 865                                 closesocket( socket )
 866                                 out_put "server.lua: found no handler and closed socket (readlist)" -- this can happen
 867                         end
 868                 end
 869                 for handler, err in pairs( _closelist ) do
 870                         handler.disconnect( )( handler, err )
 871                         handler:force_close()    -- forced disconnect
 872                         _closelist[ handler ] = nil;
 873                 end
 874                 _currenttime = luasocket_gettime( )
 875
 876                 -- Check for socket timeouts
 877                 local difftime = os_difftime( _currenttime - _starttime )
 878                 if difftime > _checkinterval then
 879                         _starttime = _currenttime
 880                         for handler, timestamp in pairs( _writetimes ) do
 881                                 if os_difftime( _currenttime - timestamp ) > _sendtimeout then
 882                                         handler.disconnect( )( handler, "send timeout" )
 883                                         handler:force_close()    -- forced disconnect
 884                                 end
 885                         end
 886                         for handler, timestamp in pairs( _readtimes ) do
 887                                 if os_difftime( _currenttime - timestamp ) > _readtimeout then
 888                                         if not(handler.onreadtimeout) or handler:onreadtimeout() ~= true then
 889                                                 handler.disconnect( )( handler, "read timeout" )
 890                                                 handler:close( )        -- forced disconnect?
 891                                         else
 892                                                 _readtimes[ handler ] = _currenttime -- reset timer
 893                                         end
 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                 -- wait some time (0 by default)
 911                 socket_sleep( _sleeptime )
 912         until quitting;
 913         if once and quitting == "once" then quitting = nil; return; end
 914         return "quitting"
 915 end
 916
 917 local function step()
 918         return loop(true);
 919 end
 920
 921 local function get_backend()
 922         return "select";
 923 end
 924
 925 --// EXPERIMENTAL //--
 926
 927 local wrapclient = function( socket, ip, serverport, listeners, pattern, sslctx )
 928         local handler, socket, err = wrapconnection( nil, listeners, socket, ip, serverport, "clientport", pattern, sslctx )
 929         if not handler then return nil, err end
 930         _socketlist[ socket ] = handler
 931         if not sslctx then
 932                 _sendlistlen = addsocket(_sendlist, socket, _sendlistlen)
 933                 if listeners.onconnect then
 934                         -- When socket is writeable, call onconnect
 935                         local _sendbuffer = handler.sendbuffer;
 936                         handler.sendbuffer = function ()
 937                                 handler.sendbuffer = _sendbuffer;
 938                                 listeners.onconnect(handler);
 939                                 return _sendbuffer(); -- Send any queued outgoing data
 940                         end
 941                 end
 942         end
 943         return handler, socket
 944 end
 945
 946 local addclient = function( address, port, listeners, pattern, sslctx, typ )
 947         local err
 948         if type( listeners ) ~= "table" then
 949                 err = "invalid listener table"
 950         elseif type ( address ) ~= "string" then
 951                 err = "invalid address"
 952         elseif type( port ) ~= "number" or not ( port >= 0 and port <= 65535 ) then
 953                 err = "invalid port"
 954         elseif sslctx and not has_luasec then
 955                 err = "luasec not found"
 956         end
 957         if not typ then
 958                 local addrinfo, err = getaddrinfo(address)
 959                 if not addrinfo then return nil, err end
 960                 if addrinfo[1] and addrinfo[1].family == "inet6" then
 961                         typ = "tcp6"
 962                 else
 963                         typ = "tcp"
 964                 end
 965         end
 966         local create = luasocket[typ]
 967         if type( create ) ~= "function"  then
 968                 err = "invalid socket type"
 969         end
 970
 971         if err then
 972                 out_error( "server.lua, addclient: ", err )
 973                 return nil, err
 974         end
 975
 976         local client, err = create( )
 977         if err then
 978                 return nil, err
 979         end
 980         client:settimeout( 0 )
 981         local ok, err = client:connect( address, port )
 982         if ok or err == "timeout" then
 983                 return wrapclient( client, address, port, listeners, pattern, sslctx )
 984         else
 985                 return nil, err
 986         end
 987 end
 988
 989 --// EXPERIMENTAL //--
 990
 991 ----------------------------------// BEGIN //--
 992
 993 use "setmetatable" ( _socketlist, { __mode = "k" } )
 994 use "setmetatable" ( _readtimes, { __mode = "k" } )
 995 use "setmetatable" ( _writetimes, { __mode = "k" } )
 996
 997 _timer = luasocket_gettime( )
 998 _starttime = luasocket_gettime( )
 999
1000 local function setlogger(new_logger)
1001         local old_logger = log;
1002         if new_logger then
1003                 log = new_logger;
1004         end
1005         return old_logger;
1006 end
1007
1008 ----------------------------------// PUBLIC INTERFACE //--
1009
1010 return {
1011         _addtimer = addtimer,
1012
1013         addclient = addclient,
1014         wrapclient = wrapclient,
1015
1016         loop = loop,
1017         link = link,
1018         step = step,
1019         stats = stats,
1020         closeall = closeall,
1021         addserver = addserver,
1022         getserver = getserver,
1023         setlogger = setlogger,
1024         getsettings = getsettings,
1025         setquitting = setquitting,
1026         removeserver = removeserver,
1027         get_backend = get_backend,
1028         changesettings = changesettings,
1029 }