TcpRouter端口转发工具

using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;

namespace TcpRouter
{
    class Program
    {
        private int listenPort;
        private string ip;
        private int port;
        private ConcurrentDictionary<IPEndPoint, ProxyItem> proxies = new ConcurrentDictionary<IPEndPoint, ProxyItem>();
        private TcpListener listener;
        private log4net.ILog log;

        public Program(int listenPort, string ip, int port)
        {
            // TODO: Complete member initialization
            this.listenPort = listenPort;
            this.ip = ip;
            this.port = port;
        }
        static void Main(string[] args)
        {
            log4net.Config.XmlConfigurator.ConfigureAndWatch(new System.IO.FileInfo(System.AppDomain.CurrentDomain.SetupInformation.ConfigurationFile));


            Console.Write("请输入监听端口:");
            int listenPort = int.Parse(Console.ReadLine());


            Console.Write("请输入转发目标(IP:PORT):");
            string strDest = Console.ReadLine();

            string ip;
            int port;

            {
                string[] items = strDest.Split(':');

                ip = items[0];
                port = int.Parse(items[1]);
            }

            Console.Title = string.Format("TCP:{0}=>{1}", listenPort, strDest);

            Program p = new Program(listenPort, ip, port);
            p.Run();
        }

        private void Run()
        {
            this.log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
            System.AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            IPEndPoint localEP = new IPEndPoint(IPAddress.Any, this.listenPort);
            this.listener = new TcpListener(localEP);
            listener.Start(100);
            listener.BeginAcceptSocket(OnAccepted, listener);

            Console.ReadLine();
        }

        void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            log.Fatal("UnhandledException", (Exception)e.ExceptionObject);
        }
        public void OnAccepted(IAsyncResult ar)
        {
            TcpListener listener = ar.AsyncState as TcpListener;
            Socket remoteSocket = listener.EndAcceptSocket(ar);
            listener.BeginAcceptSocket(OnAccepted, listener);
            Socket proxy = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                proxy.BeginConnect(this.ip, this.port, arConn =>
                {
                    try
                    {
                        proxy.EndConnect(arConn);

                        this.SetupProxy(new ProxyItem() { Proxy = proxy, RemoteSocket = remoteSocket });

                    }
                    catch (Exception exp)
                    {
                        log.Debug(exp.Message);

                        //断开连接
                        //remoteSocket.BeginDisconnect(false, ardc => {
                        //    remoteSocket.EndDisconnect(ardc);
                        //}, remoteSocket);

                        //改为增加日志
                        byte[] buffer = new byte[1024];
                        remoteSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, arRecv =>
                        {
                            try
                            {
                                int received = remoteSocket.EndReceive(arRecv);

                                this.Print(remoteSocket.RemoteEndPoint.ToString(), "non", buffer, 0, received);
                            }
                            catch (SocketException ex)
                            {
                                log.Debug(ex);
                            }
                            catch (ObjectDisposedException ex)
                            {
                                log.Debug(ex);
                            }


                        }, null);
                    }



                }, proxy);
            }
            catch (Exception exp)
            {
                log.Debug(exp);
            }

        }

        private void SetupTransfer(Socket src, Socket des)
        {
            string srcAddress = src.RemoteEndPoint.ToString();
            string desAddress = des.RemoteEndPoint.ToString();

            byte[] buffer = new byte[1024];
            Action<IAsyncResult> action = null;
            
            action = new Action<IAsyncResult>(ar =>
            {
                int received = -1;
                try
                {
                    received = src.EndReceive(ar);
                }
                catch (Exception exp)
                {

                    log.ErrorFormat("src.EndReceive ERROR, srcAddress:{0},{1}", srcAddress, exp.Message);
                    try
                    {
                        des.Disconnect(false);
                        log.Debug("断开连接" + desAddress);

                    }
                    catch{}
                }
              

                if(received > 0)
                {

                    this.Print(srcAddress, desAddress, buffer, 0, received);
                    try
                    {
                        des.BeginSend(buffer, 0, received, SocketFlags.None, arSend =>
                        {
                            try
                            {
                                des.EndSend(arSend);
                            }
                            catch (Exception exp)
                            {
                                log.ErrorFormat("des.EndSend ERROR, desAddress:{0},{1}", desAddress, exp.Message);
                                log.Error(exp);
                                try
                                {
                                    src.Disconnect(false);
                                    log.Debug("断开连接" + srcAddress);
                                }
                                catch { }
                                return;
                            }

                            try
                            {
                                src.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(action), null);
                            }
                            catch (Exception exp)
                            {
                                log.ErrorFormat("src.BeginReceive ERROR, srcAddress:{0},{1}", srcAddress, exp.Message);
                                log.Error(exp);
                                try
                                {
                                    des.Disconnect(false);
                                    log.Debug("断开连接" + desAddress);
                                }
                                catch { }
                                try
                                {
                                    src.Disconnect(false);
                                    log.Debug("断开连接" + srcAddress);
                                }
                                catch { }
                            }


                        }, des);
                    }
                    catch (Exception exp)
                    {
                        log.ErrorFormat("des.BeginSend ERROR, srcAddress:{0},{1}", srcAddress, exp.Message);
                        log.Error(exp);
                        try
                        {
                            des.Disconnect(false);
                            log.Debug("断开连接" + desAddress);
                        }
                        catch { }
                        try
                        {
                            src.Disconnect(false);
                            log.Debug("断开连接" + srcAddress);
                        }
                        catch { }
                    }
                }
                else
                {
                    log.ErrorFormat("主动断开连接, srcAddress:{0},{1}", srcAddress, "没有收到数据");
                    //应该是断开了
                    try
                    {
                        des.Disconnect(false);
                        log.Debug("断开连接" + desAddress);
                    }
                    catch { }
                    try
                    {
                        src.Disconnect(false);
                        log.Debug("断开连接" + srcAddress);
                    }
                    catch { }
                }
                
            });

            try
            {
                src.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(action), null);
            }
            catch (Exception exp)
            {
                log.Debug(exp);
                try
                {
                    des.Disconnect(false);
                    log.Debug("断开连接" + desAddress);
                }
                catch { }
                try
                {
                    src.Disconnect(false);
                    log.Debug("断开连接" + srcAddress);
                }
                catch { }
            }

        }


        private void SetupProxy(ProxyItem proxy)
        {
            var p = proxy;
            SetupTransfer(proxy.RemoteSocket, proxy.Proxy);
            SetupTransfer(proxy.Proxy, proxy.RemoteSocket);
        }


        private void Print(string src, string des, byte[] bytes, int offset , int count)
        {
            string str = string.Format("{0}=>{1}:{2}", src, des, BitConverter.ToString(bytes, offset, count));
            //Console.WriteLine(str);
            log.Debug(str);
        }
    }


    public class ProxyItem
    {

        public Socket RemoteSocket { get; set; }

        public Socket Proxy { get; set; }

    }
}