![]() |
Disk ARchive 2.8.1
Full featured and portable backup and archiving tool
|
Directory dependency graph for libdar:Files | |
| file | archive.hpp [code] |
| the archive class is defined in this module | |
| 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_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 | block_compressor.hpp [code] |
| provide per block compression/decompression independant from libthreadar but single threaded | |
| file | bzip2_module.hpp [code] |
| per block encryption using bzip2 algorithm/library | |
| 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 | compress_block_header.hpp [code] |
| block header used for compression per block | |
| file | compress_module.hpp [code] |
| provides abstracted interface of per-block compression/decompression | |
| file | compression.hpp [code] |
| compression parameters for API | |
| file | compressor.hpp [code] |
| compression engine implementation | |
| file | compressor_zstd.hpp [code] |
| streaming compression implementation for zstd algorithm | |
| 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_module.hpp [code] |
| per block cryptography implementation | |
| file | crypto_segment.hpp [code] |
| defines unit block of information ciphered as once | |
| 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 | 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 | delta_sig_block_size.hpp [code] |
| structure used to define how to select block size for delta signature | |
| 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 operations | |
| 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. | |
| file | entrepot_aux.hpp [code] |
| set of datastructures used to interact with entrepot objects | |
| file | entrepot_libcurl.hpp [code] |
| defines the implementation for remote filesystem entrepot using libcurl | |
| file | entrepot_libssh.hpp [code] |
| defines the implementation for libssh filesystem entrepot The entrepot_libssh correspond to the libssh filesystems. | |
| file | entrepot_local.hpp [code] |
| defines the implementation for local filesystem entrepot The entrepot_local correspond to the local filesystems. | |
| file | eols.hpp [code] |
| provide a way to detect the presence of string from a list of string in a byte flow | |
| 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 archives | |
| file | escape_catalogue.hpp [code] |
| class escape_catalogue definition. Used for sequential writing to archives, as well as several other inherited classes from catalogue.hpp | |
| 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_libssh.hpp [code] |
| class fichier_libssh definition. This is a full implementation/inherited class of class fichier_global this type of object are generated by entrepot_libssh. | |
| 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_ids.hpp [code] |
| gather the ids of different filesystem to provide a filter based on filesystem | |
| 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 fichier | |
| 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_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 | gzip_module.hpp [code] |
| per block encryption using gzip algorithm/library | |
| file | hash_fichier.hpp [code] |
| class hash_fichier definition. | |
| file | header.hpp [code] |
| slice header structure is defined here | |
| file | header_flags.hpp [code] |
| archive header flag field management | |
| file | header_version.hpp [code] |
| archive global header/trailer structure is defined here | |
| file | heap.hpp [code] |
| heap data structure (relying on FIFO) | |
| 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 | libdar_slave.hpp [code] |
| API for dar_slave functionnality. | |
| file | libdar_xform.hpp [code] |
| API for dar_xform functionnality. | |
| file | libssh_connection.hpp [code] |
| class holding libssh related data structure for an ssh and sftp session | |
| file | limitint.hpp [code] |
| the reviewed implementation of infinint based on system limited integers | |
| file | list_entry.hpp [code] |
| class of objects describing an entry in the archive, used by archive::get_children_in_table | |
| file | lz4_module.hpp [code] |
| per block encryption using LZ4 algorithm/library | |
| file | lzo_module.hpp [code] |
| per block encryption using LZO algorithm/library | |
| file | macro_tools.hpp [code] |
| macroscopic tools for libdar internals | |
| file | mask.hpp [code] |
| here lies a collection of mask classes | |
| file | mask_database.hpp [code] |
| mask_database class is a dar_manager database based mask class | |
| file | mask_list.hpp [code] |
| here lies a mask that selects files present in a given list | |
| file | mem_block.hpp [code] |
| structure to hold block of memory and manipulate in coherence with idexes and sizes | |
| 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 | 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_param_list.hpp [code] |
| wrapper for element a CURL* object can receive as parameter in order to be put in etherogeneous list | |
| file | mycurl_slist.hpp [code] |
| wrapper of the curl_slist struct to allow usual copy/move on C++ object | |
| 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 interface | |
| file | op_tools.hpp [code] |
| contains tools helper for overwriting policy management | |
| file | parallel_block_compressor.hpp [code] |
| provide per block and parallel compression/decompression | |
| file | parallel_tronconneuse.hpp [code] |
| defines a block structured file. | |
| file | path.hpp [code] |
| here is the definition of the path class | |
| 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_compressor.hpp [code] |
| abstracted ancestor class for compressor and parallel_compressor classes | |
| file | proto_generic_file.hpp [code] |
| precursor class of generic_file used to avoid cyclic dependencies with storage and infinint | |
| file | proto_tronco.hpp [code] |
| defines common interface for tronconneuse and parallel_tronconneuse | |
| 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 implementation | |
| file | remote_entrepot_api.hpp [code] |
| Libdar API to create entrepot objects. | |
| file | restore_tree.hpp [code] |
| restore_tree class stores archive location needed to restore files | |
| 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 memory | |
| 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_zapette.hpp [code] |
| remote control for dar_slave. | |
| 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 files | |
| 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 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. | |
| file | tronconneuse.hpp [code] |
| defines a block structured file. | |
| 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. | |
| file | tuyau_global.hpp [code] |
| seekable pipe on top of another fichier_global | |
| 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_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 functions | |
| file | wrapperlib.hpp [code] |
| libz and libbz2 wrapper to have identical interface to these libraries. | |
| file | xz_module.hpp [code] |
| per block encryption using xz algorithm/library | |
| file | zapette.hpp [code] |
| remote control between dar and dar_slave. | |
| file | zapette_protocol.hpp [code] |
| protocol management between archive and libdar_slave classes | |
| file | zstd_module.hpp [code] |
| per block encryption using zstd algorithm/library | |