sipcregaction.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client.Base;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.IO;
    using System.Threading;
    using System.Xml;

    public sealed class SipCRegAction : LoginAction
    {
        private MainPresence curPresence;
        private const string errorMessage = "SipC注册过程中发生错误";
        private bool result;
        private int sipResponseCode;
        private AutoResetEvent waitRegResult;

        public SipCRegAction(User user, ILoginListner listener) : base(user, listener)
        {
        }

        public override void Cancel()
        {
        }

        public override void Clear()
        {
            base.User.ClearRegState();
        }

        public override void Dispose()
        {
        }

        public override bool Execute()
        {
            return this.Execute(new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.req_FinalResponseReceived), new EventHandler<FailedEventArgs>(this, (IntPtr) this.req_SendMessageFailed), new EventHandler(this.req_WaitResponseTimeout), base.User.SipConnection, false);
        }

        public bool Execute(ISipConnection connection)
        {
            return this.Execute(new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.req_FinalResponseReceived), new EventHandler<FailedEventArgs>(this, (IntPtr) this.req_SendMessageFailed), new EventHandler(this.req_WaitResponseTimeout), connection, true);
        }

        public bool Execute(EventHandler<SipResponseReceivedEventArgs> finalResponseReceived, EventHandler<FailedEventArgs> sendMessageFailed, EventHandler waitResponseTimeout, ISipConnection connection, bool reg1Only)
        {
            SipRequest msg = null;
            try
            {
                this.waitRegResult = new AutoResetEvent(false);
                base.NotifyMessage("开始SipC注册");
                this.result = false;
                this.Init();
                msg = base.User.CreateSipRequest("R");
                base.User.RegCallId = msg.Message.CallId.CallId;
                base.User.RegCSeq = msg.Message.CSeq.Number;
                using (StringWriter tw = new StringWriter())
                {
                    XmlHelper.CreateXmlWriterForSipRequest(tw, base.User, new XmlHelper.WriteXmlContentDelegate(this.InnerBuidRegBody));
                    msg.Message.Body = tw.ToString();
                }
                msg.FinalResponseReceived += finalResponseReceived;
                msg.SendMessageFailed += sendMessageFailed;
                msg.WaitResponseTimeout += waitResponseTimeout;
                if (reg1Only)
                {
                    connection.Send(msg);
                }
                else
                {
                    base.User.SendSipMessage(msg);
                }
                if (!this.waitRegResult.WaitOne(this.TimeOut, false) && !reg1Only)
                {
                    base.NotifyLoginFailed("等待SipC注册事件通知超时", ExceptionType.CommonException, null);
                }
                base.NotifyMessage("SipC注册完成");
            }
            catch (ThreadAbortException exception)
            {
                base.NotifyWarning("SipC注册过程中发生错误", exception);
            }
            catch (Exception exception2)
            {
                base.NotifyLoginFailed("SipC注册过程中发生错误", ExceptionType.CommonException, exception2);
            }
            finally
            {
                if (msg != null)
                {
                    try
                    {
                        ReflectionHelper.ClearAllEvents(msg);
                    }
                    catch
                    {
                    }
                }
            }
            return this.result;
        }

        private void Init()
        {
            this.Clear();
        }

        private void InnerBuidRegBody(XmlWriter writer, object context)
        {
            User user = context as User;
            writer.WriteStartElement("device");
            writer.WriteAttributeString("type", "PC");
            writer.WriteAttributeString("version", user.Configuration.UserSetting.CustomerCfgVersion.ToString());
            writer.WriteAttributeString("client-version", Configuration.FixedClientSetting.Version);
            writer.WriteEndElement();
            writer.WriteStartElement("caps");
            writer.WriteAttributeString("value", "simple-im;im-session;temp-group;personal-group");
            writer.WriteEndElement();
            writer.WriteStartElement("events");
            writer.WriteAttributeString("value", "contact;permission;system-message;personal-group");
            writer.WriteEndElement();
            string oemTag = OemSetting.Instance.OemTag;
            if (!string.IsNullOrEmpty(oemTag))
            {
                writer.WriteStartElement("oem-tag");
                writer.WriteAttributeString("value", oemTag);
                writer.WriteEndElement();
            }
            writer.WriteStartElement("user-info");
            writer.WriteAttributeString("attributes", "all");
            writer.WriteEndElement();
            writer.WriteStartElement("presence");
            this.curPresence = base.GetCurrentLoginPresence();
            int serverPresence = Imps.Client.Core.Presence.GetServerPresence((int) this.curPresence);
            this.curPresence = (MainPresence) serverPresence;
            writer.WriteStartElement("basic");
            writer.WriteAttributeString("value", serverPresence.ToString());
            writer.WriteAttributeString("desc", string.Empty);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }

        private void req_FinalResponseReceived(object sender, SipResponseReceivedEventArgs e)
        {
            SipResponse response = e.Response;
            this.sipResponseCode = response.Message.StatusCode;
            try
            {
                switch (response.Message.StatusCode)
                {
                    case 200:
                    {
                        SipcExpiresHeader expires = e.Response.Message.Expires;
                        if (expires != null)
                        {
                            base.User.ExpiredSeconds = expires.Seconds;
                        }
                        else
                        {
                            base.User.ExpiredSeconds = 600;
                        }
                        try
                        {
                            XmlDocument xmlDoc = new XmlDocument();
                            xmlDoc.LoadXml(response.Message.Body);
                            base.User.Reg2Result.LoadFromXml(xmlDoc);
                            ClientLogger.WriteGeneral("Reg2 Result", base.User.Reg2Result.ToString(), 0);
                            XmlNode xmlNode = xmlDoc.DocumentElement.SelectSingleNode("client");
                            base.User.Configuration.LoadUserSetting(xmlNode);
                            if (base.User.Reg2Result.IsSetPresenceOK)
                            {
                                base.User.Presence.RealValue = (int) this.curPresence;
                                if (base.User._lastPresence != null)
                                {
                                    base.User.Presence.PreviousPresencePriority = base.User._lastPresence._priority;
                                }
                                else
                                {
                                    base.User._lastPresence = new UserLastPresence(base.User);
                                }
                            }
                        }
                        catch (Exception exception)
                        {
                            base.NotifyException("加载用户配置过程中出现错误", exception);
                        }
                        this.result = true;
                        this.waitRegResult.Set();
                        return;
                    }
                    case 0x191:
                        this.SipcAuth(e.Response);
                        return;

                    case 0x194:
                        base.User.SipConnection = null;
                        base.ClearUri();
                        base.NotifyLoginFailed("SipC注册过程中发生错误", ExceptionType.SipCException, new SipCException(response.Message.StatusCode, "SipC注册过程中发生错误"));
                        this.result = false;
                        this.waitRegResult.Set();
                        return;
                }
                base.User.SipConnection = null;
                base.NotifyLoginFailed("SipC注册过程中发生错误", ExceptionType.SipCException, new SipCException(response.Message.StatusCode, "SipC注册过程中发生错误"));
                this.result = false;
                this.waitRegResult.Set();
            }
            catch (Exception exception2)
            {
                base.NotifyLoginFailed("Sip认证过程中出现错误", ExceptionType.CommonException, exception2);
                this.result = false;
                this.waitRegResult.Set();
            }
        }

        private void req_SendMessageFailed(object sender, FailedEventArgs e)
        {
            base.NotifyLoginFailed("SipC注册过程中发生错误", ExceptionType.SipCException, new SipCException(900, "SipC注册过程中发生错误"));
            this.result = false;
            this.waitRegResult.Set();
        }

        private void req_WaitResponseTimeout(object sender, EventArgs e)
        {
            base.NotifyLoginFailed("SipC注册过程中发生错误", ExceptionType.SipCException, new SipCException(0x385, "SipC注册过程中发生错误"));
            this.result = false;
            this.waitRegResult.Set();
        }

        private void SipcAuth(SipResponse sipResponse)
        {
            try
            {
                base.NotifyMessage("开始SipC认证");
                SipcWWWAuthenticateHeader wWWAuthenticate = sipResponse.Message.WWWAuthenticate;
                if (wWWAuthenticate == null)
                {
                    this.result = false;
                    this.waitRegResult.Set();
                }
                else
                {
                    User user = base.User;
                    SipRequest msg = base.User.CreateSipRequest("R", base.User.RegCallId, ++user.RegCSeq);
                    ComputeAuthResponse response = new ComputeAuthResponse(base.User.Sid.ToString(), base.User.Password, base.User.Domain, wWWAuthenticate.Nonce, !FuncLimitedSetting.SSIEncryptLoginLimited);
                    string cnonce = response.GetCNonce();
                    string text2 = response.ComputeResponse();
                    if (!FuncLimitedSetting.SSIEncryptLoginLimited)
                    {
                        msg.Message.AddHeader(new SipcAuthorizationHeader("Digest", "SHA1-sess", text2, cnonce, base.User.Password.Substring(0, 8)));
                    }
                    else
                    {
                        msg.Message.AddHeader(new SipcAuthorizationHeader("Digest", "MD5-sess", text2, cnonce));
                    }
                    using (StringWriter tw = new StringWriter())
                    {
                        XmlHelper.CreateXmlWriterForSipRequest(tw, base.User, new XmlHelper.WriteXmlContentDelegate(this.InnerBuidRegBody));
                        msg.Message.Body = tw.ToString();
                    }
                    msg.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.req_FinalResponseReceived);
                    msg.WaitResponseTimeout += new EventHandler(this.req_WaitResponseTimeout);
                    msg.SendMessageFailed += new EventHandler<FailedEventArgs>(this, (IntPtr) this.req_SendMessageFailed);
                    base.User.SendSipMessage(msg);
                }
            }
            catch (Exception exception)
            {
                base.NotifyLoginFailed("SipC认证过程中出现错误", ExceptionType.CommonException, exception);
                this.result = false;
                this.waitRegResult.Set();
            }
        }

        public override bool LocalCacheHit
        {
            get
            {
                return false;
            }
        }

        public override Imps.Client.Core.LoginStage LoginStage
        {
            get
            {
                return Imps.Client.Core.LoginStage.SipcRegister;
            }
        }

        public int SipResponseCode
        {
            get
            {
                return this.sipResponseCode;
            }
        }

        public override int TimeOut
        {
            get
            {
                return (base.TimeOut * 2);
            }
        }

        public AutoResetEvent WaitRegResult
        {
            get
            {
                return this.waitRegResult;
            }
        }
    }
}