agi.cc

/* vim: set et sw=3 tw=0 fo=croqlaw cino=t0:
 * 
 * Astxx, the Asterisk C++ API and Utility Library.
 * Copyright (C) 2005-2007  Matthew A. Nicholson
 * Copyright (C) 2005-2007  Digium, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <astxx/agi.h>
#include <iostream>
#include <sstream>
#include <csignal>
#include <cerrno>
#include <cstring>

using namespace std;
using namespace astxx;

// initialize and declare our state variables
// XXX These variables are of type bool and not sig_atomic_t.  This may cause 
// problems on certain platforms.  Hopefully the volatile keyword will help 
// here.
volatile bool agi::got_sighup = false;
volatile bool agi::got_sigpipe = false;

agi& agi::instance() {
   static agi instance;
   return instance;
}

agi::agi() {
   // block signals
   sigset_t new_set;
   sigset_t original_set;

   if (sigfillset(&new_set) && sigprocmask(SIG_BLOCK, &new_set, &original_set))
      throw agi::error("Error blocking signals during initilization: " + string(strerror(errno)));

   // set our signal handler
   if (SIG_ERR == signal(SIGHUP, agi::handle_sighup) || SIG_ERR == signal(SIGPIPE, agi::handle_sigpipe)) {
      sigprocmask(SIG_SETMASK, &original_set, NULL);
      throw agi::error("Error blocking signals during initilization: " + string(strerror(errno)));
   }

   // read our environment
   read_env();

   // restore the previous sigmask, unblocking signals
   if (sigprocmask(SIG_SETMASK, &original_set, NULL))
      throw agi::error("Error restoring original signal mask during initilization: " + string(strerror(errno)));
}

void agi::read_env() {
   // read our environment
   while (cin.peek() != '\n') {
      string key;
      string value;

      getline(cin, key, ':');

      if (cin.peek() == ' ')
         cin.ignore(1);

      getline(cin, value);

      env.insert(make_pair(key, value));
   }
}

string agi::operator [] (const std::string& key) {
   return env[key];
}

map<string, string>::const_iterator agi::begin() const {
   return env.begin();
}

map<string, string>::const_iterator agi::end() const {
   return env.end();
}

void agi::send_command(const std::string& command) const {
   cout << command << endl;
}

agi::result agi::execute(const std::string& command) const {
   // It is important to test for a hangup here because if we attempt to 
   // execute a command, after there was a hangup Asterisk is no longer around 
   // to service us.  If we recieve a hangup during execution of an 
   // application, it will return -1 or hangup as it's data.
   test_hangup();

   send_command(command);
   agi::result result = get_result();

   if (result.data == "hangup")
      throw agi::hangup_result();

   if (result.result == -1)
      throw agi::application_error("An error occured executing an agi command or the channel was hungup");

   if (got_sigpipe)
      throw agi::io_error("Received SIGPIPE");

   return result;
}


agi::result agi::get_result() const {
   agi::result result;

   if (!(cin >> result.code)) {
      cin.clear();
      throw agi::io_error("There was a error reading from the Asterisk server");
   }

   if (cin.peek() == ' ')
      cin.ignore(1);

   getline(cin, result.message);

   istringstream message(result.message);

   // Handle various result codes.  Different codes have different data 
   // associated with them.  Below we handle the various codes.
   switch (result.code) {
      case 200:
         message.ignore(32, '=');

         // make sure result= actually has a value after '='
         if (message.peek() != ' ') {
            // store the result= portion in a stirng and int
            message >> result.result_string;
            istringstream ss(result.result_string);
            if (!(ss >> result.result))
               result.result = 0;
         }
         else {
            result.result_string = "";
            result.result = 0;
            message.ignore();
         }

         // extract any data between ()
         {
            string end_str;
            if (result.message.find("(") != string::npos) {
               message.ignore(32, '(');
               getline(message, result.data);

               const string::size_type token = result.data.find_last_of(')');
               end_str = result.data.substr(token);
               result.data.erase(token);

               message.str(end_str);
            }
            else {
               getline(message, end_str);
               message.str(end_str);
            }

            // extract endpos if applicable
            if (end_str.find("endpos=") != string::npos) {
               message.ignore(32, '=');
               message >> result.endpos;
            }
         }

         break;
      case 510:
         throw agi::invalid_command(result.message + ".  This could be a bug in Astxx, or your Asterisk installation may be too old.");

      case 520:
         {
            string buffer;
            while (getline(cin, buffer)) {
               istringstream message(buffer);
               int end;

               if (message >> end) {
                  if (end == 520)
                     break;
               }
               else {
                  message.clear();
                  result.message += buffer;
               }
            }

            throw agi::usage_error(result.message);
         }

      default:
         throw agi::unknown_error(result.code, result.message);
   }

   return result;
}

void agi::handle_sighup(int) {
   got_sighup = true;
}

void agi::handle_sigpipe(int) {
   got_sigpipe = true;
}

void agi::test_hangup() const {
   if (got_sighup)
      throw agi::hangup_signal();
}

void agi::clear() {
   got_sighup = false;
   got_sigpipe = false;
}

agi& agi::answer() {
   agi::result result = execute("ANSWER");
   return *this;
}

int agi::channel_status(const std::string& channel) const {
   return execute("CHANNEL STATUS " + quote(channel)).result;
}

char agi::control_stream_file(const std::string& filename, const std::string& escape_digits, int skip_time, char fastforward, char rewind, char pause) const {
   ostringstream ss;
   ss << "STREAM FILE " << quote(filename) << " " << quote(escape_digits);

   /* The extra if checks below are just incase a user decides to pass one of 
    * our default values (0 in this case).  The checks make sure the extra 
    * values are passed in the correct positions for Asterisk to properly 
    * identify them.
    */
   if (skip_time != control_stream_file_skip_time || fastforward || rewind || pause)
      ss << " " << skip_time;
   if (fastforward || rewind || pause)
      ss << " " << quote(fastforward);
   if (rewind || pause)
      ss << " " << quote(rewind);
   if (pause)
      ss << " " << quote(pause);

   return execute(ss.str()).result;
}

agi& agi::database_del(const std::string& family, const std::string& key) {
   agi::result result = execute("DATABASE DEL " + quote(family) + " " + quote(key));

   // posibly pass key and value with the execption
   if (result.result == 0)
      throw agi::database_error("Error deleting database value");
   return *this;
}

agi& agi::database_deltree(const std::string& family, const std::string& keytree) {
   agi::result result = execute("DATABASE DELTREE " + quote(family) + " " + quote(keytree));

   // posibly pass key and value with the execption
   if (result.result == 0)
      throw agi::database_error("Error deleting database family/keytree");
   return *this;
}

string agi::database_get(const std::string& family, const std::string& key) const {
   return execute("DATABASE GET " + quote(family) + " " + quote(key)).data;
}

agi& agi::database_put(const std::string& family, const std::string& key, const std::string& value) {
   if (execute("DATABASE PUT " + quote(family) + " " + quote(key) + quote(value)).result == 0)
      throw agi::database_error("Error putting value in Asterisk database");
   return *this;
}

int agi::exec(const std::string& app, const std::string& options) const {
   return execute("EXEC " + quote(app) + " " + quote(options)).result;
}

string agi::get_data(const std::string& file, int timeout, int max_digits) const {
   ostringstream ss;
   ss << "GET DATA " << file;

   if (timeout != 0 || max_digits != get_data_max_digits)
      ss << " " << timeout;

   if (max_digits != get_data_max_digits)
      ss << " " << max_digits;

   return execute(ss.str()).result_string;
}

string agi::get_full_variable(const std::string& variable, const std::string& channel) const {
   agi::result result;
   try {
      ostringstream ss;
      ss << "GET FULL VARIABLE " << quote(variable);

      if (!channel.empty())
         ss << " " << quote(channel);

      result = execute(ss.str());
   }
   catch (agi::hangup_result& e) {
      result.data = "hangup"; 
   }

   if (result.result == 0); // possibly throw an exception here

   return result.data;
}

char agi::get_option(const std::string& file, const std::string& escape_digits, int timeout) const {
   ostringstream ss;
   ss << "GET OPTION " << quote(file) << " " << quote(escape_digits);

   if (timeout != 0)
      ss << " " << timeout;

   agi::result result = execute(ss.str());

   return result.result;
}

string agi::get_variable(const std::string& variable) const {
   agi::result result;
   try {
      result = execute("GET VARIABLE " + quote(variable));
   }
   catch (agi::hangup_result& e) {
      result.data = "hangup"; 
   }

   if (result.result == 0); // possibly throw an exception here

   return result.data;
}

agi& agi::hangup(const std::string& channel) {
   execute("HANGUP " + quote(channel));
   return *this;
}

agi& agi::noop() {
   execute("NOOP");
   return *this;
}

char agi::receive_char(int timeout) const {
   std::stringstream ss;
   ss << "RECEIVE CHAR " << timeout;
   return execute(ss.str()).result;
}

std::string agi::receive_text(int timeout) const {
   std::stringstream ss;
   ss << "RECEIVE TEXT " << timeout;
   return execute(ss.str()).data;
}

char agi::record_file(const std::string& filename, const std::string& format, const std::string& escape_digits, int timeout, int silence, bool beep, long offset) const {
   ostringstream ss;
   ss << "RECORD FILE " << quote(filename) << " " << quote(format) << " " << quote(escape_digits) << " " << timeout;

   if (offset)
      ss << " " << offset;

   if (beep)
      ss << " BEEP";

   if (silence)
      ss << " s=" << silence;

   return execute(ss.str()).result;
}

char agi::say_alpha(const std::string& alphanum, const std::string& escape_digits) const {
   return execute("SAY ALPHA " + quote(alphanum) + " " + quote(escape_digits)).result;
}

char agi::say_alpha(int number, const std::string& escape_digits) const {
   ostringstream ss;
   ss << "SAY ALPHA " << number << " " << quote(escape_digits);
   return execute(ss.str()).result;
}

char agi::say_date(time_t date, const std::string& escape_digits) const {
   ostringstream ss;
   ss << "SAY DATE " << date << " " << quote(escape_digits);
   return execute(ss.str()).result;
}

char agi::say_datetime(time_t date, const std::string& escape_digits, const std::string& format, const std::string& timezone) const {
   ostringstream ss;
   ss << "SAY DATETIME " << date << " " << quote(escape_digits);

   if (not format.empty() or not timezone.empty())
      ss << " " << quote(format);

   if (not timezone.empty())
      ss << " " << quote(timezone);

   return execute(ss.str()).result;
}

char agi::say_digits(int digits, const std::string& escape_digits) const {
   ostringstream ss;
   ss << "SAY DIGITS " << digits << " " << quote(escape_digits);
   return execute(ss.str()).result;
}

char agi::say_number(int number, const std::string& escape_digits) const {
   ostringstream ss;
   ss << "SAY NUMBER " << number << " " << quote(escape_digits);
   return execute(ss.str()).result;
}

char agi::say_phonetic(const std::string& characters, const std::string& escape_digits) const {
   return execute("SAY PHONETIC " + quote(characters) + " " + quote(escape_digits)).result;
}

char agi::say_time(time_t time, const std::string& escape_digits) const {
   ostringstream ss;
   ss << "SAY TIME " << time << " " << quote(escape_digits);
   return execute(ss.str()).result;
}

agi& agi::send_image(const std::string& image) {
   execute("SEND IMAGE " + quote(image));
   return *this;
}

agi& agi::send_text(const std::string& text) {
   execute("SEND TEXT " + quote(text));
   return *this;
}

agi& agi::set_autohangup(int delay) {
   ostringstream ss;
   ss << "SET AUTOHANGUP " << delay;
   execute(ss.str());
   return *this;
}

agi& agi::set_callerid(int number) {
   ostringstream ss;
   ss << "SET CALLERID " << number;
   execute(ss.str());
   return *this;
}

agi& agi::set_callerid(const std::string& cid) {
   execute("SET CALLERID " + quote(cid));
   return *this;
}

agi& agi::set_context(const std::string& context) {
   execute("SET CONTEXT " + quote(context));
   return *this;
}

agi& agi::set_extension(int extension) {
   ostringstream ss;
   ss << "SET EXTENSION " << extension;
   execute(ss.str());
   return *this;
}

agi& agi::set_extension(const std::string& extension) {
   execute("SET EXTENSION " + quote(extension));
   return *this;
}

agi& agi::set_music(bool enable, const std::string& music_class) {
   ostringstream ss;
   ss << "SET MUSIC ";

   if (enable)
      ss << "ON";
   else
      ss << "OFF";

   if (not music_class.empty())
      ss << " " << quote(music_class);

   execute(ss.str());
   return *this;
}

agi& agi::set_priority(int priority) {
   ostringstream ss;
   ss << "SET PRIORITY " << priority;
   execute(ss.str());
   return *this;
}

agi& agi::set_priority(const std::string& priority) {
   execute("SET PRIORITY " + quote(priority));
   return *this;
}

agi& agi::set_variable(const std::string& variable, const std::string& value) {
   execute("SET VARIABLE " + quote(variable) + " " + quote(value));
   return *this;
}

char agi::stream_file(const std::string& filename, const std::string& escape_digits, long offset) const {
   ostringstream ss;
   ss << "STREAM FILE " << quote(filename) << " " << quote(escape_digits);

   if (offset)
      ss << " " << offset;

   return execute(ss.str()).result;
}

agi& agi::tdd_mode(bool enable) {
   if (enable)
      execute("TDD MODE ON");
   else
      execute("TDD MODE OFF");
   return *this;
}

agi& agi::tdd_mode(const std::string& mode) {
   execute("TDD MODE " + quote(mode));
   return *this;
}

agi& agi::verbose(const std::string& text, int level) {
   string::size_type end_pos = 0;
   string::size_type start_pos = 0;
   while (end_pos != string::npos) {
      end_pos = text.find('\n', start_pos);

      ostringstream ss;
      ss << "VERBOSE "
         << quote(text.substr(start_pos, end_pos == string::npos ? string::npos : end_pos - start_pos))
         << " " << level;
      execute(ss.str());

      start_pos = end_pos + 1;
   }
   
   return *this;
}

char agi::wait_for_digit(long timeout) const {
   ostringstream ss;
   ss << "WAIT FOR DIGIT " << timeout;
   return execute(ss.str()).result;
}

/* @} end of agi Commands group */