Ejemplo n.º 1
0
        public static async Task Upload(CancellationToken cancellation, string filename = null)
        {
            string[] filenames;

            // Find the IRD file
            if (string.IsNullOrEmpty(filename))
            {
                filenames = await Interaction.Instance.GetIrdFiles();
            }
            else
            {
                filenames = new[] { filename }
            };

            if (filenames == null || filenames.Length == 0)
            {
                return;
            }

            Interaction.Instance.TaskBegin();

            int totalSize = (int)filenames.Sum(f => new FileInfo(f).Length);

            Interaction.Instance.SetProgressMaximum(totalSize);

            int processedSize = 0;

            foreach (var f in filenames)
            {
                string hash;
                try
                {
                    hash = IrdFile.GetHash(f);
                }
                catch (FileLoadException)
                {
                    Interaction.Instance.ReportMessage(
                        "Version of IRD file " + Path.GetFileName(f) + " cannot be handled", ReportType.Fail);
                    continue;
                }

                byte[] content = File.ReadAllBytes(f);

                Encryption enc = new Encryption();
                enc.Encrypt(content, hash);

                try
                {
                    string authInfo = string.Format("{0}:{1}", enc.PublicKey.Join().Md5().AsString(),
                                                    enc.EncryptedKey.AsString());

                    HttpWebRequest wr = (HttpWebRequest)WebRequest.Create(URL);
                    wr.Method = "POST";
                    wr.Headers["Authentication"] = "K3Y " + Convert.ToBase64String(Encoding.ASCII.GetBytes(authInfo));
                    using (Stream s = await wr.GetRequestStreamAsync())
                    {
                        if (cancellation.IsCancellationRequested)
                        {
                            return;
                        }

                        int bytesToWrite = enc.EncryptedContent.Length;
                        totalSize += bytesToWrite - content.Length;

                        Interaction.Instance.SetProgressMaximum(totalSize);
                        int bytesWritten = 0;
                        while (bytesToWrite > 0)
                        {
                            int l = bytesToWrite > 2048 ? 2048 : bytesToWrite;
                            await s.WriteAsync(enc.EncryptedContent, bytesWritten, l);

                            bytesWritten  += l;
                            bytesToWrite  -= l;
                            processedSize += l;

                            Interaction.Instance.ReportProgress(processedSize);
                            if (cancellation.IsCancellationRequested)
                            {
                                return;
                            }
                        }
                    }
                    using (HttpWebResponse response = (HttpWebResponse)await wr.GetResponseAsync())
                    {
                        // Fetch the response
                        string resp = GetResponseString(response);

                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            Interaction.Instance.ReportMessage(Path.GetFileName(f) + ": IRD file upload failed: " +
                                                               (string.IsNullOrEmpty(resp) ? response.StatusDescription : resp), ReportType.Fail);
                        }
                        else
                        {
                            Interaction.Instance.ReportMessage(Path.GetFileName(f) + ": IRD file successfully uploaded", ReportType.Success);
                            ProcessMessages(resp);
                        }
                    }
                }
                catch (WebException e)
                {
                    string errorMessage = e.Response != null ? e.Response.Headers["X-Error"] : null;
                    if (!string.IsNullOrEmpty(errorMessage))
                    {
                        Interaction.Instance.ReportMessage(Path.GetFileName(f) + ": Upload failed: " + errorMessage, ReportType.Fail);
                    }
                    else
                    {
                        Interaction.Instance.ReportMessage(Path.GetFileName(f) + ": Upload failed: " + e.Message, ReportType.Fail);
                    }
                }
            }

            Interaction.Instance.TaskComplete();
        }
Ejemplo n.º 2
0
        private async void LoadIrd(string filename)
        {
            IrdFile irdFile = await TaskEx.Run(() => IrdFile.Load(filename));

            lblVersion.Text         = irdFile.Version.ToString(CultureInfo.InvariantCulture);
            lblUpdateVersion.Text   = irdFile.UpdateVersion;
            lblGameId.Text          = irdFile.GameID;
            lblGameName.Text        = irdFile.GameName;
            lblGameVersion.Text     = irdFile.GameVersion;
            lblAppVersion.Text      = irdFile.AppVersion;
            lblAmountOfRegions.Text = irdFile.RegionHashes.Count.ToString(CultureInfo.InvariantCulture);

            Region[] regions = await TaskEx.Run(() => irdFile.Header.GetRegions());

            for (int i = 0; i < irdFile.RegionHashes.Count && i < regions.Length; i++)
            {
                ListViewItem itm = new ListViewItem(i.ToString(CultureInfo.InvariantCulture));
                itm.SubItems.Add(regions[i].Start.ToString("X2"));
                itm.SubItems.Add(regions[i].End.ToString("X2"));
                itm.SubItems.Add(irdFile.RegionHashes[i].AsString());
                lvHashes.Items.Add(itm);
            }

            lblData1.Text = irdFile.Data1.AsString();
            lblData2.Text = irdFile.Data2.AsString();
            picHex.Stream = new MemoryStream(irdFile.PIC); // Shouldn't I dispose this one?
            d2            = irdFile.Data2;

            lblHeaderLength.Text =
                (irdFile.Header.Length / Utilities.SectorSize).ToString(CultureInfo.InvariantCulture);
            lblFooterLength.Text =
                (irdFile.Footer.Length / Utilities.SectorSize).ToString(CultureInfo.InvariantCulture);

            headerHex.Stream = irdFile.Header;
            footerHex.Stream = irdFile.Footer;

            lblCrc.Text     = BitConverter.GetBytes(irdFile.Crc).AsString();
            lblIRDHash.Text = IrdFile.GetHash(irdFile.FullPath);

            tabCtrl.Visible   = true;
            pbLoading.Visible = false;

            lvFiles.BeginUpdate();

            // Load files
            PS3CDReader cdReader = await TaskEx.Run(() => new PS3CDReader(irdFile.Header));

            foreach (var dmi in cdReader.Members.Where(d => d.IsFile).Distinct())
            {
                ListViewItem itm = new ListViewItem(dmi.Path);
                KeyValuePair <long, byte[]> h = irdFile.FileHashes.FirstOrDefault(f => f.Key == dmi.StartSector);
                itm.SubItems.Add(dmi.StartSector.ToString("X2"));
                itm.SubItems.Add(dmi.Length.ToString("X2"));
                itm.SubItems.Add(h.Value.AsString());
                lvFiles.Items.Add(itm);
            }

            lvFiles.EndUpdate();
            lblLoadingFiles.Visible = pbLoadingFiles.Visible = false;
            lvFiles.Visible         = true;
        }