now with files

8 files changed, 410 insertions, 0 deletions

diff --git a/README b/README
index 9b8c516..987a3b7 100644
--- a/README
+++ b/README
@@ -10,6 +10,7 @@ libboost-serialization-dev
 libboost-thread-dev
 libboost-dev
 asciidoc
+libasio-dev
 
 OpenBSD
 -------
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