This file is indexed.

/usr/include/libpar2/libpar2.h is in libpar2-dev 0.4-3ubuntu1.

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__