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