|
file | archive_version.hpp |
| class archive_version that rules which archive format to follow
|
|
file | cache.hpp |
| contains the cache class
|
|
file | catalogue.hpp |
| here is defined the many classed which is build of the catalogue
|
|
file | compressor.hpp |
| compression engine implementation
|
|
file | crc.hpp |
| class crc definition, used to handle Cyclic Redundancy Checks
|
|
file | crypto.hpp |
| the crypto algoritm definition
|
|
file | cygwin_adapt.hpp |
| thin adaptation layer to Cygwin specifities
|
|
file | data_tree.hpp |
| two classes used to store tree information in dar_manager databases
|
|
|
file | defile.hpp |
| here is defined the defile class
|
|
file | ea.hpp |
| contains a set of routines to manage EA values associated to a file
|
|
file | ea_filesystem.hpp |
| filesystem dependent Extended Attributes operationsThis file contains a set of routines used to manipulate (read, write or test the presence of) Extended Attributes
|
|
file | elastic.hpp |
| here is defined the elastic class
|
|
file | erreurs_ext.hpp |
| contains some additional exception class thrown by libdar
|
|
file | escape.hpp |
| class escape definition, used for sequential reading of archivesThe class escape is used to insert escape sequences before each new file's data in an archive. The normal file's data is also rewritten if it contains such an escape sequence for it does not collide with real escape sequences At reading time, this class revert backs modification done to file's data containing escape sequences for they contain the original data. This class also provides the feature to skip to the next (real) escape sequence. This class inherits of generic files and its objects are to be used in a stack of generic file's objects. The object below contains modified data and escape sequences, the file over gets the normal file data and does never see escape sequences. Expected implementation is to have a compressor above an escape object and a sar or scrambler/blowfish/... object above it.
|
|
file | escape_catalogue.hpp |
| class escape_catalogue definition. Used for sequential writing to archives, as well as several other inherited classes from catalogue.hppThis class inherits from the class catalogue and implements the pre_add(...) method, which role is to add an escape sequence followed by an entry dump (usually used at the end of archive is the so called catalogue part of the archive. This sequence followed by entry dump is added before each file's data all along the archive. Other inherited classes, implement the escape specific part, used when performing sequential reading of the catalogue
|
|
file | etage.hpp |
| definition of the etage structure is done here
|
|
file | fichier.hpp |
| class fichier definition. This is a full implementation of a generic_file applied to a plain file
|
|
file | filesystem.hpp |
| defines several classes that realize the interface with the filesystem
|
|
file | filtre.hpp |
| here is all the core routines for the operations
|
|
file | generic_file.hpp |
| class generic_file is defined here as well as class fichierthe generic_file interface is widely used in libdar it defines the standard way of transmitting data between different part of the library
|
|
file | hash_fichier.hpp |
| class hash_fichier definition.This is an inherited class from class fichier Objects of that class are write-only objects that provide a hash of the written data other hash algorithm may be added in the future
|
|
|
|
file | infinint.hpp |
| switch module to limitint (32 ou 64 bits integers) or infinint
|
|
file | int_tools.hpp |
| elementary operation for infinint integers
|
|
file | integers.hpp |
| are defined here basic integer types that tend to be portable
|
|
file | label.hpp |
| define the datastructure "label" used to identify slice membership to an archive
|
|
file | limitint.hpp |
| the reviewed implementation of infinint based on system limited integersthe limitint template class implementation defined in this module can handle positive integers and detect overflow. It shares with infinint the same interface, so it can be use in place of it, but throw Elimitint exceptions if overflow is detected.
|
|
file | macro_tools.hpp |
| macroscopic tools for libdar internals
|
|
file | mem_ui.hpp |
| class mem_ui definition. This class is to be used as parent class to handle user_interaction object management
|
|
file | memory_file.hpp |
| Memory_file is a generic_file class that only uses virtual memory.
|
|
file | nls_swap.hpp |
| provides a set of macro to change the NLS from user application domaine to libdar domain and viceversa
|
|
file | null_file.hpp |
| /dev/null type file implementation under the generic_file interfacethis class is used in particular when doing dry-run execution
|
|
file | pile.hpp |
| class pile definition. Used to manage a stack of generic_file objects
|
|
file | real_infinint.hpp |
| the original infinint class implementationthe infinint class implementation defined in this module can handle arbitrary large positive integer numbers
|
|
file | sar.hpp |
| the sar class holds all the slicing feature
|
|
file | sar_tools.hpp |
| a set of tools aims to help Segmentation And Reassemblement (sar) class
|
|
file | scrambler.hpp |
| contains the definition of the scrambler class, a very weak encryption scheme
|
|
file | secu_string.hpp |
| this file contains the definition of secu_string class, a std::string like class but allocated in secure memorysecure memory is a allocated memory that is never swapped out (wrote to disk) the implementation relies on gcrypt_malloc_secure() call (libgcrypt) rather than relying on mlock()/munlock() posix system call. as the need for secure string is for strong encryption, there is no much interest in re-inventing the wheel as the need is dependent on gcrypt availability
|
|
file | semaphore.hpp |
| definition of class semaphore, used to manage invocation of backup hook for files
|
|
file | sparse_file.hpp |
| class sparse_file definition, used to handle holes in filesthis class is used to receive plain file's data to be written to the archive or to be read out from an archive. The class uses escape sequences to replace holes in files (long serie of zeros) by the number of zeros preceeded by a escape sequence mark. this class internally uses an escape object, with a modifed fixed escape sequence that optimizes the use of sparse_file objects with other escape objects.
|
|
file | special_alloc.hpp |
| re-definition of new and delete class operatorthis is a set of macro that makes the new and delete operator for a class be re-defined in a way that allocation is done in big chunks at the system level, and is split in small requested pieces for a given object allocation. This bring some performance improvment, because a lot a small objects that live and die toghether have to be allocated.
|
|
file | storage.hpp |
| contains a class that permits arbitrary large data storage
|
|
file | string_file.hpp |
| emulate a generic_file from a string of characters
|
|
file | terminateur.hpp |
| the terminateur class which defines the position of the cataloguethe terminateur is a byte sequence present as the last bytes of an archive which indicates how much byte backward libdar must skip back to find the beginning of the catalogue.
|
|
file | tlv.hpp |
| Generic Type Length Value data structures.
|
|
file | tlv_list.hpp |
| List of Generic Type Length Value data structures.
|
|
file | tronc.hpp |
| defines a limited segment over another generic_file.This is used to read a part of a file as if it was a real file generating end of file behavior when reaching the given length.
|
|
file | tronconneuse.hpp |
| defines a block structured file.Mainly used for strong encryption.
|
|
file | trontextual.hpp |
| class trontextual is a contextual variant of class tronc
|
|
file | tuyau.hpp |
| defines the implementation of pipe under the generic_file interface.mainly used between zapette and slave_zapette, this is a full implementation of the generic_file interface that takes care of dead lock when two pipes needs to be openned between the same two entities, each having one for reading and the other for writing.
|
|
file | user_group_bases.hpp |
| defines class that speed up the uid to username and gid to group name lookup
|
|
file | wrapperlib.hpp |
| libz and libbz2 wrapper to have identical interface to these libraries.libz and libbz2 library differ in several in the way they return values in certain circumpstances. This module defines the wrapperlib class that make their use homogeneous.
|
|
file | zapette.hpp |
| remote control between dar and dar_slave.Two classes are defined in this module
|
|
|
bool | libdar::compatible_signature (unsigned char a, unsigned char b) |
|
unsigned char | libdar::mk_signature (unsigned char base, saved_status state) |
|
unsigned char | libdar::get_base_signature (unsigned char a) |
|
compression | libdar::char2compression (char a) |
|
crc * | libdar::create_crc_from_file (generic_file &f, bool old=false) |
|
crc * | libdar::create_crc_from_size (infinint width) |
|
void | libdar::crypto_split_algo_pass (const secu_string &all, crypto_algo &algo, secu_string &pass) |
|
generic_file * | libdar::database_header_create (user_interaction &dialog, const std::string &filename, bool overwrite) |
| create the header for a dar_manager database More...
|
|
ea_attributs * | libdar::ea_filesystem_read_ea (const std::string &chemin, const mask &filter) |
| read EA associated to a given file More...
|
|
void | libdar::filtre_restore (user_interaction &dialog, const mask &filtre, const mask &subtree, catalogue &cat, const path &fs_racine, bool fs_warn_overwrite, bool info_details, statistics &st, const mask &ea_mask, bool flat, inode::comparison_fields what_to_check, bool warn_remove_no_match, bool empty, bool display_skipped, bool empty_dir, const crit_action &x_overwrite, archive_options_extract::t_dirty dirty, bool only_deleted, bool not_deleted) |
|
gf_mode | libdar::generic_file_get_mode (S_I fd) |
|
const char * | libdar::generic_file_get_name (gf_mode mode) |
|
std::string | libdar::hash_algo_to_string (hash_algo algo) |
|
void | libdar::header_version::read (generic_file &f) |
|
void | libdar::header_version::write (generic_file &f) |
|
void | libdar::int_tools_swap_bytes (unsigned char &a, unsigned char &b) |
|
void | libdar::int_tools_swap_bytes (unsigned char *a, U_I size) |
|
void | libdar::int_tools_expand_byte (unsigned char a, int_tools_bitfield &bit) |
|
void | libdar::int_tools_contract_byte (const int_tools_bitfield &b, unsigned char &a) |
|
template<class T > |
T | libdar::int_tools_rotate_right_one_bit (T v) |
|
template<class T > |
T | libdar::int_tools_maxof_agregate (T unused) |
|
| libdar::limitint< B >::limitint (size_t a=0) |
|
| libdar::limitint< B >::limitint (user_interaction &dialog, S_I fd) |
|
| libdar::limitint< B >::limitint (generic_file &x) |
|
void | libdar::limitint< B >::dump (user_interaction &dialog, S_I fd) const |
|
void | libdar::limitint< B >::dump (generic_file &x) const |
|
void | libdar::limitint< B >::read (generic_file &f) |
|
limitint & | libdar::limitint< B >::operator+= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator-= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator*= (const limitint &ref) |
|
template<class T > |
limitint | libdar::limitint< B >::power (const T &exponent) const |
|
limitint & | libdar::limitint< B >::operator/= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator%= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator&= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator|= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator^= (const limitint &ref) |
|
limitint & | libdar::limitint< B >::operator>>= (U_32 bit) |
|
limitint & | libdar::limitint< B >::operator>>= (limitint bit) |
|
limitint & | libdar::limitint< B >::operator<<= (U_32 bit) |
|
limitint & | libdar::limitint< B >::operator<<= (limitint bit) |
|
limitint | libdar::limitint< B >::operator++ (int a) |
|
limitint | libdar::limitint< B >::operator-- (int a) |
|
limitint & | libdar::limitint< B >::operator++ () |
|
limitint & | libdar::limitint< B >::operator-- () |
|
U_32 | libdar::limitint< B >::operator% (U_32 arg) const |
|
template<class T > |
void | libdar::limitint< B >::unstack (T &v) |
|
limitint | libdar::limitint< B >::get_storage_size () const |
|
unsigned char | libdar::limitint< B >::operator[] (const limitint &position) const |
|
bool | libdar::limitint< B >::operator< (const limitint &x) const |
|
bool | libdar::limitint< B >::operator== (const limitint &x) const |
|
bool | libdar::limitint< B >::operator> (const limitint &x) const |
|
bool | libdar::limitint< B >::operator<= (const limitint &x) const |
|
bool | libdar::limitint< B >::operator!= (const limitint &x) const |
|
bool | libdar::limitint< B >::operator>= (const limitint &x) const |
|
static bool | libdar::limitint< B >::is_system_big_endian () |
|
B | libdar::limitint< B >::debug_get_max () const |
|
B | libdar::limitint< B >::debug_get_bytesize () const |
|
template<class B > |
limitint< B > | libdar::operator+ (const limitint< B > &, const limitint< B > &) |
|
template<class B > |
limitint< B > | libdar::operator+ (const limitint< B > &a, U_I b) |
|
template<class B > |
limitint< B > | libdar::operator- (const limitint< B > &, const limitint< B > &) |
|
template<class B > |
limitint< B > | libdar::operator- (const limitint< B > &a, U_I b) |
|
template<class B > |
limitint< B > | libdar::operator* (const limitint< B > &, const limitint< B > &) |
|
template<class B > |
limitint< B > | libdar::operator* (const limitint< B > &a, U_I b) |
|
template<class B > |
limitint< B > | libdar::operator/ (const limitint< B > &, const limitint< B > &) |
|
template<class B > |
limitint< B > | libdar::operator/ (const limitint< B > &a, U_I b) |
|
template<class B > |
limitint< B > | libdar::operator% (const limitint< B > &, const limitint< B > &) |
|
template<class B > |
limitint< B > | libdar::operator>> (const limitint< B > &a, U_32 bit) |
|
template<class B > |
limitint< B > | libdar::operator>> (const limitint< B > &a, const limitint< B > &bit) |
|
template<class B > |
limitint< B > | libdar::operator<< (const limitint< B > &a, U_32 bit) |
|
template<class B > |
limitint< B > | libdar::operator<< (const limitint< B > &a, const limitint< B > &bit) |
|
template<class B > |
limitint< B > | libdar::operator& (const limitint< B > &a, U_32 bit) |
|
template<class B > |
limitint< B > | libdar::operator& (const limitint< B > &a, const limitint< B > &bit) |
|
template<class B > |
limitint< B > | libdar::operator| (const limitint< B > &a, U_32 bit) |
|
template<class B > |
limitint< B > | libdar::operator| (const limitint< B > &a, const limitint< B > &bit) |
|
template<class B > |
limitint< B > | libdar::operator^ (const limitint< B > &a, U_32 bit) |
|
template<class B > |
limitint< B > | libdar::operator^ (const limitint< B > &a, const limitint< B > &bit) |
|
template<class T > |
void | libdar::euclide (T a, T b, T &q, T &r) |
|
template<class B > |
void | libdar::euclide (limitint< B > a, U_I b, limitint< B > &q, limitint< B > &r) |
|
std::string | libdar::sar_make_filename (const std::string &base_name, const infinint &num, const infinint &min_digits, const std::string &ext) |
| return the name of a slice given the base_name, slice number and extension
|
|
trivial_sar * | libdar::sar_tools_open_archive_tuyau (user_interaction &dialog, S_I fd, gf_mode mode, const label &data_name, bool slice_header_format_07, const std::string &execute) |
| create an container to write a archive to a pipe
|
|
template<class T > |
bool | libdar::pile::pop_and_close_if_type_is (T *ptr) |
|
template<class T > |
void | libdar::pile::find_first_from_top (T *&ref) |
|
template<class T > |
void | libdar::pile::find_first_from_bottom (T *&ref) |
| this template is similar to the template "find_first_from_top" except that the search is started from the bottom of the stack
|
|
Symbols that are not to be used by external software.
never use threses symboles (function, macro, variables, types, etc.) they are not intended to be used by external programs and may change or disapear without any warning or backward compatibility. Some are however documented for libdar development ease.