udtlogicsocket.cs

破解的飞信源代码

namespace Imps.Client.Core.P2P.BlockingTransportor
{
    using NCindy.Protocol.UDT;
    using System;
    using System.Net;
    using System.Net.Sockets;

    public class UdtLogicSocket : ILogicSocket
    {
        private readonly UDTSocket innerSocket;

        public UdtLogicSocket() : this(new UDTSocket(AddressFamily.InterNetwork))
        {
        }

        public UdtLogicSocket(UDTSocket socket)
        {
            this.innerSocket = socket;
        }

        public ILogicSocket Accept()
        {
            return new UdtLogicSocket(this.innerSocket.Accept());
        }

        public IAsyncResult BeginAccept(AsyncCallback callback, object state)
        {
            return this.innerSocket.BeginAccept(callback, state);
        }

        public IAsyncResult BeginConnect(IPEndPoint remoteEP, AsyncCallback callback, object state)
        {
            return this.innerSocket.BeginConnect(remoteEP, callback, state);
        }

        public IAsyncResult BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state)
        {
            return this.innerSocket.BeginReceive(buffer, offset, size, socketFlags, callback, state);
        }

        public IAsyncResult BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state)
        {
            return this.innerSocket.BeginSend(buffer, offset, size, socketFlags, callback, state);
        }

        public void Bind(EndPoint localEP)
        {
            this.innerSocket.Bind(localEP);
        }

        public void Close()
        {
            this.innerSocket.Close();
        }

        public void Connect(EndPoint remoteEP)
        {
            this.innerSocket.Connect(remoteEP);
        }

        public void Connect(IPAddress address, int port)
        {
            this.innerSocket.Connect(new IPEndPoint(address, port));
        }

        public ILogicSocket EndAccept(IAsyncResult asyncResult)
        {
            return new UdtLogicSocket(this.innerSocket.EndAccept(asyncResult));
        }

        public void EndConnect(IAsyncResult asyncResult)
        {
            this.innerSocket.EndConnect(asyncResult);
        }

        public int EndReceive(IAsyncResult asyncResult)
        {
            return this.innerSocket.EndReceive(asyncResult);
        }

        public int EndSend(IAsyncResult asyncResult)
        {
            return this.innerSocket.EndSend(asyncResult);
        }

        public void Listen(int backlog)
        {
            this.innerSocket.Listen(backlog);
        }

        public bool Poll(int microSeconds, SelectMode mode)
        {
            return this.innerSocket.Poll(microSeconds, mode);
        }

        public int Receive(byte[] buffer, SocketFlags socketFlags)
        {
            return this.Receive(buffer, buffer.Length, socketFlags);
        }

        public int Receive(byte[] buffer, int size, SocketFlags socketFlags)
        {
            return this.innerSocket.Receive(buffer, size, socketFlags);
        }

        public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags)
        {
            return this.innerSocket.Receive(buffer, offset, size, socketFlags);
        }

        public int Send(byte[] buffer)
        {
            return this.innerSocket.Send(buffer);
        }

        public int Send(byte[] buffer, SocketFlags socketFlags)
        {
            return this.innerSocket.Send(buffer, socketFlags);
        }

        public int Send(byte[] buffer, int size, SocketFlags socketFlags)
        {
            return this.innerSocket.Send(buffer, size, socketFlags);
        }

        public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags)
        {
            return this.innerSocket.Send(buffer, offset, size, socketFlags);
        }

        public bool Connected
        {
            get
            {
                return this.innerSocket.Connected;
            }
        }

        public IPEndPoint LocalEndPoint
        {
            get
            {
                return (IPEndPoint) this.innerSocket.LocalEndPoint;
            }
        }
    }
}