From 1001e35e17dc09c3b7206479627b1ca9619891ec Mon Sep 17 00:00:00 2001 From: Christian Pointner Date: Thu, 13 Mar 2008 13:59:50 +0000 Subject: added commandhandler commandhandler supports Version Commands --- anyrtpproxy/Makefile | 4 + anyrtpproxy/anyrtpproxy.cpp | 56 ++++++------ anyrtpproxy/commandHandler.cpp | 200 +++++++++++++++++++++++++++++++++++++++++ anyrtpproxy/commandHandler.h | 83 +++++++++++++++++ anyrtpproxy/options.cpp | 36 +------- anyrtpproxy/options.h | 6 -- 6 files changed, 319 insertions(+), 66 deletions(-) create mode 100644 anyrtpproxy/commandHandler.cpp create mode 100644 anyrtpproxy/commandHandler.h (limited to 'anyrtpproxy') 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 @@ -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 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 + * + * 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 +#include + +#include +#include + +#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(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(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 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 + * + * 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 +#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 to make a chroot to" << std::endl; std::cout << " [-d|--nodaemonize] don't run in background" << std::endl; std::cout << " [-s|--control] the address/port to listen on for control commands" << std::endl; - std::cout << " [-p|--port] use this port to send out packets to remote hosts" << std::endl; - std::cout << " [-r|--remote-hosts] [, .. ] 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; -- cgit v1.2.3