Disk ARchive  2.5.4
Full featured and portable backup and archiving tool
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
catalogue.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2052 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 "generic_file.hpp"
40 #include "path.hpp"
41 #include "compressor.hpp"
42 #include "integers.hpp"
43 #include "mask.hpp"
44 #include "user_interaction.hpp"
45 #include "label.hpp"
46 #include "escape.hpp"
47 #include "on_pool.hpp"
48 #include "datetime.hpp"
49 #include "slice_layout.hpp"
50 #include "mem_ui.hpp"
51 #include "cat_entree.hpp"
52 #include "cat_nomme.hpp"
53 #include "cat_directory.hpp"
54 
55 namespace libdar
56 {
57 
60 
62  class catalogue : protected mem_ui, public on_pool
63  {
64  public :
65  catalogue(const user_interaction & dialog,
66  const datetime & root_last_modif,
67  const label & data_name);
68  catalogue(const user_interaction & dialog,
69  const pile_descriptor & pdesc,
70  const archive_version & reading_ver,
71  compression default_algo,
72  bool lax,
73  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
74  bool only_detruit = false); //< if set to true, only directories and detruit objects are read from the archive
75  catalogue(const catalogue & ref) : mem_ui(ref), out_compare(ref.out_compare) { partial_copy_from(ref); };
76  const catalogue & operator = (const catalogue &ref);
77  virtual ~catalogue() { detruire(); };
78 
79 
80  // reading methods. The reading is iterative and uses the current_read cat_directory pointer
81 
82  virtual void reset_read() const; // set the reading cursor to the beginning of the catalogue
83  virtual void end_read() const; // set the reading cursor to the end of the catalogue
84  virtual void skip_read_to_parent_dir() const;
85  // skip all items of the current dir and of any subdir, the next call will return
86  // next item of the parent dir (no cat_eod to exit from the current dir !)
87  virtual bool read(const cat_entree * & ref) const;
88  // sequential read (generates cat_eod) and return false when all files have been read
89  virtual bool read_if_present(std::string *name, const cat_nomme * & ref) const;
90  // pseudo-sequential read (reading a directory still
91  // implies that following read are located in this subdirectory up to the next EOD) but
92  // it returns false if no entry of this name are present in the current directory
93  // a call with nullptr as first argument means to set the current dir the parent directory
94  void remove_read_entry(std::string & name);
95  // in the currently read directory, removes the entry which name is given in argument
96  const cat_directory & get_current_reading_dir() const { if(current_read == nullptr) throw SRC_BUG; return *current_read; };
97  // remove from the catalogue all the entries that have not yet been read
98  // by read().
99  void tail_catalogue_to_current_read();
100 
101 
102  void reset_sub_read(const path &sub); // initialise sub_read to the given directory
103  bool sub_read(const cat_entree * &ref); // sequential read of the catalogue, ignoring all that
104  // is not part of the subdirectory specified with reset_sub_read
105  // the read include the inode leading to the sub_tree as well as the pending cat_eod
106 
107  // return true if the last read entry has already been read
108  // and has not to be counted again. This is never the case for catalogue but may occure
109  // with escape_catalogue (where from the 'virtual').
110  // last this method gives a valid result only if the last read() entry is a directory as
111  // only directory may be read() twice.
112  virtual bool read_second_time_dir() const { return false; };
113 
114 
115  // Additions methods. The addition is also iterative but uses its specific current_add directory pointer
116 
117  void reset_add();
118 
120  // real implementation is only needed in escape_catalogue class, here there nothing to be done
121  virtual void pre_add(const cat_entree *ref) const {};
122  virtual void pre_add_ea(const cat_entree *ref) const {};
123  virtual void pre_add_crc(const cat_entree *ref) const {};
124  virtual void pre_add_dirty() const {};
125  virtual void pre_add_ea_crc(const cat_entree *ref) const {};
126  virtual void pre_add_waste_mark() const {};
127  virtual void pre_add_failed_mark() const {};
128  virtual void pre_add_fsa(const cat_entree *ref) const {};
129  virtual void pre_add_fsa_crc(const cat_entree *ref) const {};
130  virtual escape *get_escape_layer() const { return nullptr; };
131 
132  void add(cat_entree *ref); // add at end of catalogue (sequential point of view)
133  void re_add_in(const std::string &subdirname); // return into an already existing subdirectory for further addition
134  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
135  void add_in_current_read(cat_nomme *ref); // add in currently read directory
136  const cat_directory & get_current_add_dir() const { if(current_add == nullptr) throw SRC_BUG; return *current_add; };
137 
138 
139 
140  // Comparison methods. The comparision is here also iterative and uses its specific current_compare directory pointer
141 
142  void reset_compare() const;
143  bool compare(const cat_entree * name, const cat_entree * & extracted) const;
144  // returns true if the ref exists, and gives it back in second argument as it is in the current catalogue.
145  // returns false is no entry of that nature exists in the catalogue (in the current directory)
146  // if ref is a directory, the operation is normaly relative to the directory itself, but
147  // such a call implies a chdir to that directory. thus, a call with an EOD is necessary to
148  // change to the parent directory.
149  // note :
150  // if a directory is not present, returns false, but records the inexistant subdirectory
151  // structure defined by the following calls to this routine, this to be able to know when
152  // the last available directory is back the current one when changing to parent directory,
153  // and then proceed with normal comparison of inode. In this laps of time, the call will
154  // always return false, while it temporary stores the missing directory structure
155 
156 
157 
158  // non interative methods
159 
160 
164  infinint update_destroyed_with(const catalogue & ref);
165 
166 
172  void update_absent_with(const catalogue & ref, infinint aborting_next_etoile);
173 
174 
176  void drop_all_non_detruits();
177 
182  bool is_subset_of(const catalogue & ref) const;
183 
185  void reset_dump() const;
186 
188  void dump(const pile_descriptor & pdesc) const;
189 
190  void listing(bool isolated,
191  const mask &selection,
192  const mask & subtree,
193  bool filter_unsaved,
194  bool list_ea,
195  std::string marge) const;
196  void tar_listing(bool isolated,
197  const mask & selection,
198  const mask & subtree,
199  bool filter_unsaved,
200  bool list_ea,
201  std::string beginning) const;
202  void xml_listing(bool isolated,
203  const mask & selection,
204  const mask & subtree,
205  bool filter_unsaved,
206  bool list_ea,
207  std::string beginning) const;
208  void slice_listing(bool isolated,
209  const mask & selection,
210  const mask & subtree,
211  const slice_layout & slicing) const;
212 
213  entree_stats get_stats() const { return stats; };
214 
216  bool is_empty() const { if(contenu == nullptr) throw SRC_BUG; return contenu->is_empty(); };
217 
218  const cat_directory *get_contenu() const { return contenu; }; // used by data_tree
219 
220  const label & get_data_name() const { return ref_data_name; };
221  datetime get_root_dir_last_modif() const { return contenu->get_last_modif(); };
222 
225 
227  void set_all_mirage_s_inode_wrote_field_to(bool val) const { const_cast<cat_directory *>(contenu)->set_all_mirage_s_inode_wrote_field_to(val); };
228 
229  datetime get_root_mtime() const { return contenu->get_last_modif(); };
230 
232  void reset_all();
233 
234  void set_to_unsaved_data_and_FSA() { if(contenu == nullptr) throw SRC_BUG; contenu->recursively_set_to_unsaved_data_and_FSA(); };
235 
237  void change_location(const pile_descriptor & pdesc);
238 
239  protected:
240  entree_stats & access_stats() { return stats; };
241  void set_data_name(const label & val) { ref_data_name = val; };
242  void copy_detruits_from(const catalogue & ref); // needed for escape_catalogue implementation only.
243 
244  const cat_eod * get_r_eod_address() const { return & r_eod; }; // cat_eod are never stored in the catalogue
245  // however it is sometimes required to return such a reference to a valid object
246  // owned by the catalogue.
247 
248 
251  void swap_stuff(catalogue & ref);
252 
253  private :
254  cat_directory *contenu;
255  path out_compare;
256  cat_directory *current_compare;
257  cat_directory *current_add;
258  cat_directory *current_read;
259  path *sub_tree;
260  signed int sub_count;
261  entree_stats stats;
262  label ref_data_name;
263 
264  void partial_copy_from(const catalogue &ref);
265  void detruire();
266 
267  static const cat_eod r_eod; // needed to return eod reference, without taking risk of saturating memory
268  static const U_I CAT_CRC_SIZE;
269  };
270 
271 
272 
274 
275 } // end of namespace
276 
277 #endif