threadsipconnectionbase.cs

破解的飞信源代码

namespace Imps.Client.CommLayer.Common
{
    using Imps.Client.Base;
    using Imps.Client.Base.Comm;
    using Imps.Client.CommLayer;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using System;
    using System.Collections.Generic;
    using System.Runtime.CompilerServices;
    using System.Threading;

    internal abstract class ThreadSipConnectionBase : SipConnectionBase
    {
        protected static readonly byte[] physicalHeartbeat = Encoding.UTF8.GetBytes("\r\n");
        private Thread ReceivingMessageThread;
        private Queue<SipMessageBase>[] SendingMessageList;
        private AutoResetEvent SendingMessageListEvent;
        protected const int SendingMessageListEventTimeOut = 0x7530;
        private Thread SendingMessageThread;
        private ManualResetEvent SendingMessageThreadDownEvent;

        public event EventHandler<SendFailedEventArgs> SendFailed;

        public ThreadSipConnectionBase(object context) : base(context)
        {
            this.SendingMessageList = new Queue<SipMessageBase>[] { new Queue<SipMessageBase>(), new Queue<SipMessageBase>() };
            this.SendingMessageListEvent = new AutoResetEvent(false);
            this.SendingMessageThreadDownEvent = new ManualResetEvent(true);
        }

        protected override void AfterStateFieldUpdated(ConnectionState oldState, ConnectionState newState)
        {
            if (newState == ConnectionState.Connected)
            {
                this.Start();
            }
            else if (newState == ConnectionState.Disconnecting)
            {
                this.Stop();
            }
        }

        private void AppendMessageItem(SipMessageBase msg)
        {
            lock (this.SendingMessageList)
            {
                if ((msg is SipResponse) || (msg is SipAckRequest))
                {
                    this.SendingMessageList[0].Enqueue(msg);
                }
                else
                {
                    this.SendingMessageList[1].Enqueue(msg);
                }
            }
        }

        private void ClearMessageItems()
        {
            lock (this.SendingMessageList)
            {
                foreach (Queue<SipMessageBase> queue in this.SendingMessageList)
                {
                    queue.Clear();
                }
            }
        }

        public override void Close()
        {
            base.Close();
            this.RaiseAllMessageSendFaild();
            this.ClearMessageItems();
        }

        public override void Dispose()
        {
            base.Dispose();
            this.Stop();
        }

        protected sealed override void OnMessageParsingFailed()
        {
            base.OnMessageParsingFailed();
        }

        protected virtual void OnSendingMessageListEventTimeout()
        {
        }

        private void RaiseAllMessageSendFaild()
        {
            SipMessageBase msg;
            while ((msg = this.ReadMessageItem()) != null)
            {
                string explanation = StringTable.ClientCommLayerString.DefaultSendFaildText;
                SipMessageHelper.RaiseSendMessageFailed(msg, new ApplicationException(explanation), explanation, new RaiseEventDelegate<SendFailedEventArgs>(this.RaiseSendFailed));
            }
        }

        protected SipMessageBase ReadMessageItem()
        {
            lock (this.SendingMessageList)
            {
                foreach (Queue<SipMessageBase> queue in this.SendingMessageList)
                {
                    if (queue.get_Count() > 0)
                    {
                        return queue.Dequeue();
                    }
                }
                return null;
            }
        }

        protected abstract int ReceiveMessage(byte[] buffer);
        private void ReceivingMessageProcess()
        {
            WaitCallback callBack = null;
            byte[] buffer = new byte[0x1000];
            while (base.State == ConnectionState.Connected)
            {
                try
                {
                    int count = this.ReceiveMessage(buffer);
                    if (count == 0)
                    {
                        ClientLogger.WriteConnection("接收数据", 10, "收到 0 字节数据！", 0);
                        break;
                    }
                    base.ParseMessage(buffer, 0, count);
                    continue;
                }
                catch (ThreadAbortException)
                {
                    continue;
                }
                catch (Exception exception)
                {
                    base.LogError(exception);
                    break;
                }
            }
            if (base.State == ConnectionState.Connected)
            {
                if (callBack == null)
                {
                    callBack = delegate {
                        this.Close();
                    };
                }
                ThreadPool.QueueUserWorkItem(callBack);
            }
        }

        public sealed override void Send(SipMessageBase msg)
        {
            this.AppendMessageItem(msg);
            this.SendingMessageListEvent.Set();
        }

        private void SendingMessageProcess()
        {
            try
            {
                bool flag;
                SipMessageBase msg;
                SendWindow window = new SendWindow(0xea60, 100);
            Label_000D:
                flag = this.SendingMessageListEvent.WaitOne(0x7530, true);
                if ((base.State != ConnectionState.Connected) && (base.State != ConnectionState.Connecting))
                {
                    return;
                }
                if (flag)
                {
                    goto Label_004B;
                }
                this.OnSendingMessageListEventTimeout();
                goto Label_000D;
            Label_003E:
                window.SendRateControl();
                this.SendMessage(msg);
            Label_004B:
                if ((msg = this.ReadMessageItem()) != null)
                {
                    goto Label_003E;
                }
                goto Label_000D;
            }
            catch (ThreadAbortException)
            {
            }
            catch (Exception exception)
            {
                base.LogError(exception);
            }
            finally
            {
                this.SendingMessageThreadDownEvent.Set();
            }
        }

        private void SendMessage(SipMessageBase[] msgs)
        {
            base.SendMessage(msgs);
        }

        private void SendMessage(SipMessageBase msg)
        {
            base.SendMessage(msg);
        }

        private void Start()
        {
            this.SendingMessageThread = new Thread(new ThreadStart(this.SendingMessageProcess));
            this.SendingMessageThread.Name = "Imps.Client.Pc.SendingMessageThread";
            this.SendingMessageThread.IsBackground = true;
            this.SendingMessageThreadDownEvent.Reset();
            this.SendingMessageThread.Start();
            this.ReceivingMessageThread = new Thread(new ThreadStart(this.ReceivingMessageProcess));
            this.ReceivingMessageThread.Name = "Imps.Client.Pc.ReceivingMessaggeThread";
            this.ReceivingMessageThread.IsBackground = true;
            this.ReceivingMessageThread.Start();
        }

        private void Stop()
        {
            this.SendingMessageListEvent.Set();
            this.SendingMessageThreadDownEvent.WaitOne();
            Thread receivingMessageThread = this.ReceivingMessageThread;
            if ((receivingMessageThread != null) && receivingMessageThread.IsAlive)
            {
                receivingMessageThread.Abort();
                this.ReceivingMessageThread = null;
            }
        }
    }
}