sipconnectionbase.cs

破解的飞信源代码

                    if (this.IsPairUpMessage(msg))
                    {
                        MessageValue value2 = this.FindPairUpMessage(msg);
                        SipMessageBase base2 = (SipMessageBase) value2;
                        if (base2 != null)
                        {
                            bool flag = this.IsTempResponse(msg);
                            if (base2 is SipAckRequest)
                            {
                                if (!flag)
                                {
                                    this.RemovePairUpMessage(base2);
                                }
                            }
                            else if (base2 is SipInviteResponse)
                            {
                                if (msg is SipcRequest)
                                {
                                    if (!flag)
                                    {
                                        this.RemovePairUpMessage(base2);
                                    }
                                    SipMessageHelper.RaiseAckReceived(base2 as SipInviteResponse, new SipAckRequest(msg as SipcRequest, base2 as SipInviteResponse));
                                }
                            }
                            else if (base2 is SipResponse)
                            {
                                if (!flag)
                                {
                                    this.RemovePairUpMessage(base2);
                                }
                            }
                            else if (base2 is SipRequest)
                            {
                                SipRequest parentRequest = (SipRequest) base2;
                                if (msg is SipcResponse)
                                {
                                    SipcResponse sipcResponse = (SipcResponse) msg;
                                    SipResponse respReceived = (parentRequest.Message.Method == "I") ? new SipInviteResponse(sipcResponse, parentRequest) : new SipResponse(sipcResponse, parentRequest);
                                    if (flag)
                                    {
                                        if (sipcResponse.StatusCode == 0xbc)
                                        {
                                            value2.AppendBodyPart(sipcResponse);
                                        }
                                        SipMessageHelper.RaiseResponseReceived(parentRequest, respReceived);
                                    }
                                    else
                                    {
                                        respReceived.Message.Body = value2.GetFullBody(sipcResponse);
                                        this.RemovePairUpMessage(parentRequest);
                                        SipMessageHelper.RaiseFinalResponseReceived(parentRequest, respReceived);
                                    }
                                }
                            }
                            if (flag)
                            {
                                value2.ResetTimerCounter();
                            }
                        }
                        else
                        {
                            ClientLogger.WriteConnection("接收消息匹配失败", 20, msg.ToString(), 1);
                        }
                    }
                    else if (msg is SipcRequest)
                    {
                        this.RaiseRequestReceived(new SipRequestReceivedEventArgs(new SipRequest(msg as SipcRequest)));
                    }
                }
            }
            catch (ThreadAbortException)
            {
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        public void ReConnect()
        {
        }

        private void RemovePairUpMessage(SipMessageBase msg)
        {
            if (msg != null)
            {
                lock (this.PairUpMessageList)
                {
                    MessageKey key = new MessageKey(msg);
                    if (this.PairUpMessageList.ContainsKey(key))
                    {
                        this.PairUpMessageList.Remove(key);
                    }
                }
            }
        }

        private void RetrySendMessage(MessageValue mv)
        {
            SipMessageBase msg = mv.Message;
            if (mv.RetryTimes > 0)
            {
                try
                {
                    int num = this._SendMessage(msg);
                    mv.RetryTimes -= num;
                }
                catch (Exception exception)
                {
                    SipMessageHelper.RaiseSendMessageFailed(msg, exception, StringTable.ClientCommLayerString.DefaultSendFaildText, new RaiseEventDelegate<SendFailedEventArgs>(this.RaiseSendFailed));
                    this.LogError(exception);
                }
            }
        }

        public abstract void Send(SipMessageBase msg);
        protected void SendMessage(SipMessageBase msg)
        {
            if (this.CheckMessage(msg))
            {
                object obj2;
                Monitor.Enter(obj2 = this._syncObjSendReceive);
                try
                {
                    this._SendMessage(msg);
                    this.AppendPairUpMessage(msg);
                    SipMessageHelper.RaiseSent(msg);
                }
                catch (SipConnectionException exception)
                {
                    SipMessageHelper.RaiseSendMessageFailed(msg, exception, exception.Message, new RaiseEventDelegate<SendFailedEventArgs>(this.RaiseSendFailed));
                    this.LogError(exception);
                }
                catch (Exception exception2)
                {
                    SipMessageHelper.RaiseSendMessageFailed(msg, exception2, StringTable.ClientCommLayerString.DefaultSendFaildText, new RaiseEventDelegate<SendFailedEventArgs>(this.RaiseSendFailed));
                    this.LogError(exception2);
                }
                finally
                {
                    Monitor.Exit(obj2);
                }
            }
        }

        protected void SendMessage(SipMessageBase[] msgs)
        {
            if (msgs.Length != 0)
            {
                if (msgs.Length == 1)
                {
                    this.SendMessage(msgs[0]);
                }
                else
                {
                    lock (this._syncObjSendReceive)
                    {
                        List<MessageTimesPair> list = new List<MessageTimesPair>();
                        foreach (SipMessageBase base2 in msgs)
                        {
                            if (this.CheckMessage(base2))
                            {
                                list.Add(new MessageTimesPair(base2, base2.RetryTimes + 1));
                            }
                        }
                        int num = 0;
                        while (true)
                        {
                            using (MemoryStream stream = new MemoryStream())
                            {
                                if (list.get_Count() == 0)
                                {
                                    break;
                                }
                                List<MessageTimesPair> list2 = new List<MessageTimesPair>();
                                List<MessageTimesPair>.Enumerator enumerator = list.GetEnumerator();
                                try
                                {
                                    while (enumerator.MoveNext())
                                    {
                                        MessageTimesPair pair = enumerator.get_Current();
                                        SipMessageBase message = pair.Message;
                                        if (--pair.TryTimes <= 0)
                                        {
                                            list2.Add(pair);
                                        }
                                        byte[] buffer = message.Message.ToBinary();
                                        stream.Write(buffer, 0, buffer.Length);
                                    }
                                }
                                finally
                                {
                                    enumerator.Dispose();
                                }
                                try
                                {
                                    this.SendMessage(stream.ToArray());
                                    List<MessageTimesPair>.Enumerator enumerator2 = list.GetEnumerator();
                                    try
                                    {
                                        while (enumerator2.MoveNext())
                                        {
                                            MessageTimesPair pair2 = enumerator2.get_Current();
                                            try
                                            {
                                                SipMessageBase msg = pair2.Message;
                                                ClientLogger.WriteSipc("Send", msg.Message);
                                                MessageValue value2 = this.FindPairUpMessageValue(msg);
                                                if (value2 != null)
                                                {
                                                    value2.RetryTimes -= num;
                                                    value2.ResetTimerCounter();
                                                }
                                                this.AppendPairUpMessage(msg);
                                                this.OnSendSuccessed(msg);
                                                SipMessageHelper.RaiseSent(msg);
                                                continue;
                                            }
                                            catch (Exception exception)
                                            {
                                                this.LogError(exception);
                                                continue;
                                            }
                                        }
                                    }
                                    finally
                                    {
                                        enumerator2.Dispose();
                                    }
                                    break;
                                }
                                catch (Exception exception2)
                                {
                                    List<MessageTimesPair>.Enumerator enumerator3 = list2.GetEnumerator();
                                    try
                                    {
                                        while (enumerator3.MoveNext())
                                        {
                                            MessageTimesPair pair3 = enumerator3.get_Current();
                                            SipMessageBase base5 = pair3.Message;
                                            list.Remove(pair3);
                                            SipMessageHelper.RaiseSendMessageFailed(base5, exception2, StringTable.ClientCommLayerString.DefaultSendFaildText, new RaiseEventDelegate<SendFailedEventArgs>(this.RaiseSendFailed));
                                        }
                                    }
                                    finally
                                    {
                                        enumerator3.Dispose();
                                    }
                                    this.LogError(exception2);
                                    if (list.get_Count() == 0)
                                    {
                                        break;
                                    }
                                    Thread.Sleep((int) (this.Option.SendFaildDelay * 0x3e8));
                                }
                            }
                            num++;
                        }
                    }
                }
            }
        }

        protected abstract void SendMessage(byte[] buffer);
        public override string ToString()
        {
            return Tools.GetConnectionStateString(this.State);
        }

        public object Context
        {
            get
            {
                return this._context;
            }
            private set
            {
                this._context = value;
            }
        }

        public virtual long CurrentAdapterSpeed
        {
            get
            {
                return (long) 0;
            }
        }

        public abstract IPEndPoint LocalEndPoint { get; }

        public virtual int NextInterval
        {
            get
            {
                return 0;
            }
            set
            {
            }
        }

        public SipConnectionOption Option
        {
            get
            {
                return this._option;
            }
            protected set
            {
                this._option = value;
            }
        }

        public abstract IPEndPoint RemoteEndPoint { get; }

        public ConnectionState State
        {
            get
            {
                return this._state;
            }
            protected set
            {
                StateChangedEventArgs argument = null;
                lock (this.stateSyncRoot)
                {
                    if (((ConnectionState) this._state) != value)
                    {
                        ConnectionState oldState = this._state;
                        this._state = value;
                        this.AfterStateFieldUpdated(oldState, value);
                        if (this._state == 11)
                        {
                            this.CheckMessageTimeOutTimer = new Timer(new TimerCallback(this.CheckMessageTimeOut), null, 0, 0x3e8);
                        }
                        argument = new StateChangedEventArgs(oldState, value);
                    }
                }
                if (argument != null)
                {
                    this.RaiseStateChanged(argument);
                }
            }
        }

        public virtual int TryCounter
        {
            get
            {
                return 0;
            }
            set
            {
            }
        }

        private class MessageTimesPair
        {
            private SipMessageBase _Message;
            private int _TryTimes;

            public MessageTimesPair(SipMessageBase message, int tryTimes)
            {
                this.Message = message;
                this.TryTimes = tryTimes;
            }

            public SipMessageBase Message
            {
                get
                {
                    return this._Message;
                }
                set
                {
                    this._Message = value;
                }
            }

            public int TryTimes
            {
                get
                {
                    return this._TryTimes;
                }
                set
                {
                    this._TryTimes = value;
                }
            }
        }
    }
}