tools.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2025 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/
 
 
 
#ifndef TOOLS_HPP
#define TOOLS_HPP
 
#include "../my_config.h"
 
extern "C"
{
#if HAVE_SIGNAL_H
#include <signal.h>
#endif
#if HAVE_GPGME_H
#include <gpgme.h>
#endif
}
 
#include <string>
#include <vector>
#include <deque>
#include <map>
#include <set>
#include <cstdarg>
#include "path.hpp"
#include "infinint.hpp"
#include "generic_file.hpp"
#include "integers.hpp"
#include "tlv_list.hpp"
#include "datetime.hpp"
#include "entrepot.hpp"
 
namespace libdar
{
 
 
 
    extern void tools_init();
    extern void tools_end();
 
 
    extern void tools_write_string(generic_file & f, const std::string & s);
 
 
    extern void tools_read_string(generic_file & f, std::string & s);
 
 
    extern void tools_write_string_all(generic_file & f, const std::string & s);
 
 
    extern void tools_read_string_size(generic_file & f, std::string & s, infinint taille);
 
 
    extern infinint tools_get_filesize(const path &p);
 
    extern std::string tools_display_integer_in_metric_system(infinint number, const std::string & unit, bool binary);
 
 
    extern std::string::iterator tools_find_last_char_of(std::string &s, unsigned char v);
 
 
    extern void tools_blocking_read(int fd, bool mode);
 
 
    extern std::string tools_name_of_uid(const infinint & uid);
 
 
    extern std::string tools_name_of_gid(const infinint & gid);
 
 
    extern std::string tools_uword2str(U_16 x);
 
 
    extern std::string tools_int2str(S_I x);
    extern std::string tools_uint2str(U_I x);
 
 
    extern std::string tools_addspacebefore(std::string s, U_I expected_size);
 
 
    extern std::string tools_display_date(const datetime & date, bool fully_detailed = false);
 
 
    extern char *tools_str2charptr(const std::string &x);
 
 
    extern U_I tools_str2int(const std::string & x);
 
 
    extern void tools_system(user_interaction & dialog, const std::vector<std::string> & argvector);
 
 
    extern void tools_system_with_pipe(const std::shared_ptr<user_interaction> & dialog,
                       const std::string & dar_cmd,
                       const std::vector<std::string> & argvpipe);
 
 
    extern void tools_write_vector(generic_file & f, const std::vector<std::string> & x);
 
 
    extern void tools_read_vector(generic_file & f, std::vector<std::string> & x);
 
 
    extern std::string tools_concat_vector(const std::string & separator,
                                           const std::vector<std::string> & x);
 
 
    std::vector<std::string> operator + (std::vector<std::string> a, std::vector<std::string> b);
 
 
 
    extern bool tools_is_equal_with_hourshift(const infinint & hourshift, const datetime & date1, const datetime & date2);
 
 
    template <class T> std::vector<T> operator +=(std::vector<T> & a, const std::vector<T> & b)
    {
        a = a + b;
        return a;
    }
 
 
 
 
    extern std::string tools_readlink(const char *root);
 
 
    extern void tools_noexcept_make_date(const std::string & chem, bool symlink, const datetime & last_acc, const datetime & last_mod, const datetime & birth);
 
 
    extern void tools_make_date(const std::string & chemin, bool symlink, const datetime & access, const datetime & modif, const datetime & birth);
 
 
    extern bool tools_is_case_insensitive_equal(const std::string & a, const std::string & b);
 
    extern void tools_to_upper(const std::string & r, std::string & uppered);
 
#if HAVE_WCTYPE_H
    extern void tools_to_wupper(std::wstring & r);
#endif
 
 
    extern std::string tools_printf(const char *format, ...);
 
 
    extern std::string tools_vprintf(const char *format, va_list ap);
 
 
    extern bool tools_do_some_files_match_mask_regex(const entrepot & ent,
                             const std::string & file_mask);
 
 
 
    extern void tools_unlink_file_mask_regex(user_interaction & dialog,
                         const entrepot & ent,
                         const std::string & file_mask,
                         bool info_details);
 
 
 
    extern void tools_avoid_slice_overwriting_regex(user_interaction & dialog,
                            const entrepot & ent,
                            const std::string & basename,
                            const std::string & extension,
                            bool info_details,
                            bool allow_overwriting,
                            bool warn_overwriting,
                            bool dry_run);
 
 
    extern bool tools_are_on_same_filesystem(const std::string & file1, const std::string & file2);
 
 
    extern path tools_relative2absolute_path(const path & src, const path & cwd);
 
 
    extern void tools_block_all_signals(sigset_t &old_mask);
 
 
    extern void tools_block_all_signals_except(const std::deque<int> & non_blocked, sigset_t &old_mask);
 
 
 
    extern void tools_set_back_blocked_signals(sigset_t old_mask);
 
 
    extern U_I tools_count_in_string(const std::string & s, const char a);
 
 
    extern datetime tools_get_mtime(user_interaction & dialog,
                    const std::string & s,
                    bool auto_zeroing,
                    bool silent,
                    const std::set<std::string> & ignored_as_symlink = std::set<std::string>());
 
 
    extern infinint tools_get_size(const std::string & s);
 
 
    extern infinint tools_get_extended_size(std::string s, U_I base);
 
 
    extern std::string tools_substitute(const std::string & hook,
                    const std::map<char, std::string> & corres);
 
 
 
    extern std::string tools_hook_substitute(const std::string & hook,
                         const std::string & path,
                         const std::string & basename,
                         const std::string & num,
                         const std::string & padded_num,
                         const std::string & ext,
                         const std::string & context,
                         const std::string & base_url);
 
 
 
    extern void tools_hook_execute(user_interaction & ui,
                   const std::string & cmd_line);
 
 
 
    extern void tools_hook_substitute_and_execute(user_interaction & ui,
                          const std::string & hook,
                          const std::string & path,
                          const std::string & basename,
                          const std::string & num,
                          const std::string & padded_num,
                          const std::string & ext,
                          const std::string & context,
                          const std::string & base_url);
 
 
 
    extern std::string tools_output2xml(const std::string & src);
 
 
    extern U_I tools_octal2int(const std::string & perm);
 
 
 
    extern std::string tools_int2octal(const U_I & perm);
 
 
    extern char tools_cast_type_to_unix_type(char type);
 
 
    extern std::string tools_get_permission_string(char type, U_32 perm, bool hard);
 
 
    extern void tools_set_permission(S_I fd, U_I perm);
 
 
    extern U_I tools_get_permission(S_I fd);
 
 
 
    extern uid_t tools_ownership2uid(const std::string & user);
 
 
    extern uid_t tools_ownership2gid(const std::string & group);
 
 
    extern void tools_set_ownership(S_I filedesc, const std::string & slice_user, const std::string & slice_group);
 
 
    extern void tools_memxor(void *dest, const void *src, U_I n);
 
 
    extern tlv_list tools_string2tlv_list(user_interaction & dialog, const U_16 & type, const std::vector<std::string> & data);
 
 
 
 
    extern U_I tools_pseudo_random(U_I max);
 
 
 
 
    template <class N, class B> std::deque<B> tools_number_base_decomposition_in_big_endian(N number, const B & base)
    {
    std::deque<B> ret;
 
    if(base <= 0)
        throw Erange("tools_number_decoupe_in_big_endian", "base must be strictly positive");
 
    while(number != 0)
    {
        ret.push_back(number % base);
        number /= base;
    }
 
    return ret;
    }
 
 
    extern std::string tools_unsigned_char_to_hexa(unsigned char x);
 
 
    extern std::string tools_string_to_hexa(const std::string & input);
 
    extern std::string tools_U_I_to_hexa(U_I x);
 
 
    extern infinint tools_file_size_to_crc_size(const infinint & size);
 
    extern std::string tools_getcwd();
 
    extern std::string tools_get_compression_ratio(const infinint & storage_size, const infinint & file_size, bool compressed);
 
    extern std::string tools_strerror_r(int errnum);
 
#ifdef GPGME_SUPPORT
    extern std::string tools_gpgme_strerror_r(gpgme_error_t err);
#endif
 
#if HAVE_WCHAR_H
    extern std::wstring tools_string_to_wstring(const std::string & val);
 
    extern std::string tools_wstring_to_string(const std::wstring & val);
#endif
 
    extern void tools_secu_string_show(user_interaction & dialog, const std::string & msg, const secu_string & key);
 
    template <class T> T tools_max(T a, T b) { return a > b ? a : b; }
    template <class T> T tools_min(T a, T b) { return a > b ? b : a; }
 
    void tools_unlink(const std::string & filename);
 
    extern std::string tools_escape_chars_in_string(const std::string & val, const char *to_escape);
 
 
    extern bool tools_infinint2U_64(infinint val, U_64 & res);
 
 
    extern bool tools_my_atoi(const char *a, U_I & val);
 
    extern infinint tools_double2infinint(double arg);
 
 
    template <class T> void tools_check_negative_date(T & val,
                              user_interaction & ui,
                              const char *inode_path,
                              const char *nature,
                              bool ask_before,
                              bool silent)
    {
    if(val < 0)
    {
        if(!silent)
        {
        std::string msg = tools_printf(gettext("Found negative date (%s) for inode %s ."),
                           nature,
                      inode_path);
        if(ask_before)
            ui.pause(tools_printf(gettext("%S Can we read it as if it was zero (1st January 1970 at 00:00:00 UTC)?"),
                      &msg));
        else // just warn
            ui.message(msg + gettext("Considering date as if it was zero (Jan 1970)"));
        }
 
        val = 0;
    }
    }
 
 
 
    extern infinint tools_upper_rounded_log2(const infinint & ref);
 
 
 
    extern infinint tools_lower_rounded_exp2(const infinint & ref);
 
 
 
    extern infinint tools_rounded_square_root(const infinint & ref);
 
 
 
    extern infinint tools_rounded_cube_root(const infinint & ref);
 
 
    extern std::string tools_build_regex_for_exclude_mask(const std::string & prefix,
                              const std::string & relative_part);
 
 
 
} 
 
#endif