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