tools.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// to contact the author : http://dar.linux.free.fr/email.html
/*********************************************************************/




#ifndef TOOLS_HPP
#define TOOLS_HPP

#include "../my_config.h"

extern "C"
{
#if STDC_HEADERS
#include <stdarg.h>
#endif
#if HAVE_SIGNAL_H
#include <signal.h>
#endif
}

#include <string>
#include <vector>
#include <map>
#include "path.hpp"
#include "infinint.hpp"
#include "generic_file.hpp"
#include "tuyau.hpp"
#include "integers.hpp"
#include "tlv_list.hpp"

#define TOOLS_SI_SUFFIX 1000
#define TOOLS_BIN_SUFFIX 1024

namespace libdar
{



    extern void tools_init();
    extern void tools_end();


    extern char *tools_str2charptr(const std::string &x);


    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 infinint tools_get_extended_size(std::string s, U_I base);


    extern void tools_extract_basename(const char *command_name, std::string & basename);



    extern std::string::iterator tools_find_last_char_of(std::string &s, unsigned char v);


    extern std::string::iterator tools_find_first_char_of(std::string &s, unsigned char v);


    extern void tools_split_path_basename(const char *all, path * &chemin, std::string & base);


    extern void tools_split_path_basename(const std::string &all, std::string & chemin, std::string & base);


    extern void tools_open_pipes(user_interaction & dialog, const std::string &input, const std::string & output,
                                 tuyau *&in, tuyau *&out);


    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 U_I tools_str2int(const std::string & x);


    extern S_I tools_str2signed_int(const std::string & x);


    extern bool tools_my_atoi(const char *a, U_I & val);


    extern std::string tools_addspacebefore(std::string s, U_I expected_size);


    extern std::string tools_display_date(infinint date);


    extern infinint tools_convert_date(const std::string & repres);


    extern void tools_system(user_interaction & dialog, const std::vector<std::string> & argvector);


    extern void tools_system_with_pipe(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_member(const std::string & val, const std::vector<std::string> & liste);


    extern void tools_display_features(user_interaction & dialog,
                                       bool ea,
                                       bool largefile,
                                       bool nodump,
                                       bool special_alloc,
                                       U_I bits,
                                       bool thread_safe,
                                       bool libz,
                                       bool libbz2,
                                       bool liblzo2,
                                       bool libcrypto,
                                       bool furtive_read);


    extern void tools_display_features(user_interaction & dialog);



    extern bool tools_is_equal_with_hourshift(const infinint & hourshift, const infinint & date1, const infinint & date2);


    template <class T> std::vector<T> operator +=(std::vector<T> & a, const std::vector<T> & b)
    {
        a = a + b;
        return a;
    }



    extern const char *tools_get_from_env(const char **env, const char *clef);


    extern void tools_check_basename(user_interaction & dialog,
                                     const path & loc, std::string & base, const std::string & extension);


    extern std::string tools_getcwd();


    extern std::string tools_readlink(const char *root);


    extern bool tools_look_for(const char *argument, S_I argc, char *const argv[]);



    extern void tools_noexcept_make_date(const std::string & chem, const infinint & last_acc, const infinint & last_mod);


    extern void tools_make_date(const std::string & chemin, infinint access, infinint modif);


    extern bool tools_is_case_insensitive_equal(const std::string & a, const std::string & b);

    extern void tools_to_upper(char *nts);

    extern void tools_to_upper(std::string & r);


    extern void tools_remove_last_char_if_equal_to(char c, std::string & s);


    extern void tools_read_range(const std::string & s, S_I & min, U_I & max);



    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(user_interaction & ui, const std::string & c_chemin, const std::string & file_mask);



    extern void tools_unlink_file_mask_regex(user_interaction & dialog, const std::string & c_chemin, const std::string & file_mask, bool info_details);



    extern void tools_avoid_slice_overwriting_regex(user_interaction & dialog,
                                                    const path & chemin,
                                                    const std::string & x_file_mask,
                                                    bool info_details,
                                                    bool allow_overwriting,
                                                    bool warn_overwriting,
                                                    bool dry_run);


    extern void tools_add_elastic_buffer(generic_file & f, U_32 max_size);



    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_set_back_blocked_signals(sigset_t old_mask);


    extern U_I tools_count_in_string(const std::string & s, const char a);


    extern infinint tools_get_mtime(const std::string & s);


    extern infinint tools_get_size(const std::string & s);


    extern infinint tools_get_ctime(const std::string & s);


    extern std::vector<std::string> tools_split_in_words(generic_file & f);


    extern bool tools_find_next_char_out_of_parenthesis(const std::string & data, const char what,  U_32 start, U_32 & found);



    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);



    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);



    extern std::string tools_build_regex_for_exclude_mask(const std::string & prefix,
                                                          const std::string & relative_part);


    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 void tools_set_permission(S_I fd, U_I perm);


    extern U_I tools_get_permission(S_I fd);


    extern void tools_set_ownership(S_I fd, 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 void tools_read_from_pipe(user_interaction & dialog, S_I fd, tlv_list & result);




    extern U_I tools_pseudo_random(U_I max);




    template <class N, class B> std::vector<B> tools_number_base_decomposition_in_big_endian(N number, const B & base)
    {
        std::vector<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;
    }


    std::string tools_unsigned_char_to_hexa(unsigned char x);



    std::string tools_string_to_hexa(const std::string & input);


    extern infinint tools_file_size_to_crc_size(const infinint & size);


    extern std::string tools_get_euid();



    extern std::string tools_get_egid();


    extern std::string tools_get_hostname();


    extern std::string tools_get_date_utc();


    extern std::string tools_get_compression_ratio(const infinint & storage_size, const infinint & file_size);

} 

#endif