應用場景是這樣的：

客戶端和服務器在不同的網段內，它們之間不能直接通過TCP連接，但是有一臺機器（暫時稱為轉發器）有雙網卡，兩塊網卡分別在客戶端和服務器端的網段內，這樣轉發器就能分別和客戶端即服務器建立連接，并來回傳輸數據。

設計思路是這樣的：

當客戶端連接到轉發器后，轉發器馬上建立一條到服務器之間的連接，與服務器端的連接建立后，就同時異步地從客戶端和服務器端接收數據到兩個緩沖區 中，一旦任何一方有數據接收，就通過另外一條連接將數據發送到另一方，發送完畢后又開始新一輪的數據接收。如果在接收數據的過程中有任何一方出現錯誤，就 將取消另外一條連接的異步調用，這樣整個連接就會關閉。

其中用到了Boost庫的以下特性：

1.Asio的異步IO調用

2.多線程

3.share_ptr的自動指針管理

遺留的一些問題：

  1 /*
  2  * =====================================================================================
  3  *
  4  * Filename: xproxy_connection.cpp
  5  *
  6  * Description:
  7  *
  8  * Version: 1.0
  9  * Created: 2009年11月26 日 15時12分33秒
 10  * Revision: none
 11  * Compiler: gcc
 12  *
 13  * Author: David Fang (A free programmer), qi_fd@163.com
 14  * Company: nocompany
 15  *
 16  * =====================================================================================
 17  */
 18 
 19 #include "xproxy_connection.hpp"
 20 #include <vector>
 21 #include <iostream>
 22 #include <boost/bind.hpp>
 23 
 24 xproxy_connection::xproxy_connection(boost::asio::io_service& io_service,
 25     tcp::endpoint& ana_endpoint)
 26     :strand_(io_service),
 27     ana_endpoint_(ana_endpoint),
 28     login_clt_sock_(io_service),
 29     ana_srv_sock_(io_service)
 30 {
 31     std::cout<<"new connection construct\n";
 32 }
 33 
 34 xproxy_connection::~xproxy_connection()
 35 {
 36     std::cout<<"connection destruct\n";
 37 }
 38 
 39 tcp::socket& xproxy_connection::login_clt_sock()
 40 {
 41     return login_clt_sock_;
 42 }
 43         
 44 void xproxy_connection::start()
 45 {
 46     std::cout<<"connection start to connect to analysing server\n";
 47     ana_srv_sock_.async_connect(ana_endpoint_,
 48         strand_.wrap(boost::bind(&xproxy_connection::handle_connect_to_ana_server,
 49             shared_from_this(), boost::asio::placeholders::error)));
 50 }
 51 
 52 void xproxy_connection::handle_connect_to_ana_server(const boost::system::error_code& e)
 53 {
 54     if(!e)
 55     {
 56         std::cout<<"connect to analysing server succeed,"
 57             <<"now start to receive data from both sides\n";
 58 
 59         login_clt_sock_.async_read_some(boost::asio::buffer(clt_buffer_),
 60                 strand_.wrap(
 61                     boost::bind(&xproxy_connection::handle_login_clt_sock_read,
 62                         shared_from_this(), boost::asio::placeholders::error,
 63                         boost::asio::placeholders::bytes_transferred)));
 64 
 65         ana_srv_sock_.async_read_some(boost::asio::buffer(srv_buffer_),
 66                 strand_.wrap(
 67                     boost::bind(&xproxy_connection::handle_ana_srv_sock_read,
 68                         shared_from_this(), boost::asio::placeholders::error,
 69                         boost::asio::placeholders::bytes_transferred)));
 70 
 71     }
 72 }
 73 
 74 void xproxy_connection::handle_login_clt_sock_read
 75     (const boost::system::error_code& e, std::size_t bytes_transferred)
 76 {
 77     if(!e)
 78     {
 79         std::cout<<"data read from login client:\n";
 80         std::cout.write(clt_buffer_.data(), bytes_transferred);
 81         std::cout<<"\nnow send it to analysing server\n";
 82         boost::asio::async_write(ana_srv_sock_,
 83                 boost::asio::buffer(clt_buffer_.data(), bytes_transferred),
 84                 strand_.wrap(boost::bind(
 85                         &xproxy_connection::handle_ana_srv_sock_write,
 86                         shared_from_this(), boost::asio::placeholders::error)));
 87     }
 88     else
 89     {
 90         std::cout<<"read data from login client error, "
 91             <<"now need to shutdown this connection\n";
 92         ana_srv_sock_.cancel();
 93     }
 94 }
 95 
 96 void xproxy_connection::handle_ana_srv_sock_write(const boost::system::error_code& e)
 97 {
 98     if(!e)
 99     {
100         std::cout<<"data send to analysing server complete, "
101             <<"now start to receive data from login client again\n";
102         login_clt_sock_.async_read_some(boost::asio::buffer(clt_buffer_),
103                 strand_.wrap(
104                     boost::bind(&xproxy_connection::handle_login_clt_sock_read,
105                         shared_from_this(), boost::asio::placeholders::error,
106                         boost::asio::placeholders::bytes_transferred)));
107     }
108 }
109 
110 void xproxy_connection::handle_ana_srv_sock_read(
111         const boost::system::error_code& e,
112         std::size_t bytes_transferred)
113 {
114     if(!e)
115     {
116         std::cout<<"data read from analysing server:\n";
117         std::cout.write(srv_buffer_.data(), bytes_transferred);
118         std::cout<<"\nnow send it to login client\n";
119         boost::asio::async_write(login_clt_sock_,
120                 boost::asio::buffer(srv_buffer_.data(), bytes_transferred),
121                 strand_.wrap(
122                     boost::bind(&xproxy_connection::handle_login_clt_sock_write,
123                         shared_from_this(), boost::asio::placeholders::error)));
124     }
125     else
126     {
127         std::cout<<"read data from analysing server error, "
128             <<"now need to shutdown this connection\n";
129         login_clt_sock_.cancel();
130     }
131 }
132 
133 void xproxy_connection::handle_login_clt_sock_write(const boost::system::error_code& e)
134 {
135     if(!e)
136     {
137         std::cout<<"data send to login client complete, "
138             <<"now start to receive data from analysing server again\n";
139         ana_srv_sock_.async_read_some(boost::asio::buffer(srv_buffer_),
140                 strand_.wrap(
141                     boost::bind(&xproxy_connection::handle_ana_srv_sock_read,
142                         shared_from_this(), boost::asio::placeholders::error,
143                         boost::asio::placeholders::bytes_transferred)));
144     }
145 }