void DoWork()
        {
            IOpticalMediaImage opticalMediaImage = inputFormat as IOpticalMediaImage;
            bool formatHasTracks = false;

            if (opticalMediaImage != null)
            {
                try { formatHasTracks = opticalMediaImage.Tracks?.Count > 0; }
                catch { formatHasTracks = false; }
            }

            // Setup progress bars
            Application.Instance.Invoke(() =>
            {
                stkProgress.Visible   = true;
                prgProgress.MaxValue  = 1;
                prgProgress2.MaxValue = (int)(inputFormat.Info.Sectors / SECTORS_TO_READ);

                if (formatHasTracks && chkChecksumTracks.Checked == true && opticalMediaImage != null)
                {
                    prgProgress.MaxValue += opticalMediaImage.Tracks.Count;
                }
                else
                {
                    prgProgress.MaxValue = 2;
                    prgProgress2.Visible = false;
                    lblProgress2.Visible = false;
                }
            });

            EnableChecksum enabledChecksums = new EnableChecksum();

            if (chkAdler32.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Adler32;
            }
            if (chkCrc16.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Crc16;
            }
            if (chkCrc32.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Crc32;
            }
            if (chkCrc64.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Crc64;
            }
            if (chkMd5.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Md5;
            }
            if (chkSha1.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Sha1;
            }
            if (chkSha256.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Sha256;
            }
            if (chkSha384.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Sha384;
            }
            if (chkSha512.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Sha512;
            }
            if (chkSpamsum.Checked == true)
            {
                enabledChecksums |= EnableChecksum.SpamSum;
            }
            if (chkFletcher16.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Fletcher16;
            }
            if (chkFletcher32.Checked == true)
            {
                enabledChecksums |= EnableChecksum.Fletcher32;
            }

            Checksum mediaChecksum = null;

            TreeGridItemCollection trackHashes = new TreeGridItemCollection();
            TreeGridItemCollection mediaHashes = new TreeGridItemCollection();

            if (opticalMediaImage != null)
            {
                try
                {
                    Checksum trackChecksum = null;

                    if (chkChecksumMedia.Checked == true)
                    {
                        mediaChecksum = new Checksum(enabledChecksums);
                    }

                    ulong previousTrackEnd = 0;

                    foreach (Track currentTrack in opticalMediaImage.Tracks)
                    {
                        Application.Instance.Invoke(() =>
                        {
                            lblProgress.Text =
                                $"Hashing track {currentTrack.TrackSequence} of {opticalMediaImage.Tracks.Count}";
                            prgProgress.Value++;
                        });

                        if (currentTrack.TrackStartSector - previousTrackEnd != 0 && chkChecksumMedia.Checked == true)
                        {
                            for (ulong i = previousTrackEnd + 1; i < currentTrack.TrackStartSector; i++)
                            {
                                ulong sector = i;
                                Application.Instance.Invoke(() =>
                                {
                                    prgProgress2.Value = (int)(sector / SECTORS_TO_READ);
                                    lblProgress2.Text  = $"Hashing track-less sector {sector}";
                                });

                                byte[] hiddenSector = opticalMediaImage.ReadSector(i);

                                mediaChecksum?.Update(hiddenSector);
                            }
                        }

                        DicConsole.DebugWriteLine("Checksum command",
                                                  "Track {0} starts at sector {1} and ends at sector {2}",
                                                  currentTrack.TrackSequence, currentTrack.TrackStartSector,
                                                  currentTrack.TrackEndSector);

                        if (chkChecksumTracks.Checked == true)
                        {
                            trackChecksum = new Checksum(enabledChecksums);
                        }

                        ulong sectors     = currentTrack.TrackEndSector - currentTrack.TrackStartSector + 1;
                        ulong doneSectors = 0;

                        while (doneSectors < sectors)
                        {
                            if (cancel)
                            {
                                Application.Instance.Invoke(() =>
                                {
                                    btnClose.Visible = true;
                                    btnStart.Visible = false;
                                    btnStop.Visible  = false;
                                });
                                return;
                            }

                            byte[] sector;

                            if (sectors - doneSectors >= SECTORS_TO_READ)
                            {
                                sector = opticalMediaImage.ReadSectors(doneSectors, SECTORS_TO_READ,
                                                                       currentTrack.TrackSequence);

                                ulong doneSectorsToInvoke = doneSectors;
                                Application.Instance.Invoke(() =>
                                {
                                    prgProgress2.Value = (int)(doneSectorsToInvoke / SECTORS_TO_READ);
                                    lblProgress2.Text  =
                                        $"Hashings sectors {doneSectorsToInvoke} to {doneSectorsToInvoke + SECTORS_TO_READ} of track {currentTrack.TrackSequence}";
                                });

                                doneSectors += SECTORS_TO_READ;
                            }
                            else
                            {
                                sector = opticalMediaImage.ReadSectors(doneSectors, (uint)(sectors - doneSectors),
                                                                       currentTrack.TrackSequence);

                                ulong doneSectorsToInvoke = doneSectors;
                                Application.Instance.Invoke(() =>
                                {
                                    prgProgress2.Value = (int)(doneSectorsToInvoke / SECTORS_TO_READ);
                                    lblProgress2.Text  =
                                        $"Hashings sectors {doneSectorsToInvoke} to {doneSectorsToInvoke + (sectors - doneSectorsToInvoke)} of track {currentTrack.TrackSequence}";
                                });

                                doneSectors += sectors - doneSectors;
                            }

                            if (chkChecksumMedia.Checked == true)
                            {
                                mediaChecksum?.Update(sector);
                            }

                            if (chkChecksumTracks.Checked == true)
                            {
                                trackChecksum?.Update(sector);
                            }
                        }

                        if (chkChecksumTracks.Checked == true)
                        {
                            if (trackChecksum != null)
                            {
                                foreach (ChecksumType chk in trackChecksum.End())
                                {
                                    trackHashes.Add(new TreeGridItem
                                    {
                                        Values = new object[]
                                        {
                                            currentTrack.TrackSequence, chk.type, chk.Value
                                        }
                                    });
                                }
                            }
                        }

                        previousTrackEnd = currentTrack.TrackEndSector;
                    }

                    if (opticalMediaImage.Info.Sectors - previousTrackEnd != 0 && chkChecksumMedia.Checked == true)
                    {
                        for (ulong i = previousTrackEnd + 1; i < opticalMediaImage.Info.Sectors; i++)
                        {
                            ulong sector = i;
                            Application.Instance.Invoke(() =>
                            {
                                prgProgress2.Value = (int)(sector / SECTORS_TO_READ);
                                lblProgress2.Text  = $"Hashing track-less sector {sector}";
                            });

                            byte[] hiddenSector = opticalMediaImage.ReadSector(i);
                            mediaChecksum?.Update(hiddenSector);
                        }
                    }

                    if (chkChecksumMedia.Checked == true)
                    {
                        if (mediaChecksum != null)
                        {
                            foreach (ChecksumType chk in mediaChecksum.End())
                            {
                                mediaHashes.Add(new TreeGridItem {
                                    Values = new object[] { chk.type, chk.Value }
                                });
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    DicConsole.DebugWriteLine("Could not get tracks because {0}", ex.Message);
                    DicConsole.WriteLine("Unable to get separate tracks, not checksumming them");
                }
            }
            else
            {
                Application.Instance.Invoke(() => { stkProgress1.Visible = false; });
                mediaChecksum = new Checksum(enabledChecksums);

                ulong doneSectors = 0;

                while (doneSectors < inputFormat.Info.Sectors)
                {
                    if (cancel)
                    {
                        Application.Instance.Invoke(() =>
                        {
                            btnClose.Visible = true;
                            btnStart.Visible = false;
                            btnStop.Visible  = false;
                        });
                        return;
                    }

                    byte[] sector;

                    if (inputFormat.Info.Sectors - doneSectors >= SECTORS_TO_READ)
                    {
                        sector = inputFormat.ReadSectors(doneSectors, SECTORS_TO_READ);

                        ulong doneSectorsToInvoke = doneSectors;
                        Application.Instance.Invoke(() =>
                        {
                            prgProgress2.Value = (int)(doneSectorsToInvoke / SECTORS_TO_READ);
                            lblProgress2.Text  =
                                $"Hashings sectors {doneSectorsToInvoke} to {doneSectorsToInvoke + SECTORS_TO_READ}";
                        });
                        doneSectors += SECTORS_TO_READ;
                    }
                    else
                    {
                        sector = inputFormat.ReadSectors(doneSectors, (uint)(inputFormat.Info.Sectors - doneSectors));
                        ulong doneSectorsToInvoke = doneSectors;
                        Application.Instance.Invoke(() =>
                        {
                            prgProgress2.Value = (int)(doneSectorsToInvoke / SECTORS_TO_READ);
                            lblProgress2.Text  =
                                $"Hashings sectors {doneSectorsToInvoke} to {doneSectorsToInvoke + (inputFormat.Info.Sectors - doneSectorsToInvoke)}";
                        });
                        doneSectors += inputFormat.Info.Sectors - doneSectors;
                    }

                    mediaChecksum.Update(sector);
                }

                foreach (ChecksumType chk in mediaChecksum.End())
                {
                    mediaHashes.Add(new TreeGridItem {
                        Values = new object[] { chk.type, chk.Value }
                    });
                }
            }

            if (chkChecksumTracks.Checked == true)
            {
                Application.Instance.Invoke(() =>
                {
                    grpTrackChecksums.Text    = "Track checksums:";
                    stkTrackChecksums.Visible = true;

                    treeTrackChecksums.Columns.Add(new GridColumn
                    {
                        HeaderText = "Track", DataCell = new TextBoxCell(0)
                    });
                    treeTrackChecksums.Columns.Add(new GridColumn
                    {
                        HeaderText = "Algorithm", DataCell = new TextBoxCell(1)
                    });
                    treeTrackChecksums.Columns.Add(new GridColumn {
                        HeaderText = "Hash", DataCell = new TextBoxCell(2)
                    });

                    treeTrackChecksums.AllowMultipleSelection = false;
                    treeTrackChecksums.ShowHeader             = true;
                    treeTrackChecksums.DataStore = trackHashes;
                });
            }

            if (chkChecksumMedia.Checked == true)
            {
                Application.Instance.Invoke(() =>
                {
                    grpMediaChecksums.Text    = "Media checksums:";
                    stkMediaChecksums.Visible = true;

                    treeMediaChecksums.Columns.Add(new GridColumn
                    {
                        HeaderText = "Algorithm", DataCell = new TextBoxCell(0)
                    });
                    treeMediaChecksums.Columns.Add(new GridColumn {
                        HeaderText = "Hash", DataCell = new TextBoxCell(1)
                    });

                    treeMediaChecksums.AllowMultipleSelection = false;
                    treeMediaChecksums.ShowHeader             = true;
                    treeMediaChecksums.DataStore = mediaHashes;
                });
            }

            Statistics.AddCommand("checksum");

            Application.Instance.Invoke(() =>
            {
                stkOptions.Visible  = false;
                stkResults.Visible  = true;
                stkProgress.Visible = false;
                btnStart.Visible    = false;
                btnStop.Visible     = false;
                btnClose.Visible    = true;
            });
        }
示例#2
0
 private static Task <IpBin> GetIpData(IOpticalMediaImage opticalImage, Partition partition)
 {
     return(Task.Run(() => GetIpData(opticalImage.ReadSector(partition.Start))));
 }