Disk ARchive  2.6.2
Full featured and portable backup and archiving tool
catalogue.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2019 Denis Corbin
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 //
19 // to contact the author : http://dar.linux.free.fr/email.html
20 /*********************************************************************/
21 
25 
26 #ifndef CATALOGUE_HPP
27 #define CATALOGUE_HPP
28 
29 #include "../my_config.h"
30 
31 extern "C"
32 {
33 #if HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 } // end extern "C"
37 
38 #include "infinint.hpp"
39 #include "path.hpp"
40 #include "integers.hpp"
41 #include "mask.hpp"
42 #include "user_interaction.hpp"
43 #include "label.hpp"
44 #include "escape.hpp"
45 #include "datetime.hpp"
46 #include "slice_layout.hpp"
47 #include "cat_entree.hpp"
48 #include "cat_nomme.hpp"
49 #include "cat_directory.hpp"
50 #include "mem_ui.hpp"
51 
52 namespace libdar
53 {
54 
57 
59  class catalogue: public mem_ui
60  {
61  public :
62  catalogue(const std::shared_ptr<user_interaction> & ui,
63  const datetime & root_last_modif,
64  const label & data_name);
65  catalogue(const std::shared_ptr<user_interaction> & ui,
66  const pile_descriptor & pdesc,
67  const archive_version & reading_ver,
68  compression default_algo,
69  bool lax,
70  const label & lax_layer1_data_name, // ignored unless in lax mode, in lax mode unless it is a cleared label, forces the catalogue label to be equal to the lax_layer1_data_name for it be considered a plain internal catalogue, even in case of corruption
71  bool only_detruit = false); // if set to true, only directories and detruit objects are read from the archive
72  catalogue(const catalogue & ref) : mem_ui(ref), out_compare(ref.out_compare) { partial_copy_from(ref); };
73  catalogue(catalogue && ref) = delete;
74  catalogue & operator = (const catalogue &ref);
75  catalogue & operator = (catalogue && ref) = delete;
76  virtual ~catalogue() { detruire(); };
77 
78 
79  // reading methods. The reading is iterative and uses the current_read cat_directory pointer
80 
81  virtual void reset_read() const; // set the reading cursor to the beginning of the catalogue
82  virtual void end_read() const; // set the reading cursor to the end of the catalogue
83  virtual void skip_read_to_parent_dir() const;
84  // skip all items of the current dir and of any subdir, the next call will return
85  // next item of the parent dir (no cat_eod to exit from the current dir !)
86  virtual bool read(const cat_entree * & ref) const;
87  // sequential read (generates cat_eod) and return false when all files have been read
88  virtual bool read_if_present(std::string *name, const cat_nomme * & ref) const;
89  // pseudo-sequential read (reading a directory still
90  // implies that following read are located in this subdirectory up to the next EOD) but
91  // it returns false if no entry of this name are present in the current directory
92  // a call with nullptr as first argument means to set the current dir the parent directory
93  void remove_read_entry(std::string & name);
94  // in the currently read directory, removes the entry which name is given in argument
95  const cat_directory & get_current_reading_dir() const { if(current_read == nullptr) throw SRC_BUG; return *current_read; };
96  // remove from the catalogue all the entries that have not yet been read
97  // by read().
98  virtual void tail_catalogue_to_current_read();
99 
100 
101  void reset_sub_read(const path &sub); // initialise sub_read to the given directory
102  bool sub_read(user_interaction & ui, const cat_entree * &ref); // sequential read of the catalogue, ignoring all that
103  // is not part of the subdirectory specified with reset_sub_read
104  // the read include the inode leading to the sub_tree as well as the pending cat_eod
105 
106  // return true if the last read entry has already been read
107  // and has not to be counted again. This is never the case for catalogue but may occure
108  // with escape_catalogue (where from the 'virtual').
109  // last this method gives a valid result only if the last read() entry is a directory as
110  // only directory may be read() twice.
111  virtual bool read_second_time_dir() const { return false; };
112 
113 
114  // Additions methods. The addition is also iterative but uses its specific current_add directory pointer
115 
116  void reset_add();
117 
119  // real implementation is only needed in escape_catalogue class, here there nothing to be done
120  virtual void pre_add(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
121  virtual void pre_add_ea(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
122  virtual void pre_add_crc(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
123  virtual void pre_add_dirty( const pile_descriptor* dest = nullptr) const {};
124  virtual void pre_add_ea_crc(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
125  virtual void pre_add_waste_mark(const pile_descriptor* dest = nullptr) const {};
126  virtual void pre_add_failed_mark(const pile_descriptor* dest = nullptr) const {};
127  virtual void pre_add_fsa(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
128  virtual void pre_add_fsa_crc(const cat_entree *ref, const pile_descriptor* dest = nullptr) const {};
129  virtual void pre_add_delta_sig(const pile_descriptor* dest = nullptr) const {};
130  virtual escape *get_escape_layer() const { return nullptr; };
131  virtual void drop_escape_layer() {};
132 
133  void add(cat_entree *ref); // add at end of catalogue (sequential point of view)
134  void re_add_in(const std::string &subdirname); // return into an already existing subdirectory for further addition
135  void re_add_in_replace(const cat_directory &dir); // same as re_add_in but also set the properties of the existing directory to those of the given argument
136  void add_in_current_read(cat_nomme *ref); // add in currently read directory
137  const cat_directory & get_current_add_dir() const { if(current_add == nullptr) throw SRC_BUG; return *current_add; };
138 
139 
140 
141  // Comparison methods. The comparision is here also iterative and uses its specific current_compare directory pointer
142 
143  void reset_compare() const;
144  bool compare(const cat_entree * name, const cat_entree * & extracted) const;
145  // returns true if the ref exists, and gives it back in second argument as it is in the current catalogue.
146  // returns false is no entry of that nature exists in the catalogue (in the current directory)
147  // if ref is a directory, the operation is normaly relative to the directory itself, but
148  // such a call implies a chdir to that directory. thus, a call with an EOD is necessary to
149  // change to the parent directory.
150  // note :
151  // if a directory is not present, returns false, but records the inexistant subdirectory
152  // structure defined by the following calls to this routine, this to be able to know when
153  // the last available directory is back the current one when changing to parent directory,
154  // and then proceed with normal comparison of inode. In this laps of time, the call will
155  // always return false, while it temporary stores the missing directory structure
156 
157 
158 
159  // non interative methods
160 
161 
163 
166 
167 
169 
173  void update_absent_with(const catalogue & ref, infinint aborting_next_etoile);
174 
175 
177  void drop_all_non_detruits();
178 
180 
183  bool is_subset_of(const catalogue & ref) const;
184 
186  void reset_dump() const;
187 
189  void dump(const pile_descriptor & pdesc) const;
190 
191  entree_stats get_stats() const { return stats; };
192 
194  bool is_empty() const { if(contenu == nullptr) throw SRC_BUG; return contenu->is_empty(); };
195 
196  const cat_directory *get_contenu() const { return contenu; }; // used by data_tree
197 
198  const label & get_data_name() const { return ref_data_name; };
199  void set_data_name(const label & val) { ref_data_name = val; };
200 
201  datetime get_root_dir_last_modif() const { return contenu->get_last_modif(); };
202 
205 
208 
209  datetime get_root_mtime() const { return contenu->get_last_modif(); };
210 
212  void reset_all();
213 
214  void set_to_unsaved_data_and_FSA() { if(contenu == nullptr) throw SRC_BUG; contenu->recursively_set_to_unsaved_data_and_FSA(); };
215 
217  void change_location(const pile_descriptor & pdesc);
218 
220 
227  void transfer_delta_signatures(const pile_descriptor & destination,
228  bool sequential_read,
229  bool build,
230  const mask & delta_mask,
231  const infinint & delta_sig_min_size);
232 
234  void drop_delta_signatures();
235 
236  protected:
237  entree_stats & access_stats() { return stats; };
238  void copy_detruits_from(const catalogue & ref); // needed for escape_catalogue implementation only.
239 
240  const cat_eod * get_r_eod_address() const { return & r_eod; }; // cat_eod are never stored in the catalogue
241  // however it is sometimes required to return such a reference to a valid object
242  // owned by the catalogue.
243 
244 
247  void swap_stuff(catalogue & ref);
248 
249  private :
251  mutable path out_compare;
256  mutable signed int sub_count;
259 
260  void partial_copy_from(const catalogue &ref);
261  void detruire();
262 
263  static const cat_eod r_eod;
264  static const U_I CAT_CRC_SIZE;
265  };
266 
267 
268 
270 
271 } // end of namespace
272 
273 #endif
label ref_data_name
name of the archive where is located the data
Definition: catalogue.hpp:258
infinint update_destroyed_with(const catalogue &ref)
add into "this" detruit object corresponding to object of ref absent in "this"
base class of all objects contained in a catalogue and that can be named
void set_all_mirage_s_inode_wrote_field_to(bool val) const
recursive setting of mirage inode_wrote flag
Definition: catalogue.hpp:207
the generic class, parent of all masks
Definition: mask.hpp:61
class mem_ui definition. This class is to be used as parent class to handle user_interaction object m...
class used to organize objects in tree in catalogue as like directories in a filesystem ...
are defined here basic integer types that tend to be portable
the catalogue class which gather all objects contained in a give archive
Definition: catalogue.hpp:59
holds the statistics contents of a catalogue
mem_ui(const std::shared_ptr< user_interaction > &dialog)
constructor
the End of Directory entry class
Definition: cat_eod.hpp:45
void reset_all()
reset all pointers to the root (a bit better than reset_add() + reset_read() + reset_compare() + rese...
define the datastructure "label" used to identify slice membership to an archive
path * sub_tree
path to sub_tree
Definition: catalogue.hpp:255
path out_compare
stores the missing directory structure, when extracting
Definition: catalogue.hpp:251
static const cat_eod r_eod
needed to return eod reference, without taking risk of saturating memory
Definition: catalogue.hpp:263
This is a pure virtual class that is used by libdar when interaction with the user is required...
stores time information
Definition: datetime.hpp:58
entree_stats stats
statistics catalogue contents
Definition: catalogue.hpp:257
void swap_stuff(catalogue &ref)
void dump(const pile_descriptor &pdesc) const
write down the whole catalogue to file
void recursive_has_changed_update() const
ask recursive update for the recursive_has_changed field
void update_absent_with(const catalogue &ref, infinint aborting_next_etoile)
copy from ref missing files in "this" and mark then as "not_saved" (no change since reference) ...
object describing the slicing of an archive
virtual void pre_add(const cat_entree *ref, const pile_descriptor *dest=nullptr) const
catalogue extension routines for escape sequence
Definition: catalogue.hpp:120
the cat_directory inode class
defines the interaction interface between libdar and users.
here is the definition of the path classthe path class handle path and provide several operation on t...
class escape definition, used for sequential reading of archivesThe class escape is used to insert es...
void reset_dump() const
before dumping the catalogue, need to set all hardlinked inode they have not been saved once ...
void transfer_delta_signatures(const pile_descriptor &destination, bool sequential_read, bool build, const mask &delta_mask, const infinint &delta_sig_min_size)
copy delta signatures to the given stack and update the cat_file objects accordingly ...
the base class for all entry that have a name
Definition: cat_nomme.hpp:44
base class for all object contained in a catalogue
switch module to limitint (32 ou 64 bits integers) or infinint
here lies a collection of mask classes
compression
the different compression algorithm available
Definition: compression.hpp:45
this file contains the definition of class datetime that stores unix times in a portable way ...
void launch_recursive_has_changed_update() const
recursive evaluation of directories that have changed (make the cat_directory::get_recurisve_has_chan...
Definition: catalogue.hpp:204
cat_directory * current_compare
points to the current directory when extracting
Definition: catalogue.hpp:252
void drop_all_non_detruits()
remove/destroy from "this" all objects that are neither directory nor detruit objects ...
class mem_ui to keep a copy of a user_interaction object
Definition: mem_ui.hpp:54
manage label data structure used in archive slice headers
Definition: label.hpp:42
the arbitrary large positive integer class
class archive_version manages the version of the archive format
the root class from all other inherite for any entry in the catalogue
Definition: cat_entree.hpp:59
bool is_subset_of(const catalogue &ref) const
check whether all inode existing in the "this" and ref have the same attributes
bool is_empty() const
whether the catalogue is empty or not
Definition: catalogue.hpp:194
bool is_empty() const
whether this cat_directory is empty or not
void change_location(const pile_descriptor &pdesc)
change location where to find EA, FSA and DATA for all the objects of the catalogue ...
cat_directory * current_add
points to the directory where to add the next file with add_file;
Definition: catalogue.hpp:253
cat_directory * contenu
catalogue contents
Definition: catalogue.hpp:250
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:46
cat_directory * current_read
points to the directory where the next item will be read
Definition: catalogue.hpp:254
signed int sub_count
count the depth in of read routine in the sub_tree
Definition: catalogue.hpp:256
the class path is here to manipulate paths in the Unix notation: using&#39;/&#39;
Definition: path.hpp:50
void drop_delta_signatures()
remove delta signature from the catalogue object as if they had never been calculated ...