net/server.lua

   1 --[[\r
   2 \r
   3                 server.lua by blastbeat of the luadch project\r
   4                 \r
   5                 re-used here under the MIT/X Consortium License\r
   6 \r
   7                 - this script contains the server loop of the program\r
   8                 - other scripts can reg a server here\r
   9 \r
  10 ]]--\r
  11 \r
  12 ----------------------------------// DECLARATION //--\r
  13 \r
  14 --// constants //--\r
  15 \r
  16 local STAT_UNIT = 1 / ( 1024 * 1024 )    -- mb\r
  17 \r
  18 --// lua functions //--\r
  19 \r
  20 local function use( what ) return _G[ what ] end\r
  21 \r
  22 local type = use "type"\r
  23 local pairs = use "pairs"\r
  24 local ipairs = use "ipairs"\r
  25 local tostring = use "tostring"\r
  26 local collectgarbage = use "collectgarbage"\r
  27 \r
  28 --// lua libs //--\r
  29 \r
  30 local table = use "table"\r
  31 local coroutine = use "coroutine"\r
  32 \r
  33 --// lua lib methods //--\r
  34 \r
  35 local table_concat = table.concat\r
  36 local table_remove = table.remove\r
  37 local string_sub = use'string'.sub\r
  38 local coroutine_wrap = coroutine.wrap\r
  39 local coroutine_yield = coroutine.yield\r
  40 local print = print;\r
  41 local out_put = function () end --print;\r
  42 local out_error = print;\r
  43 \r
  44 --// extern libs //--\r
  45 \r
  46 local luasec = require "ssl"\r
  47 local luasocket = require "socket"\r
  48 \r
  49 --// extern lib methods //--\r
  50 \r
  51 local ssl_wrap = ( luasec and luasec.wrap )\r
  52 local socket_bind = luasocket.bind\r
  53 local socket_select = luasocket.select\r
  54 local ssl_newcontext = ( luasec and luasec.newcontext )\r
  55 \r
  56 --// functions //--\r
  57 \r
  58 local loop\r
  59 local stats\r
  60 local addtimer\r
  61 local closeall\r
  62 local addserver\r
  63 local firetimer\r
  64 local closesocket\r
  65 local removesocket\r
  66 local wrapserver\r
  67 local wraptcpclient\r
  68 local wrapsslclient\r
  69 \r
  70 --// tables //--\r
  71 \r
  72 local listener\r
  73 local readlist\r
  74 local writelist\r
  75 local socketlist\r
  76 local timelistener\r
  77 \r
  78 --// simple data types //--\r
  79 \r
  80 local _\r
  81 local readlen = 0    -- length of readlist\r
  82 local writelen = 0    -- lenght of writelist\r
  83 \r
  84 local sendstat= 0\r
  85 local receivestat = 0\r
  86 \r
  87 ----------------------------------// DEFINITION //--\r
  88 \r
  89 listener = { }    -- key = port, value = table\r
  90 readlist = { }    -- array with sockets to read from\r
  91 writelist = { }    -- arrary with sockets to write to\r
  92 socketlist = { }    -- key = socket, value = wrapped socket\r
  93 timelistener = { }\r
  94 \r
  95 stats = function( )\r
  96         return receivestat, sendstat\r
  97 end\r
  98 \r
  99 wrapserver = function( listener, socket, ip, serverport, mode, sslctx )    -- this function wraps a server\r
 100 \r
 101         local dispatch, disconnect = listener.listener, listener.disconnect    -- dangerous\r
 102 \r
 103         local wrapclient, err\r
 104 \r
 105         if sslctx then\r
 106                 if not ssl_newcontext then\r
 107                         return nil, "luasec not found"\r
 108 --        elseif not cfg_get "use_ssl" then\r
 109 --            return nil, "ssl is deactivated"\r
 110                 end\r
 111                 if type( sslctx ) ~= "table" then\r
 112                         out_error "server.lua: wrong server sslctx"\r
 113                         return nil, "wrong server sslctx"\r
 114                 end\r
 115                 sslctx, err = ssl_newcontext( sslctx )\r
 116                 if not sslctx then\r
 117                         err = err or "wrong sslctx parameters"\r
 118                         out_error( "server.lua: ", err )\r
 119                         return nil, err\r
 120                 end\r
 121                 wrapclient = wrapsslclient\r
 122         else\r
 123                 wrapclient = wraptcpclient\r
 124         end\r
 125 \r
 126         local accept = socket.accept\r
 127         local close = socket.close\r
 128 \r
 129         --// public methods of the object //--    \r
 130 \r
 131         local handler = { }\r
 132 \r
 133         handler.shutdown = function( ) end\r
 134 \r
 135         --[[handler.listener = function( data, err )\r
 136                 return ondata( handler, data, err )\r
 137         end]]\r
 138         handler.ssl = function( )\r
 139                 return sslctx and true or false\r
 140         end\r
 141         handler.close = function( closed )\r
 142                 _ = not closed and close( socket )\r
 143                 writelen = removesocket( writelist, socket, writelen )\r
 144                 readlen = removesocket( readlist, socket, readlen )\r
 145                 socketlist[ socket ] = nil\r
 146                 handler = nil\r
 147         end\r
 148         handler.ip = function( )\r
 149                 return ip\r
 150         end\r
 151         handler.serverport = function( )\r
 152                 return serverport\r
 153         end\r
 154         handler.socket = function( )\r
 155                 return socket\r
 156         end\r
 157         handler.receivedata = function( )\r
 158                 local client, err = accept( socket )    -- try to accept\r
 159                 if client then\r
 160                         local ip, clientport = client:getpeername( )\r
 161                         client:settimeout( 0 )\r
 162                         local handler, client, err = wrapclient( listener, client, ip, serverport, clientport, mode, sslctx )    -- wrap new client socket\r
 163                         if err then    -- error while wrapping ssl socket\r
 164                                 return false\r
 165                         end\r
 166                         out_put( "server.lua: accepted new client connection from ", ip, ":", clientport )\r
 167                         return dispatch( handler )\r
 168                 elseif err then    -- maybe timeout or something else\r
 169                         out_put( "server.lua: error with new client connection: ", err )\r
 170                         return false\r
 171                 end\r
 172         end\r
 173         return handler\r
 174 end\r
 175 \r
 176 wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, sslctx )    -- this function wraps a ssl cleint\r
 177 \r
 178         local dispatch, disconnect = listener.listener, listener.disconnect\r
 179 \r
 180         --// transform socket to ssl object //--\r
 181 \r
 182         local err\r
 183         socket, err = ssl_wrap( socket, sslctx )    -- wrap socket\r
 184         if err then\r
 185                 out_put( "server.lua: ssl error: ", err )\r
 186                 return nil, nil, err    -- fatal error\r
 187         end\r
 188         socket:settimeout( 0 )\r
 189 \r
 190         --// private closures of the object //--\r
 191 \r
 192         local writequeue = { }    -- buffer for messages to send\r
 193 \r
 194         local eol   -- end of buffer\r
 195 \r
 196         local sstat, rstat = 0, 0\r
 197 \r
 198         --// local import of socket methods //--\r
 199 \r
 200         local send = socket.send\r
 201         local receive = socket.receive\r
 202         local close = socket.close\r
 203         --local shutdown = socket.shutdown\r
 204 \r
 205         --// public methods of the object //--\r
 206 \r
 207         local handler = { }\r
 208 \r
 209         handler.getstats = function( )\r
 210                 return rstat, sstat\r
 211         end\r
 212 \r
 213         handler.listener = function( data, err )\r
 214                 return listener( handler, data, err )\r
 215         end\r
 216         handler.ssl = function( )\r
 217                 return true\r
 218         end\r
 219         handler.send = function( _, data, i, j )\r
 220                         return send( socket, data, i, j )\r
 221         end\r
 222         handler.receive = function( pattern, prefix )\r
 223                         return receive( socket, pattern, prefix )\r
 224         end\r
 225         handler.shutdown = function( pattern )\r
 226                 --return shutdown( socket, pattern )\r
 227         end\r
 228         handler.close = function( closed )\r
 229                 close( socket )\r
 230                 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen\r
 231                 readlen = removesocket( readlist, socket, readlen )\r
 232                 socketlist[ socket ] = nil\r
 233                 out_put "server.lua: closed handler and removed socket from list"\r
 234         end\r
 235         handler.ip = function( )\r
 236                 return ip\r
 237         end\r
 238         handler.serverport = function( )\r
 239                 return serverport\r
 240         end\r
 241         handler.clientport = function( ) \r
 242                 return clientport\r
 243         end\r
 244 \r
 245         handler.write = function( data )\r
 246                 if not eol then\r
 247                         writelen = writelen + 1\r
 248                         writelist[ writelen ] = socket\r
 249                         eol = 0\r
 250                 end\r
 251                 eol = eol + 1\r
 252                 writequeue[ eol ] = data\r
 253         end\r
 254         handler.writequeue = function( )\r
 255                 return writequeue\r
 256         end\r
 257         handler.socket = function( )\r
 258                 return socket\r
 259         end\r
 260         handler.mode = function( )\r
 261                 return mode\r
 262         end\r
 263         handler._receivedata = function( )\r
 264                 local data, err, part = receive( socket, mode )    -- receive data in "mode"\r
 265                 if not err or ( err == "timeout" or err == "wantread" ) then    -- received something\r
 266                         local data = data or part or ""\r
 267                         local count = #data * STAT_UNIT\r
 268                         rstat = rstat + count\r
 269                         receivestat = receivestat + count\r
 270                         out_put( "server.lua: read data '", data, "', error: ", err )\r
 271                         return dispatch( handler, data, err )\r
 272                 else    -- connections was closed or fatal error\r
 273                         out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
 274                         handler.close( )\r
 275                         disconnect( handler, err )\r
 276                         writequeue = nil\r
 277                         handler = nil\r
 278                         return false\r
 279                 end\r
 280         end\r
 281         handler._dispatchdata = function( )    -- this function writes data to handlers\r
 282                 local buffer = table_concat( writequeue, "", 1, eol )\r
 283                 local succ, err, byte = send( socket, buffer )\r
 284                 local count = ( succ or 0 ) * STAT_UNIT\r
 285                 sstat = sstat + count\r
 286                 sendstat = sendstat + count\r
 287                 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )\r
 288                 if succ then    -- sending succesful\r
 289                         --writequeue = { }\r
 290                         eol = nil\r
 291                         writelen = removesocket( writelist, socket, writelen )    -- delete socket from writelist\r
 292                         return true\r
 293                 elseif byte and ( err == "timeout" or err == "wantwrite" ) then    -- want write\r
 294                         buffer = string_sub( buffer, byte + 1, -1 )    -- new buffer\r
 295                         writequeue[ 1 ] = buffer    -- insert new buffer in queue\r
 296                         eol = 1\r
 297                         return true\r
 298                 else    -- connection was closed during sending or fatal error\r
 299                         out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
 300                         handler.close( )\r
 301                         disconnect( handler, err )\r
 302                         writequeue = nil\r
 303                         handler = nil\r
 304                         return false\r
 305                 end\r
 306         end\r
 307 \r
 308         -- // COMPAT // --\r
 309 \r
 310         handler.getIp = handler.ip\r
 311         handler.getPort = handler.clientport\r
 312 \r
 313         --// handshake //--\r
 314 \r
 315         local wrote\r
 316 \r
 317         handler.handshake = coroutine_wrap( function( client )\r
 318                         local err\r
 319                         for i = 1, 10 do    -- 10 handshake attemps\r
 320                                 _, err = client:dohandshake( )\r
 321                                 if not err then\r
 322                                         out_put( "server.lua: ssl handshake done" )\r
 323                                         writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen\r
 324                                         handler.receivedata = handler._receivedata    -- when handshake is done, replace the handshake function with regular functions\r
 325                                         handler.dispatchdata = handler._dispatchdata\r
 326                                         return dispatch( handler )\r
 327                                 else\r
 328                                         out_put( "server.lua: error during ssl handshake: ", err )\r
 329                                         if err == "wantwrite" then\r
 330                                                 if wrote == nil then\r
 331                                                         writelen = writelen + 1\r
 332                                                         writelist[ writelen ] = client\r
 333                                                         wrote = true\r
 334                                                 end\r
 335                                         end\r
 336                                         coroutine_yield( handler, nil, err )    -- handshake not finished\r
 337                                 end\r
 338                         end\r
 339                         _ = err ~= "closed" and close( socket )\r
 340                         handler.close( )\r
 341                         disconnect( handler, err )\r
 342                         writequeue = nil\r
 343                         handler = nil\r
 344                         return false    -- handshake failed\r
 345                 end\r
 346         )\r
 347         handler.receivedata = handler.handshake\r
 348         handler.dispatchdata = handler.handshake\r
 349 \r
 350         handler.handshake( socket )    -- do handshake\r
 351 \r
 352         socketlist[ socket ] = handler\r
 353         readlen = readlen + 1\r
 354         readlist[ readlen ] = socket\r
 355 \r
 356         return handler, socket\r
 357 end\r
 358 \r
 359 wraptcpclient = function( listener, socket, ip, serverport, clientport, mode )    -- this function wraps a socket\r
 360 \r
 361         local dispatch, disconnect = listener.listener, listener.disconnect\r
 362 \r
 363         --// private closures of the object //--\r
 364 \r
 365         local writequeue = { }    -- list for messages to send\r
 366 \r
 367         local eol\r
 368 \r
 369         local rstat, sstat = 0, 0\r
 370 \r
 371         --// local import of socket methods //--\r
 372 \r
 373         local send = socket.send\r
 374         local receive = socket.receive\r
 375         local close = socket.close\r
 376         local shutdown = socket.shutdown\r
 377 \r
 378         --// public methods of the object //--\r
 379 \r
 380         local handler = { }\r
 381 \r
 382         handler.getstats = function( )\r
 383                 return rstat, sstat\r
 384         end\r
 385 \r
 386         handler.listener = function( data, err )\r
 387                 return listener( handler, data, err )\r
 388         end\r
 389         handler.ssl = function( )\r
 390                 return false\r
 391         end\r
 392         handler.send = function( _, data, i, j )\r
 393                         return send( socket, data, i, j )\r
 394         end\r
 395         handler.receive = function( pattern, prefix )\r
 396                         return receive( socket, pattern, prefix )\r
 397         end\r
 398         handler.shutdown = function( pattern )\r
 399                 return shutdown( socket, pattern )\r
 400         end\r
 401         handler.close = function( closed )\r
 402                 _ = not closed and shutdown( socket )\r
 403                 _ = not closed and close( socket )\r
 404                 writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen\r
 405                 readlen = removesocket( readlist, socket, readlen )\r
 406                 socketlist[ socket ] = nil\r
 407                 out_put "server.lua: closed handler and removed socket from list"\r
 408         end\r
 409         handler.ip = function( )\r
 410                 return ip\r
 411         end\r
 412         handler.serverport = function( )\r
 413                 return serverport\r
 414         end\r
 415         handler.clientport = function( ) \r
 416                 return clientport\r
 417         end\r
 418         handler.write = function( data )\r
 419                 if not eol then\r
 420                         writelen = writelen + 1\r
 421                         writelist[ writelen ] = socket\r
 422                         eol = 0\r
 423                 end\r
 424                 eol = eol + 1\r
 425                 writequeue[ eol ] = data\r
 426         end\r
 427         handler.writequeue = function( )\r
 428                 return writequeue\r
 429         end\r
 430         handler.socket = function( )\r
 431                 return socket\r
 432         end\r
 433         handler.mode = function( )\r
 434                 return mode\r
 435         end\r
 436         handler.receivedata = function( )\r
 437                 local data, err, part = receive( socket, mode )    -- receive data in "mode"\r
 438                 if not err or ( err == "timeout" or err == "wantread" ) then    -- received something\r
 439                         local data = data or part or ""\r
 440                         local count = #data * STAT_UNIT\r
 441                         rstat = rstat + count\r
 442                         receivestat = receivestat + count\r
 443                         out_put( "server.lua: read data '", data, "', error: ", err )\r
 444                         return dispatch( handler, data, err )\r
 445                 else    -- connections was closed or fatal error\r
 446                         out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
 447                         handler.close( )\r
 448                         disconnect( handler, err )\r
 449                         writequeue = nil\r
 450                         handler = nil\r
 451                         return false\r
 452                 end\r
 453         end\r
 454         handler.dispatchdata = function( )    -- this function writes data to handlers\r
 455                 local buffer = table_concat( writequeue, "", 1, eol )\r
 456                 local succ, err, byte = send( socket, buffer )\r
 457                 local count = ( succ or 0 ) * STAT_UNIT\r
 458                 sstat = sstat + count\r
 459                 sendstat = sendstat + count\r
 460                 out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )\r
 461                 if succ then    -- sending succesful\r
 462                         --writequeue = { }\r
 463                         eol = nil\r
 464                         writelen = removesocket( writelist, socket, writelen )    -- delete socket from writelist\r
 465                         return true\r
 466                 elseif byte and ( err == "timeout" or err == "wantwrite" ) then    -- want write\r
 467                         buffer = string_sub( buffer, byte + 1, -1 )    -- new buffer\r
 468                         writequeue[ 1 ] = buffer    -- insert new buffer in queue\r
 469                         eol = 1\r
 470                         return true\r
 471                 else    -- connection was closed during sending or fatal error\r
 472                         out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
 473                         handler.close( )\r
 474                         disconnect( handler, err )\r
 475                         writequeue = nil\r
 476                         handler = nil\r
 477                         return false\r
 478                 end\r
 479         end\r
 480 \r
 481         -- // COMPAT // --\r
 482 \r
 483         handler.getIp = handler.ip\r
 484         handler.getPort = handler.clientport\r
 485 \r
 486         socketlist[ socket ] = handler\r
 487         readlen = readlen + 1\r
 488         readlist[ readlen ] = socket\r
 489 \r
 490         return handler, socket\r
 491 end\r
 492 \r
 493 addtimer = function( listener )\r
 494         timelistener[ #timelistener + 1 ] = listener\r
 495 end\r
 496 \r
 497 firetimer = function( listener )\r
 498         for i, listener in ipairs( timelistener ) do\r
 499                 listener( )\r
 500         end\r
 501 end\r
 502 \r
 503 addserver = function( listeners, port, addr, mode, sslctx )    -- this function provides a way for other scripts to reg a server\r
 504         local err\r
 505         if type( listeners ) ~= "table" then\r
 506                 err = "invalid listener table"\r
 507         else\r
 508                 for name, func in pairs( listeners ) do\r
 509                         if type( func ) ~= "function" then\r
 510                                 err = "invalid listener function"\r
 511                                 break\r
 512                         end\r
 513                 end\r
 514         end\r
 515         if not type( port ) == "number" or not ( port >= 0 and port <= 65535 ) then\r
 516                 err = "invalid port"\r
 517         elseif listener[ port ] then\r
 518                 err=  "listeners on port '" .. port .. "' already exist"\r
 519         elseif sslctx and not luasec then\r
 520                 err = "luasec not found"\r
 521         end\r
 522         if err then\r
 523                 out_error( "server.lua: ", err )\r
 524                 return nil, err\r
 525         end\r
 526         addr = addr or "*"\r
 527         local server, err = socket_bind( addr, port )\r
 528         if err then\r
 529                 out_error( "server.lua: ", err )\r
 530                 return nil, err\r
 531         end\r
 532         local handler, err = wrapserver( listeners, server, addr, port, mode, sslctx )    -- wrap new server socket\r
 533         if not handler then\r
 534                 server:close( )\r
 535                 return nil, err\r
 536         end\r
 537         server:settimeout( 0 )\r
 538         readlen = readlen + 1\r
 539         readlist[ readlen ] = server\r
 540         listener[ port ] = listeners\r
 541         socketlist[ server ] = handler\r
 542         out_put( "server.lua: new server listener on ", addr, ":", port )\r
 543         return true\r
 544 end\r
 545 \r
 546 removesocket = function( tbl, socket, len )    -- this function removes sockets from a list\r
 547         for i, target in ipairs( tbl ) do\r
 548                 if target == socket then\r
 549                         len = len - 1\r
 550                         table_remove( tbl, i )\r
 551                         return len\r
 552                 end\r
 553         end\r
 554         return len\r
 555 end\r
 556 \r
 557 closeall = function( )\r
 558         for sock, handler in pairs( socketlist ) do\r
 559                 handler.shutdown( )\r
 560                 handler.close( )\r
 561                 socketlist[ sock ] = nil\r
 562         end\r
 563         writelist, readlist, socketlist = { }, { }, { }\r
 564 end\r
 565 \r
 566 closesocket = function( socket )\r
 567         writelen = removesocket( writelist, socket, writelen )\r
 568         readlen = removesocket( readlist, socket, readlen )\r
 569         socketlist[ socket ] = nil\r
 570         socket:close( )\r
 571 end\r
 572 \r
 573 loop = function( )    -- this is the main loop of the program\r
 574         --signal_set( "hub", "run" )\r
 575         repeat\r
 576                 local read, write, err = socket_select( readlist, writelist, 1 )    -- 1 sec timeout, nice for timers\r
 577                 for i, socket in ipairs( write ) do    -- send data waiting in writequeues\r
 578                         local handler = socketlist[ socket ]\r
 579                         if handler then\r
 580                                 handler.dispatchdata( )\r
 581                         else\r
 582                                 closesocket( socket )\r
 583                                 out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen\r
 584                         end\r
 585                 end\r
 586                 for i, socket in ipairs( read ) do    -- receive data\r
 587                         local handler = socketlist[ socket ]\r
 588                         if handler then\r
 589                                 handler.receivedata( )\r
 590                         else\r
 591                                 closesocket( socket )\r
 592                                 out_put "server.lua: found no handler and closed socket (readlist)"    -- this can happen\r
 593                         end\r
 594                 end\r
 595                 firetimer( )\r
 596                 --collectgarbage "collect"\r
 597         until false --signal_get "hub" ~= "run"\r
 598         return --signal_get "hub"\r
 599 end\r
 600 \r
 601 ----------------------------------// BEGIN //--\r
 602 \r
 603 ----------------------------------// PUBLIC INTERFACE //--\r
 604 \r
 605 return {\r
 606 \r
 607         add = addserver,\r
 608         loop = loop,\r
 609         stats = stats,\r
 610         closeall = closeall,\r
 611         addtimer = addtimer,\r
 612 \r
 613 }\r