rudpstack.cs

破解的飞信源代码

            }
            if (fragments.AsyncResult != null)
            {
                fragments.rudp._physical.OnEndSend(fragments.rudp, fragments.AsyncResult);
            }
            return true;
        }

        internal static RUDPSocketError SendPayload(RUDPSocket rudp, byte[] payload, int offset, int payloadLength, bool reliable, RUDPSendIAsyncResult asyncResult)
        {
            if (!_isStackRunning)
            {
                return RUDPSocketError.SystemNotReady;
            }
            if (rudp._status != RUDPSocketStatus.Connected)
            {
                return RUDPSocketError.NotConnected;
            }
            asyncResult.ForceAsyncCall = true;
            FragmentInformation information = NewFragmentInformation(rudp, reliable, payload, offset, payloadLength, asyncResult);
            rudp._fragmentsLock.EnterWriteLock();
            rudp._fragments.AddFirst(information);
            rudp._fragmentsLock.ExitWriteLock();
            ForceFragmentsSending(rudp._controlThreadId);
            return information.Error;
        }

        private static void SetPacketACKed(RUDPSocket rudp, RUDPOutgoingPacket packet, double currentRTT)
        {
            lock (packet)
            {
                if (packet.IsACKed)
                {
                    return;
                }
                rudp._controlWindow.OnACK(packet, currentRTT);
                packet.IsACKed = true;
            }
            if (((packet.Channel != RUDPPacketChannel.Ping) && (packet.Channel != RUDPPacketChannel.PingRendezVous)) || (rudp._status != RUDPSocketStatus.Connecting))
            {
                if ((packet.Channel == RUDPPacketChannel.TearDown) && (rudp._status == RUDPSocketStatus.Closing))
                {
                    rudp._status = RUDPSocketStatus.ClosingACKed;
                    if (rudp._remoteEndPoint != null)
                    {
                        UnregisterRUDPSocket(rudp);
                        rudp._physical.UnregisterConnectedSocket(rudp);
                    }
                }
            }
            else
            {
                rudp._status = RUDPSocketStatus.Connected;
                if (rudp._usePMTUDiscovery)
                {
                    rudp._pmtuDiscovery.StartTuning();
                }
                rudp.OnEndConnect(RUDPSocketError.Success);
            }
        }

        internal static void Shutdown(RUDPSocket rudp)
        {
            if (rudp._status == RUDPSocketStatus.Accepting)
            {
                rudp.Reset(RUDPSocketStatus.Closed);
            }
            else if (((rudp._status != RUDPSocketStatus.Closed) && !rudp._isShutingDown) && ((rudp._status != RUDPSocketStatus.Closing) && (rudp._status != RUDPSocketStatus.ClosingACKed)))
            {
                if (rudp._status == RUDPSocketStatus.Connecting)
                {
                    rudp.Reset(RUDPSocketStatus.Closed);
                }
                else
                {
                    rudp._isShutingDown = true;
                    rudp._status = RUDPSocketStatus.Closing;
                    while (!rudp._controlWindow.CanSend(0))
                    {
                        if (rudp._status != RUDPSocketStatus.Closing)
                        {
                            return;
                        }
                        Thread.Sleep(100);
                    }
                    PushPacketToSend(rudp, true, RUDPPacketChannel.TearDown, null, 0, 0);
                    long microSeconds = HiResTimer.MicroSeconds;
                    while (((rudp._status == RUDPSocketStatus.Closing) && (rudp._outgoingPackets.get_Count() > 0)) && ((HiResTimer.MicroSeconds - microSeconds) < rudp._sto))
                    {
                        Thread.Sleep(100);
                    }
                    rudp.Reset(RUDPSocketStatus.Closed);
                    rudp._physical.OnDisconnected(rudp, RUDPSocketError.Shutdown);
                }
            }
        }

        private static RUDPSocketError SocketErrorToRUDPSocketError(SocketError socketError)
        {
            int num = socketError;
            return (RUDPSocketError) Enum.ToObject(typeof(RUDPSocketError), num);
        }

        private static bool SocketSendACK(RUDPSocket rudp, PhysicalSocket physical, IPEndPoint remoteEndPoint, byte[] rudpPayload)
        {
            try
            {
                physical._socket.SendTo(rudpPayload, remoteEndPoint);
            }
            catch (SocketException exception)
            {
                if (rudp != null)
                {
                    OnSocketUnhandledError(rudp, SocketErrorToRUDPSocketError(exception.get_SocketErrorCode()), null);
                }
                return false;
            }
            if (rudp != null)
            {
                rudp._lastACKSendTS = HiResTimer.MicroSeconds;
            }
            return true;
        }

        private static bool SocketSendPacket(RUDPSocket rudp, RUDPOutgoingPacket packet, byte[] rudpPayload, long now)
        {
            try
            {
                rudp._physical._socket.SendTo(rudpPayload, rudp._remoteEndPoint);
            }
            catch (SocketException exception)
            {
                if ((exception.ErrorCode == 0x2738) && (packet.Channel == RUDPPacketChannel.MTUTuning))
                {
                    rudp._pmtuDiscovery.OnICMPError(packet);
                    return true;
                }
                OnSocketUnhandledError(rudp, SocketErrorToRUDPSocketError(exception.get_SocketErrorCode()), null);
                return false;
            }
            rudp._lastSendTS = now;
            packet.TSLastSend = now;
            return true;
        }

        private static void StackFatalException(Exception exception)
        {
            HandleException(exception, new object[0]);
        }

        public static void StallThread()
        {
            if (IsSingleCpuMachine)
            {
                SwitchToThread();
            }
            else
            {
                Thread.SpinWait(1);
            }
        }

        internal static void StopStack()
        {
            for (int i = 0; i < _controlThreadInformations.Length; i++)
            {
                _controlThreadInformations[i]._rudpSocketsLock.EnterWriteLock();
                for (int j = _controlThreadInformations[i]._rudpSockets.get_Count() - 1; j > -1; j--)
                {
                    Close(_controlThreadInformations[i]._rudpSockets.get_Item(j));
                }
                _controlThreadInformations[i]._rudpSocketsLock.ExitWriteLock();
            }
            _isStackRunning = false;
        }

        [return: MarshalAs(UnmanagedType.Bool)]
        [SuppressUnmanagedCodeSecurity, DllImport("Kernel32", ExactSpelling=true)]
        private static extern bool SwitchToThread();
        [Conditional("CONSOLE_TRACE")]
        internal static void Trace(string text)
        {
            Console.WriteLine(text);
        }

        private static bool TransmissionTimer(RUDPSocket rudp, ControlThreadInformation controlInformation)
        {
            if (rudp._fragments.get_Count() < 1)
            {
                return true;
            }
            rudp._fragmentsLock.EnterReadLock();
            FragmentInformation fragments = rudp._fragments.get_Last().get_Value();
            rudp._fragmentsLock.ExitReadLock();
            if (SendFragments(fragments, controlInformation))
            {
                rudp._fragmentsLock.EnterWriteLock();
                rudp._fragments.RemoveLast();
                rudp._fragmentsLock.ExitWriteLock();
                ReleaseFragmentInformation(fragments);
                return true;
            }
            ForceFragmentsSending(controlInformation.ControlThreadId);
            return false;
        }

        internal static void UnregisterRUDPSocket(RUDPSocket rudp)
        {
            if (rudp._controlThreadId > -1)
            {
                int index = rudp._controlThreadId;
                _controlThreadInformations[index]._rudpSocketsLock.EnterWriteLock();
                _controlThreadInformations[index]._rudpSockets.Remove(rudp);
                rudp._controlThreadId = -1;
                _controlThreadInformations[index]._rudpSocketsLock.ExitWriteLock();
            }
        }

        private static void UpdateAffinity()
        {
            Process currentProcess = Process.GetCurrentProcess();
            int num = ((int) Math.Pow(2, (double) ProcessorsCount)) - 1;
            currentProcess.ProcessorAffinity = new IntPtr(num);
        }

        private static void UpdatePacketPayload(byte[] packetPayload, SACKSlot slot1, SACKSlot slot2, SACKSlot slot3, SACKSlot slot4)
        {
            byte num = 0;
            if (slot1 != null)
            {
                num = (byte) (num + 1);
            }
            if (slot2 != null)
            {
                num = (byte) (num + 1);
            }
            if (slot3 != null)
            {
                num = (byte) (num + 1);
            }
            if (slot4 != null)
            {
                num = (byte) (num + 1);
            }
            packetPayload[1] = num;
            int offset = 15;
            if (slot1 != null)
            {
                BinaryHelper.WriteInt(slot1.StartPacketId, packetPayload, offset);
                offset += 4;
                BinaryHelper.WriteInt(slot1.EndPacketId, packetPayload, offset);
                offset += 4;
            }
            else
            {
                offset += 8;
            }
            if (slot2 != null)
            {
                BinaryHelper.WriteInt(slot2.StartPacketId, packetPayload, offset);
                offset += 4;
                BinaryHelper.WriteInt(slot2.EndPacketId, packetPayload, offset);
                offset += 4;
            }
            else
            {
                offset += 8;
            }
            if (slot3 != null)
            {
                BinaryHelper.WriteInt(slot3.StartPacketId, packetPayload, offset);
                offset += 4;
                BinaryHelper.WriteInt(slot3.EndPacketId, packetPayload, offset);
                offset += 4;
            }
            else
            {
                offset += 8;
            }
            if (slot4 != null)
            {
                BinaryHelper.WriteInt(slot4.StartPacketId, packetPayload, offset);
                offset += 4;
                BinaryHelper.WriteInt(slot4.EndPacketId, packetPayload, offset);
                offset += 4;
            }
        }

        private static void UpdateThreadAffinity(ControlThreadInformation controlInformation)
        {
            int currentThreadId = AppDomain.GetCurrentThreadId();
            foreach (ProcessThread thread in Process.GetCurrentProcess().Threads)
            {
                if (thread.Id == currentThreadId)
                {
                    controlInformation.ProcessThread = thread;
                    thread.ProcessorAffinity = new IntPtr(controlInformation.ThreadAffinity);
                }
            }
        }
    }
}