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 "config.h"

#include "dvbd.h"

#include "utils.h"

#include "stringutil.h"

#include "select.h"

#include "clientconnection.h"

#include "unixclientsocket.h"

#include "parsetime.h"

#include <string>

#include <iostream>

#include <time.h>

#include <getopt.h>

#include <cerrno>

#include <fstream>

// Unfortunately, large file support (LFS) in gcc 3.2, 3.3 is broken

// on Debian sarge/sid. Work around with LFS_WORKAROUND

#define LFS_WORKAROUND

#ifdef LFS_WORKAROUND

#include <fcntl.h>

#include <ext/stdio_filebuf.h>

#endif

void usage(const char *progname);

time_t convertTime(const char *theTime);

int main(int argc, char *argv[])

{

  // improve iostream performance

  std::ios::sync_with_stdio(false);

  std::string socketFile = DEFAULT_SOCKET_FILE;

  bool convertToPS = false;

  int priority = 10;

  while (true) {

    static struct option long_options[] = {

      {"priority", 1, 0, 'p'},

      {"socket", 1, 0, 's'},

      {"ps", 0, 0, 'P'},

      {0, 0, 0, 0}

    };

    int option_index = 0;

    int c = getopt_long(argc, argv, "d:s:", long_options, &option_index);

    if (c == -1)

      break;

    switch (c) {

    case 'p':

      priority = toInt(optarg);

      break;

    case 's':

      socketFile = optarg;

      break;

    case 'P':

      convertToPS = true;

      break;

    default:

      usage(argv[0]);

      return 1;

    }

  }

  if (argc - optind != 5) {

    if (argc - optind != 0)

      std::cerr << "Incorrect number of arguments passed (expected 5, got " 

                << argc - optind << ")\n\n";

    usage(argv[0]);

    return 1;

  }

  // Parse the command line arguments

  std::string type(argv[optind++]);

  std::string channel(argv[optind++]);

  time_t scheduleTime = convertTime(argv[optind++]);

  unsigned duration = toInt(argv[optind++]);

  std::string outputFile = argv[optind++];

  ClientConnection client(socketFile);

  if (!client) {

    std::cerr << "Fatal error: failed to connect to server on socket " << socketFile << std::endl;

    return 1;

  }

  // Schedule

    int job = client.schedule(type, channel, convertToPS, scheduleTime, duration, priority, outputFile);

    if (job < 0) {

      std::cerr << "Failed to schedule job\n";

      return 1;

    }

    std::cout << "Job number is " << job << std::endl;

    StringList messages;

    client.checkSchedule(messages);

    if (!messages.empty()) {

      std::cout << "The following schedule problems were identified:\n";

      for (StringList::iterator i = messages.begin(); i != messages.end(); i++)

        std::cout << *i << "\n";

      std::cout << "Do you still wish to schedule the job?\n";

      char answer;

      while (std::cin >> answer) {

        switch (tolower(answer)) {

        case 'y':

          std::cout << "Job Scheduled\n";

          return 0;

        case 'n':

          client.removeJob(job);

          std::cout << "Job not scheduled.\n";

          return 0;

        default:

          std::cout << "Please answer Y or N\n";

          break;

        }

      }

    }

}

time_t convertTime(const char *theTime)

{

  // Check that the date time is OK

  char *argv[2] = { const_cast<char *>(theTime), 0 };

  time_t result = parsetime( 1, argv );

  if (result == 0) {

    std::cerr << "Fatal error: failed to parse date time: " << theTime << "\n";

    exit(1);

  }

  return result;

}

void usage(const char *progname) {

  std::cerr << "Usage: " << progname << " [OPTION] TYPE CHANNEL TIME DURATION OUTPUT\n"

            << "Schedule DVB recording for channel CHANNEL, using DVB-card\n"

            << "\n"

            << "TYPE can be dvb-t, dvb-s or dvb-c.\n"

            << "TIME is time to schedule recording. format is\n"

            << "     same as for at(1)."

            << "DURATION is time to stream for in minutes.\n"

            << "OUTPUT is the output file, must be owned by the user\n"

            << "       and writable by dvbd.\n"

            << "\n"

            << "  -p, --priority         Priority of stream (default is 10\n"

            << "                         higher priorities may dislodge lower\n"

            << "                         ones).\n"

            << "  -s, --socket           Specify socket to connect to\n"

            << "                         (default is " << DEFAULT_SOCKET_FILE << ")\n"

            << "  -P, --ps               Convert stream to program stream\n";

}

// For parsetime

extern "C" 

int yywrap()

{

  return 1;

}