Disk ARchive: line_tools.hpp Source File

| Disk ARchive 2.8.3 Full featured and portable backup and archiving tool

Loading...
Searching...
No Matches
line_tools.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2026 Denis Corbin
4//
5// This program is free software; you can redistribute it and/or
6// modify it under the terms of the GNU General Public License
7// as published by the Free Software Foundation; either version 2
8// of the License, or (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18//
19// to contact the author, see the AUTHOR file
20/*********************************************************************/
21
25
26#ifndef LINE_TOOLS_HPP
27#define LINE_TOOLS_HPP
28
29#include "../my_config.h"
30
31#include <string>
32#include <vector>
33#include <deque>
34#include <memory>
35#include "libdar.hpp"
36#include "tlv_list.hpp"
37#include "tools.hpp"
38
39using namespace libdar;
40
43
44constexpr U_I LINE_TOOLS_SI_SUFFIX = 1000;
45constexpr U_I LINE_TOOLS_BIN_SUFFIX = 1024;
46
47class argc_argv
48{
49public:
50 argc_argv(S_I size = 0);
51 argc_argv(const argc_argv & ref) { throw Efeature("argc_argv"); };
52 argc_argv & operator = (const argc_argv & ref) { throw Efeature("argc_argv"); };
53 ~argc_argv() noexcept(false);
54
55 void resize(S_I size);
56 void set_arg(const std::string & arg, S_I index);
57 void set_arg(generic_file & f, U_I size, S_I index);
58
59 S_I argc() const { return x_argc; };
60 char* const * argv() const { return x_argv; }; // well, the const method is a bit silly, as the caller has the possibility to modify what is pointed to by the returned value...
61
62private:
63 S_I x_argc;
64 char **x_argv;
65};
66
67extern void line_tools_slice_ownership(const std::string & cmd, std::string & slice_permission, std::string & slice_user_ownership, std::string & slice_group_ownership);
68extern void line_tools_repeat_param(const std::string & cmd, infinint & repeat_count, infinint & repeat_byte);
69extern void line_tools_tlv_list2argv(user_interaction & dialog, tlv_list & list, argc_argv & arg);
70
72 extern S_I line_tools_reset_getopt();
73
74
75std::string::const_iterator line_tools_find_first_char_out_of_parenth(const std::string & argument, unsigned char to_find);
76std::string::const_iterator line_tools_find_last_char_out_of_parenth(const std::string & argument, unsigned char to_find);
77
78std::string line_tools_expand_user_comment(const std::string & user_comment, S_I argc, char *const argv[]);
79
81std::deque<std::string> line_tools_explode_PATH(const char *the_path);
82
84std::string line_tools_get_full_path_from_PATH(const std::deque<std::string> & the_path, const char * filename);
85
87 void line_tools_split_at_first_space(const char *field, std::string & before_space, std::string & after_space);
88
89void line_tools_get_min_digits(std::string arg, infinint & num, infinint & ref_num, infinint & aux_num);
90
92
97#if HAVE_GETOPT_LONG
99#endif
102 extern void line_tools_look_for(const std::deque<char> & arguments,
103 S_I argc,
104 char *const argv[],
105 const char *getopt_string,
106#if HAVE_GETOPT_LONG
107 const struct option *long_options,
108#endif
109 char stop_scan,
110 std::deque<char> & presence);
111
112
114
118#if HAVE_GETOPT_LONG
120#endif
123 extern void line_tools_look_for_Q(S_I argc,
124 char *const argv[],
125 const char *getopt_string,
126#if HAVE_GETOPT_LONG
127 const struct option *long_options,
128#endif
129 char stop_scan,
130 bool & Q_is_present);
131
132
134
135 template <class T> void line_tools_split(const std::string & val, char sep, T & split)
136{
137 std::string::const_iterator be = val.begin();
138 std::string::const_iterator ne = val.begin();
139 split.clear();
140
141 while(ne != val.end())
142 {
143 if(*ne != sep)
144 ++ne;
145 else
146 {
147 split.push_back(std::string(be, ne));
148 ++ne;
149 be = ne;
150 }
151 }
152
153 if(be != val.end())
154 split.push_back(std::string(be, ne));
155}
156
157extern std::set<std::string> line_tools_deque_to_set(const std::deque<std::string> & list);
158
159extern void line_tools_4_4_build_compatible_overwriting_policy(bool allow_over,
160 bool detruire,
161 bool more_recent,
162 const libdar::infinint & hourshift,
163 bool ea_erase,
164 const libdar::crit_action * & overwrite);
165
172 extern void line_tools_crypto_split_algo_pass(const secu_string & all,
173 crypto_algo & algo,
174 secu_string & pass,
175 bool & no_cipher_given,
176 std::vector<std::string> & recipients);
177
179 extern void line_tools_display_signatories(user_interaction & ui, const std::list<signator> & gnupg_signed);
180
182
186 extern void line_tools_read_from_pipe(std::shared_ptr<user_interaction> & dialog, S_I fd, tlv_list & result);
187
189
193 extern void line_tools_extract_basename(const char *command_name, std::string & basename);
194
196
202 extern std::string::iterator line_tools_find_first_char_of(std::string &s, unsigned char v);
203
205
211 extern std::string::iterator line_tools_find_last_char_of(std::string &s, unsigned char v);
212
214
219 extern void line_tools_split_path_basename(const char *all, path * &chemin, std::string & base);
220
222
227 extern void line_tools_split_path_basename(const std::string &all, std::string & chemin, std::string & base);
228
230
239 extern bool line_tools_split_entrepot_path(const std::string &all,
240 std::string & proto,
241 std::string & login,
242 secu_string & password,
243 std::string & hostname,
244 std::string & port,
245 std::string & path_basename);
246
248
251 extern S_I line_tools_str2signed_int(const std::string & x);
252
254
258 extern infinint line_tools_convert_date(const std::string & repres);
259
261
265 extern void line_tools_display_features(user_interaction & dialog);
266
268
273 extern const char *line_tools_get_from_env(const char **env, const char *clef);
274
276
283 extern void line_tools_check_basename(user_interaction & dialog,
284 const path & loc,
285 std::string & base,
286 const std::string & extension,
287 bool create);
288
290
296 void line_tools_check_min_digits(user_interaction & dialog,
297 const path & loc,
298 const std::string & base,
299 const std::string & extension,
300 infinint & num_digits);
301
302
304
312 extern void line_tools_read_range(const std::string & s, S_I & min, U_I & max);
313
315
319 template <class T> void line_tools_split_in_words(generic_file & f, T & mots)
320{
321 std::deque <char> quotes;
322 std::string current = "";
323 char a;
324 bool loop = true;
325 bool escaped = false;
326
327 mots.clear();
328 while(loop)
329 {
330 if(f.read(&a, 1) != 1) // reached end of file
331 {
332 loop = false;
333 a = ' '; // to close the last word
334 }
335
336 if(escaped)
337 {
338 current += a; // added without consideration of quoting of any sort
339 escaped = false;
340 continue; // continuing at beginning of the while loop
341 }
342 else
343 {
344 if(a == '\\')
345 {
346 escaped = true;
347 continue; // continuing at beginning of the while loop
348 }
349 }
350
351 if(quotes.empty()) // outside a word
352 switch(a)
353 {
354 case ' ':
355 case '\t':
356 case '\n':
357 case '\r':
358 break;
359 case '"':
360 case '\'':
361 case '`':
362 quotes.push_back(a);
363 break;
364 default:
365 quotes.push_back(' '); // the quote space means no quote
366 current += a; // a new argument is starting
367 break;
368 }
369 else // inside a word
370 switch(a)
371 {
372 case '\t':
373 if(quotes.back() != ' ')
374 {
375 // this is the end of the wor(l)d ;-)
376 // ...once again... 1000, 1999, 2012, and the next ones to come...
377 break;
378 }
379 // no break !
380 case '\n':
381 case '\r':
382 a = ' '; // replace carriage return inside quoted string by a space
383 // no break !
384 case ' ':
385 case '"':
386 case '\'':
387 case '`':
388 if(a == quotes.back()) // "a" is an ending quote
389 {
390 quotes.pop_back();
391 if(quotes.empty()) // reached end of word
392 {
393 mots.push_back(current);
394 current = "";
395 }
396 else
397 current += a;
398 }
399 else // "a" is a nested starting quote
400 {
401 if(a != ' ') // quote ' ' does not have ending quote
402 quotes.push_back(a);
403 current += a;
404 }
405 break;
406 default:
407 current += a;
408 }
409 }
410 if(!quotes.empty())
411 throw Erange("make_args_from_file", tools_printf(dar_gettext("Parse error: Unmatched `%c'"), quotes.back()));
412}
413
414
415
417
421 template <class T> void line_tools_split_in_words(const std::string & arg, T & mots)
422{
423 memory_file mem;
424
425 mem.write(arg.c_str(), arg.size());
426 mem.skip(0);
427 line_tools_split_in_words(mem, mots);
428}
429
431 extern std::string line_tools_get_euid();
432
434 extern std::string line_tools_get_egid();
435
437 extern std::string line_tools_get_hostname();
438
440 extern std::string line_tools_get_date_utc();
441
443 extern void line_tools_merge_to_deque(std::deque<std::string> & a, const std::deque<std::string> & b);
444
446 extern std::deque<std::string> line_tools_substract_from_deque(const std::deque<std::string> & a, const std::deque<std::string> & b);
447
449
451 extern delta_sig_block_size::fs_function_t line_tools_string_to_sig_block_size_function(const std::string & funname);
452
453 extern void line_tools_split_compression_algo(const char *arg,
454 U_I base,
455 compression & algo,
456 U_I & level,
457 U_I & block_size
458 );
459
461 extern void line_tools_split_mask_list_from_eols(const std::string & arg, std::string & filename, std::deque<std::string> & eols);
462
464 extern std::string line_tools_replace_escape_sequences(const std::string & arg);
465
467
468#endif
libdar::Erange
exception used to signal range error
Definition erreurs.hpp:220
libdar::crit_action
the global action for overwriting
Definition crit_action.hpp:81
libdar::eols
the class eols provide a way to detect the presence of string from a list of string in a byte flow
Definition eols.hpp:48
libdar::generic_file
this is the interface class from which all other data transfer classes inherit
Definition generic_file.hpp:77
libdar::generic_file::write
virtual void write(const char *a, U_I size) override
write data to the generic_file inherited from proto_generic_file
libdar::generic_file::read
virtual U_I read(char *a, U_I size) override
read data from the generic_file inherited from proto_generic_file
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::memory_file
generic_file stored in memory
Definition memory_file.hpp:41
libdar::memory_file::skip
virtual bool skip(const infinint &pos) override
skip at the absolute position
libdar::path
the class path is here to manipulate paths in the Unix notation: using'/'
Definition path.hpp:51
libdar::secu_string
class secu_string
Definition secu_string.hpp:54
libdar::user_interaction
This is a pure virtual class that is used by libdar when interaction with the user is required.
Definition user_interaction.hpp:58
libdar::compression
compression
the different compression algorithm available
Definition compression.hpp:46
libdar::crypto_algo
crypto_algo
the different cypher available for encryption (strong or weak)
Definition crypto.hpp:50
libdar::dar_gettext
const char * dar_gettext(const char *)
a routine to change NLS domaine forth and back for inline routines
libdar::comparison_fields::all
@ all
consider any available field for comparing inodes
Definition archive_aux.hpp:54
line_tools_split_path_basename
void line_tools_split_path_basename(const char *all, path *&chemin, std::string &base)
split a given full path in path part and basename part
line_tools_crypto_split_algo_pass
void line_tools_crypto_split_algo_pass(const secu_string &all, crypto_algo &algo, secu_string &pass, bool &no_cipher_given, std::vector< std::string > &recipients)
line_tools_replace_escape_sequences
std::string line_tools_replace_escape_sequences(const std::string &arg)
replace escape sequences by their real byte value
line_tools_get_date_utc
std::string line_tools_get_date_utc()
return a string containing the current time (UTC)
line_tools_explode_PATH
std::deque< std::string > line_tools_explode_PATH(const char *the_path)
split a PATH environement variable string into its components (/usr/lib:/lib => /usr/lib /lib)
line_tools_reset_getopt
S_I line_tools_reset_getopt()
returns the old position of parsing (next argument to parse)
line_tools_string_to_sig_block_size_function
delta_sig_block_size::fs_function_t line_tools_string_to_sig_block_size_function(const std::string &funname)
converts string name to function
line_tools_get_euid
std::string line_tools_get_euid()
return a string containing the Effective UID
line_tools_split_mask_list_from_eols
void line_tools_split_mask_list_from_eols(const std::string &arg, std::string &filename, std::deque< std::string > &eols)
convert –include-from-file / –exclude-from-file argument to its different components
line_tools_read_from_pipe
void line_tools_read_from_pipe(std::shared_ptr< user_interaction > &dialog, S_I fd, tlv_list &result)
Extract from anonymous pipe a tlv_list.
line_tools_merge_to_deque
void line_tools_merge_to_deque(std::deque< std::string > &a, const std::deque< std::string > &b)
add in 'a', element of 'b' not already found in 'a'
line_tools_split
void line_tools_split(const std::string &val, char sep, T &split)
split a line in words given the separator character (sep)
Definition line_tools.hpp:135
line_tools_get_hostname
std::string line_tools_get_hostname()
return a string containing the hostname of the current host
line_tools_split_in_words
void line_tools_split_in_words(generic_file &f, T &mots)
read a file and split its contents into words
Definition line_tools.hpp:319
line_tools_check_basename
void line_tools_check_basename(user_interaction &dialog, const path &loc, std::string &base, const std::string &extension, bool create)
does sanity checks on a slice name, check presence and detect whether the given basename is not rathe...
line_tools_find_first_char_of
std::string::iterator line_tools_find_first_char_of(std::string &s, unsigned char v)
give a pointer to the first character of the given value in the given string
line_tools_extract_basename
void line_tools_extract_basename(const char *command_name, std::string &basename)
extracts the basename of a file (removing path part)
line_tools_get_full_path_from_PATH
std::string line_tools_get_full_path_from_PATH(const std::deque< std::string > &the_path, const char *filename)
return the full path of the given filename (eventually unchanged of pointing to the first file of tha...
line_tools_check_min_digits
void line_tools_check_min_digits(user_interaction &dialog, const path &loc, const std::string &base, const std::string &extension, infinint &num_digits)
if a slice number 1 is met with the provided basename, set the num_digits accordingly
line_tools_read_range
void line_tools_read_range(const std::string &s, S_I &min, U_I &max)
from a string with a range notation (min-max) extract the range values
line_tools_substract_from_deque
std::deque< std::string > line_tools_substract_from_deque(const std::deque< std::string > &a, const std::deque< std::string > &b)
remove from 'a' elements found in 'b' and return the resulting deque
line_tools_get_from_env
const char * line_tools_get_from_env(const char **env, const char *clef)
isolate the value of a given variable from the environment vector
line_tools_find_last_char_of
std::string::iterator line_tools_find_last_char_of(std::string &s, unsigned char v)
give a pointer to the last character of the given value in the given string
line_tools_get_egid
std::string line_tools_get_egid()
return a string containing the Effective UID
line_tools_convert_date
infinint line_tools_convert_date(const std::string &repres)
convert a human readable date representation in number of second since the system reference date
line_tools_display_signatories
void line_tools_display_signatories(user_interaction &ui, const std::list< signator > &gnupg_signed)
display information about the signatories
line_tools_display_features
void line_tools_display_features(user_interaction &dialog)
display the compilation time features of libdar
line_tools_look_for
void line_tools_look_for(const std::deque< char > &arguments, S_I argc, char *const argv[], const char *getopt_string, char stop_scan, std::deque< char > &presence)
test the presence of a set of argument on the command line
line_tools_split_entrepot_path
bool line_tools_split_entrepot_path(const std::string &all, std::string &proto, std::string &login, secu_string &password, std::string &hostname, std::string &port, std::string &path_basename)
split a given full remote repository path in parts
line_tools_str2signed_int
S_I line_tools_str2signed_int(const std::string &x)
convert a signed integer written in decimal notation to the corresponding value
line_tools_look_for_Q
void line_tools_look_for_Q(S_I argc, char *const argv[], const char *getopt_string, char stop_scan, bool &Q_is_present)
test the presence of -Q and -j options on the command line
line_tools_split_compression_algo
void line_tools_split_compression_algo(const char *arg, U_I base, compression &algo, U_I &level, U_I &block_size)
line_tools_split_at_first_space
void line_tools_split_at_first_space(const char *field, std::string &before_space, std::string &after_space)
return split at the first space met the string given as first argument, and provide the two splitted ...
libdar::tools_printf
std::string tools_printf(const char *format,...)
make printf-like formating to a std::string
libdar.hpp
the main file of the libdar API definitions
my_config.h
include macro defined by the configure script and some specific additional ones
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
libdar::delta_sig_block_size::fs_function_t
fs_function_t
defines the function to use to derivate block size from file size
Definition delta_sig_block_size.hpp:53
tlv_list.hpp
List of Generic Type Length Value data structures.
tools.hpp
a set of general purpose routines