Fixed the build error for riscv64 arch using gcc 13
[platform/upstream/cryptsetup.git] / src / utils_tools.c
1 /*
2  * cryptsetup - setup cryptographic volumes for dm-crypt
3  *
4  * Copyright (C) 2004 Jana Saout <jana@saout.de>
5  * Copyright (C) 2004-2007 Clemens Fruhwirth <clemens@endorphin.org>
6  * Copyright (C) 2009-2021 Red Hat, Inc. All rights reserved.
7  * Copyright (C) 2009-2021 Milan Broz
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  */
23
24 #include "cryptsetup.h"
25 #include <math.h>
26 #include <signal.h>
27
28 int opt_verbose = 0;
29 int opt_debug = 0;
30 int opt_debug_json = 0;
31 int opt_batch_mode = 0;
32 int opt_progress_frequency = 0;
33
34 /* interrupt handling */
35 volatile int quit = 0;
36 static int signals_blocked = 0;
37
38 static void int_handler(int sig __attribute__((__unused__)))
39 {
40         quit++;
41 }
42
43 int tools_signals_blocked(void)
44 {
45         return signals_blocked;
46 }
47
48 void set_int_block(int block)
49 {
50         sigset_t signals_open;
51
52         log_dbg("%slocking interruption on signal.", block ? "B" : "Unb");
53
54         sigemptyset(&signals_open);
55         sigaddset(&signals_open, SIGINT);
56         sigaddset(&signals_open, SIGTERM);
57         sigprocmask(block ? SIG_SETMASK : SIG_UNBLOCK, &signals_open, NULL);
58         signals_blocked = block;
59         quit = 0;
60 }
61
62 void set_int_handler(int block)
63 {
64         struct sigaction sigaction_open;
65
66         log_dbg("Installing SIGINT/SIGTERM handler.");
67         memset(&sigaction_open, 0, sizeof(struct sigaction));
68         sigaction_open.sa_handler = int_handler;
69         sigaction(SIGINT, &sigaction_open, 0);
70         sigaction(SIGTERM, &sigaction_open, 0);
71         set_int_block(block);
72 }
73
74 void check_signal(int *r)
75 {
76         if (quit && !*r)
77                 *r = -EINTR;
78 }
79
80 #define LOG_MAX_LEN 4096
81
82 __attribute__((format(printf, 5, 6)))
83 void clogger(struct crypt_device *cd, int level, const char *file, int line,
84              const char *format, ...)
85 {
86         va_list argp;
87         char target[LOG_MAX_LEN + 2];
88
89         va_start(argp, format);
90
91         if (vsnprintf(&target[0], LOG_MAX_LEN, format, argp) > 0) {
92                 /* All verbose and error messages in tools end with EOL. */
93                 if (level == CRYPT_LOG_VERBOSE || level == CRYPT_LOG_ERROR ||
94                     level == CRYPT_LOG_DEBUG || level == CRYPT_LOG_DEBUG_JSON)
95                         strncat(target, "\n", LOG_MAX_LEN);
96
97                 crypt_log(cd, level, target);
98         }
99
100         va_end(argp);
101 }
102
103 void tool_log(int level, const char *msg, void *usrptr __attribute__((unused)))
104 {
105         switch(level) {
106
107         case CRYPT_LOG_NORMAL:
108                 fprintf(stdout, "%s", msg);
109                 break;
110         case CRYPT_LOG_VERBOSE:
111                 if (opt_verbose)
112                         fprintf(stdout, "%s", msg);
113                 break;
114         case CRYPT_LOG_ERROR:
115                 fprintf(stderr, "%s", msg);
116                 break;
117         case CRYPT_LOG_DEBUG_JSON:
118         case CRYPT_LOG_DEBUG:
119                 if (opt_debug)
120                         fprintf(stdout, "# %s", msg);
121                 break;
122         }
123 }
124
125 void quiet_log(int level, const char *msg, void *usrptr)
126 {
127         if (!opt_verbose && (level == CRYPT_LOG_ERROR || level == CRYPT_LOG_NORMAL))
128                 level = CRYPT_LOG_VERBOSE;
129         tool_log(level, msg, usrptr);
130 }
131
132 static int _dialog(const char *msg, void *usrptr, int default_answer)
133 {
134         const char *fail_msg = (const char *)usrptr;
135         char *answer = NULL;
136         size_t size = 0;
137         int r = default_answer, block;
138
139         block = tools_signals_blocked();
140         if (block)
141                 set_int_block(0);
142
143         if (isatty(STDIN_FILENO) && !opt_batch_mode) {
144                 log_std("\nWARNING!\n========\n");
145                 log_std("%s\n\nAre you sure? (Type 'yes' in capital letters): ", msg);
146                 fflush(stdout);
147                 if(getline(&answer, &size, stdin) == -1) {
148                         r = 0;
149                         /* Aborted by signal */
150                         if (!quit)
151                                 log_err(_("Error reading response from terminal."));
152                         else
153                                 log_dbg("Query interrupted on signal.");
154                 } else {
155                         r = !strcmp(answer, "YES\n");
156                         if (!r && fail_msg)
157                                 log_err("%s", fail_msg);
158                 }
159         }
160
161         if (block && !quit)
162                 set_int_block(1);
163
164         free(answer);
165         return r;
166 }
167
168 int yesDialog(const char *msg, void *usrptr)
169 {
170         return _dialog(msg, usrptr, 1);
171 }
172
173 int noDialog(const char *msg, void *usrptr)
174 {
175         return _dialog(msg, usrptr, 0);
176 }
177
178 void show_status(int errcode)
179 {
180         char *crypt_error;
181
182         if(!opt_verbose)
183                 return;
184
185         if(!errcode) {
186                 log_std(_("Command successful.\n"));
187                 return;
188         }
189
190         if (errcode < 0)
191                 errcode = translate_errno(errcode);
192
193         if (errcode == 1)
194                 crypt_error = _("wrong or missing parameters");
195         else if (errcode == 2)
196                 crypt_error = _("no permission or bad passphrase");
197         else if (errcode == 3)
198                 crypt_error = _("out of memory");
199         else if (errcode == 4)
200                 crypt_error = _("wrong device or file specified");
201         else if (errcode == 5)
202                 crypt_error = _("device already exists or device is busy");
203         else
204                 crypt_error = _("unknown error");
205
206         log_std(_("Command failed with code %i (%s).\n"), -errcode, crypt_error);
207 }
208
209 const char *uuid_or_device(const char *spec)
210 {
211         static char device[PATH_MAX];
212         char s, *ptr;
213         int i = 0, uuid_len = 5;
214
215         /* Check if it is correct UUID=<LUKS_UUID> format */
216         if (spec && !strncmp(spec, "UUID=", uuid_len)) {
217                 strcpy(device, "/dev/disk/by-uuid/");
218                 ptr = &device[strlen(device)];
219                 i = uuid_len;
220                 while ((s = spec[i++]) && i < (PATH_MAX - 13)) {
221                         if (!isxdigit(s) && s != '-')
222                                 return spec; /* Bail it out */
223                         if (isalpha(s))
224                                 s = tolower(s);
225                         *ptr++ = s;
226                 }
227                 *ptr = '\0';
228                 return device;
229         }
230
231         return spec;
232 }
233
234 __attribute__ ((noreturn)) void usage(poptContext popt_context,
235                                              int exitcode, const char *error,
236                                              const char *more)
237 {
238         poptPrintUsage(popt_context, stderr, 0);
239         if (error)
240                 log_err("%s: %s", more, error);
241         tools_cleanup();
242         poptFreeContext(popt_context);
243         exit(exitcode);
244 }
245
246 void dbg_version_and_cmd(int argc, const char **argv)
247 {
248         int i;
249
250         log_std("# %s %s processing \"", PACKAGE_NAME, PACKAGE_VERSION);
251         for (i = 0; i < argc; i++) {
252                 if (i)
253                         log_std(" ");
254                 log_std("%s", argv[i]);
255         }
256         log_std("\"\n");
257 }
258
259 /* Translate exit code to simple codes */
260 int translate_errno(int r)
261 {
262         switch (r) {
263         case 0:         r = EXIT_SUCCESS; break;
264         case -EEXIST:
265         case -EBUSY:    r = 5; break;
266         case -ENOTBLK:
267         case -ENODEV:   r = 4; break;
268         case -ENOMEM:   r = 3; break;
269         case -EPERM:    r = 2; break;
270         case -EINVAL:
271         case -ENOENT:
272         case -ENOSYS:
273         default:        r = EXIT_FAILURE;
274         }
275         return r;
276 }
277
278 void tools_keyslot_msg(int keyslot, crypt_object_op op)
279 {
280         if (keyslot < 0)
281                 return;
282
283         if (op == CREATED)
284                 log_verbose(_("Key slot %i created."), keyslot);
285         else if (op == UNLOCKED)
286                 log_verbose(_("Key slot %i unlocked."), keyslot);
287         else if (op == REMOVED)
288                 log_verbose(_("Key slot %i removed."), keyslot);
289 }
290
291 void tools_token_msg(int token, crypt_object_op op)
292 {
293         if (token < 0)
294                 return;
295
296         if (op == CREATED)
297                 log_verbose(_("Token %i created."), token);
298         else if (op == REMOVED)
299                 log_verbose(_("Token %i removed."), token);
300 }
301
302 /*
303  * Device size string parsing, suffixes:
304  * s|S - 512 bytes sectors
305  * k  |K  |m  |M  |g  |G  |t  |T   - 1024 base
306  * kiB|KiB|miB|MiB|giB|GiB|tiB|TiB - 1024 base
307  * kb |KB |mM |MB |gB |GB |tB |TB  - 1000 base
308  */
309 int tools_string_to_size(struct crypt_device *cd, const char *s, uint64_t *size)
310 {
311         char *endp = NULL;
312         size_t len;
313         uint64_t mult_base, mult, tmp;
314
315         *size = strtoull(s, &endp, 10);
316         if (!isdigit(s[0]) ||
317             (errno == ERANGE && *size == ULLONG_MAX) ||
318             (errno != 0 && *size == 0))
319                 return -EINVAL;
320
321         if (!endp || !*endp)
322                 return 0;
323
324         len = strlen(endp);
325         /* Allow "B" and "iB" suffixes */
326         if (len > 3 ||
327            (len == 3 && (endp[1] != 'i' || endp[2] != 'B')) ||
328            (len == 2 && endp[1] != 'B'))
329                 return -EINVAL;
330
331         if (len == 1 || len == 3)
332                 mult_base = 1024;
333         else
334                 mult_base = 1000;
335
336         mult = 1;
337         switch (endp[0]) {
338         case 's':
339         case 'S': mult = 512;
340                 break;
341         case 't':
342         case 'T': mult *= mult_base;
343                  /* Fall through */
344         case 'g':
345         case 'G': mult *= mult_base;
346                  /* Fall through */
347         case 'm':
348         case 'M': mult *= mult_base;
349                  /* Fall through */
350         case 'k':
351         case 'K': mult *= mult_base;
352                 break;
353         default:
354                 return -EINVAL;
355         }
356
357         tmp = *size * mult;
358         if (*size && (tmp / *size) != mult) {
359                 log_dbg("Device size overflow.");
360                 return -EINVAL;
361         }
362
363         *size = tmp;
364         return 0;
365 }
366
367 /* Time progress helper */
368
369 /* The difference in seconds between two times in "timeval" format. */
370 static double time_diff(struct timeval *start, struct timeval *end)
371 {
372         return (end->tv_sec - start->tv_sec)
373                 + (end->tv_usec - start->tv_usec) / 1E6;
374 }
375
376 void tools_clear_line(void)
377 {
378         if (opt_progress_frequency)
379                 return;
380         /* vt100 code clear line */
381         log_std("\33[2K\r");
382 }
383
384 static void tools_time_progress(uint64_t device_size, uint64_t bytes, uint64_t *start_bytes,
385                          struct timeval *start_time, struct timeval *end_time)
386 {
387         struct timeval now_time;
388         unsigned long long mbytes, eta;
389         double tdiff, uib, frequency;
390         int final = (bytes == device_size);
391         const char *eol, *ustr = "";
392
393         if (opt_batch_mode)
394                 return;
395
396         gettimeofday(&now_time, NULL);
397         if (start_time->tv_sec == 0 && start_time->tv_usec == 0) {
398                 *start_time = now_time;
399                 *end_time = now_time;
400                 *start_bytes = bytes;
401                 return;
402         }
403
404         if (opt_progress_frequency) {
405                 frequency = (double)opt_progress_frequency;
406                 eol = "\n";
407         } else {
408                 frequency = 0.5;
409                 eol = "";
410         }
411
412         if (!final && time_diff(end_time, &now_time) < frequency)
413                 return;
414
415         *end_time = now_time;
416
417         tdiff = time_diff(start_time, end_time);
418         if (!tdiff)
419                 return;
420
421         mbytes = bytes  / 1024 / 1024;
422         uib = (double)(bytes - *start_bytes) / tdiff;
423
424         /* FIXME: calculate this from last minute only. */
425         eta = (unsigned long long)(device_size / uib - tdiff);
426
427         if (uib > 1073741824.0f) {
428                 uib /= 1073741824.0f;
429                 ustr = "Gi";
430         } else if (uib > 1048576.0f) {
431                 uib /= 1048576.0f;
432                 ustr = "Mi";
433         } else if (uib > 1024.0f) {
434                 uib /= 1024.0f;
435                 ustr = "Ki";
436         }
437
438         tools_clear_line();
439         if (final)
440                 log_std("Finished, time %02llu:%02llu.%03llu, "
441                         "%4llu MiB written, speed %5.1f %sB/s\n",
442                         (unsigned long long)tdiff / 60,
443                         (unsigned long long)tdiff % 60,
444                         (unsigned long long)((tdiff - floor(tdiff)) * 1000.0),
445                         mbytes, uib, ustr);
446         else
447                 log_std("Progress: %5.1f%%, ETA %02llu:%02llu, "
448                         "%4llu MiB written, speed %5.1f %sB/s%s",
449                         (double)bytes / device_size * 100,
450                         eta / 60, eta % 60, mbytes, uib, ustr, eol);
451         fflush(stdout);
452 }
453
454 int tools_wipe_progress(uint64_t size, uint64_t offset, void *usrptr)
455 {
456         static struct timeval start_time = {}, end_time = {};
457         static uint64_t start_offset = 0;
458         int r = 0;
459
460         tools_time_progress(size, offset, &start_offset, &start_time, &end_time);
461
462         check_signal(&r);
463         if (r) {
464                 tools_clear_line();
465                 log_err(_("\nWipe interrupted."));
466         }
467
468         return r;
469 }
470
471 static void report_partition(const char *value, const char *device)
472 {
473         if (opt_batch_mode)
474                 log_dbg("Device %s already contains a '%s' partition signature.", device, value);
475         else
476                 log_std(_("WARNING: Device %s already contains a '%s' partition signature.\n"), device, value);
477 }
478
479 static void report_superblock(const char *value, const char *device)
480 {
481         if (opt_batch_mode)
482                 log_dbg("Device %s already contains a '%s' superblock signature.", device, value);
483         else
484                 log_std(_("WARNING: Device %s already contains a '%s' superblock signature.\n"), device, value);
485 }
486
487 int tools_detect_signatures(const char *device, int ignore_luks, size_t *count)
488 {
489         int r;
490         size_t tmp_count;
491         struct blkid_handle *h;
492         blk_probe_status pr;
493
494         if (!count)
495                 count = &tmp_count;
496
497         *count = 0;
498
499         if (!blk_supported()) {
500                 log_dbg("Blkid support disabled.");
501                 return 0;
502         }
503
504         if ((r = blk_init_by_path(&h, device))) {
505                 log_err(_("Failed to initialize device signature probes."));
506                 return -EINVAL;
507         }
508
509         blk_set_chains_for_full_print(h);
510
511         if (ignore_luks && blk_superblocks_filter_luks(h)) {
512                 r = -EINVAL;
513                 goto out;
514         }
515
516         while ((pr = blk_probe(h)) < PRB_EMPTY) {
517                 if (blk_is_partition(h))
518                         report_partition(blk_get_partition_type(h), device);
519                 else if (blk_is_superblock(h))
520                         report_superblock(blk_get_superblock_type(h), device);
521                 else {
522                         log_dbg("Internal tools_detect_signatures() error.");
523                         r = -EINVAL;
524                         goto out;
525                 }
526                 (*count)++;
527         }
528
529         if (pr == PRB_FAIL)
530                 r = -EINVAL;
531 out:
532         blk_free(h);
533         return r;
534 }
535
536 int tools_wipe_all_signatures(const char *path)
537 {
538         int fd, flags, r;
539         blk_probe_status pr;
540         struct stat st;
541         struct blkid_handle *h = NULL;
542
543         if (!blk_supported()) {
544                 log_dbg("Blkid support disabled.");
545                 return 0;
546         }
547
548         if (stat(path, &st)) {
549                 log_err(_("Failed to stat device %s."), path);
550                 return -EINVAL;
551         }
552
553         flags = O_RDWR;
554         if (S_ISBLK(st.st_mode))
555                 flags |= O_EXCL;
556
557         /* better than opening regular file with O_EXCL (undefined) */
558         /* coverity[toctou] */
559         fd = open(path, flags);
560         if (fd < 0) {
561                 if (errno == EBUSY)
562                         log_err(_("Device %s is in use. Can not proceed with format operation."), path);
563                 else
564                         log_err(_("Failed to open file %s in read/write mode."), path);
565                 return -EINVAL;
566         }
567
568         if ((r = blk_init_by_fd(&h, fd))) {
569                 log_err(_("Failed to initialize device signature probes."));
570                 r = -EINVAL;
571                 goto out;
572         }
573
574         blk_set_chains_for_wipes(h);
575
576         while ((pr = blk_probe(h)) < PRB_EMPTY) {
577                 if (blk_is_partition(h))
578                         log_verbose(_("Existing '%s' partition signature (offset: %" PRIi64 " bytes) on device %s will be wiped."),
579                                     blk_get_partition_type(h), blk_get_offset(h), path);
580                 if (blk_is_superblock(h))
581                         log_verbose(_("Existing '%s' superblock signature (offset: %" PRIi64 " bytes) on device %s will be wiped."),
582                                     blk_get_superblock_type(h), blk_get_offset(h), path);
583                 if (blk_do_wipe(h)) {
584                         log_err(_("Failed to wipe device signature."));
585                         r = -EINVAL;
586                         goto out;
587                 }
588         }
589
590         if (pr != PRB_EMPTY) {
591                 log_err(_("Failed to probe device %s for a signature."), path);
592                 r = -EINVAL;
593         }
594 out:
595         close(fd);
596         blk_free(h);
597         return r;
598 }
599
600 /*
601  * Keyfile - is standard input treated as a binary file (no EOL handling).
602  */
603 int tools_is_stdin(const char *key_file)
604 {
605         if (!key_file)
606                 return 1;
607
608         return strcmp(key_file, "-") ? 0 : 1;
609 }
610
611 int tools_reencrypt_progress(uint64_t size, uint64_t offset, void *usrptr)
612 {
613         static struct timeval start_time = {}, end_time = {};
614         static uint64_t start_offset = 0;
615         int r = 0;
616
617         tools_time_progress(size, offset, &start_offset, &start_time, &end_time);
618
619         check_signal(&r);
620         if (r) {
621                 tools_clear_line();
622                 log_err(_("\nReencryption interrupted."));
623         }
624
625         return r;
626 }