PeerStreamer

/*

  Copyright 2003 John Knottenbelt

  This program is free software; you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation; either version 2 of the License, or

  (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

*/

#include "lobby.h"

#include "unixserversocket.h"

#include "controlledconnection.h"

#include "connectionmanager.h"

#include "stringutil.h"

#include "utils.h"

#include "dvbd.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <cerrno>

#include <cstring>

#include <cstdio>

#include <cstdlib>

#include <fcntl.h>

#include <time.h>

#include <iostream>

#include <unistd.h>

Lobby::Lobby(const std::string &socketFilename,

             const std::string &socketUid,

             const std::string &socketGid,

             const std::string &socketMode,

             TunerManager *tm, 

             ConnectionManager *cm, 

             Scheduler *scheduler)

  : tm(tm), cm(cm), scheduler(scheduler)

{

  server = new UnixServerSocket(socketFilename, socketUid, socketGid, socketMode);

  server->setNonBlocking();

  setRandomSeed();

}

Lobby::~Lobby()

{

  delete server;

}

void Lobby::addSelectFDs(Select &s) const

{

  server->addSelectFDs(s);

  for (ClientList::const_iterator i = clients.begin(); i != clients.end(); i++)

    s.addReadFD(*i);

  for (ControlList::const_iterator i = controllers.begin(); i != controllers.end(); i++)

    s.addReadFD(i->getFD());

}

bool Lobby::isReady(const Select &s) const

{

  if (server->isReady(s))

    return true;

  for (ClientList::const_iterator i = clients.begin(); i != clients.end(); i++) 

    if (s.readyToRead(*i))

      return true;

  for (ControlList::const_iterator i = controllers.begin(); i != controllers.end(); i++)

    if (s.readyToRead(i->getFD()))

      return true;

  return false;

}

void Lobby::processReady(Select &s)

{

  if (server->isReady(s)) {

    int fd = server->accept();

    if (fd >= 0) {

      // ALRM signal can interrupt the accept causing it to return -1

      // and errno = EAGAIN

      ::setNonBlocking(fd);

      clients.push_back(fd);

    }

  }

  for (ControlList::iterator i = controllers.begin(); i != controllers.end();) {

    int fd = i->getFD();

    if (s.readyToRead(fd)) {

      std::cerr << "Controller sent data before establishing connection.\n"

                << "(Hint: wait for welcome messagae)\n"

                << "Closing connection.\n";

      // Controllers are not supposed to be saying anything at this

      // time. Close the connection.

      ::close(fd);

      i = controllers.erase(i);

    }

    i++;

  }

  for (ClientList::iterator i = clients.begin(); i != clients.end(); ) {

    int fd = *i;

    if (s.readyToRead(fd)) {

      std::string command;

      int bytesread = readLineStripTrailingWS(fd, command);

      if (bytesread <= 0) {

        // Close the connection

        ::close(fd);

        i = clients.erase(i);

        continue;

      }

      if (command == "CONTROL") {

        if (debugLevel > 2)

          std::cerr << "Control socket registered\n";

        // Upgrade this connection to a Controller

        std::string id = generateId();

        controllers.push_back(Control(fd, id));

        i = clients.erase(i);

        writeString(fd, id + "\n");

        continue;

      }

      else if (command.substr(0, 5) == "DATA ") {

        if (debugLevel > 2)

          std::cerr << "Data socket registered\n";

        // Upgrade this connection to a Data connection

        std::string key = command.substr(5);

        bool success = false;

        for (ControlList::iterator j = controllers.begin(); j != controllers.end(); j++) {

          Control &c = *j;

          if (c.matches(key)) {

            cm->add(new ControlledConnection(tm, scheduler, cm, c.getFD(), fd));

            controllers.erase(j);

            success = true;

            break;

          }

        }

        if (success) {

          if (debugLevel > 1)

            std::cerr << "Data socket paired with control socket\n";

          i = clients.erase(i);

          continue;

        }

        else {

          std::cerr << "Failed to pair data socket with control socket\n";

          // Close the connection

          ::close(fd);

          i = clients.erase(i);

          continue;

        }

      }

      else

        std::cerr << "Unknown lobby command: " << command << "\n";

    }

    i++;

  }

}

void Lobby::setRandomSeed()

{

  int fd = open("/dev/random", O_RDONLY);

  if (fd < 0) 

    srandom((unsigned) time(NULL));

  else {

    union {

      char data[4];

      unsigned seed;

    } x;

    read(fd, x.data, 4);

    srandom(x.seed);

    close(fd);

  }

}

std::string Lobby::generateId()

{

  static unsigned serial = 0;

  char key[65];

  for (int i = 0; i < 64; i++)

    key[i] = 'A' + random() % 26;

  key[64] = '\x0';

  serial++;

  return toString(serial) + "_" + key;

}