user.cs

破解的飞信源代码

            msg.RetryTimes = 5;
            msg.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<AsyncSipcKeepLogon>b__15);
            ClientLogger.WriteLoginSuccessed("发送保持登录：\r\n" + msg.Message.ToString(), 1);
            this.SendSipMessage(msg);
        }

        private void AsyncSipcSignout(SignoutMode mode)
        {
            EventHandler<FailedEventArgs> handler = null;
            EventHandler handler2 = null;
            EventHandler<FailedEventArgs> handler3 = null;
            EventHandler handler4 = null;
            AsyncBizOperation op = new AsyncBizOperation();
            op.IsImpsErrorHandled = true;
            ClientLogger.WriteLogin("保存用户配置到server", 0, string.Empty, 1);
            this.Configuration.CommitChanges(op);
            ClientLogger.WriteLogin("会话管理器进行注销处理……", 0, string.Empty, 1);
            this.ConversationManager.AsyncDoLogout(op);
            ClientLogger.WriteLogin("群管理器进行注销处理……", 0, string.Empty, 1);
            this.PersonalGroupManager.AsyncDoLogout(op);
            ClientLogger.WriteLogin("联系人列表进行注销处理……", 0, string.Empty, 1);
            this.ContactList.AsyncDoLogout(op);
            ClientLogger.WriteLogin("发送注销命令", 0, string.Empty, 1);
            SipRequest msg = this.CreateSipRequest("R", this._regCallId, ++this._regCSeq);
            msg.Message.AddHeader(new SipcExpiresHeader(0));
            if (mode == SignoutMode.Standby)
            {
                if (!UserAccounts.LatestAccountAutoLogin)
                {
                    this._lastPresence = null;
                }
                if (handler == null)
                {
                    handler = new EventHandler<FailedEventArgs>(this, (IntPtr) this.<AsyncSipcSignout>b__d);
                }
                msg.SendMessageFailed += handler;
                if (handler2 == null)
                {
                    handler2 = delegate {
                        Thread.Sleep(500);
                        this.DoAfterLogout(SignoutMode.Standby);
                    };
                }
                msg.Sent += handler2;
            }
            else
            {
                this._lastPresence = null;
                if (handler3 == null)
                {
                    handler3 = new EventHandler<FailedEventArgs>(this, (IntPtr) this.<AsyncSipcSignout>b__f);
                }
                msg.SendMessageFailed += handler3;
                if (handler4 == null)
                {
                    handler4 = delegate {
                        Thread.Sleep(500);
                        this.DoAfterLogout(SignoutMode.Normal);
                    };
                }
                msg.Sent += handler4;
            }
            this.SendSipMessage(msg);
        }

        private bool AsyncSsiKeepLogon()
        {
            ThreadPool.QueueUserWorkItem(delegate {
                this.DoSsiKeepLogon(5);
            });
            return true;
        }

        private void AsyncSsiSignout()
        {
            try
            {
                this.ClearSsiCredential();
            }
            catch
            {
            }
        }

        public void AsyncSubscribeService(string serviceId, AsyncBizOperation op)
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            try
            {
                SipRequest req = this.CreateSipRequest("S");
                req.Message.AddHeader(new SipcEventHeader("SubscribeService"));
                req.Context = op;
                StringWriter tw = new StringWriter();
                if (writeContentCallback == null)
                {
                    writeContentCallback = delegate (XmlWriter writer, object context) {
                        writer.WriteStartElement("services");
                        writer.WriteStartElement("service");
                        writer.WriteAttributeString("id", serviceId);
                        writer.WriteEndElement();
                        writer.WriteEndElement();
                    };
                }
                XmlHelper.CreateXmlWriterForSipRequest(tw, null, writeContentCallback);
                req.Message.Body = tw.ToString();
                tw.Dispose();
                ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                if (handler == null)
                {
                    <>c__DisplayClass4 class2;
                    handler = new EventHandler<SipResponseReceivedEventArgs>(class2, (IntPtr) this.<AsyncSubscribeService>b__1);
                }
                req.FinalResponseReceived += handler;
                this.SendSipMessage(req);
            }
            catch (Exception exception)
            {
                LogHelper.LogException(exception);
            }
        }

        public void AsyncUnregister(AsyncBizOperation op)
        {
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            try
            {
                SipRequest req = this.CreateSipRequest("S");
                req.Context = op;
                req.Message.AddHeader(new SipcEventHeader("UnsubcribeIIC"));
                ErrorHelper.HandleSendRequestErrorAndTimeout(req, this, op, StringTable.Services.UnregisterFailed);
                if (handler == null)
                {
                    handler = new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<AsyncUnregister>b__16);
                }
                req.FinalResponseReceived += handler;
                this.SendSipMessage(req);
            }
            catch (Exception exception)
            {
                LogHelper.LogException(exception);
            }
        }

        public void AsyncUnsubscribeService(string serviceId, AsyncBizOperation op)
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            try
            {
                SipRequest req = this.CreateSipRequest("S");
                req.Message.AddHeader(new SipcEventHeader("UnsubscribeService"));
                req.Context = op;
                StringWriter tw = new StringWriter();
                if (writeContentCallback == null)
                {
                    writeContentCallback = delegate (XmlWriter writer, object context) {
                        writer.WriteStartElement("services");
                        writer.WriteStartElement("service");
                        writer.WriteAttributeString("id", serviceId);
                        writer.WriteEndElement();
                        writer.WriteEndElement();
                    };
                }
                XmlHelper.CreateXmlWriterForSipRequest(tw, null, writeContentCallback);
                req.Message.Body = tw.ToString();
                tw.Dispose();
                ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                if (handler == null)
                {
                    <>c__DisplayClassa classa;
                    handler = new EventHandler<SipResponseReceivedEventArgs>(classa, (IntPtr) this.<AsyncUnsubscribeService>b__7);
                }
                req.FinalResponseReceived += handler;
                this.SendSipMessage(req);
            }
            catch (Exception exception)
            {
                LogHelper.LogException(exception);
            }
        }

        public void ChangeExServiceStatus(string id, bool subscribe)
        {
            if (this.SubscribedServices.ContainsKey(id))
            {
                this.SubscribedServices.get_Item(id).Subscribed = subscribe;
                if (this.ExServicesStatusChanged != null)
                {
                    FuncDispatcher.InvokeEventHandlerInUiThread<ExServiceEventArgs>(this, this.ExServicesStatusChanged, new ExServiceEventArgs(this.SubscribedServices.get_Item(id)));
                }
            }
            this.PersistentManager.SaveSubscribedServiceInfos(delegate (XmlNode node) {
                XmlHelper.SetNodeAttribute(node, "version", this.ServiceVersion);
                node.InnerXml = this.ToServiceNodeXml();
            });
        }

        private bool CheckNetworkInterface(bool isAutoLogin)
        {
            if (NetworkInterface.GetIsNetworkAvailable())
            {
                return true;
            }
            string failedReason = string.Format("本次{0}登录时无可用网络连接，登录中止", isAutoLogin ? "自动" : "");
            ClientLogger.WriteLoginFailed("登录前检查", failedReason);
            if (isAutoLogin)
            {
                this.Status = UserAccountStatus.WaitReconnect;
                return false;
            }
            try
            {
                if (this.ImpsError == null)
                {
                    return false;
                }
                this.ImpsError.Invoke(this, new ImpsErrorEventArgs("网络不可用，错误码：10001800", "当前没有可用的网络连接，请检查您的网络。", 0x7d1));
            }
            catch
            {
            }
            return false;
        }

        internal void Clear()
        {
            this.Clear(UserAccountStatus.None);
        }

        internal void Clear(UserAccountStatus status)
        {
            lock (this._syncObjLogin)
            {
                ClientLogger.WriteGeneral("开始执行清理操作");
                this.ClearPerLogin();
                this._loginCancelled = false;
                this._initPresence = MainPresence.Unknown;
                this._loginStep = string.Empty;
                this.ExpiredSeconds = 0;
                this.ExpiredSecondsSsi = 0;
                this.PersonalInfo.Clear();
                this.ContactList.Clear();
                this.ConversationManager.Clear();
                this.PersonalGroupManager.Clear();
                if (this._ceManager != null)
                {
                    this._ceManager.Dispose();
                    this._ceManager = null;
                }
                this.Presence.Clear();
                this.PermissionManager.Clear();
                this.BlackList.Clear();
                this.MobileMailInfo.Clear();
                this.ScoreInfo.Clear();
                if (this._ssmsMgr != null)
                {
                    this._ssmsMgr.Clear();
                }
                if (status != UserAccountStatus.Disconnected)
                {
                    this.Configuration.Clear();
                }
                this._provisionStatus = UserProvisionStatus.Unknown;
                this._serviceVersion = string.Empty;
            }
        }

        private void ClearBeforeLogout()
        {
            this.ExpiredSeconds = 0;
            this.ExpiredSecondsSsi = 0;
        }

        private void ClearPerLogin()
        {
            this.ClearRegState();
            this._loginCancelled = false;
            this.ContactList.Clear();
        }

        private void ClearPreLoginThread()
        {
            Thread thread = null;
            lock (this._syncObjPreLoginThread)
            {
                if (this._threadPreLogin == null)
                {
                    return;
                }
                thread = this._threadPreLogin;
                this._threadPreLogin = null;
            }
            if (thread.IsAlive)
            {
                thread.Abort();
            }
        }

        public void ClearRegState()
        {
            this._regCallId = -1;
            this._regCSeq = -1;
            this._reg2Result.Clear();
            lock (this._syncObjPendingSipRequestReceived)
            {
                this._pendingSipRequestReceived = null;
            }
        }

        internal void ClearSsiCredential()
        {
            this.SsiCredential = string.Empty;
            this._ssicUrlEncoded = string.Empty;
        }

        private void ClearUserAccountInfo()
        {
            this._sid = 0;
            this._password = string.Empty;
        }

        internal SipRequest CreateSipRequest(string method)
        {
            return this.CreateSipRequest(method, (long) 0, 1);
        }

        internal SipRequest CreateSipRequest(string method, long callId, int cSeq)
        {
            return new SipRequest(this.InnerCreateSipcRequest(method, ref callId, cSeq));
        }

        internal SipRequestEx CreateSipRequestEx(string method, AsyncBizOperation op)
        {
            return this.CreateSipRequestEx(method, (long) 0, 1, op);
        }

        internal SipRequestEx CreateSipRequestEx(string method, long callId, int cSeq, AsyncBizOperation op)
        {