Disk ARchive  2.5.5
Full featured and portable backup and archiving tool
libdar Directory Reference

Files

file  archive.hpp [code]
 the archive class is defined in this module
 
file  archive_options.hpp [code]
 this file contains a set of classes used to transmit options to archive operation
 
file  archive_version.hpp [code]
 class archive_version that rules which archive format to follow
 
file  cache.hpp [code]
 contains the cache class
 
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_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_tools.hpp [code]
 set of routines used by catalogue related classes
 
file  cat_tube.hpp [code]
 class to record named pipes in a catalogue
 
file  catalogue.hpp [code]
 here is defined the many classed which is build of the catalogue
 
file  compile_time_features.hpp [code]
 nested namespace containing routines that give features activated at compile time
 
file  compressor.hpp [code]
 compression engine implementation
 
file  crc.hpp [code]
 class crc definition, used to handle Cyclic Redundancy Checks
 
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  cygwin_adapt.hpp [code]
 thin adaptation layer to Cygwin specifities
 
file  data_tree.hpp [code]
 two classes used to store tree information in dar_manager databases
 
file  database.hpp [code]
 this file holds the database class definition
 
file  database_header.hpp [code]
 defines the database structure in file
 
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  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_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_local.hpp [code]
 class fichier_global definition. This is a full implementation/inherited class of class fichier_global this type of object are generated by entrepot_local.
 
file  filesystem.hpp [code]
 defines several classes that realize the interface with the filesystem
 
file  filesystem_specific_attribute.hpp [code]
 filesystem specific attributes
 
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_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  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  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  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_allocator.hpp [code]
 this is the base class of object that can provide dynamically allocated memory blocks
 
file  mem_cluster.hpp [code]
 defines mem_cluster class that holds a fixed set of fixed size allocatable memory blocks
 
file  mem_sized.hpp [code]
 defines mem_sized class that holds a variable sized set of fixed sized blocks using class mem_cluster
 
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  memory_pool.hpp [code]
 class memory_pool allocates and recycles blocks of memory for better performances it is expected to be used with classes that inherit from class on_pool
 
file  messaging.hpp [code]
 messaging_decode and messaging_encode are used to insert messages in a flow if data blocks
 
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  on_pool.hpp [code]
 this is the base class of object that can be allocated on a memory pool
 
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  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  slave_thread.hpp [code]
 class slave_thread is runs a I/O operations on a given genercif_file in a separated thread
 
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]
 handle the statistic structure that gives a summary of treated files after each operatio
 
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.the class thread_cancellation implemented in this module permits to define checkpoints where is looked whether the current thread has been marked as to be canceled by the user The advantage of this class is that it then throws a Euser_abort exception which properly terminates the libdar operation in the thread freeing allocated memory and release mutex properly. Note that the thread is not canceled but libdar call in this thread returns as soon as a checkpoint is met during the execution.
 
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 between libdar and the user.Three classes are defined
 
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