summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/controldTcpConnection.cpp34
-rw-r--r--src/syncClient.cpp153
-rw-r--r--src/syncClient.h57
-rw-r--r--src/syncServer.cpp30
-rw-r--r--src/syncServer.h27
-rw-r--r--src/syncTcpConnection.cpp80
-rw-r--r--src/syncTcpConnection.h28
7 files changed, 409 insertions, 0 deletions
diff --git a/src/controldTcpConnection.cpp b/src/controldTcpConnection.cpp
new file mode 100644
index 0000000..658fff2
--- /dev/null
+++ b/src/controldTcpConnection.cpp
@@ -0,0 +1,34 @@
+#include "syncTcpConnection.h"
+#include <boost/bind.hpp>
+#include <asio.hpp>
+
+#include <sstream>
+#include <iostream>
+#include <string>
+
+ asio::ip::tcp::socket& SyncTcpConnection::socket()
+ {
+ return socket_;
+ }
+
+void SyncTcpConnection::start()
+{
+ //TODO send file content here
+ Send("Hello");
+}
+void SyncTcpConnection::Send(std::string message)
+{
+ asio::async_write(socket_, asio::buffer(message),
+ boost::bind(&SyncTcpConnection::handle_write, shared_from_this(),
+ asio::placeholders::error,
+ asio::placeholders::bytes_transferred));
+}
+SyncTcpConnection::SyncTcpConnection(asio::io_service& io_service)
+ : socket_(io_service)
+{
+}
+
+void SyncTcpConnection::handle_write(const asio::error_code& /*error*/,
+ size_t /*bytes_transferred*/)
+{
+}
diff --git a/src/syncClient.cpp b/src/syncClient.cpp
new file mode 100644
index 0000000..d6ede4a
--- /dev/null
+++ b/src/syncClient.cpp
@@ -0,0 +1,153 @@
+/*
+ * 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-2008 Othmar Gsenger, Erwin Nindl,
+ * Christian Pointner <satp@wirdorange.org>
+ *
+ * This file is part of Anytun.
+ *
+ * Anytun is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Anytun 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 anytun. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <sstream>
+#include <iostream>
+#include <string>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+
+#include "log.h"
+//#include "connectionParam.h"
+#include "syncClient.h"
+#include "buffer.h"
+#include <boost/array.hpp>
+
+
+SyncClient::SyncClient(std::string hostname,uint16_t port)
+:hostname_( hostname),port_(port)
+{
+}
+
+void SyncClient::run()
+{
+ try
+ {
+ asio::io_service io_service;
+ for(;;)
+ {
+ std::stringstream portsrt;
+ portsrt << port_;
+ asio::ip::tcp::resolver resolver(io_service);
+ asio::ip::tcp::resolver::query query( hostname_, portsrt.str());
+ asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+ asio::ip::tcp::resolver::iterator end;
+
+ asio::ip::tcp::socket socket(io_service);
+ asio::error_code error = asio::error::host_not_found;
+ while (error && endpoint_iterator != end)
+ {
+ socket.close();
+ socket.connect(*endpoint_iterator++, error);
+ }
+ if (error)
+ throw asio::system_error(error);
+
+ for (;;)
+ {
+ boost::array<char, 128> buf;
+ asio::error_code error;
+
+ size_t len = socket.read_some(asio::buffer(buf), error);
+
+ if (error == asio::error::eof)
+ break; // Connection closed cleanly by peer.
+ else if (error)
+ throw asio::system_error(error); // Some other error.
+
+ OnRawData(buf.data(), len);
+ }
+ }
+ sleep(10);
+ }
+ catch (std::exception& e)
+ {
+ std::cerr << e.what() << std::endl;
+ }
+}
+
+void SyncClient::OnRawData(const char *buf,size_t len)
+//void SyncClientSocket::OnLine(const std::string& line)
+{
+ ConnectionList & cl_ (gConnectionList);
+ for(size_t index=0;index<len;index++)
+ {
+// std::cout << buf[index];
+ iss_ << buf[index];
+ buffer_size_++;
+ }
+ while (1)
+ {
+// cLog.msg(Log::PRIO_NOTICE) << "buffer size "<< buffer_size_ << " missing_chars " << missing_chars;
+ if(missing_chars==-1 && buffer_size_>5)
+ {
+ char * buffer = new char [6+1];
+ iss_.read(buffer,6);
+ std::stringstream tmp;
+ tmp.write(buffer,6);
+ tmp>>missing_chars;
+// cLog.msg(Log::PRIO_NOTICE) << "recieved sync inforamtaion length from " << GetRemoteHostname() <<" "<<tmp.str()<<"bytes of data"<< std::endl;
+ delete[] buffer;
+ buffer_size_-=6;
+ } else
+ if(missing_chars>0 && missing_chars<=buffer_size_)
+ {
+ char * buffer = new char [missing_chars+1];
+ iss_.read(buffer,missing_chars);
+ std::stringstream tmp;
+ tmp.write(buffer,missing_chars);
+// cLog.msg(Log::PRIO_NOTICE) << "recieved sync inforamtaion from " << GetRemoteHostname() <<" \""<<tmp.str()<<'"'<< std::endl;
+ boost::archive::text_iarchive ia(tmp);
+ SyncCommand scom(cl_);
+ ia >> scom;
+ buffer_size_-=missing_chars;
+ missing_chars=-1;
+ delete[] buffer;
+ } else
+ break;
+ }
+
+ //u_int16_t mux = scom.getMux();
+ //const ConnectionParam & conn = cl_.getConnection(mux)->second;
+ //cLog.msg(Log::PRIO_NOTICE) << "sync connection #"<<mux<<" remote host " << conn.remote_host_ << ":" << conn.remote_port_ << std::endl;
+}
+
+//void StatusClientSocket::InitSSLServer()
+//{
+// InitializeContext("server.pem", "keypwd", SSLv23_method());
+//}
+//
+//
+//void StatusClientSocket::Init()
+//{
+// EnableSSL();
+//}
diff --git a/src/syncClient.h b/src/syncClient.h
new file mode 100644
index 0000000..d1b020a
--- /dev/null
+++ b/src/syncClient.h
@@ -0,0 +1,57 @@
+/*
+ * 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-2008 Othmar Gsenger, Erwin Nindl,
+ * Christian Pointner <satp@wirdorange.org>
+ *
+ * This file is part of Anytun.
+ *
+ * Anytun is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Anytun 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 anytun. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _SYNCCLIENT_H
+#define _SYNCCLIENT_H
+
+#include "connectionList.h"
+#include "syncCommand.h"
+#include <sstream>
+#include <iostream>
+#include <string>
+#include <asio.hpp>
+
+class SyncClient
+{
+public:
+ SyncClient(std::string hostname,uint16_t port);
+
+ void run();
+private:
+ void OnRawData(const char *buf,size_t len);
+ std::string hostname_;
+ uint16_t port_;
+ std::stringstream iss_;
+ int32_t missing_chars;
+ int32_t buffer_size_;
+};
+
+
+#endif // _SYNCSOCKET_H
diff --git a/src/syncServer.cpp b/src/syncServer.cpp
new file mode 100644
index 0000000..fc0c4bc
--- /dev/null
+++ b/src/syncServer.cpp
@@ -0,0 +1,30 @@
+#include "syncServer.h"
+
+//using asio::ip::tcp;
+
+SyncServer::SyncServer(asio::io_service& io_service, asio::ip::tcp::endpoint tcp_endpoint )
+ : acceptor_(io_service, tcp_endpoint)
+{
+ start_accept();
+}
+
+void SyncServer::start_accept()
+{
+ SyncTcpConnection::pointer new_connection =
+ SyncTcpConnection::create(acceptor_.io_service());
+ conns_.push_back(new_connection);
+
+ acceptor_.async_accept(new_connection->socket(),
+ boost::bind(&SyncServer::handle_accept, this, new_connection,
+ asio::placeholders::error));
+}
+
+void SyncServer::handle_accept(SyncTcpConnection::pointer new_connection,
+ const asio::error_code& error)
+{
+ if (!error)
+ {
+ new_connection->start();
+ start_accept();
+ }
+}
diff --git a/src/syncServer.h b/src/syncServer.h
new file mode 100644
index 0000000..3fde1cc
--- /dev/null
+++ b/src/syncServer.h
@@ -0,0 +1,27 @@
+#ifndef _SYNC_SERVER_H_
+#define _SYNC_SERVER_H_
+//#include <iostream>
+//#include <string>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <asio.hpp>
+#include <list>
+#include "syncTcpConnection.h"
+
+//using boost::asio::ip::tcp;
+
+class SyncServer
+{
+public:
+ SyncServer(asio::io_service& io_service, asio::ip::tcp::endpoint tcp_endpoint );
+
+ std::list<SyncTcpConnection::pointer> conns_;
+private:
+ void start_accept();
+ void handle_accept(SyncTcpConnection::pointer new_connection,
+ const asio::error_code& error);
+
+ asio::ip::tcp::acceptor acceptor_;
+};
+#endif
diff --git a/src/syncTcpConnection.cpp b/src/syncTcpConnection.cpp
new file mode 100644
index 0000000..185781f
--- /dev/null
+++ b/src/syncTcpConnection.cpp
@@ -0,0 +1,80 @@
+#include "syncTcpConnection.h"
+#include <boost/bind.hpp>
+#include <asio.hpp>
+
+#include <sstream>
+#include <iostream>
+#include <string>
+#include "routingTable.h"
+#include "rtpSessionTable.h"
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+
+#include "syncCommand.h"
+#include "buffer.h"
+
+ asio::ip::tcp::socket& SyncTcpConnection::socket()
+ {
+ return socket_;
+ }
+
+void SyncTcpConnection::start()
+{
+ ConnectionList & cl_(gConnectionList);
+ ConnectionMap::iterator cit = cl_.getBeginUnlocked();
+ for (;cit!=cl_.getEndUnlocked();++cit)
+ {
+ std::ostringstream sout;
+ boost::archive::text_oarchive oa(sout);
+ const SyncCommand scom(cl_,cit->first);
+ oa << scom;
+ std::stringstream lengthout;
+ lengthout << std::setw(5) << std::setfill('0') << sout.str().size()<< ' ';
+ Send(lengthout.str());
+ Send(sout.str());
+ }
+ //TODO Locking here
+ RoutingMap::iterator it = gRoutingTable.getBeginUnlocked();
+ for (;it!=gRoutingTable.getEndUnlocked();++it)
+ {
+ NetworkPrefix tmp(it->first);
+ std::ostringstream sout;
+ boost::archive::text_oarchive oa(sout);
+ const SyncCommand scom(tmp);
+ oa << scom;
+ std::stringstream lengthout;
+ lengthout << std::setw(5) << std::setfill('0') << sout.str().size()<< ' ';
+ Send(lengthout.str());
+ Send(sout.str());
+ }
+ //TODO Locking here
+ RtpSessionMap::iterator rit = gRtpSessionTable.getBeginUnlocked();
+ for (;rit!=gRtpSessionTable.getEndUnlocked();++rit)
+ {
+ std::ostringstream sout;
+ boost::archive::text_oarchive oa(sout);
+ const SyncCommand scom(rit->first);
+ oa << scom;
+ std::stringstream lengthout;
+ lengthout << std::setw(5) << std::setfill('0') << sout.str().size()<< ' ';
+ Send(lengthout.str());
+ Send(sout.str());
+ }
+}
+void SyncTcpConnection::Send(std::string message)
+{
+ asio::async_write(socket_, asio::buffer(message),
+ boost::bind(&SyncTcpConnection::handle_write, shared_from_this(),
+ asio::placeholders::error,
+ asio::placeholders::bytes_transferred));
+}
+SyncTcpConnection::SyncTcpConnection(asio::io_service& io_service)
+ : socket_(io_service)
+{
+}
+
+void SyncTcpConnection::handle_write(const asio::error_code& /*error*/,
+ size_t /*bytes_transferred*/)
+{
+}
diff --git a/src/syncTcpConnection.h b/src/syncTcpConnection.h
new file mode 100644
index 0000000..5caf1a0
--- /dev/null
+++ b/src/syncTcpConnection.h
@@ -0,0 +1,28 @@
+#ifndef _SYNCTCPCONNECTION_H_
+#define _SYNCTCPCONNECTION_H_
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <asio.hpp>
+
+#include <string>
+
+class SyncTcpConnection
+ : public boost::enable_shared_from_this<SyncTcpConnection>
+{
+public:
+ typedef boost::shared_ptr<SyncTcpConnection> pointer;
+ static pointer create(asio::io_service& io_service)
+ {
+ return pointer(new SyncTcpConnection(io_service));
+ };
+ asio::ip::tcp::socket& socket();
+ void start();
+ void Send(std::string message);
+private:
+ SyncTcpConnection(asio::io_service& io_service);
+
+ void handle_write(const asio::error_code& /*error*/,
+ size_t /*bytes_transferred*/);
+ asio::ip::tcp::socket socket_;
+};
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 23:34:18 +0000