#include <cstdlib>
#include <iostream>
#include <unistd.h>

#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>

typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;

class Server
 {
 public:
   Server(boost::asio::io_service& io_service, unsigned short port) :
     io_service_(io_service),
     acceptor_(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
     context_(boost::asio::ssl::context::sslv3)
   {
     context_.set_options(boost::asio::ssl::context::no_sslv2
			  | boost::asio::ssl::context::single_dh_use);
     context_.use_certificate_chain_file("cert.pem");
     context_.use_private_key_file("key.pem", boost::asio::ssl::context::pem);
     context_.use_tmp_dh_file("dh512.pem");

     std::cout << "Server: Server accepting connection on localhost 5005\n";
     socket_ = boost::shared_ptr<ssl_socket>(new ssl_socket(io_service_, context_));
     
     acceptor_.async_accept(socket_->lowest_layer(),
			    boost::bind(&Server::HandleAccept, this, 
					boost::asio::placeholders::error));
   }

   void HandleAccept(const boost::system::error_code& error)
   {
     if (error)
     {
	std::cerr << "Server: Connect error: " << error.message() << "\n";
     }
     else
     {
        std::cout << "Server: Client connected\n";
	socket_->async_handshake(boost::asio::ssl::stream_base::server,
        	                boost::bind(&Server::HandleHandshake, this, 
					 boost::asio::placeholders::error));
     }
   }

   void HandleHandshake(const boost::system::error_code& error)
   {
     if (error)
     {	
       std::cerr << "Server: Handshake failed: " << error.message() << "\n";
     }
     else
     {
       std::cout << "Server: Handshake succeeded\n";
     }
   }


 private:
   boost::asio::io_service& io_service_;
   boost::asio::ip::tcp::acceptor acceptor_;
   boost::asio::ssl::context context_;
   boost::shared_ptr<ssl_socket> socket_; 
 };

 class Client
 {
 public:
   Client(boost::asio::io_service& io_service,
	  boost::asio::ssl::context& context,
	  boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
     : socket_(io_service, context)
   {
     socket_.set_verify_mode(boost::asio::ssl::verify_peer);
     boost::asio::async_connect(socket_.lowest_layer(), endpoint_iterator,
				boost::bind(&Client::HandleConnect, this,
					    boost::asio::placeholders::error));
   }

   void HandleConnect(const boost::system::error_code& error)
   {
     if (error)
     {
       std::cerr << "Client: Connection failed: " << error.message() << "\n";
     }
     else
     {
       std::cout << "Client: Connected\n";
       socket_.async_handshake(boost::asio::ssl::stream_base::client, 
			       boost::bind(&Client::HandleHandshake, this, 
					   boost::asio::placeholders::error));
     }
   }

   void HandleHandshake(const boost::system::error_code& error)
   {
     if (error)
     {
       std::cerr << "Client: Handshake failed: " << error.message() << "\n";
     }
     else
     {
       std::cout << "Client: Handshake succeeded\n";
     }
   }

 private:
   boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_;
 }; 



 void StartServer()
 {
   try
   {
     boost::asio::io_service io_service;
     Server server(io_service, 5005);

     io_service.run();
    }
   catch(const std::exception& e)
   {
     std::cerr << "Exception: " << std::string(e.what()) + "\n";
   }
 }


 void StartClient()
 {
   try
   {
     boost::asio::io_service io_service;
     
     boost::asio::ip::tcp::resolver resolver(io_service);
     boost::asio::ip::tcp::resolver::query query("127.0.0.1", "5005");
     boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
     
     boost::asio::ssl::context ctx(boost::asio::ssl::context::tlsv1);
     ctx.load_verify_file("ca.pem");
     ctx.set_options(boost::asio::ssl::context::no_sslv2);
     ctx.set_options(boost::asio::ssl::context::no_sslv3);
     
     Client client(io_service, ctx, iterator);
     
     io_service.run();
   }
   catch (std::exception& e)
   {
     std::cerr << "Exception: " << e.what() << "\n";
   }
 }


 int main(int argc, char *argv[])
 {
   pid_t pid = fork();
   if (pid > 0)
   {
     //parent
     StartServer();
   }
   else if (pid == 0)
   {
     //child
     sleep(2);
     StartClient();
   }
   else
   {
     std::cerr << "Fork failed\n";
   }
   return 0;
 }