uploadsharecontent.cs

破解的飞信源代码

        private void CancelShareContentInThread(object context)
        {
            try
            {
                if (this.UploadUri != null)
                {
                    string url = this.UploadUri + ((this.UploadUri.IndexOf("?") > -1) ? "&cancel=1" : "?cancel=1");
                    HttpWebRequest request = ConnectionFactory.CreateHttpWebRequest(url, base.Owner, false, true);
                    request.Headers.Add("Pragma", base.SessionId);
                    HttpWebResponse response = null;
                    response = request.GetResponse() as HttpWebResponse;
                    if (response.StatusCode != HttpStatusCode.OK)
                    {
                        LogHelper.LogFatalError(string.Format("{0} StatusCode:{1}", url, response.StatusCode));
                    }
                    response.Close();
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException("Cancel File Upload Exception", exception);
            }
        }

        public override void Close()
        {
            try
            {
                if (this.relayAcceptEvent != null)
                {
                    this.relayAcceptEvent.Set();
                    this.relayAcceptEvent.Close();
                }
            }
            catch (Exception)
            {
            }
            base.Close();
        }

        private void ConvertP2pToRelay()
        {
            if (base.OtherSideSharedContentOption.SupportRelayV2)
            {
                base.Transmittype = ShareContentTransmitType.Relay;
                base.P2pFailedToRelay = true;
                this.SendFileRelayMode();
                ClientLogger.WriteGeneral("P2P失败  尝试用Relay方式重新发送文件！" + base.FileName);
            }
            else
            {
                base.OnTransportFailed();
            }
        }

        private void dialog_StatusChange(object sender, DialogStatusChangeEventArgs e)
        {
            if ((e.NewStatus != DialogStatus.Inviting) && (this.waitInviteEvent != null))
            {
                this.waitInviteEvent.Set();
                this.waitInviteEvent.Close();
            }
        }

        private void GernerateFileInfo()
        {
            try
            {
                if (string.IsNullOrEmpty(base.First100MMd5))
                {
                    base.TransportingFile = new TransportingFile(base.FilePath);
                    base.First100MMd5 = base.TransportingFile.First100MMd5;
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        private string GetReceiverQueryString()
        {
            string text = string.Empty;
            if (this.SendToSelf)
            {
                return base.Owner.Sid.ToString();
            }
            if ((base.CurrentDialog != null) && (base.CurrentDialog.Participants != null))
            {
                if (base.CurrentDialog.Participants.Count == 1)
                {
                    return base.CurrentDialog.Participants[0].Contact.Uri.Sid.ToString();
                }
                if (!base.CurrentDialog.IsMulitiConversation)
                {
                    return text;
                }
                for (int i = 0; i < base.CurrentDialog.Participants.Count; i++)
                {
                    text = text + base.CurrentDialog.Participants[i].Contact.Uri.Sid.ToString();
                    if (i < (base.CurrentDialog.Participants.Count - 1))
                    {
                        text = text + ";";
                    }
                }
            }
            return text;
        }

        private void InitShareContent(string filePath, bool directToMobile)
        {
            base.FileName = Path.GetFileName(filePath);
            FileInfo info = new FileInfo(filePath);
            base.FileSize = info.Length;
            this.DirectToMobile = directToMobile;
            base.SessionId = "xz4BBcV" + Guid.NewGuid().ToString().Replace("-", "");
            Image image = ImageHelper.IsImageFile(base.FilePath);
            if (image != null)
            {
                base.PreviewImageBase64String = ImageHelper.Image2Base64(image, 40);
            }
        }

        protected override void OnTransportFailed()
        {
            if (base.P2pTransport != null)
            {
                base.P2pTransport.Stop();
            }
            base.P2pTransport = null;
            this.ConvertP2pToRelay();
        }

        private void req_FinalResponseReceived(object sender, SipResponseReceivedEventArgs e)
        {
            if (e.Response.Message.StatusCode > 300)
            {
                ClientLogger.WriteGeneral(string.Format("发送WapPush失败！Error Code:", e.Response.Message.StatusCode));
            }
        }

        private void req_SendMessageFailed(object sender, FailedEventArgs e)
        {
            ClientLogger.WriteGeneral("发送WapPush失败！", e.Explain);
        }

        private void req_WaitResponseTimeout(object sender, EventArgs e)
        {
            ClientLogger.WriteGeneral("发送WapPush超时！");
        }

        public void ResumeRelayUpload()
        {
            this.relayAcceptEvent.Set();
        }

        private void SaveShareContentHistory()
        {
            if (base.Owner.Configuration.UserSetting.ConversationSetting.SaveMessages)
            {
                if (base.CurrentDialog != null)
                {
                    ShareContentMessage message = new ShareContentMessage(base.CurrentDialog, string.Format(StringTable.Conversation.MsgSendShareContent, base.FileName), base.Owner.Nickname, base.Owner.Uri.ToString(), false);
                    message.MessageType = MessageType.ImFile;
                    message.Time = Imps.Client.Core.User.ServerTime;
                    message.SaveMessage();
                }
                else if (this.SendToSelf)
                {
                    DateTime serverTime = Imps.Client.Core.User.ServerTime;
                    string id = null;
                    IHistoryManager historyManager = base.Owner.HistoryManager;
                    Player sender = new Player(base.Owner.Uri.Raw, base.Owner.Nickname, PlayerType.User);
                    List<Player> list = new List<Player>();
                    list.Add(new Player(base.Owner.Uri.Raw, base.Owner.Nickname, PlayerType.Contact));
                    IMessage msg = new InstantMessage(id, sender, string.Format("您给自己发送了文件:《{0}》", base.FileName), list.ToArray());
                    msg.Type = MessageType.ImFile;
                    msg.Time = serverTime;
                    historyManager.SaveMessage(msg);
                }
            }
        }

        public void SendFile()
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.AsyncSendFile));
        }

        private void SendFileAfterGetOptions()
        {
            if (!base.IsClosed && !base.IsCancel)
            {
                if (!base.OtherSideSharedContentOption.SupportBlock)
                {
                    this.CancelShareContent();
                    base.CurrentDialog.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.Conversation.MsgNotSupportShareContent), base.BizOperation);
                }
                else
                {
                    ShareContentType shareContentType = Imps.Client.Core.Configuration.FixedClientSetting.ShareContentType;
                    if (((base.MyEndPoints != null) && base.OtherSideSharedContentOption.SupportP2PV2) && ((shareContentType & ShareContentType.P2P) != ShareContentType.None))
                    {
                        this.SendP2PAfterGetOptions();
                    }
                    else if ((shareContentType & ShareContentType.RelayAndBlock) == ShareContentType.None)
                    {
                        base.RaiseShareContentFailed("");
                    }
                    else if (base.OtherSideSharedContentOption.SupportRelay)
                    {
                        this.SendFileRelayMode();
                    }
                    else if (base.OtherSideSharedContentOption.SupportBlock)
                    {
                        this.SendFileBlockMode();
                    }
                    else
                    {
                        base.RaiseShareContentFailed("");
                    }
                }
            }
        }

        private void SendFileBlockMode()
        {
            if (base.FileSize > base.Owner.Configuration.SystemSetting.FileShareSetting.MaxShareContentSize)
            {
                this.CancelShareContent();
                base.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs(string.Format(StringTable.Conversation.MsgSendFileLimit, StringHelper.GetFileSize((long) base.Owner.Configuration.SystemSetting.FileShareSetting.MaxShareContentSize))), base.BizOperation);
            }
            else
            {
                base.Transmittype = ShareContentTransmitType.Block;
                ThreadPool.QueueUserWorkItem(new WaitCallback(this.SendFileInThread), null);
            }
        }

        public void SendFileInThread(object context)
        {
            FileStream stream = null;
            try
            {
                FileInfo info = new FileInfo(base.FilePath);
                int num = 0;
                int num2 = 0;
                DateTime now = DateTime.Now;
                int num3 = 200;
                DateTime time2 = DateTime.Now;
                string text = string.Empty;
                using (stream = info.OpenRead())
                {
                    int from = 0;
                    int to = 0;
                    while (to < (stream.Length - 1))
                    {
                        byte[] buffer;
                        HttpWebRequest request;
                        base.WaitEvent.WaitOne();
                        base.WaitEvent.Set();
                        from = to;
                        bool flag = from == 0;
                        string url = this.UploadUri;
                        if (flag)
                        {
                            url = (base.Transmittype == ShareContentTransmitType.Relay) ? base.Owner.Configuration.SystemSetting.FileShareSetting.RelayUploadUri : base.Owner.Configuration.SystemSetting.FileShareSetting.BlockUploadUri;
                            url = url + "?FileSize=" + stream.Length;
                            string str = this.GetReceiverQueryString();
                            if (!string.IsNullOrEmpty(str))
                            {
                                url = url + string.Format("&To={0}", HttpWebRequestHelper.UrlEncode(str));
                            }
                        }
                        else if ((from != 0) && (from != base.LastTimeCompleteSize))
                        {
                            from++;
                        }
                        if (string.IsNullOrEmpty(url))
                        {
                            this.CancelShareContent();
                            ClientLogger.WriteGeneral("Upload Faile:", "url地址为空");
                            return;
                        }
                        if (base.IsOnce)
                        {