/usr/include/libpar2/libpar2.h is in libpar2-dev 0.4-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | // This file is part of par2cmdline (a PAR 2.0 compatible file verification and
// repair tool). See http://parchive.sourceforge.net for details of PAR 2.0.
//
// Copyright (c) 2003 Peter Brian Clements
// Copyright (c) 2011 Andreas Moog
// par2cmdline is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// par2cmdline is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef __LIBPAR2_H__
#define __LIBPAR2_H__
#include <sigc++/sigc++.h>
#include "par2cmdline.h"
class LibPar2
{
public:
LibPar2(CommandLine* commandline);
~LibPar2(void);
Result PreProcess();
Result Process(bool dorepair);
sigc::signal<void, std::string> sig_filename;
sigc::signal<void, double> sig_progress;
sigc::signal<void, ParHeaders*> sig_headers;
sigc::signal<void, std::string, int, int> sig_done;
protected:
void signal_filename(std::string str);
void signal_progress(double value);
void signal_headers(ParHeaders* headers);
void signal_done(std::string filename, int blocks_available,
int blocks_total);
protected:
CommandLine* commandLine;
Par1Repairer* par1Repairer;
Par2Repairer* par2Repairer;
// Steps in verifying and repairing files:
/* // Load packets from the specified file */
/* bool LoadPacketsFromFile(string filename); */
/* // Finish loading a recovery packet */
/* bool LoadRecoveryPacket(DiskFile *diskfile, u64 offset, PACKET_HEADER &header); */
/* // Finish loading a file description packet */
/* bool LoadDescriptionPacket(DiskFile *diskfile, u64 offset, PACKET_HEADER &header); */
/* // Finish loading a file verification packet */
/* bool LoadVerificationPacket(DiskFile *diskfile, u64 offset, PACKET_HEADER &header); */
/* // Finish loading the main packet */
/* bool LoadMainPacket(DiskFile *diskfile, u64 offset, PACKET_HEADER &header); */
/* // Finish loading the creator packet */
/* bool LoadCreatorPacket(DiskFile *diskfile, u64 offset, PACKET_HEADER &header); */
/* // Load packets from other PAR2 files with names based on the original PAR2 file */
/* bool LoadPacketsFromOtherFiles(string filename); */
/* // Load packets from any other PAR2 files whose names are given on the command line */
/* bool LoadPacketsFromExtraFiles(const list<CommandLine::ExtraFile> &extrafiles); */
/* // Check that the packets are consistent and discard any that are not */
/* bool CheckPacketConsistency(void); */
/* // Use the information in the main packet to get the source files */
/* // into the correct order and determine their filenames */
/* bool CreateSourceFileList(void); */
/* // Determine the total number of DataBlocks for the recoverable source files */
/* // The allocate the DataBlocks and assign them to each source file */
/* bool AllocateSourceBlocks(void); */
/* // Create a verification hash table for all files for which we have not */
/* // found a complete version of the file and for which we have */
/* // a verification packet */
/* bool PrepareVerificationHashTable(void); */
/* // Compute the table for the sliding CRC computation */
/* bool ComputeWindowTable(void); */
/* // Attempt to verify all of the source files */
/* bool VerifySourceFiles(void); */
/* // Scan any extra files specified on the command line */
/* bool VerifyExtraFiles(const list<CommandLine::ExtraFile> &extrafiles); */
/* // Attempt to match the data in the DiskFile with the source file */
/* bool VerifyDataFile(DiskFile *diskfile, Par2RepairerSourceFile *sourcefile); */
/* // Perform a sliding window scan of the DiskFile looking for blocks of data that */
/* // might belong to any of the source files (for which a verification packet was */
/* // available). If a block of data might be from more than one source file, prefer */
/* // the one specified by the "sourcefile" parameter. If the first data block */
/* // found is for a different source file then "sourcefile" is changed accordingly. */
/* bool ScanDataFile(DiskFile *diskfile, // [in] The file being scanned */
/* Par2RepairerSourceFile* &sourcefile, // [in/out] The source file matched */
/* MatchType &matchtype, // [out] The type of match */
/* MD5Hash &hashfull, // [out] The full hash of the file */
/* MD5Hash &hash16k, // [out] The hash of the first 16k */
/* u32 &count); // [out] The number of blocks found */
/* // Find out how much data we have found */
/* void UpdateVerificationResults(void); */
/* // Check the verification results and report the results */
/* bool CheckVerificationResults(void); */
/* // Rename any damaged or missnamed target files. */
/* bool RenameTargetFiles(void); */
/* // Work out which files are being repaired, create them, and allocate */
/* // target DataBlocks to them, and remember them for later verification. */
/* bool CreateTargetFiles(void); */
/* // Work out which data blocks are available, which need to be copied */
/* // directly to the output, and which need to be recreated, and compute */
/* // the appropriate Reed Solomon matrix. */
/* bool ComputeRSmatrix(void); */
/* // Allocate memory buffers for reading and writing data to disk. */
/* bool AllocateBuffers(size_t memorylimit); */
/* // Read source data, process it through the RS matrix and write it to disk. */
/* bool ProcessData(u64 blockoffset, size_t blocklength); */
/* // Verify that all of the reconstructed target files are now correct */
/* bool VerifyTargetFiles(void); */
/* // Delete all of the partly reconstructed files */
/* bool DeleteIncompleteTargetFiles(void); */
/* protected: */
/* CommandLine::NoiseLevel noiselevel; // OnScreen display */
/* string searchpath; // Where to find files on disk */
/* bool firstpacket; // Whether or not a valid packet has been found. */
/* MD5Hash setid; // The SetId extracted from the first packet. */
/* map<u32, RecoveryPacket*> recoverypacketmap; // One recovery packet for each exponent value. */
/* MainPacket *mainpacket; // One copy of the main packet. */
/* CreatorPacket *creatorpacket; // One copy of the creator packet. */
/* DiskFileMap diskFileMap; */
/* map<MD5Hash,Par2RepairerSourceFile*> sourcefilemap;// Map from FileId to SourceFile */
/* vector<Par2RepairerSourceFile*> sourcefiles; // The source files */
/* vector<Par2RepairerSourceFile*> verifylist; // Those source files that are being repaired */
/* u64 blocksize; // The block size. */
/* u64 chunksize; // How much of a block can be processed. */
/* u32 sourceblockcount; // The total number of blocks */
/* u32 availableblockcount; // How many undamaged blocks have been found */
/* u32 missingblockcount; // How many blocks are missing */
/* bool blocksallocated; // Whether or not the DataBlocks have been allocated */
/* vector<DataBlock> sourceblocks; // The DataBlocks that will be read from disk */
/* vector<DataBlock> targetblocks; // The DataBlocks that will be written to disk */
/* u32 windowtable[256]; // Table for sliding CRCs */
/* u32 windowmask; // Maks for sliding CRCs */
/* bool blockverifiable; // Whether and files can be verified at the block level */
/* VerificationHashTable verificationhashtable; // Hash table for block verification */
/* list<Par2RepairerSourceFile*> unverifiablesourcefiles; // Files that are not block verifiable */
/* u32 completefilecount; // How many files are fully verified */
/* u32 renamedfilecount; // How many files are verified but have the wrong name */
/* u32 damagedfilecount; // How many files exist but are damaged */
/* u32 missingfilecount; // How many files are completely missing */
/* vector<DataBlock*> inputblocks; // Which DataBlocks will be read from disk */
/* vector<DataBlock*> copyblocks; // Which DataBlocks will copied back to disk */
/* vector<DataBlock*> outputblocks; // Which DataBlocks have to calculated using RS */
/* ReedSolomon<Galois16> rs; // The Reed Solomon matrix. */
/* void *inputbuffer; // Buffer for reading DataBlocks (chunksize) */
/* void *outputbuffer; // Buffer for writing DataBlocks (chunksize * missingblockcount) */
/* u64 progress; // How much data has been processed. */
/* u64 totaldata; // Total amount of data to be processed. */
/* }; */
};
#endif // __LIBPAR2_H__
|