cygnal/handler.cpp

   1 //
   2 //   Copyright (C) 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   3 //
   4 // This program is free software; you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation; either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 //
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "gnashconfig.h"
  21 #endif
  22
  23 #include <mutex>
  24 #include <memory>
  25 #include <functional>
  26 #include <algorithm>
  27 #include <string>
  28 #include <deque>
  29 #include <list>
  30 #include <map>
  31 #include <vector>
  32 #if defined(WIN32) || defined(_WIN32)
  33 # define LIBLTDL_DLL_IMPORT 1
  34 #endif
  35 #ifdef HAVE_DLFCN_H
  36 # include <dlfcn.h>
  37 #endif
  38 #ifdef HAVE_LIBGEN_H
  39 # include <libgen.h>
  40 #endif
  41
  42 #include "ltdl.h"
  43 #include "log.h"
  44 #include "network.h"
  45 #include "buffer.h"
  46 #include "utility.h"
  47 #include "dsodefs.h" //For DSOEXPORT.
  48 #include "URL.h"
  49 #include "handler.h"
  50 #include "diskstream.h"
  51 #include "rtmp.h"
  52 #include "http.h"
  53 #include "crc.h"
  54 #include "flv.h"
  55
  56 #include "rtmp_server.h"
  57 #include "http_server.h"
  58
  59 using namespace gnash;
  60 using namespace std;
  61 using namespace boost;
  62
  63 namespace cygnal
  64 {
  65
  66 map<int, Handler *> DSOEXPORT handlers;
  67
  68 // The user config for Cygnal is loaded and parsed here:
  69 static CRcInitFile& crcfile = CRcInitFile::getDefaultInstance();
  70
  71 Handler::Handler()
  72     :_streams(1),       // note that stream 0 is reserved by the system.
  73      // _diskstreams(new gnash::DiskStream[STREAMS_BLOCK]),
  74      _in_fd(0)
  75 {
  76 //    GNASH_REPORT_FUNCTION;
  77     // reserve memory for the vector as it makes vector operations
  78     // must faster.
  79 }
  80
  81 Handler::~Handler()
  82 {
  83 //    GNASH_REPORT_FUNCTION;
  84 }
  85
  86 bool
  87 Handler::sync(int /* in_fd */)
  88 {
  89 //    GNASH_REPORT_FUNCTION;
  90
  91     return false;
  92 }
  93
  94 size_t
  95 Handler::addClient(int fd, Network::protocols_supported_e proto)
  96 {
  97     // GNASH_REPORT_FUNCTION;
  98
  99     std::lock_guard<std::mutex> lock(_mutex);
 100
 101     log_debug("Adding %d to the client array.", fd);
 102     switch (proto) {
 103       case Network::NONE:
 104           break;
 105       case Network::HTTP:
 106       {
 107           std::shared_ptr<HTTPServer> http(new HTTPServer);
 108           _http[fd] = http;
 109           break;
 110       }
 111       case Network::HTTPS:
 112           break;
 113       case Network::RTMP:
 114       {
 115           std::shared_ptr<RTMPServer> rtmp(new RTMPServer);
 116           _rtmp[fd] = rtmp;
 117           break;
 118       }
 119       case Network::RTMPT:
 120       case Network::RTMPTS:
 121       case Network::RTMPE:
 122       case Network::RTMPS:
 123       case Network::DTN:
 124       default:
 125           log_unimpl(_("Protocol %d for Handler::AddClient()"), proto);
 126           break;
 127     }
 128
 129     _clients.push_back(fd);
 130     _protocol[fd] = proto;
 131
 132     return _clients.size();
 133 }
 134
 135 // Parse the first nessages when starting a new message handler,
 136 // which is used to determine the name of the resource to
 137 // initialize, or load from the cache.
 138 cygnal::Buffer *
 139 Handler::parseFirstRequest(int fd, gnash::Network::protocols_supported_e proto)
 140 {
 141     GNASH_REPORT_FUNCTION;
 142     string key;
 143     Network net;
 144     cygnal::Buffer *buf = 0;
 145     std::lock_guard<std::mutex> lock(_mutex);
 146
 147     switch (proto) {
 148       case Network::NONE:
 149           break;
 150       case Network::HTTP:
 151       {
 152 #if 0
 153           int ret = _http[fd]->readNet(fd, buf);
 154           if (ret) {
 155               _http[fd]->processHeaderFields(buf);
 156               string hostname, path;
 157               string::size_type pos = _http[fd]->getField("host").find(":", 0);
 158               if (pos != string::npos) {
 159                   hostname += _http[fd]->getField("host").substr(0, pos);
 160               } else {
 161                   hostname += "localhost";
 162               }
 163               path = _http[fd]->getFilespec();
 164               key = hostname + path;
 165               log_debug("HTTP key is: %s", key);
 166               _keys[fd] = key;
 167           } else {
 168               log_error(_("HTTP key couldn't be read!"));
 169           }
 170 #else
 171           HTTPServer http;
 172           size_t bytes = http.sniffBytesReady(fd);
 173           if (bytes) {
 174               buf = new cygnal::Buffer(bytes);
 175           } else {
 176               return 0;
 177           }
 178           int ret = http.readNet(fd, buf);
 179           if (ret) {
 180               http.processHeaderFields(buf);
 181               string hostname, path;
 182               string::size_type pos = http.getField("host").find(":", 0);
 183               if (pos != string::npos) {
 184                   hostname += http.getField("host").substr(0, pos);
 185               } else {
 186                   hostname += "localhost";
 187               }
 188               path = http.getFilespec();
 189               key = hostname + path;
 190               log_debug("HTTP key is: %s", key);
 191               _keys[fd] = key;
 192           } else {
 193               log_error(_("HTTP key couldn't be read!"));
 194           }
 195 #endif
 196           break;
 197       }
 198       case Network::HTTPS:
 199           break;
 200       case Network::RTMP:
 201       {
 202           // _rtmp[fd]->recvMsg(fd);
 203           break;
 204       }
 205       case Network::RTMPT:
 206       case Network::RTMPTS:
 207       case Network::RTMPE:
 208       case Network::RTMPS:
 209       case Network::DTN:
 210       default:
 211           log_error(_("FD #%d has no protocol handler registered"), fd);
 212           break;
 213     };
 214
 215     return buf;
 216 }
 217
 218 int
 219 Handler::recvMsg(int fd)
 220 {
 221     // GNASH_REPORT_FUNCTION;
 222     std::lock_guard<std::mutex> lock(_mutex);
 223
 224     switch (_protocol[fd]) {
 225       case Network::NONE:
 226           break;
 227       case Network::HTTP:
 228       {
 229           return _http[fd]->recvMsg(fd);
 230           break;
 231       }
 232       case Network::HTTPS:
 233           break;
 234       case Network::RTMP:
 235       case Network::RTMPT:
 236       case Network::RTMPTS:
 237       case Network::RTMPE:
 238       case Network::RTMPS:
 239       case Network::DTN:
 240       default:
 241           log_error(_("FD #%d has no protocol handler registered"), fd);
 242           break;
 243     }
 244
 245     return 0;
 246 }
 247
 248 void
 249 Handler::removeClient(int x)
 250 {
 251     // GNASH_REPORT_FUNCTION;
 252
 253     std::lock_guard<std::mutex> lock(_mutex);
 254
 255     vector<int>::iterator it;
 256     for (it = _clients.begin(); it < _clients.end(); ++it) {
 257         if (*it == x) {
 258             log_debug("Removing %d from the client array.", *it);
 259             _clients.erase(it);
 260         }
 261     }
 262 }
 263
 264 void
 265 Handler::setPlugin(std::shared_ptr<Handler::cygnal_init_t> &/* init */)
 266 {
 267 //    GNASH_REPORT_FUNCTION;
 268 //     _plugin.reset(init.get());
 269 }
 270
 271 void
 272 Handler::setPlugin(Handler::cygnal_io_read_t /* read_ptr */, Handler::cygnal_io_write_t /* write_ptr */)
 273 {
 274 //    GNASH_REPORT_FUNCTION;
 275
 276     _plugin.reset(new Handler::cygnal_init_t);
 277 }
 278
 279 std::shared_ptr<Handler::cygnal_init_t>
 280 Handler::initModule(const std::string& str)
 281 {
 282     // GNASH_REPORT_FUNCTION;
 283
 284     if (str.empty()) {
 285         return _plugin;
 286     }
 287
 288     string module = str;
 289     if (module[0] == '/') {
 290         module.erase(0,1);
 291     }
 292
 293     SharedLib *sl;
 294     string symbol(module);
 295
 296     _pluginsdir = PLUGINSDIR;
 297     log_security(_("Initializing module: \"%s\" from %s"), symbol, _pluginsdir);
 298
 299     // Update the list of loaded plugins so we only load them once.
 300     if (_plugins[module] == 0) {
 301         sl = new SharedLib(module);
 302         lt_dlsetsearchpath(_pluginsdir.c_str());
 303         sl->openLib();
 304         _plugins[module] = sl;
 305     } else {
 306         sl = _plugins[module];
 307     }
 308
 309     _plugin.reset(new Handler::cygnal_init_t);
 310
 311     symbol = module;
 312     symbol.append("_init_func");
 313     Handler::cygnal_io_init_t init_symptr = reinterpret_cast<Handler::cygnal_io_init_t>
 314         (sl->getInitEntry(symbol));
 315     if (!init_symptr) {
 316         log_network(_("No %s symbol in plugin"), symbol);
 317     } else {
 318         std::shared_ptr<cygnal_init_t> info = init_symptr(_netconnect);
 319         log_network(_("Initialized Plugin: \"%s\": %s"), info->version,
 320                     info->description);
 321     }
 322
 323     // Look for the "module"_read_init function we'll use to get data
 324     // from the cgi-bin as a dynamically loadable plugin.
 325     symbol = module;
 326     symbol.append("_read_func");
 327
 328     Handler::cygnal_io_read_t read_symptr = reinterpret_cast<Handler::cygnal_io_read_t>
 329         (sl->getInitEntry(symbol));
 330
 331      if (!read_symptr) {
 332          log_error(_("Couldn't get %s symbol"), symbol);
 333          _plugin.reset();
 334          return _plugin;
 335      }
 336
 337      _plugin->read_func = read_symptr;
 338
 339      // Look for the "module"_write_init function we'll use to send data
 340      // to the cgi-bin as a dynamically loadable plugin.
 341      symbol = module;
 342      symbol.append("_write_func");
 343      Handler::cygnal_io_write_t write_symptr = reinterpret_cast<Handler::cygnal_io_write_t>
 344         (sl->getInitEntry(symbol));
 345
 346      if (!write_symptr) {
 347          log_error(_("Couldn't get %s symbol"), symbol);
 348          _plugin.reset();
 349          return _plugin;
 350      }
 351
 352      _plugin->write_func = write_symptr;
 353
 354     return _plugin;
 355 }
 356
 357 size_t
 358 Handler::writeToPlugin(std::uint8_t *data, size_t size)
 359 {
 360     // GNASH_REPORT_FUNCTION;
 361     size_t ret = 0;
 362     if (_plugin) {
 363         ret = _plugin->write_func(data, size);
 364     }
 365
 366     return ret;
 367 }
 368
 369 std::shared_ptr<cygnal::Buffer>
 370 Handler::readFromPlugin()
 371 {
 372     // GNASH_REPORT_FUNCTION;
 373
 374     std::shared_ptr<cygnal::Buffer> buf;
 375     if (_plugin) {
 376         buf = _plugin->read_func();
 377     }
 378
 379     return buf;
 380 }
 381
 382 bool
 383 Handler::initialized()
 384 {
 385     // GNASH_REPORT_FUNCTION;
 386     if (_files.empty()
 387         && (_clients.size() == 1)
 388         && !_local
 389         && _remote.empty()
 390         && !_plugin) {
 391         return false;
 392     }
 393
 394     return true;
 395 }
 396
 397 // Find a stream in the vector or Disk Streams
 398 std::shared_ptr<gnash::DiskStream>
 399 Handler::findStream(const std::string &filespec)
 400 {
 401 //    GNASH_REPORT_FUNCTION;
 402
 403     for (int i = 0; i < _streams; i++) {
 404         if (_diskstreams[i]->getFilespec() == filespec) {
 405             return _diskstreams[i];
 406         }
 407     }
 408
 409     return _diskstreams[0];
 410 }
 411
 412 // Create a new DiskStream
 413 double
 414 Handler::createStream(double /* transid */)
 415 {
 416     GNASH_REPORT_FUNCTION;
 417
 418     _diskstreams[_streams]->setState(DiskStream::CREATED);
 419
 420     return _streams;
 421 }
 422
 423 // Create a new DiskStream
 424 double
 425 Handler::createStream(double /* transid */, const std::string &filespec)
 426 {
 427     GNASH_REPORT_FUNCTION;
 428
 429     if (filespec.empty()) {
 430         return -1;
 431     }
 432
 433     _diskstreams[_streams]->setState(DiskStream::CREATED);
 434     _diskstreams[_streams]->setFilespec(filespec);
 435
 436     return _streams;
 437 }
 438
 439 bool
 440 Handler::playStream()
 441 {
 442     GNASH_REPORT_FUNCTION;
 443
 444     // _diskstreams[int(streamid)]->setState(DiskStream::PLAY);
 445
 446     return false;
 447 }
 448
 449 bool
 450 Handler::playStream(const std::string &filespec)
 451 {
 452     GNASH_REPORT_FUNCTION;
 453
 454     std::shared_ptr<gnash::DiskStream> ds = _diskstreams[_streams];
 455
 456     string fullpath = crcfile.getDocumentRoot();
 457     fullpath += "/";
 458     fullpath += filespec;
 459     log_debug("FILENAME: %s", fullpath);
 460
 461     // gnash::DiskStream &ds = findStream(filespec);
 462     if (ds->getState() == DiskStream::CREATED) {
 463         if (ds->open(fullpath)) {
 464             ds->loadToMem(0); // FIXME: load only part of the whole file for now
 465             ds->setState(DiskStream::PLAY);
 466             return true;
 467         }
 468     }
 469
 470     return false;
 471 }
 472
 473 // Publish a live stream
 474 int
 475 Handler::publishStream()
 476 {
 477     GNASH_REPORT_FUNCTION;
 478
 479     return publishStream("", Handler::LIVE);
 480 }
 481
 482 int
 483 Handler::publishStream(const std::string &/*filespec */, Handler::pub_stream_e /* op
 484                                                                            */)
 485 {
 486     GNASH_REPORT_FUNCTION;
 487
 488     // _diskstreams[int(streamid)]->setState(DiskStream::PUBLISH);
 489
 490     return -1;
 491 }
 492
 493 // Seek within the RTMP stream
 494 int
 495 Handler::seekStream()
 496 {
 497     GNASH_REPORT_FUNCTION;
 498     // _diskstreams[int(streamid)]->setState(DiskStream::SEEK);
 499
 500     return -1;
 501 }
 502
 503 int
 504 Handler::seekStream(int /* offset */)
 505 {
 506     GNASH_REPORT_FUNCTION;
 507     // _diskstreams[int(streamid)]->setState(DiskStream::SEEK);
 508
 509     return -1;
 510 }
 511
 512 // Pause the RTMP stream
 513 int
 514 Handler::pauseStream(double streamid)
 515 {
 516     GNASH_REPORT_FUNCTION;
 517
 518     _diskstreams[int(streamid)]->setState(DiskStream::PAUSE);
 519
 520     return -1;
 521 }
 522
 523 // Pause the RTMP stream
 524 int
 525 Handler::togglePause(double streamid)
 526 {
 527     GNASH_REPORT_FUNCTION;
 528
 529     if (_diskstreams[int(streamid)]->getState() == DiskStream::PAUSE) {
 530         _diskstreams[int(streamid)]->setState(DiskStream::PLAY);
 531     } if (_diskstreams[int(streamid)]->getState() == DiskStream::PLAY) {
 532         _diskstreams[int(streamid)]->setState(DiskStream::PAUSE);
 533     }
 534
 535     return -1;
 536 }
 537
 538 // Resume the paused RTMP stream
 539 double
 540 Handler::resumeStream(double streamid)
 541 {
 542     GNASH_REPORT_FUNCTION;
 543
 544     togglePause(streamid);
 545
 546     return -1;
 547 }
 548
 549 // Close the RTMP stream
 550 double
 551 Handler::closeStream(double streamid)
 552 {
 553     GNASH_REPORT_FUNCTION;
 554
 555     _diskstreams[int(streamid)]->setState(DiskStream::CLOSED);
 556
 557     return -1;
 558 }
 559
 560 // Delete the RTMP stream
 561 double
 562 Handler::deleteStream(double streamid)
 563 {
 564     GNASH_REPORT_FUNCTION;
 565
 566     _diskstreams[int(streamid)]->setState(DiskStream::NO_STATE);
 567
 568     _streams++;
 569
 570     return _streams;
 571 }
 572
 573 // Dump internal data.
 574 void
 575 Handler::dump()
 576 {
 577     const char *proto_str[] = {
 578         "NONE",
 579         "HTTP",
 580         "HTTPS",
 581         "RTMP",
 582         "RTMPT",
 583         "RTMPTS",
 584         "RTMPE",
 585         "RTMPS",
 586         "DTN"
 587     };
 588
 589 //    GNASH_REPORT_FUNCTION;
 590     cerr << "Currently there are " <<_clients.size() << " clients connected."
 591          << endl;
 592     for (size_t i = 0; i < _clients.size(); i++) {
 593         cerr << "Client on fd #" << _clients[i] << " is using  "
 594              << proto_str[_protocol[i]] << endl;
 595     }
 596
 597     cerr << "Currently there are " << dec <<_diskstreams.size() << " DiskStreams."
 598          << endl;
 599     map<int, std::shared_ptr<DiskStream> >::iterator it;
 600     for (it = _diskstreams.begin(); it != _diskstreams.end(); ++it) {
 601         if (it->second) {
 602             cerr << "DiskStream for fd #" << dec << it->first << endl;
 603             it->second->dump();
 604         }
 605     }
 606
 607 }
 608
 609 } // end of gnash namespace
 610
 611 // local Variables:
 612 // mode: C++
 613 // indent-tabs-mode: t
 614 // End:
 615