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