uploadsharecontent.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client;
    using Imps.Client.Base;
    using Imps.Client.Core.History;
    using Imps.Client.Core.P2P.FileTransportor;
    using Imps.Client.Core.P2P.ICE;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.IO;
    using System.Net;
    using System.Text;
    using System.Threading;
    using System.Xml;

    public class UploadShareContent : ShareContent
    {
        private bool _directToMobile;
        private bool _sendToSelf;
        private string _uploadUri;
        private AutoResetEvent relayAcceptEvent;
        private AutoResetEvent waitInviteEvent;

        public UploadShareContent(string filePath, Dialog dialog, bool directToMobile) : base(filePath, dialog.Owner)
        {
            EventHandler handler = null;
            this.relayAcceptEvent = new AutoResetEvent(false);
            this.InitShareContent(filePath, directToMobile);
            base.CurrentDialog = dialog;
            dialog.StatusChange += new EventHandler<DialogStatusChangeEventArgs>(this, (IntPtr) this.dialog_StatusChange);
            if (handler == null)
            {
                handler = delegate {
                    dialog.StatusChange -= new EventHandler<DialogStatusChangeEventArgs>(this, (IntPtr) this.dialog_StatusChange);
                };
            }
            base.Closed += handler;
        }

        public UploadShareContent(string filePath, Imps.Client.Core.User owner, bool directToMobile) : base(filePath, owner)
        {
            this.relayAcceptEvent = new AutoResetEvent(false);
            this.InitShareContent(filePath, directToMobile);
        }

        private void AsyncSendFile(object context)
        {
            if (base.CurrentDialog.Status == DialogStatus.Inviting)
            {
                this.waitInviteEvent = new AutoResetEvent(false);
                if (!this.waitInviteEvent.WaitOne(0x2bf20, true))
                {
                    return;
                }
            }
            if (this.DirectToMobile || base.CurrentDialog.IsMulitiConversation)
            {
                this.SendFileBlockMode();
            }
            else
            {
                Imps.Client.Core.Contact contact = base.CurrentDialog.Participants[0].Contact;
                if (base.CurrentDialog.Status == DialogStatus.Invited)
                {
                    this.AsyncSendOptions(contact);
                }
                else
                {
                    this.SendFileBlockMode();
                }
            }
        }

        internal void AsyncSendFileInfo()
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            if (!base.IsClosed && !base.IsCancel)
            {
                if (this.SendToSelf || (!base.CurrentDialog.IsMulitiConversation && (this.DirectToMobile || (base.CurrentDialog.Status != DialogStatus.Invited))))
                {
                    this.AsyncSendWapPushMessage();
                }
                else
                {
                    SipRequest req = base.CurrentDialog.InnerCreateSipRequest("IN", base.CurrentDialog.CallId, base.CurrentDialog.NextCSeq);
                    req.Message.AddHeader(new SipcToHeader(this.To));
                    StringWriter tw = new StringWriter();
                    if (writeContentCallback == null)
                    {
                        writeContentCallback = delegate (XmlWriter writer, object context) {
                            writer.WriteAttributeString("type", "share-content");
                            writer.WriteAttributeString("method", "request");
                            writer.WriteStartElement("transmit");
                            writer.WriteAttributeString("type", base.Transmittype.ToString().ToLower());
                            writer.WriteAttributeString("session-id", base.SessionId);
                            writer.WriteEndElement();
                            writer.WriteStartElement("file");
                            writer.WriteAttributeString("name", base.FileName);
                            writer.WriteAttributeString("size", base.FileSize.ToString());
                            writer.WriteAttributeString("url", base.DownLoadUrl);
                            if ((base.Transmittype == ShareContentTransmitType.P2P) || (base.Transmittype == ShareContentTransmitType.Relay))
                            {
                                writer.WriteAttributeString("md5", base.First100MMd5);
                                writer.WriteAttributeString("id", base.Id);
                            }
                            if ((base.Transmittype == ShareContentTransmitType.Relay) && base.P2pFailedToRelay)
                            {
                                writer.WriteAttributeString("p2ptorelay", "1");
                            }
                            writer.WriteEndElement();
                            if (base.PreviewImageBase64String != null)
                            {
                                writer.WriteElementString("preview-image", base.PreviewImageBase64String);
                            }
                        };
                    }
                    XmlHelper.CreateXmlWriterForSipMessage(tw, null, writeContentCallback, "action");
                    if (<>9__CachedAnonymousMethodDelegatec == null)
                    {
                        <>9__CachedAnonymousMethodDelegatec = new EventHandler<SipResponseReceivedEventArgs>(null, (IntPtr) <AsyncSendFileInfo>b__a);
                    }
                    req.FinalResponseReceived += <>9__CachedAnonymousMethodDelegatec;
                    req.Message.Body = tw.ToString();
                    ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                    base.Owner.SendSipMessage(req);
                }
            }
        }

        private void AsyncSendOptions(Imps.Client.Core.Contact contact)
        {
            int cSeq = base.CurrentDialog.NextCSeq;
            SipRequest req = base.CurrentDialog.InnerCreateSipRequest("O", base.CurrentDialog.CallId, cSeq);
            req.Message.Headers.Add(new SipcSupportedHeader("ShareContent"));
            req.Message.AddHeader(new SipcToHeader(contact.Uri.Raw));
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.asyncSendOptions_req_FinalResponseReceived);
            req.WaitResponseTimeout += delegate {
                this.SendFileBlockMode();
            };
            req.SendMessageFailed += new EventHandler<FailedEventArgs>(this, (IntPtr) this.<AsyncSendOptions>b__5);
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipMessage(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteAttributeString("id", this.Id);
                if (this.P2pFinder == null)
                {
                    this.P2pFinder = new P2PSessionFinder(contact.Uri.Sid, true);
                }
                this.RemotePeer = this.P2pFinder.RemotePeer;
                this.MyEndPoints = this.P2pFinder.GetLocalEndpoints();
                writer.WriteStartElement("caps");
                writer.WriteAttributeString("modes", ConversationManager.GetShareContentOptionString());
                writer.WriteAttributeString("max-size", (this.Owner.Configuration.SystemSetting.FileShareSetting.MaxRelaySize / 0x400).ToString());
                writer.WriteEndElement();
                writer.WriteStartElement("client");
                StringBuilder builder = new StringBuilder();
                if (this.MyEndPoints != null)
                {
                    List<IPEndPoint>.Enumerator enumerator = this.MyEndPoints.InnerEndPoints.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            IPEndPoint point = enumerator.get_Current();
                            builder.Append(this.CurrentDialog.EndPointToString(point) + ";");
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
                writer.WriteAttributeString("outer-ip", (this.MyEndPoints == null) ? "" : this.CurrentDialog.EndPointToString(this.MyEndPoints.OuterEndPoint));
                writer.WriteAttributeString("inner-ip", builder.ToString());
                writer.WriteAttributeString("port", "");
                writer.WriteEndElement();
            }, "share-content");
            req.Message.Body = tw.ToString();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.CurrentDialog.Owner.SendSipMessage(req);
        }

        private void asyncSendOptions_req_FinalResponseReceived(object sender, SipResponseReceivedEventArgs e)
        {
            if (e.Response.Message.StatusCode == 420)
            {
                this.SendFileBlockMode();
                this.CancelShareContent();
                base.BizOperation.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.Conversation.MsgNotSupportShareContent));
            }
            if (e.Response.Message.StatusCode == 200)
            {
                ShareContent.OtherSideOption option = base.CurrentDialog.ParserEndPoints(e.Response.Message.Body);
                if (option == null)
                {
                    base.RaiseShareContentFailed("");
                }
                option.Id = base.Id;
                if (option.MaxSize.get_HasValue() && (base.FileSize > ((long) option.MaxSize.get_Value())))
                {
                    this.CancelShareContent();
                    base.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs(string.Format(StringTable.Conversation.MsgSendFileLimit, StringHelper.GetFileSize((long) option.MaxSize.get_Value()))), base.BizOperation);
                }
                else
                {
                    base.OtherSideSharedContentOption = option;
                    this.SendFileAfterGetOptions();
                }
            }
            else
            {
                this.SendFileBlockMode();
            }
        }

        public void AsyncSendWapPushMessage()
        {
            SipRequest req = base.Owner.CreateSipRequest("M", base.Owner.SipConnection.NextCallId(), 1);
            req.Message.AddHeader(new SipcToHeader(this.SendToSelf ? base.Owner.Uri.Raw : this.To));
            req.Message.AddHeader(new SipcEventHeader("ShareContent"));
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipMessage(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteAttributeString("type", "share-content");
                writer.WriteStartElement("file");
                writer.WriteAttributeString("name", base.FileName);
                writer.WriteAttributeString("size", base.FileSize.ToString());
                writer.WriteAttributeString("url", base.DownLoadUrl);
                writer.WriteEndElement();
            }, "action");
            req.Message.Body = tw.ToString();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.req_FinalResponseReceived);
            req.SendMessageFailed += new EventHandler<FailedEventArgs>(this, (IntPtr) this.req_SendMessageFailed);
            req.WaitResponseTimeout += new EventHandler(this.req_WaitResponseTimeout);
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.Owner.SendSipMessage(req);
        }

        internal override void AsyncStartP2P()
        {
            if (base.P2pTransport != null)
            {
                try
                {
                    base.P2pTransport.TargetFile.CompletedSize = base.LastTimeCompleteSize;
                    base.P2pTransport.TargetFile.InnerFileStream.Position = base.LastTimeCompleteSize;
                    base.P2pTransport.Start();
                    this.SaveShareContentHistory();
                    ClientLogger.WriteGeneral(string.Format("--P2P传送开始,上传 {0} 给 {1}--", base.FileName, this.To));
                }
                catch (IOException)
                {
                    base.RaiseShareContentFailed("请检测此文件是否正在被使用！");
                }
                catch (Exception)
                {
                    base.RaiseShareContentFailed("");
                }
            }
            else
            {
                this.ConvertP2pToRelay();
            }
        }

        public override void CancelShareContent()
        {
            base.CancelShareContent();
            lock (this)
            {
                if ((!base.IsCancel && !base.Complete) && !base.IsFailed)
                {
                    base.IsCancel = true;
                    ThreadPool.QueueUserWorkItem(new WaitCallback(this.CancelShareContentInThread));
                    base.RaiseShareContentCancel();
                    if (((base.CurrentDialog != null) && (base.CurrentDialog.Status == DialogStatus.Invited)) && !base.CurrentDialog.CloseByBye)
                    {
                        base.AsyncSendCancelInfo();
                    }
                    this.Close();
                }
            }
        }