Disk ARchive
2.4.2
|
00001 /*********************************************************************/ 00002 // dar - disk archive - a backup/restoration program 00003 // Copyright (C) 2002-2052 Denis Corbin 00004 // 00005 // This program is free software; you can redistribute it and/or 00006 // modify it under the terms of the GNU General Public License 00007 // as published by the Free Software Foundation; either version 2 00008 // of the License, or (at your option) any later version. 00009 // 00010 // This program is distributed in the hope that it will be useful, 00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 // GNU General Public License for more details. 00014 // 00015 // You should have received a copy of the GNU General Public License 00016 // along with this program; if not, write to the Free Software 00017 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00018 // 00019 // to contact the author : http://dar.linux.free.fr/email.html 00020 /*********************************************************************/ 00021 // $Id: escape.hpp,v 1.25 2011/04/17 18:43:39 edrusb Rel $ 00022 // 00023 /*********************************************************************/ 00024 00040 00041 00042 #ifndef ESCAPE_HPP 00043 #define ESCAPE_HPP 00044 00045 #include "../my_config.h" 00046 00047 extern "C" 00048 { 00049 #if HAVE_LIMITS_H 00050 #include <limits.h> 00051 #endif 00052 } 00053 00054 #include <set> 00055 00056 #include "generic_file.hpp" 00057 00058 #define ESCAPE_FIXED_SEQUENCE_NORMAL 0xAD 00059 #define ESCAPE_FIXED_SEQUENCE_SPARSE_FILE 0xAE 00060 00061 #define MAX_BUFFER_SIZE 204800 00062 #ifdef SSIZE_MAX 00063 #if SSIZE_MAX < MAX_BUFFER_SIZE 00064 #undef MAX_BUFFER_SIZE 00065 #define MAX_BUFFER_SIZE SSIZE_MAX 00066 #endif 00067 #endif 00068 00069 namespace libdar 00070 { 00071 00074 00075 class escape : public generic_file 00076 { 00077 public: 00078 enum sequence_type 00079 { 00080 seqt_undefined, //< not enough data to define the type of the escape sequence 00081 seqt_not_a_sequence, //< to escape data corresponding to an escape sequence's fixed byte sequence 00082 seqt_file, //< placed before inode information, eventually followed by file data 00083 seqt_ea, //< placed before EA data 00084 seqt_catalogue, //< placed before the archive's internal catalogue 00085 seqt_data_name, //< placed before the archive data_name (at the beginning of the archive) 00086 seqt_file_crc, //< placed before the CRC of file's data 00087 seqt_ea_crc, //< placed before the CRC of file's EA 00088 seqt_changed, //< placed before new copy of file's data if file's data changed while reading it for backup 00089 seqt_dirty, //< placed after data CRC if file is dirty 00090 seqt_failed_backup //< placed after inode information if the file could not be openned at backup time 00091 }; 00092 00093 // the archive layout of marks is : 00094 // ... <seqt_file> <inode> [<file data> [<seqt_changed> <new copy of data> [...] ] <seqt_file_crc> <CRC>[<seqt_dirty>]] [<seqt_ea> <EA> <sqt_ea_crc> <CRC>] ... 00095 // this previous sequence that we will call <SEQ> is repeated for each file, then on the overall archive we have : 00096 // <seqt_data_name> <data_name> <SEQ> ... <SEQ> <seqt_catalogue> <catalogue> <terminator> 00097 00098 // the provided "below" object must exist during the whole live of the escape object, the escape object does not own this "below" object 00099 // it must be destroyed by the caller/creator of the escape object. 00100 00101 00102 // constructors & destructors 00103 00104 escape(generic_file *below, //< "Below" is the generic file that holds the escaped data 00105 const std::set<sequence_type> & x_unjumpable); //< a set of marks that can never been jumped over when skipping for the next mark of a any given type. 00106 escape(const escape & ref) : generic_file(ref) { copy_from(ref); }; 00107 const escape & operator = (const escape & ref); 00108 ~escape(); 00109 00110 // escape specific routines 00111 00112 void add_mark_at_current_position(sequence_type t); 00113 00115 00120 bool skip_to_next_mark(sequence_type t, bool jump); 00121 bool next_to_read_is_mark(sequence_type t); 00122 bool next_to_read_is_which_mark(sequence_type & t); 00123 00124 void add_unjumpable_mark(sequence_type t) { if(is_terminated()) throw SRC_BUG; unjumpable.insert(t); }; 00125 void remove_unjumpable_mark(sequence_type t); 00126 bool is_unjumpable_mark(sequence_type t) const { return unjumpable.find(t) != unjumpable.end(); }; 00127 void clear_all_unjumpable_marks() { unjumpable.clear(); }; 00128 00129 // generic_file inherited routines 00130 // NOTA: Nothing is done to prevent skip* operation to put the read cursor in the middle of an escape sequence and 00131 // thus incorrectly consider it as normal data. Such event should only occure upon archive corruption and will be detected 00132 // by checksum mechanisms. 00133 00134 bool skip(const infinint & pos); 00135 bool skip_to_eof(); 00136 bool skip_relative(S_I x); 00137 infinint get_position(); 00138 00139 generic_file *get_below() const { return x_below; }; 00140 00141 protected: 00142 U_I inherited_read(char *a, U_I size); 00143 void inherited_write(const char *a, U_I size); 00144 void inherited_sync_write() { flush_write(); }; 00145 void inherited_terminate() { flush_or_clean(); }; 00146 00147 void change_fixed_escape_sequence(unsigned char value) { fixed_sequence[0] = value; }; 00148 bool has_escaped_data_since_last_skip() const { return escaped_data_count_since_last_skip > 0; }; 00149 00150 private: 00151 00152 //-- constants 00153 00155 static const U_I ESCAPE_SEQUENCE_LENGTH = 6; 00156 static const U_I WRITE_BUFFER_SIZE = 2*ESCAPE_SEQUENCE_LENGTH; 00157 static const U_I READ_BUFFER_SIZE = MAX_BUFFER_SIZE; 00158 00160 00166 static const unsigned char usual_fixed_sequence[ESCAPE_SEQUENCE_LENGTH]; 00167 00168 //-- variables 00169 00170 generic_file *x_below; //< the generic_file in which we read/write escaped data from/to the object is not owned by "this" 00171 U_I write_buffer_size; //< amount of data in write transit not yet written to "below" (may have to be escaped) 00172 char write_buffer[WRITE_BUFFER_SIZE]; //< data in write transit, all data is unescaped, up to the first real mark, after it, data is raw (may be escaped) 00173 //< the first real mark is pointed to by escape_seq_offset_in_buffer 00174 U_I read_buffer_size; //< amount of data in write transit, read from below, but not yet unescaped and returned to the upper layer 00175 U_I already_read; //< data in buffer that has already returned to the upper layer 00176 bool read_eof; //< whether we reached a escape sequence while reading data 00177 U_I escape_seq_offset_in_buffer; //< location of the first escape sequence which is not a data sequence 00178 char read_buffer[READ_BUFFER_SIZE]; //< data in read transit 00179 std::set<sequence_type> unjumpable; //< list of mark that cannot be jumped over when searching for the next mark 00180 unsigned char fixed_sequence[ESCAPE_SEQUENCE_LENGTH]; // the preambule of an escape sequence to use/search for 00181 infinint escaped_data_count_since_last_skip; 00182 00183 //-- routines 00184 00185 void set_fixed_sequence_for(sequence_type t) { fixed_sequence[ESCAPE_SEQUENCE_LENGTH - 1] = type2char(t); }; 00186 void check_below() { if(x_below == NULL) throw SRC_BUG; }; 00187 void clean_data() { read_buffer_size = already_read = escape_seq_offset_in_buffer = 0; }; //< drops all in-transit data 00188 void flush_write(); //< write down to "below" all in-transit data 00189 void flush_or_clean() 00190 { 00191 switch(get_mode()) 00192 { 00193 case gf_read_only: 00194 clean_data(); 00195 break; 00196 case gf_write_only: 00197 flush_write(); 00198 break; 00199 default: 00200 throw SRC_BUG; 00201 } 00202 }; 00203 void copy_from(const escape & ref); 00204 bool mini_read_buffer(); //< returns true if it could end having at least ESCAPE_SEQUENCE_LENGTH bytes in read_buffer, false else (EOF reached). 00205 00206 //-- static routine(s) 00207 00208 // some convertion routines 00209 static char type2char(sequence_type x); 00210 static sequence_type char2type(char x); 00211 00213 00215 00218 static U_I trouve_amorce(const char *a, U_I size, const unsigned char escape_sequence[ESCAPE_SEQUENCE_LENGTH]); 00219 00221 00228 static U_I remove_data_marks_and_stop_at_first_real_mark(char *a, U_I size, U_I & delta, const unsigned char escape_sequence[ESCAPE_SEQUENCE_LENGTH]); 00229 }; 00230 00232 00233 } // end of namespace 00234 00235 #endif