![]() |
Disk ARchive
2.6.1
Full featured and portable backup and archiving tool
|
Files | |
file | archive.hpp [code] |
the archive class is defined in this module | |
file | archive5.hpp [code] |
API v5 backward compatible class archive. | |
file | archive_aux.hpp [code] |
set of datastructures used to interact with a catalogue object | |
file | archive_listing_callback.hpp [code] |
definition of the user defined callback function used for archive listing | |
file | archive_num.hpp [code] |
class storing the position of an archive inside a database | |
file | archive_options.hpp [code] |
this file contains a set of classes used to transmit options to archive operation | |
file | archive_options5.hpp [code] |
API v5 compatible archive_options_* classes. | |
file | archive_options_listing_shell.hpp [code] |
this file contains shell_interaction options class for listing | |
file | archive_summary.hpp [code] |
datastructure returned by archive::summary_data | |
file | archive_version.hpp [code] |
class archive_version that rules which archive format to follow | |
file | cache.hpp [code] |
contains the cache class | |
file | cache_global.hpp [code] |
adaptation of the cache class to the fichier_global interface | |
file | candidates.hpp [code] |
helper class for class data_tree to find the list of archive to restore for a given file | |
file | capabilities.hpp [code] |
provide information about current thread (underlying using the widthdrawn POSIX.1e API) | |
file | cat_all_entrees.hpp [code] |
include file gathering all entree found in a catalogue | |
file | cat_blockdev.hpp [code] |
class used to record block special devices in a catalogue | |
file | cat_chardev.hpp [code] |
class used to record character special devices in a catalogue | |
file | cat_delta_signature.hpp [code] |
class used to manage binary delta signature in catalogue and archive | |
file | cat_detruit.hpp [code] |
used to record information in a catalogue about a deleted file (differential backup context) | |
file | cat_device.hpp [code] |
parent class for all special devices inodes | |
file | cat_directory.hpp [code] |
class used to organize objects in tree in catalogue as like directories in a filesystem | |
file | cat_door.hpp [code] |
class used in a catalogue to store solaris door filesystem entries | |
file | cat_entree.hpp [code] |
base class for all object contained in a catalogue | |
file | cat_eod.hpp [code] |
object exchanged with a catalogue (never stored in it) to signal the end of a directory | |
file | cat_etoile.hpp [code] |
class holding an cat_inode object that get pointed by multiple mirage objects (smart pointers) to record hard links in a catalogue | |
file | cat_file.hpp [code] |
class used to record plain files in a catalogue | |
file | cat_ignored.hpp [code] |
class used to remember that an entry has been ignored and shall not be recorded as deleted using a detruit object in a catalogue | |
file | cat_ignored_dir.hpp [code] |
class used to remember in a catalogue that a cat_directory has been ignored | |
file | cat_inode.hpp [code] |
base object for all inode types, managed EA and FSA, dates, permissions, ownership, ... | |
file | cat_lien.hpp [code] |
class used to store symbolic links in a catalogue | |
file | cat_mirage.hpp [code] |
smart pointer to an etoile object. Used to store hard link information inside a catalogue | |
file | cat_nomme.hpp [code] |
base class of all objects contained in a catalogue and that can be named | |
file | cat_prise.hpp [code] |
class to record filesystem (UNIX) sockets in a catalogue | |
file | cat_signature.hpp [code] |
class used to write and read from archive the type and status of each entry in a catalogue | |
file | cat_status.hpp [code] |
the different status of data and EA | |
file | cat_tube.hpp [code] |
class to record named pipes in a catalogue | |
file | catalogue.hpp [code] |
here is defined the classe used to manage catalogue of archives | |
file | compile_time_features.hpp [code] |
nested namespace containing routines that give features activated at compile time | |
file | compression.hpp [code] |
compression parameters for API | |
file | compressor.hpp [code] |
compression engine implementation | |
file | contextual.hpp [code] |
class contextual adds the information of phases in the generic_file | |
file | crc.hpp [code] |
class crc definition, used to handle Cyclic Redundancy Checks | |
file | crit_action.hpp [code] |
contains classes that let the user define the policy for overwriting files | |
file | criterium.hpp [code] |
contains classes that let the user define the policy for overwriting files | |
file | crypto.hpp [code] |
the crypto algoritm definition | |
file | crypto_asym.hpp [code] |
the asymetric cryptographical algoritms relying on gpgme | |
file | crypto_sym.hpp [code] |
class crypto_sym for symetrical cipherings | |
file | cygwin_adapt.h [code] |
thin C adaptation layer to Cygwin specifities | |
file | cygwin_adapt.hpp [code] |
thin C++ adaptation layer to Cygwin specifities | |
file | data_dir.hpp [code] |
classes used to store directory tree information in dar_manager databases | |
file | data_tree.hpp [code] |
base classes used to store entree information in dar_manager databases | |
file | database.hpp [code] |
this file holds the database class definition | |
file | database5.hpp [code] |
this file holds the database class definition as defined in API version 5 | |
file | database_archives.hpp [code] |
this file stores the list of archives a database has been built from. it is part of the database header | |
file | database_aux.hpp [code] |
set of datastructures used to interact with a database object | |
file | database_header.hpp [code] |
defines the database structure in file | |
file | database_listing_callback.hpp [code] |
definition of the user defined callback function used for database listing | |
file | database_options.hpp [code] |
this file holds the options for database operations | |
file | datetime.hpp [code] |
this file contains the definition of class datetime that stores unix times in a portable way | |
file | deci.hpp [code] |
manages the decimal representation of infinint | |
file | defile.hpp [code] |
here is defined the defile class | |
file | ea.hpp [code] |
contains a set of routines to manage EA values associated to a file | |
file | ea_filesystem.hpp [code] |
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 [code] |
here is defined the elastic class | |
file | entree_stats.hpp [code] |
datastructure holding the nature of file present in a given archive | |
file | entrepot.hpp [code] |
defines the entrepot interface. Entrepot interface defines a generic way to interact with files (slices) on a filesystem. It is used to instanciate file-like objects (from class inherited from class fichier_global, in order to read or write data to such file. The entrepot_local and fichier_local classes are the only one classes available from libdar to implement the entrepot and fichier classes interfaces respectively. External applications like webdar can implement entrepot_ftp and fichier_ftp classes to provide transparent access to dar backup localted on a remote ftp server. More can follow in the future. | |
file | entrepot_libcurl.hpp [code] |
defines the implementation for remote filesystem entrepot using libcurl | |
file | entrepot_libcurl5.hpp [code] |
defines the implementation for remote filesystem entrepot using libcurl | |
file | entrepot_local.hpp [code] |
defines the implementation for local filesystem entrepot The entrepot_local is the only implementation of an entrepot class present in libdar. It correspond to local filesystems. The reason of existence of the entrepot stuff is to allow external application like webdar to drop/read slices over the network using FTP protocol for example. External applications only have to define Their own implementation of the entrepot interface and file-like objects they generates (inherited from class fichier_global), libdar uses them throught the generic interface. This avoids having network related stuff inside libdar, which for security reason and functions/roles separation would not be a good idea | |
file | erreurs.hpp [code] |
contains all the excetion class thrown by libdar | |
file | erreurs_ext.hpp [code] |
contains some additional exception class thrown by libdar | |
file | escape.hpp [code] |
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 [code] |
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 [code] |
definition of the etage structure is done here | |
file | fichier_global.hpp [code] |
class fichier_global definition. This class is a pure virtual class class fichier_global is an abstraction of files objects whatever is their localisation like local filesystem, remote ftp server, etc. inherited classes (like fichier_local) provide full implementation | |
file | fichier_libcurl.hpp [code] |
class fichier_libcurl definition. This is a full implementation/inherited class of class fichier_global this type of object are generated by entrepot_libcurl. | |
file | fichier_local.hpp [code] |
class fichier_local definition. This is a full implementation/inherited class of class fichier_global this type of object are generated by entrepot_local. | |
file | filesystem_backup.hpp [code] |
filesystem_backup class realizes the interface with the filesystem for backing up | |
file | filesystem_diff.hpp [code] |
class filesystem_diff makes a flow of inode to feed the difference filter routine | |
file | filesystem_hard_link_read.hpp [code] |
filesystem_hard_link_read classes manages hardlinked inode read from filesystem | |
file | filesystem_hard_link_write.hpp [code] |
class filesystem_hard_link_write keeps trace of already written inode to restore hard links | |
file | filesystem_restore.hpp [code] |
class filesystem_restores create inodes from a flow of libdar objects | |
file | filesystem_specific_attribute.hpp [code] |
filesystem specific attributes | |
file | filesystem_tools.hpp [code] |
a set of tools used by filesystem_* classes | |
file | filtre.hpp [code] |
here is all the core routines for the operations | |
file | fsa_family.hpp [code] |
filesystem specific attributes available families and fsa_scope definition | |
file | generic_file.hpp [code] |
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 | generic_file_overlay_for_gpgme.hpp [code] |
adaptation class from gpgme data buffer to libdar generic_file interface | |
file | generic_rsync.hpp [code] |
class generic_rsync provides a generic_file interface to librsync | |
file | generic_thread.hpp [code] |
class generic_thread provides a way to interact with a generic_file ran in an other thread | |
file | generic_to_global_file.hpp [code] |
this class provides an fichier_global interface for any type of generic_file object | |
file | get_version.hpp [code] |
routine to initialize libdar and manage its running threads | |
file | gf_mode.hpp [code] |
generic modes to open file | |
file | hash_fichier.hpp [code] |
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 | header.hpp [code] |
slice header structure is defined here | |
file | header_version.hpp [code] |
archive global header/trailer structure is defined here | |
file | i_archive.hpp [code] |
the archive class implementation is defined in this module | |
file | i_database.hpp [code] |
this file holds the definition of class database implementation (pimpl idiom) | |
file | i_entrepot_libcurl.hpp [code] |
defines the implementation for remote filesystem entrepot using libcurl | |
file | i_libdar_xform.hpp [code] |
API for dar_xform functionnality. | |
file | infinint.hpp [code] |
switch module to limitint (32 ou 64 bits integers) or infinint | |
file | int_tools.hpp [code] |
elementary operation for infinint integers | |
file | integers.hpp [code] |
are defined here basic integer types that tend to be portable | |
file | label.hpp [code] |
define the datastructure "label" used to identify slice membership to an archive | |
file | libdar.hpp [code] |
the main file of the libdar API definitions | |
file | libdar5.hpp [code] |
backward compatibility to libdar API 5 | |
file | libdar_slave.hpp [code] |
API for dar_slave functionnality. | |
file | libdar_xform.hpp [code] |
API for dar_xform functionnality. | |
file | limitint.hpp [code] |
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 | list_entry.hpp [code] |
class of objects describing an entry in the archive, used by archive::get_children_in_table | |
file | macro_tools.hpp [code] |
macroscopic tools for libdar internals | |
file | mask.hpp [code] |
here lies a collection of mask classes | |
file | mask_list.hpp [code] |
here lies a mask that selects files present in a given listThe mask_list classes defined here is to be used for filtering files in the libdar API calls. | |
file | mem_ui.hpp [code] |
class mem_ui definition. This class is to be used as parent class to handle user_interaction object management | |
file | memory_file.hpp [code] |
Memory_file is a generic_file class that only uses virtual memory. | |
file | messaging.hpp [code] |
messaging_decode and messaging_encode are used to insert messages in a flow of data blocks | |
file | mycurl_easyhandle_node.hpp [code] |
used to optimize session creation done by libcurl | |
file | mycurl_easyhandle_sharing.hpp [code] |
used to optimize network session establised by libcurl | |
file | mycurl_protocol.hpp [code] |
datastructure defining the network protocols available for entrepot_libcurl class | |
file | mycurl_shared_handle.hpp [code] |
structure used to optimize network session creation done by libcurl | |
file | nls_swap.hpp [code] |
provides a set of macro to change the NLS from user application domaine to libdar domain and viceversa | |
file | null_file.hpp [code] |
/dev/null type file implementation under the generic_file interfacethis class is used in particular when doing dry-run execution | |
file | op_tools.hpp [code] |
contains tools helper for overwriting policy management | |
file | path.hpp [code] |
here is the definition of the path classthe path class handle path and provide several operation on them | |
file | pile.hpp [code] |
class pile definition. Used to manage a stack of generic_file objects | |
file | pile_descriptor.hpp [code] |
optimization structure to quickly access some commonly used layers of a stack of generic_file | |
file | proto_generic_file.hpp [code] |
precursor class of generic_file used to avoid cyclic dependencies with storage and infinint | |
file | range.hpp [code] |
class than provide a way to manipulate and represent range of integer numbers (infinint) | |
file | real_infinint.hpp [code] |
the original infinint class implementationthe infinint class implementation defined in this module can handle arbitrary large positive integer numbers | |
file | sar.hpp [code] |
the sar and trivial_sar classes, they manage the slicing layer | |
file | sar_tools.hpp [code] |
a set of tools aims to help Segmentation And Reassemblement (sar) class | |
file | scrambler.hpp [code] |
contains the definition of the scrambler class, a very weak encryption scheme | |
file | secu_memory_file.hpp [code] |
secu_memory_file is a generic_file class that only uses secured memory (not swappable and zeroed after use) | |
file | secu_string.hpp [code] |
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 [code] |
definition of class semaphore, used to manage invocation of backup hook for files | |
file | shell_interaction.hpp [code] |
user_interaction class used by default | |
file | shell_interaction_emulator.hpp [code] |
wrapper class that given a user_interaction send it the shell_interaction formatted output | |
file | slave_thread.hpp [code] |
class slave_thread is runs a I/O operations on a given generic_file in a separated thread | |
file | slave_zapette.hpp [code] |
remote control for dar_slave.Two objects communicates as in peer to each other: | |
file | slice_layout.hpp [code] |
object describing the slicing of an archive | |
file | smart_pointer.hpp [code] |
template class implementing memory efficient smart pointer | |
file | sparse_file.hpp [code] |
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 | statistics.hpp [code] |
class handling access to the data summary of treated files after and during each operation | |
file | storage.hpp [code] |
contains a class that permits arbitrary large data storage | |
file | terminateur.hpp [code] |
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 | thread_cancellation.hpp [code] |
to be able to cancel libdar operation while running in a given thread. | |
file | tlv.hpp [code] |
Generic Type Length Value data structures. | |
file | tlv_list.hpp [code] |
List of Generic Type Length Value data structures. | |
file | tools.hpp [code] |
a set of general purpose routines | |
file | trivial_sar.hpp [code] |
the trivial_sar classes manages the slicing layer when single slice is used | |
file | tronc.hpp [code] |
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 [code] |
defines a block structured file.Mainly used for strong encryption. | |
file | trontextual.hpp [code] |
class trontextual is a contextual variant of class tronc | |
file | tuyau.hpp [code] |
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 [code] |
defines class that speed up the uid to username and gid to group name lookup | |
file | user_interaction.hpp [code] |
defines the interaction interface between libdar and users. | |
file | user_interaction5.hpp [code] |
API v5 backward compatible class user_interaction. | |
file | user_interaction_blind.hpp [code] |
defines the interaction between libdar and a non communcant "blind" user | |
file | user_interaction_callback.hpp [code] |
defines the interaction between libdar and the user based on callback functionsThree classes are defined | |
file | user_interaction_callback5.hpp [code] |
API v5 backward compatible user_interaction_callback class. | |
file | wrapperlib.hpp [code] |
libz and libbz2 wrapper to have identical interface to these libraries.libz and libbz2 library differ in the way they return values in certain circumpstances. This module defines the wrapperlib class that make their use homogeneous. | |
file | zapette.hpp [code] |
remote control between dar and dar_slave.Two classes are defined in this module | |
file | zapette_protocol.hpp [code] |
protocol management between archive and libdar_slave classes | |