![]()  | 
  
    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  | |