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

#include "unixclientsocket.h"

#include "stringutil.h"

#include "utils.h"

#include <iostream>

class SetBlocking {

public:

  SetBlocking(UnixClientSocket &client, bool desiredState)

    : client_(client), savedState_(client.isBlocking())

  {

    client_.setBlocking(desiredState);

  }

  ~SetBlocking()

  {

    client_.setBlocking(savedState_);

  }

private:

  UnixClientSocket &client_;

  bool savedState_;

};

ClientConnection::ClientConnection( const std::string &socketFile )

 : control_(socketFile), data_(socketFile), good_(true)

{

  if (control_ && data_) {

    control_.write("CONTROL\n");

    std::string key;

    if (!control_.readLine(key)) {

      good_ = false;

      return;

    }

    key = stripTrailingWS(key);

    data_.write("DATA " + key + "\n");

    std::string welcome;

    if (!control_.readLine(welcome)) {

      good_ = false;

      return;

    }

  }

}

ClientConnection::operator bool () const

{

  return good_ && control_ && data_;

}

std::string ClientConnection::getError() const

{

  return error_;

}

bool ClientConnection::getChannels(const std::string &type, int priority, StringList &channels)

{

  SetBlocking blocking(control_, true);

  // Check if the command is to list the channels

  control_.write("LIST " + type + " " + toString(priority) + "\n");

  do {

    std::string reply;

    if (!control_.readLine(reply)) {

      error_ = "failed to read channel from control socket";

      return false;

    }

    if (reply.substr(0, 5) == "ERROR") {

      return false;

    }

    else if (reply == "OK\n") 

      return true;

    else 

      channels.push_back( stripTrailingWS(reply.substr(1)) );

  } while (true);

}

UnixClientSocket& ClientConnection::control()

{

  return control_;

}

UnixClientSocket& ClientConnection::data()

{

  return data_;

}

int ClientConnection::schedule(const std::string &type, const std::string &channel,

                               time_t when, unsigned duration, int priority,

                               const std::string &outputFile)

{

  SetBlocking saveBlocking(control_, true);

  // Convert the time to the right format

  char data[256];

  strftime(data, sizeof(data), "%Y-%m-%d %H:%M:%S", localtime(&when));

  std::string dateTime = data;

  std::string command = 

    "SCHEDULE " + dateTime + " " + type + " " + escapeWS(channel) + " " + 

    toString(priority) + " " + toString(duration * 60) + " " + outputFile + "\n";

  std::cerr << command;

  control_.write(command);

  std::string reply;

  control_.readLine(reply);

  if (reply.substr(0, 3) == "JOB") {

    int job = toInt(reply.substr(4));

    control_.readLine(reply);        // Ok

    return job;

  }

  error_ = stripTrailingWS(reply);

  return -1;

}

void ClientConnection::checkSchedule(StringList &messages)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("CHECK\n");

  do {

    std::string reply;

    control_.readLine(reply);

    if (reply == "OK\n")

      break;

    messages.push_back(stripTrailingWS(reply));

  } while (true);

}

bool ClientConnection::listSchedule(StringList &s)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("LISTSCHEDULE\n");

  do {

    std::string reply;

    control_.readLine(reply);

    if (reply == "OK\n")

      break;

    s.push_back(stripTrailingWS(reply));

  } while (true);

  return true;

}

bool ClientConnection::removeJob(int job)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("REMOVEJOB " + toString(job) + "\n");

  std::string reply;

  control_.readLine(reply);

  if (reply == "OK\n")

    return true;

  error_ = stripTrailingWS(reply);

  return false;

}

bool ClientConnection::tune(const std::string &type, const std::string &channel, int priority)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("TUNE " + type + " " + escapeWS(channel) + " " + toString(priority) + "\n");

  std::string reply;

  control_.readLine(reply);

  if (reply == "OK\n")

    return true;

  error_ = stripTrailingWS(reply);

  return false;

}

bool ClientConnection::getNextJobTime(time_t &nextJobTime)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("NEXTJOBTIME\n");

  std::string reply;

  control_.readLine(reply);

  if (reply.substr(0, 5) == "ERROR") {

    error_ = stripTrailingWS(reply);

    return false;

  }

  struct tm tm;

  if (strptime(reply.c_str(), "%Y-%m-%d %H:%M:%S", &tm) == NULL) {

    error_ = "Invalid date/time: " + stripTrailingWS(reply);

    return false;

  }

  nextJobTime = mktime(&tm);

  return true;

}

bool ClientConnection::listConnections(StringList &s)

{

  SetBlocking saveBlocking(control_, true);

  control_.write("LISTCONNECTIONS\n");

  do {

    std::string reply;

    control_.readLine(reply);

    if (reply == "OK\n")

      break;

    s.push_back(stripTrailingWS(reply));

  } while (true);

  return true;

}