added commandhandler

commandhandler supports Version Commands

6 files changed, 319 insertions, 66 deletions

diff --git a/anyrtpproxy/Makefile b/anyrtpproxy/Makefile
index 6f13a90..6b0e4a1 100644
--- a/anyrtpproxy/Makefile
+++ b/anyrtpproxy/Makefile
@@ -32,6 +32,7 @@ OBJS = anyrtpproxy.o \
        ../networkAddress.o \
        ../networkPrefix.o \
        ../Sockets/libSockets.a \
+       commandHandler.o \
        options.o
 
 EXECUTABLE = anyrtpproxy
@@ -47,6 +48,9 @@ options.o: options.cpp options.h
 connectionList.o: connectionList.cpp connectionList.h
 	$(C++) $(CCFLAGS) $< -c
 
+commandHandler.o: commandHandler.cpp commandHandler.h
+	$(C++) $(CCFLAGS) $< -c
+
 anyrtpproxy.o: anyrtpproxy.cpp
 	$(C++) $(CCFLAGS) $< -c
 
diff --git a/anyrtpproxy/anyrtpproxy.cpp b/anyrtpproxy/anyrtpproxy.cpp
index bace61c..df79563 100644
--- a/anyrtpproxy/anyrtpproxy.cpp
+++ b/anyrtpproxy/anyrtpproxy.cpp
@@ -21,6 +21,8 @@
 #include "../syncClientSocket.h"
 #include "../threadUtils.hpp"
 
+#include "commandHandler.h"
+
 #include "options.h"
 #include <map>
 
@@ -62,18 +64,18 @@ private:
 
 void* sender(void* dont_use_me)
 {
-  try 
-  {
-    HostList remote_host_list(gOpt.getRemoteHosts());
-    UDPSocket control_sock(gOpt.getControlInterface().addr_, gOpt.getControlInterface().port_);
-
-    Buffer buf(u_int32_t(MAX_PACKET_SIZE));
-    string remote_host;
-    u_int16_t remote_port;
-    while(1) {
-      buf.setLength(MAX_PACKET_SIZE);
-      u_int32_t len = control_sock.recvFrom(buf.getBuf(), buf.getLength(), remote_host, remote_port);
-      buf.setLength(len);
+//   try 
+//   {
+//     HostList remote_host_list(gOpt.getRemoteHosts());
+//     UDPSocket control_sock(gOpt.getControlInterface().addr_, gOpt.getControlInterface().port_);
+
+//     Buffer buf(u_int32_t(MAX_PACKET_SIZE));
+//     string remote_host;
+//     u_int16_t remote_port;
+//     while(1) {
+//       buf.setLength(MAX_PACKET_SIZE);
+//       u_int32_t len = control_sock.recvFrom(buf.getBuf(), buf.getLength(), remote_host, remote_port);
+//       buf.setLength(len);
       
 //TODO????//TODO????//TODO????//TODO????//TODO????//TODO????//TODO????      control.setHost(remote_host, remote_port);
 
@@ -83,15 +85,15 @@ void* sender(void* dont_use_me)
 //     pthread_detach(receiverThread);  
 
       
-      HostList::const_iterator it = remote_host_list.begin();
+//      HostList::const_iterator it = remote_host_list.begin();
 //      for(;it != remote_host_list.end(); it++)
 //        param->sock_.sendTo(buf.getBuf(), buf.getLength(), it->addr_, it->port_);
-    }  
-  }
-  catch(std::exception &e)
-  {
-    cLog.msg(Log::PRIO_ERR) << "sender exiting because: " << e.what() << std::endl;
-  }
+//     }  
+//   }
+//   catch(std::exception &e)
+//   {
+//     cLog.msg(Log::PRIO_ERR) << "sender exiting because: " << e.what() << std::endl;
+//   }
   pthread_exit(NULL);
 }
 
@@ -129,7 +131,7 @@ void* receiver(void* p)
 //   {
 //     cLog.msg(Log::PRIO_ERR) << "receiver exiting because: " << e.what() << std::endl;
 //   }
-//   pthread_exit(NULL);
+  pthread_exit(NULL);
 } 
 
 void chrootAndDrop(string const& chrootdir, string const& username)
@@ -239,9 +241,9 @@ int main(int argc, char* argv[])
   SignalController sig;
   sig.init();
 
-  pthread_t senderThread;
-  pthread_create(&senderThread, NULL, sender, NULL);
-  pthread_detach(senderThread);
+//   pthread_t senderThread;
+//   pthread_create(&senderThread, NULL, sender, NULL);
+//   pthread_detach(senderThread);
   pthread_t syncListenerThread;
 
   SyncQueue queue;
@@ -257,10 +259,12 @@ int main(int argc, char* argv[])
   std::list<pthread_t> connectThreads;
   for(ConnectToList::iterator it = connect_to.begin() ;it != connect_to.end(); ++it)
   {
-   connectThreads.push_back(pthread_t());
-   ThreadParam * point = new ThreadParam(queue,*it);
-   pthread_create(& connectThreads.back(),  NULL, syncConnector, point);
+    connectThreads.push_back(pthread_t());
+    ThreadParam * point = new ThreadParam(queue,*it);
+    pthread_create(& connectThreads.back(),  NULL, syncConnector, point);
   }
+
+  CommandHandler cmd(gOpt.getControlInterface().addr_, gOpt.getControlInterface().port_);
   
   int ret = sig.run();
   return ret;
diff --git a/anyrtpproxy/commandHandler.cpp b/anyrtpproxy/commandHandler.cpp
new file mode 100644
index 0000000..cac5c4b
--- /dev/null
+++ b/anyrtpproxy/commandHandler.cpp
@@ -0,0 +1,200 @@
+/*
+ *  anytun
+ *
+ *  The secure anycast tunneling protocol (satp) defines a protocol used
+ *  for communication between any combination of unicast and anycast
+ *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
+ *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
+ *  ethernet, ip, arp ...). satp directly includes cryptography and
+ *  message authentication based on the methodes used by SRTP.  It is
+ *  intended to deliver a generic, scaleable and secure solution for
+ *  tunneling and relaying of packets of any protocol.
+ *
+ *
+ *  Copyright (C) 2007 anytun.org <satp@wirdorange.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  as published by the Free Software Foundation.
+ *
+ *  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 (see the file COPYING included with this
+ *  distribution); if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <sstream>
+#include <vector>
+
+#include <iomanip>
+#include <iostream>
+
+#include "commandHandler.h"
+#include "../buffer.h"
+#include "../log.h"
+
+#define MAX_COMMAND_LENGTH 1000
+
+CommandHandler::CommandHandler(u_int16_t lp) : running_(true), control_sock_(lp), local_address_("0.0.0.0"), local_port_(lp)
+{
+  pthread_create(&thread_, NULL, run, this);
+}
+
+CommandHandler::CommandHandler(string la, u_int16_t lp) : running_(true), control_sock_(la, lp), local_address_(la), local_port_(lp)
+{
+  pthread_create(&thread_, NULL, run, this);
+}
+
+CommandHandler::~CommandHandler()
+{
+  pthread_cancel(thread_);
+  pthread_join(thread_, NULL);
+}
+
+void* CommandHandler::run(void* s)
+{
+  CommandHandler* self = reinterpret_cast<CommandHandler*>(s);
+
+  Buffer buf(u_int32_t(MAX_COMMAND_LENGTH));
+  try
+  {
+    string remote_host;
+    u_int16_t remote_port;
+ 
+    int len;
+    while(1)
+    {
+      buf.setLength(MAX_COMMAND_LENGTH);
+      len = self->control_sock_.recvFrom(buf.getBuf(), buf.getLength(), remote_host, remote_port);
+      buf.setLength(len);
+
+      std::string ret = self->handle(std::string(reinterpret_cast<char*>(buf.getBuf()), buf.getLength())); // TODO: reinterpret is ugly
+
+      cLog.msg(Log::PRIO_DEBUG) << "CommandHandler received Command from " << remote_host << ":" << remote_port 
+                                << ", ret='" << ret << "'";
+
+      self->control_sock_.sendTo(ret.c_str(), ret.length(), remote_host, remote_port);
+    }
+  }
+  catch(SocketException &e)
+  {
+    self->running_ = false;
+    pthread_exit(NULL);
+  }
+  self->running_ = false;
+  pthread_exit(NULL);
+}
+
+bool CommandHandler::isRunning()
+{
+  return running_;
+}
+
+
+
+std::string CommandHandler::handle(std::string command)
+{
+  istringstream iss(command);
+  ostringstream oss;
+  std::string cookie;
+  std::string cmd;
+
+  iss >> cookie;
+  oss << cookie << " ";
+
+  if(iss.bad() || iss.eof()) {
+    oss << RET_ERR_SYNTAX;
+    return oss.str();
+  }
+  iss >> cmd;
+
+  std::vector<std::string> params;
+  while(!iss.bad() && !iss.eof()) {
+    std::string tmp;
+    iss >> tmp;
+    params.push_back(tmp);
+  }
+
+  std::string ret;
+  switch(std::toupper(cmd[0]))
+  {
+  case CMD_REQUEST:
+    if(params.size() < 4) { ret = RET_ERR_SYNTAX; break; }
+    ret = handleRequest(cmd.erase(0,1), params[0], params[1], params[2], params[3], (params.size() < 5) ? "" : params[4]);
+    break;
+  case CMD_RESPONSE:
+    if(params.size() < 4) { ret = RET_ERR_SYNTAX; break; }
+    ret = handleResponse(cmd.erase(0,1), params[0], params[1], params[2], params[3], (params.size() < 5) ? "" : params[4]);
+    break;
+  case CMD_DELETE:
+    if(params.size() < 2) { ret = RET_ERR_SYNTAX; break; }
+    return handleDelete(params[0], params[1], (params.size() < 3) ? "" : params[2]);
+  case CMD_VERSION:
+    if(cmd.length() > 1 && cmd[1] == 'F') {
+      if(params.size() < 1) { ret = RET_ERR_SYNTAX; break; }
+      ret = handleVersionF(params[0]);
+      break;
+    }
+    ret = handleVersion();
+    break;
+  case CMD_INFO:
+    ret = handleInfo();
+    break;
+  default:
+    ret = RET_ERR_SYNTAX;
+    break;
+  }
+
+  oss << ret;
+  return oss.str();
+}
+
+string CommandHandler::handleRequest(string modifiers, string call_id, string addr, string port, string from_tag, string to_tag)
+{
+  std::cout << "received request[" << modifiers << "] command ('" << call_id << "','" << addr  << "','" << port 
+            << "','" << from_tag << "','" << to_tag << "')" << std::endl;
+
+  return RET_OK;
+}
+
+string CommandHandler::handleResponse(string modifiers, string call_id, string addr, string port, string from_tag, string to_tag)
+{
+  std::cout << "received response[" << modifiers << "] command ('" << call_id << "','" << addr  << "','" << port 
+            << "','" << from_tag << "','" << to_tag << "')" << std::endl;
+
+  return RET_OK;
+}
+
+string CommandHandler::handleDelete(string call_id, string from_tag, string to_tag)
+{
+  std::cout << "received delete command ('" << call_id << "','" << from_tag << "','" << to_tag << "')" << std::endl;
+
+  return RET_OK;
+}
+
+string CommandHandler::handleVersion()
+{
+  std::cout << "received version command" << std::endl;  
+  return BASE_VERSION;
+}
+
+string CommandHandler::handleVersionF(string date_code)
+{
+  std::cout << "received version[F] command ('" << date_code << "')" << std::endl;  
+  if(!date_code.compare(SUP_VERSION))
+    return "1";
+  
+  return "0";
+}
+
+string CommandHandler::handleInfo()
+{
+  std::cout << "received info command" << std::endl;  
+  return RET_OK;
+}
+
diff --git a/anyrtpproxy/commandHandler.h b/anyrtpproxy/commandHandler.h
new file mode 100644
index 0000000..41bff2d
--- /dev/null
+++ b/anyrtpproxy/commandHandler.h
@@ -0,0 +1,83 @@
+/*
+ *  anytun
+ *
+ *  The secure anycast tunneling protocol (satp) defines a protocol used
+ *  for communication between any combination of unicast and anycast
+ *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
+ *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
+ *  ethernet, ip, arp ...). satp directly includes cryptography and
+ *  message authentication based on the methodes used by SRTP.  It is
+ *  intended to deliver a generic, scaleable and secure solution for
+ *  tunneling and relaying of packets of any protocol.
+ *
+ *
+ *  Copyright (C) 2007 anytun.org <satp@wirdorange.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  as published by the Free Software Foundation.
+ *
+ *  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 (see the file COPYING included with this
+ *  distribution); if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _COMMAND_HANDLER_H_
+#define _COMMAND_HANDLER_H_
+
+#include <string>
+#include "../datatypes.h"
+#include "../PracticalSocket.h"
+
+using std::string;
+
+class CommandHandler
+{
+public:
+  CommandHandler(u_int16_t lp);
+  CommandHandler(string la, u_int16_t lp);
+  ~CommandHandler();
+  
+  bool isRunning();
+
+  #define CMD_REQUEST 'U'
+  #define CMD_RESPONSE 'L'
+  #define CMD_DELETE 'D'
+  #define CMD_VERSION 'V'
+  #define CMD_INFO 'I'
+
+  #define RET_OK "0"
+  #define RET_ERR_SYNTAX "E1"
+
+  #define BASE_VERSION "20040107"
+  #define SUP_VERSION "20050322"
+
+private:
+  CommandHandler(const CommandHandler &c);
+  void operator=(const CommandHandler &c);
+
+  static void* run(void* s);
+  string handle(string command);
+  
+  string handleRequest(string modifiers, string call_id, string addr, string port, string from_tag, string to_tag);
+  string handleResponse(string modifiers, string call_id, string addr, string port, string from_tag, string to_tag);
+  string handleDelete(string call_id, string from_tag, string to_tag);
+  string handleVersion();
+  string handleVersionF(string date_code);
+  string handleInfo();
+
+  pthread_t thread_;
+  bool running_;
+  UDPSocket control_sock_;
+  string local_address_;
+  u_int16_t local_port_;
+};
+
+
+#endif
diff --git a/anyrtpproxy/options.cpp b/anyrtpproxy/options.cpp
index 94825c1..0c55c90 100644
--- a/anyrtpproxy/options.cpp
+++ b/anyrtpproxy/options.cpp
@@ -49,7 +49,7 @@ Options& Options::instance()
   return *inst;
 }
 
-Options::Options() : control_interface_("0.0.0.0", 22220)
+Options::Options() : control_interface_("0.0.0.0", 22222)
 
 {
   progname_ = "anyrtpproxy";
@@ -57,8 +57,6 @@ Options::Options() : control_interface_("0.0.0.0", 22220)
   username_ = "nobody";
   chroot_dir_ = "/var/run";
   daemonize_ = true;
-  send_port_ = 22221;
-  remote_hosts_.push_back(Host("127.0.0.1", 22222));
 }
 
 Options::~Options()
@@ -155,8 +153,6 @@ bool Options::parse(int argc, char* argv[])
     PARSE_SCALAR_PARAM("-c","--chroot-dir", chroot_dir_)
     PARSE_INVERSE_BOOL_PARAM("-d","--nodaemonize", daemonize_)
     PARSE_STRING_PARAM("-s","--control", control_interface_)
-    PARSE_SCALAR_PARAM("-p","--port", send_port_)
-    PARSE_CSLIST_PARAM("-r","--remote-hosts", remote_hosts_)
     else 
       return false;
   }
@@ -166,12 +162,7 @@ bool Options::parse(int argc, char* argv[])
 
 bool Options::sanityCheck()
 {
-  if(control_interface_.port_) control_interface_.port_ = 22220;
-
-  HostList::iterator it=remote_hosts_.begin();
-  for(u_int32_t i=0; it != remote_hosts_.end(); ++it, ++i)
-    if(!it->port_) it->port_ = 22222;
-
+  if(!control_interface_.port_) control_interface_.port_ = 22220;
   return true;
 }
 
@@ -184,8 +175,6 @@ void Options::printUsage()
   std::cout << "            [-c|--chroot-dir] <directory>                          directory to make a chroot to" << std::endl;
   std::cout << "            [-d|--nodaemonize]                                     don't run in background" << std::endl;
   std::cout << "            [-s|--control] <addr[:port]>                           the address/port to listen on for control commands" << std::endl;
-  std::cout << "            [-p|--port] <port>                                     use this port to send out packets to remote hosts" << std::endl;
-  std::cout << "            [-r|--remote-hosts] <addr[:port]>[,<addr[:<port]> .. ] a list of remote hosts to send duplicates to" << std::endl;
 }
 
 void Options::printOptions()
@@ -197,15 +186,6 @@ void Options::printOptions()
   std::cout << "chroot-dir='" << chroot_dir_ << "'" << std::endl;
   std::cout << "daemonize='" << daemonize_ << "'" << std::endl;
   std::cout << "control-interface='" << control_interface_.toString() << "'" << std::endl;
-  std::cout << "send-port='" << send_port_ << "'" << std::endl;
-  std::cout << "remote hosts='";
-  HostList::const_iterator it=remote_hosts_.begin();
-  for(u_int32_t i=0; it != remote_hosts_.end(); ++it, ++i)
-  {
-    if(i) std::cout << "','";
-    std::cout << it->toString();
-  }
-  std::cout << "'" << std::endl;
 }
 
 std::string Options::getProgname()
@@ -238,24 +218,12 @@ bool Options::getDaemonize()
   return daemonize_;
 }
 
-u_int16_t Options::getSendPort()
-{
-  Lock lock(mutex);
-  return send_port_;
-}
-
 Host Options::getControlInterface()
 {
   Lock lock(mutex);
   return control_interface_;
 }
 
-HostList Options::getRemoteHosts()
-{
-  Lock lock(mutex);
-  return remote_hosts_;
-}
-
 u_int16_t Options::getLocalSyncPort()
 {
   return local_sync_port_;
diff --git a/anyrtpproxy/options.h b/anyrtpproxy/options.h
index 12107b6..e47a013 100644
--- a/anyrtpproxy/options.h
+++ b/anyrtpproxy/options.h
@@ -80,14 +80,10 @@ public:
   std::string getUsername();
   std::string getChrootDir();
   bool getDaemonize();
-  u_int16_t getSendPort();
   Host getControlInterface();
-  HostList getRemoteHosts();
   u_int16_t getLocalSyncPort();
 	Options& setLocalSyncPort(u_int16_t l);
   ConnectToList getConnectTo();
-  Options& setMux(u_int16_t m);
-
 
 private:
   Options();
@@ -115,9 +111,7 @@ private:
   bool daemonize_;
 	u_int16_t local_sync_port_;
 	ConnectToList connect_to_;
-  u_int16_t send_port_;
   Host control_interface_;
-  HostList remote_hosts_;
 };
 
 extern Options& gOpt;