应用场景是这样的：

客户端和服务器在不同的网段内，它们之间不能直接通过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 }