physicalsocket.cs

破解的飞信源代码

namespace NCindy.Protocol.RUDP.Stack
{
    using NCindy.Protocol.RUDP;
    using NCindy.Threading;
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;

    internal sealed class PhysicalSocket
    {
        internal RUDPSocket _acceptingRDUP;
        internal ReaderWriterLockSlim _acceptingRDUPLock = new ReaderWriterLockSlim();
        internal IPEndPoint _canReceiveFromEndPoint = new IPEndPoint(IPAddress.Any, 0);
        internal Dictionary<byte[], RUDPSocket> _connectedIds = new Dictionary<byte[], RUDPSocket>(1);
        internal ReaderWriterLockSlim _connectedIdsLock = new ReaderWriterLockSlim();
        internal Dictionary<IPEndPoint, RUDPSocket> _connectedRDUPs = new Dictionary<IPEndPoint, RUDPSocket>(1);
        internal ReaderWriterLockSlim _connectedRDUPsLock = new ReaderWriterLockSlim();
        internal byte[] _receiveBuffer = new byte[0x19000];
        internal Socket _socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

        internal PhysicalSocket()
        {
            this._socket.set_DontFragment(true);
            uint num = 0x80000000;
            uint num2 = 0x18000000;
            uint num3 = (num | num2) | 12;
            this._socket.IOControl((int) num3, new byte[] { Convert.ToByte(false) }, null);
            this._socket.set_SendBufferSize(0x19000);
            this._socket.set_ReceiveBufferSize(0x19000);
        }

        internal void BeginAccept(RUDPSocket rudp, AsyncCallback callback, object state)
        {
            rudp._status = RUDPSocketStatus.Accepting;
            this._acceptingRDUPLock.EnterWriteLock();
            this._acceptingRDUP = rudp;
            this._acceptingRDUPLock.ExitWriteLock();
            RUDPStack.BeginAccept(rudp);
        }

        internal RUDPSocketError BeginConnect(RUDPSocket rudp, int timeOut)
        {
            this.RegisterConnectedSocket(rudp);
            return RUDPStack.BeginConnect(rudp, timeOut);
        }

        internal void Bind(IPEndPoint endPoint)
        {
            this._socket.Bind(endPoint);
        }

        internal void Close(RUDPSocket rudp)
        {
            RUDPStack.Close(rudp);
        }

        internal void Dispose()
        {
            this._receiveBuffer = null;
            this._connectedRDUPs.Clear();
            this._acceptingRDUP = null;
            this._socket = null;
        }

        internal void OnDisconnected(RUDPSocket rudp, RUDPSocketError error)
        {
            this.UnregisterConnectedSocket(rudp);
            rudp.OnDisconnected(error);
        }

        internal RUDPSocket OnEndAccept(IPEndPoint remoteEndPoint, int packetId)
        {
            RUDPSocket rudp = new RUDPSocket();
            rudp._physical = this;
            rudp._status = RUDPSocketStatus.Connected;
            rudp._remoteEndPoint = remoteEndPoint;
            rudp._incomingPackets.CurrentPacketId = packetId;
            rudp._connectionId = RUDPSocket.GenerateUniqueId();
            RUDPStack.RegisterRUDPSocket(rudp);
            this.RegisterConnectedSocket(rudp);
            RUDPSocket socket2 = this._acceptingRDUP;
            this._acceptingRDUPLock.EnterWriteLock();
            this._acceptingRDUP = null;
            this._acceptingRDUPLock.ExitWriteLock();
            socket2.OnEndAccept(rudp);
            return rudp;
        }

        internal void OnEndSend(RUDPSocket rudp, RUDPSendIAsyncResult asyncResult)
        {
            rudp.OnEndSend(RUDPSocketError.Success, asyncResult);
        }

        internal void RegisterConnectedSocket(RUDPSocket rudp)
        {
            this._connectedRDUPsLock.EnterWriteLock();
            this._connectedRDUPs.Add(rudp._remoteEndPoint, rudp);
            this._connectedRDUPsLock.ExitWriteLock();
        }

        internal void Shutdown(RUDPSocket rudp)
        {
            RUDPStack.Shutdown(rudp);
        }

        internal void UnregisterConnectedSocket(RUDPSocket rudp)
        {
            this._connectedRDUPsLock.EnterWriteLock();
            this._connectedRDUPs.Remove(rudp._remoteEndPoint);
            this._connectedRDUPsLock.ExitWriteLock();
        }
    }
}