source: MondoRescue/branches/2.2.9/mondo/src/common/libmondo-devices.c@ 2745

Last change on this file since 2745 was 2745, checked in by Bruno Cornec, 13 years ago
  • Avoids coredump again when exclude_path is NULL with mr_make_devlist_from_pathlist (feedback from mc_at_carreira.com.pt)
  • Property svn:keywords set to Id
File size: 94.9 KB
Line 
1/* libmondo-devices.c Subroutines for handling devices
2 $Id: libmondo-devices.c 2745 2011-03-20 18:48:01Z bruno $
3*/
4
5/**
6 * @file
7 * Functions to handle interactions with backup devices.
8 */
9
10#include "my-stuff.h"
11#include "mr_mem.h"
12#include "mr_str.h"
13#include "mondostructures.h"
14#include "libmondo-files-EXT.h"
15#include "libmondo-devices.h"
16#include "lib-common-externs.h"
17#include "libmondo-string-EXT.h"
18#include "libmondo-tools-EXT.h"
19#include "libmondo-gui-EXT.h"
20#include "libmondo-fork-EXT.h"
21#include "libmondo-stream-EXT.h"
22
23#include <sys/types.h>
24#ifdef __FreeBSD__
25#define DKTYPENAMES
26#define FSTYPENAMES
27#include <sys/disklabel.h>
28#include <sys/disk.h>
29#elif linux
30#define u64 unsigned long long
31#include <linux/fs.h> /* for BLKGETSIZE64 */
32#include <linux/hdreg.h>
33#endif
34
35/*@unused@*/
36//static char cvsid[] = "$Id: libmondo-devices.c 2745 2011-03-20 18:48:01Z bruno $";
37
38extern int g_current_media_number;
39extern double g_kernel_version;
40
41extern bool g_ISO_restore_mode;
42extern char *g_selfmounted_isodir;
43extern char *MONDO_LOGFILE;
44
45extern void setup_tmpdir(char *path);
46
47static char g_cdrw_drive_is_here[MAX_STR_LEN / 4] = "";
48static char g_cdrom_drive_is_here[MAX_STR_LEN / 4] = "";
49static char g_dvd_drive_is_here[MAX_STR_LEN / 4] = "";
50
51
52/**
53 * ????? @bug ?????
54 * @ingroup globalGroup
55 */
56bool g_restoring_live_from_cd = FALSE;
57bool g_restoring_live_from_netfs = FALSE;
58
59extern t_bkptype g_backup_media_type; // set by main()
60
61/* Reference to global bkpinfo */
62extern struct s_bkpinfo *bkpinfo;
63
64/* Stuff that handles the -I and -E option when a whole disk DSF is used */
65typedef struct mounted_fs_struct {
66 char device[MAX_STR_LEN]; /* The name of the device */
67 char mount_point[MAX_STR_LEN]; /* The devices mount point */
68 unsigned char check; /* 1 == included on DSF */
69 struct mounted_fs_struct *next;
70} MOUNTED_FS_STRUCT;
71
72static MOUNTED_FS_STRUCT *DSF_Head = NULL; /* Points to the first entry of mounted_fs_struct list */
73static MOUNTED_FS_STRUCT *DSF_Tail = NULL; /* Points to the last entry of mounted_fs_struct list */
74
75
76void set_g_cdrom_and_g_dvd_to_bkpinfo_value()
77{
78 strcpy(g_cdrom_drive_is_here, bkpinfo->media_device); // just in case
79 strcpy(g_dvd_drive_is_here, bkpinfo->media_device); // just in case
80}
81
82
83
84/**
85 * Retract all CD trays and wait for autorun to complete.
86 * @ingroup deviceGroup
87 */
88void retract_CD_tray_and_defeat_autorun(void)
89{
90// log_it("rctada: Retracting all CD trays", __LINE__);
91 if (strlen(g_cdrom_drive_is_here) > 0) {
92 inject_device(g_cdrom_drive_is_here);
93 }
94 if (strlen(g_dvd_drive_is_here) > 0) {
95 inject_device(g_dvd_drive_is_here);
96 }
97 if (strlen(g_cdrw_drive_is_here) > 0) {
98 inject_device(g_cdrw_drive_is_here);
99 }
100// log_it("rctada: killing autorun");
101// run_program_and_log_output("killall autorun", TRUE);
102 if (!run_program_and_log_output("ps | grep autorun | grep -v grep", 5)) {
103 log_it("autorun detected; sleeping for 2 seconds");
104 sleep(2);
105 }
106 log_it("rctada: Unmounting all CD drives", __LINE__);
107 run_program_and_log_output("umount /dev/cdr* /dev/dvd*", 5);
108}
109
110
111
112/**
113 * Determine whether we're booted off a ramdisk.
114 * @return @c TRUE (we are) or @c FALSE (we aren't).
115 * @ingroup utilityGroup
116 */
117bool am_I_in_disaster_recovery_mode(void)
118{
119 char *tmp = NULL;
120 char *comment;
121 bool is_this_a_ramdisk = FALSE;
122
123 malloc_string(comment);
124 mr_asprintf(&tmp, "%s", where_is_root_mounted());
125 sprintf(comment, "root is mounted at %s\n", tmp);
126 log_msg(0, comment);
127 log_msg(0,
128 "No, Schlomo, that doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().",
129 tmp);
130
131#ifdef __FreeBSD__
132 if (strstr(tmp, "/dev/md")) {
133 is_this_a_ramdisk = TRUE;
134 }
135#else
136 if (!strncmp(tmp, "/dev/ram", 8)
137 || (!strncmp(tmp, "/dev/rd", 7) && !strcmp(tmp, "/dev/rd/")
138 && strncmp(tmp, "/dev/rd/cd", 10)) || strstr(tmp, "rootfs")
139 || !strcmp(tmp, "/dev/root")) {
140 is_this_a_ramdisk = TRUE;
141 } else {
142 is_this_a_ramdisk = FALSE;
143 }
144#endif
145 mr_free(tmp);
146
147 if (is_this_a_ramdisk) {
148 if (!does_file_exist("/THIS-IS-A-RAMDISK")) {
149 log_to_screen
150 ("Using /dev/root is stupid of you but I'll forgive you.");
151 is_this_a_ramdisk = FALSE;
152 }
153 }
154 if (does_file_exist("/THIS-IS-A-RAMDISK")) {
155 is_this_a_ramdisk = TRUE;
156 }
157 paranoid_free(comment);
158 log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
159 return (is_this_a_ramdisk);
160}
161
162
163
164
165
166/**
167 * Turn @c bkpinfo->backup_media_type into a human-readable string.
168 * @return The human readable string (e.g. @c cdr becomes <tt>"cdr"</tt>).
169 * @note The returned string points to static storage that will be overwritten with each call.
170 * @ingroup stringGroup
171 */
172static char *bkptype_to_string(t_bkptype bt)
173{
174 static char output[MAX_STR_LEN / 4];
175 switch (bt) {
176 case none:
177 strcpy(output, "none");
178 break;
179 case iso:
180 strcpy(output, "iso");
181 break;
182 case cdr:
183 strcpy(output, "cdr");
184 break;
185 case cdrw:
186 strcpy(output, "cdrw");
187 break;
188 case cdstream:
189 strcpy(output, "cdstream");
190 break;
191 case netfs:
192 strcpy(output, "netfs");
193 break;
194 case tape:
195 strcpy(output, "tape");
196 break;
197 case udev:
198 strcpy(output, "udev");
199 break;
200 case usb:
201 strcpy(output, "usb");
202 break;
203 default:
204 strcpy(output, "default");
205 }
206 return (output);
207}
208
209
210
211/**
212 * @addtogroup deviceGroup
213 * @{
214 */
215/**
216 * Eject the tray of the specified CD device.
217 * @param dev The device to eject.
218 * @return the return value of the @c eject command. (0=success, nonzero=failure)
219 */
220int eject_device(char *dev)
221{
222 char *command;
223 int res1 = 0, res2 = 0;
224
225 malloc_string(command);
226
227 if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
228 && g_backup_media_type != udev) {
229 sprintf(command, "mt -f %s offline", dev);
230 res1 = run_program_and_log_output(command, 1);
231 } else {
232 res1 = 0;
233 }
234
235#ifdef __FreeBSD__
236 if (strstr(dev, "acd")) {
237 sprintf(command, "cdcontrol -f %s eject", dev);
238 } else {
239 sprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
240 dev);
241 }
242#else
243 sprintf(command, "eject %s", dev);
244#endif
245
246 log_msg(3, "Ejecting %s", dev);
247 res2 = run_program_and_log_output(command, 1);
248 paranoid_free(command);
249 if (res1 && res2) {
250 return (1);
251 } else {
252 return (0);
253 }
254}
255
256/**
257 * Load (inject) the tray of the specified CD device.
258 * @param dev The device to load/inject.
259 * @return 0 for success, nonzero for failure.
260 */
261int inject_device(char *dev)
262{
263 char *command;
264 int i;
265
266 malloc_string(command);
267
268
269#ifdef __FreeBSD__
270 if (strstr(dev, "acd")) {
271 sprintf(command, "cdcontrol -f %s close", dev);
272 } else {
273 sprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`",
274 dev);
275 }
276#else
277 sprintf(command, "eject -t %s", dev);
278#endif
279 i = run_program_and_log_output(command, FALSE);
280 paranoid_free(command);
281 return (i);
282}
283
284
285/**
286 * Determine whether the specified @p device (really, you can use any file)
287 * exists.
288 * @return TRUE if it exists, FALSE if it doesn't.
289 */
290bool does_device_exist(char *device)
291{
292
293 /*@ buffers *********************************************************** */
294 char *tmp;
295 bool ret;
296
297 malloc_string(tmp);
298 assert_string_is_neither_NULL_nor_zerolength(device);
299
300 sprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
301
302 if (system(tmp)) {
303 ret = FALSE;
304 } else {
305 ret = TRUE;
306 }
307 paranoid_free(tmp);
308 return (ret);
309}
310
311
312/**
313 * Determine whether a non-Microsoft partition exists on any connected hard drive.
314 * @return TRUE (there's a Linux/FreeBSD partition) or FALSE (Microsoft has taken over yet another innocent PC).
315 */
316bool does_nonMS_partition_exist(void)
317{
318#if __FreeBSD__
319 return
320 !system
321 ("for drive in /dev/ad? /dev/da?; do fdisk $drive | grep -q FreeBSD && exit 0; done; false");
322#else
323 return
324 !system
325 ("parted2fdisk -l 2>/dev/null | grep '^/dev/' | grep -Eqv '(MS|DOS|FAT|NTFS)'");
326#endif
327}
328
329/**
330 * Determine whether the specified @p partno exists on the specified @p drive.
331 * @param drive The drive to search for the partition in.
332 * @param partno The partition number to look for.
333 * @return 0 if it exists, nonzero otherwise.
334 */
335int does_partition_exist(const char *drive, int partno)
336{
337 /*@ buffers **************************************************** */
338 char *program;
339 char *incoming;
340 char *searchstr = NULL;
341 char *tmp;
342
343 /*@ ints ******************************************************* */
344 int res = 0;
345
346 /*@ pointers *************************************************** */
347 FILE *fin;
348
349
350 /*@ end vars *************************************************** */
351 assert_string_is_neither_NULL_nor_zerolength(drive);
352 assert(partno >= 0 && partno < 999);
353
354 malloc_string(program);
355 malloc_string(incoming);
356 malloc_string(searchstr);
357 malloc_string(tmp);
358
359#ifdef __FreeBSD__
360 // We assume here that this is running from mondorestore. (It is.)
361 sprintf(program, "ls %s %s >/dev/null 2>&1", drive,
362 build_partition_name(tmp, drive, partno));
363 return system(program);
364#else
365 tmp[0] = '\0';
366#endif
367
368 sprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
369 fin = popen(program, "r");
370 if (!fin) {
371 log_it("program=%s", program);
372 log_OS_error("Cannot popen-in program");
373 return (0);
374 }
375 (void) build_partition_name(searchstr, drive, partno);
376 strcat(searchstr, " ");
377 for (res = 0; !res && fgets(incoming, MAX_STR_LEN - 1, fin);) {
378 if (strstr(incoming, searchstr)) {
379 res = 1;
380 }
381 }
382 if (pclose(fin)) {
383 log_OS_error("Cannot pclose fin");
384 }
385 paranoid_free(program);
386 paranoid_free(incoming);
387 paranoid_free(searchstr);
388 paranoid_free(tmp);
389 return (res);
390}
391
392
393
394
395
396/**
397 * Determine whether given NULL-terminated @p str exists in the MBR of @p dev.
398 * @param dev The device to look in.
399 * @param str The string to look for.
400 * @return TRUE if it exists, FALSE if it doesn't.
401 */
402bool does_string_exist_in_boot_block(char *dev, char *str)
403{
404 /*@ buffers **************************************************** */
405 char *command;
406
407 /*@ end vars *************************************************** */
408 int i;
409
410 assert_string_is_neither_NULL_nor_zerolength(dev);
411 assert_string_is_neither_NULL_nor_zerolength(str);
412
413 malloc_string(command);
414 sprintf(command,
415 "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
416 dev, str);
417 i = system(command);
418 paranoid_free(command);
419 if (i) {
420 return (FALSE);
421 } else {
422 return (TRUE);
423 }
424}
425
426/**
427 * Determine whether specified @p str exists in the first @p n sectors of
428 * @p dev.
429 * @param dev The device to look in.
430 * @param str The string to look for.
431 * @param n The number of 512-byte sectors to search.
432 */
433bool does_string_exist_in_first_N_blocks(char *dev, char *str, int n)
434{
435 /*@ buffers **************************************************** */
436 char *command;
437 /*@ end vars *************************************************** */
438 int i;
439
440 malloc_string(command);
441 sprintf(command,
442 "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
443 dev, n, str);
444 i = system(command);
445 paranoid_free(command);
446 if (i) {
447 return (FALSE);
448 } else {
449 return (TRUE);
450 }
451}
452
453
454
455/**
456 * Try to mount CD-ROM at @p mountpoint. If the CD-ROM is not found or has
457 * not been specified, call find_cdrom_device() to find it.
458 * @param bkpinfo The backup information structure. The only field used is @c bkpinfo->media_device.
459 * @param mountpoint Where to mount the CD-ROM.
460 * @return 0 for success, nonzero for failure.
461 * @see mount_CDROM_here
462 */
463int find_and_mount_actual_cd(char *mountpoint)
464{
465 /*@ buffers ***************************************************** */
466
467 /*@ int's ****************************************************** */
468 int res;
469 char *dev;
470
471 /*@ end vars **************************************************** */
472
473 malloc_string(dev);
474 assert(bkpinfo != NULL);
475 assert_string_is_neither_NULL_nor_zerolength(mountpoint);
476
477 if (g_backup_media_type == dvd) {
478 strcpy(dev, g_dvd_drive_is_here);
479 if (!dev[0]) {
480 find_dvd_device(dev, FALSE);
481 }
482 } else {
483 strcpy(dev, g_cdrom_drive_is_here);
484 if (!dev[0]) {
485 find_cdrom_device(dev, FALSE);
486 }
487 }
488
489 if (bkpinfo->backup_media_type != iso) {
490 retract_CD_tray_and_defeat_autorun();
491 }
492
493 if (!dev[0] || (res = mount_CDROM_here(dev, mountpoint))) {
494 if (!popup_and_get_string
495 ("CD-ROM device", "Please enter your CD-ROM's /dev device",
496 dev, MAX_STR_LEN / 4)) {
497 res = 1;
498 } else {
499 res = mount_CDROM_here(dev, mountpoint);
500 }
501 }
502 if (res) {
503 log_msg(1, "mount failed");
504 } else {
505 log_msg(1, "mount succeeded with %s", dev);
506 }
507 paranoid_free(dev);
508 return (res);
509}
510
511
512
513
514
515
516/**
517 * Locate a CD-R/W writer's SCSI node.
518 * @param cdrw_device SCSI node will be placed here.
519 * @return 0 for success, nonzero for failure.
520 */
521int find_cdrw_device(char *cdrw_device)
522{
523 /*@ buffers ************************ */
524 char *comment;
525 char *tmp = NULL;
526 char *cdr_exe = NULL;
527 char *command;
528
529 malloc_string(comment);
530 malloc_string(command);
531 if (g_cdrw_drive_is_here[0]) {
532 strcpy(cdrw_device, g_cdrw_drive_is_here);
533 log_msg(3, "Been there, done that. Returning %s", cdrw_device);
534 paranoid_free(comment);
535 paranoid_free(command);
536 return (0);
537 }
538 if (g_backup_media_type == dvd) {
539 log_msg(1,
540 "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
541 paranoid_free(comment);
542 paranoid_free(command);
543 return (1);
544 }
545 run_program_and_log_output("insmod ide-scsi", -1);
546 if (find_home_of_exe("cdrecord")) {
547 mr_asprintf(&cdr_exe, "cdrecord");
548 } else {
549 mr_asprintf(&cdr_exe, "dvdrecord");
550 }
551 if (find_home_of_exe(cdr_exe)) {
552 sprintf(command,
553 "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep CD | cut -d' ' -f2 | head -n1",
554 cdr_exe);
555 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
556 }
557 if ((tmp == NULL) || (strlen(tmp) < 2)) {
558 paranoid_free(comment);
559 mr_free(tmp);
560 mr_free(cdr_exe);
561 paranoid_free(command);
562 return 1;
563 } else {
564 strcpy(cdrw_device, tmp);
565 sprintf(comment, "Found CDRW device - %s", cdrw_device);
566 log_it(comment);
567 strcpy(g_cdrw_drive_is_here, cdrw_device);
568 paranoid_free(comment);
569 mr_free(tmp);
570 mr_free(cdr_exe);
571 paranoid_free(command);
572 return (0);
573 }
574}
575
576
577
578
579/**
580 * Attempt to locate a CD-ROM device's /dev entry.
581 * Several different methods may be used to find the device, including
582 * calling @c cdrecord, searching @c dmesg, and trial-and-error.
583 * @param output Where to put the located /dev entry.
584 * @param try_to_mount Whether to mount the CD as part of the test; if mount
585 * fails then return failure.
586 * @return 0 for success, nonzero for failure.
587 */
588int find_cdrom_device(char *output, bool try_to_mount)
589{
590 /*@ pointers **************************************************** */
591 FILE *fin;
592 char *p;
593 char *q;
594 char *r;
595 int retval = 0;
596
597 /*@ bool's ****************************************************** */
598 bool found_it = FALSE;
599
600 /*@ buffers ***************************************************** */
601 char *tmp;
602 char *tmp1 = NULL;
603 char *cdr_exe = NULL;
604 char *phrase_one;
605 char *phrase_two;
606 char *command;
607 char *dvd_last_resort;
608 char *mountpoint;
609 static char the_last_place_i_found_it[MAX_STR_LEN] = "";
610
611 /*@ intialize *************************************************** */
612 malloc_string(tmp);
613 malloc_string(phrase_one);
614 malloc_string(phrase_two);
615 malloc_string(command);
616 malloc_string(dvd_last_resort);
617 malloc_string(mountpoint);
618
619 output[0] = '\0';
620 phrase_one[0] = '\0';
621 phrase_two[0] = '\0';
622 dvd_last_resort[0] = '\0';
623
624 /*@ end vars **************************************************** */
625
626 if (g_cdrom_drive_is_here[0] && !isdigit(g_cdrom_drive_is_here[0])) {
627 strcpy(output, g_cdrom_drive_is_here);
628 log_msg(3, "Been there, done that. Returning %s", output);
629 retval = 0;
630 goto end_of_find_cdrom_device;
631 }
632 if (the_last_place_i_found_it[0] != '\0' && !try_to_mount) {
633 strcpy(output, the_last_place_i_found_it);
634 log_msg(3,
635 "find_cdrom_device() --- returning last found location - '%s'",
636 output);
637 retval = 0;
638 goto end_of_find_cdrom_device;
639 }
640
641 sprintf(mountpoint, "%s/cd.mnt", bkpinfo->tmpdir);
642 make_hole_for_dir(mountpoint);
643
644 if (find_home_of_exe("cdrecord")) {
645 mr_asprintf(&cdr_exe, "cdrecord");
646 } else {
647 mr_asprintf(&cdr_exe, "dvdrecord");
648 }
649 tmp[0] = '\0';
650 if (!find_home_of_exe(cdr_exe)) {
651 strcpy(output, "/dev/cdrom");
652 log_msg(4, "Can't find cdrecord; assuming %s", output);
653 if (!does_device_exist(output)) {
654 log_msg(4, "That didn't work. Sorry.");
655 retval = 1;
656 goto end_of_find_cdrom_device;
657 } else {
658 retval = 0;
659 goto end_of_find_cdrom_device;
660 }
661 }
662
663 sprintf(command, "%s -scanbus 2> /dev/null", cdr_exe);
664 fin = popen(command, "r");
665 if (!fin) {
666 log_msg(4, "command=%s", command);
667 log_OS_error("Cannot popen command");
668 mr_free(cdr_exe);
669 return (1);
670 }
671 for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
672 (void)fgets(tmp, MAX_STR_LEN, fin)) {
673 p = strchr(tmp, '\'');
674 if (p) {
675 q = strchr(++p, '\'');
676 if (q) {
677 for (r = q; *(r - 1) == ' '; r--);
678 *r = '\0';
679 strcpy(phrase_one, p);
680 p = strchr(++q, '\'');
681 if (p) {
682 q = strchr(++p, '\'');
683 if (q) {
684 while (*(q - 1) == ' ') {
685 q--;
686 }
687 *q = '\0';
688 strcpy(phrase_two, p);
689 }
690 }
691 }
692 }
693 }
694 paranoid_pclose(fin);
695
696#ifndef __FreeBSD__
697 if (strlen(phrase_two) == 0) {
698 log_msg(4, "Not running phase two. String is empty.");
699 } else {
700 sprintf(command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
701 fin = popen(command, "r");
702 if (!fin) {
703 log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
704 } else {
705 for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
706 (void)fgets(tmp, MAX_STR_LEN, fin)) {
707 log_msg(5, "--> '%s'", tmp);
708 if (tmp[0] != ' ' && tmp[1] != ' ') {
709 p = strchr(tmp, ':');
710 if (p) {
711 *p = '\0';
712 if (strstr(tmp, "DVD")) {
713 sprintf(dvd_last_resort, "/dev/%s", tmp);
714 log_msg(4,
715 "Ignoring '%s' because it's a DVD drive",
716 tmp);
717 } else {
718 sprintf(output, "/dev/%s", tmp);
719 found_it = TRUE;
720 }
721 }
722 }
723 }
724 paranoid_pclose(fin);
725 }
726 }
727
728#endif
729#ifdef __FreeBSD__
730 if (!found_it) {
731 log_msg(4, "OK, approach 2");
732 if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/cdrom"))) {
733 if (!
734 (found_it =
735 set_dev_to_this_if_rx_OK(output, "/dev/cdrom1"))) {
736 if (!
737 (found_it =
738 set_dev_to_this_if_rx_OK(output, "/dev/dvd"))) {
739 if (!
740 (found_it =
741 set_dev_to_this_if_rx_OK(output, "/dev/acd0"))) {
742 if (!
743 (found_it =
744 set_dev_to_this_if_rx_OK(output,
745 "/dev/cd01"))) {
746 if (!
747 (found_it =
748 set_dev_to_this_if_rx_OK(output,
749 "/dev/acd1"))) {
750 if (!
751 (found_it =
752 set_dev_to_this_if_rx_OK(output,
753 "/dev/cd1")))
754 {
755 retval = 1;
756 goto end_of_find_cdrom_device;
757 }
758 }
759 }
760 }
761 }
762 }
763 }
764 }
765#else
766 if (!found_it && strlen(dvd_last_resort) > 0) {
767 log_msg(4, "Well, I'll use the DVD - %s - as a last resort",
768 dvd_last_resort);
769 strcpy(output, dvd_last_resort);
770 found_it = TRUE;
771 }
772 if (found_it) {
773 sprintf(tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null",
774 strrchr(output, '/') + 1);
775 if (system(tmp) == 0) {
776 log_msg(4,
777 "%s is not right. It's being SCSI-emulated. Continuing.",
778 output);
779 found_it = FALSE;
780 output[0] = '\0';
781 }
782 }
783
784 if (found_it) {
785 log_msg(4, "(find_cdrom_device) --> '%s'", output);
786 if (!does_device_exist(output)) {
787 found_it = FALSE;
788 log_msg(4, "OK, I was wrong, I haven't found it... yet.");
789 }
790 }
791
792 if (!found_it) {
793 log_msg(4, "OK, approach 2");
794 if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/scd0"))) {
795 if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/sr0"))) {
796 if (!
797 (found_it =
798 set_dev_to_this_if_rx_OK(output, "/dev/cdrom"))) {
799 if (!
800 (found_it =
801 set_dev_to_this_if_rx_OK(output,
802 "/dev/cdrom0"))) {
803 if (!
804 (found_it =
805 set_dev_to_this_if_rx_OK(output,
806 "/dev/cdrom1"))) {
807 if (!
808 (found_it =
809 set_dev_to_this_if_rx_OK(output,
810 "/dev/sr1"))) {
811 if (!
812 (found_it =
813 set_dev_to_this_if_rx_OK(output,
814 "/dev/dvd")))
815 {
816 if (!
817 (found_it =
818 set_dev_to_this_if_rx_OK(output,
819 g_cdrw_drive_is_here)))
820 {
821 retval = 1;
822 goto end_of_find_cdrom_device;
823 }
824 }
825 }
826 }
827 }
828 }
829 }
830 }
831 }
832#endif
833
834 if (found_it && try_to_mount) {
835 if (mount_CDROM_here(output, mountpoint)) {
836 log_msg(4, "[Cardigans] I've changed my mind");
837 found_it = FALSE;
838 } else {
839 sprintf(tmp, "%s/archives", mountpoint);
840 if (!does_file_exist(tmp)) {
841 log_msg(4, "[Cardigans] I'll take it back");
842 found_it = FALSE;
843 } else {
844 sprintf(command, "umount %s", output);
845 paranoid_system(command);
846 log_msg(4, "I'm confident the Mondo CD is in %s", output);
847 }
848 }
849 }
850 unlink(mountpoint);
851
852 if (found_it) {
853 if (!does_file_exist(output)) {
854 log_msg(3, "I still haven't found it.");
855 return (1);
856 }
857 log_msg(3, "(find_cdrom_device) --> '%s'", output);
858 strcpy(the_last_place_i_found_it, output);
859 strcpy(g_cdrom_drive_is_here, output);
860 retval = 0;
861 goto end_of_find_cdrom_device;
862 }
863
864 sprintf(command,
865 "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2",
866 cdr_exe, g_cdrw_drive_is_here);
867 log_msg(1, "command=%s", command);
868 mr_asprintf(&tmp1, "%s", call_program_and_get_last_line_of_output(command));
869 if (strlen(tmp1) > 0) {
870 strcpy(output, tmp1);
871 log_msg(4, "Finally found it at %s", output);
872 retval = 0;
873 } else {
874 log_msg(4, "Still couldn't find it.");
875 retval = 1;
876 }
877 mr_free(tmp1);
878
879 end_of_find_cdrom_device:
880 paranoid_free(tmp);
881 mr_free(cdr_exe);
882 paranoid_free(phrase_one);
883 paranoid_free(phrase_two);
884 paranoid_free(command);
885 paranoid_free(dvd_last_resort);
886 paranoid_free(mountpoint);
887 return (retval);
888}
889
890
891
892
893
894int find_dvd_device(char *output, bool try_to_mount)
895{
896 char *command;
897 char *tmp;
898 int retval = 0, devno = -1;
899
900 malloc_string(command);
901 malloc_string(tmp);
902
903 if (g_dvd_drive_is_here[0]) {
904 strcpy(output, g_dvd_drive_is_here);
905 log_msg(3, "Been there, done that. Returning %s", output);
906 return (0);
907 }
908
909 sprintf(tmp, "%s", call_program_and_get_last_line_of_output
910 ("dvdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
911 );
912 log_msg(5, "tmp = '%s'", tmp);
913 if (!tmp[0])
914 sprintf(tmp, "%s", call_program_and_get_last_line_of_output
915 ("cdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
916 );
917 if (tmp[0]) {
918 devno = atoi(tmp) - 1;
919 }
920 if (devno >= 0) {
921 retval = 0;
922 sprintf(output, "/dev/scd%d", devno);
923 strcpy(g_dvd_drive_is_here, output);
924 log_msg(2, "I think DVD is at %s", output);
925 } else {
926 log_msg(2, "I cannot find DVD");
927 retval = 1;
928 }
929
930 if (try_to_mount) {
931 log_msg(1, "Ignoring the fact that try_to_mount==TRUE");
932 }
933 return (retval);
934}
935
936
937
938
939
940#include <sys/ioctl.h>
941
942/**
943 * Find the size of the specified @p drive, in megabytes. Uses @c ioctl calls
944 * and @c dmesg.
945 * @param drive The device to find the size of.
946 * @return size in megabytes.
947 */
948long get_phys_size_of_drive(char *drive)
949{
950 int fd;
951#if linux
952 unsigned long long s = 0;
953 int fileid, cylinders = 0, cylindersleft = 0;
954 int cylindersize = 0;
955 int gotgeo = 0;
956
957
958 struct hd_geometry hdgeo;
959#elif __FreeBSD__
960 off_t s;
961#endif
962
963 long outvalA = -1;
964 long outvalB = -1;
965 long outvalC = -1;
966
967 if ((fd = open(drive, O_RDONLY)) != -1) {
968 if (ioctl(fd,
969#if linux
970#ifdef BLKGETSIZE64
971 BLKGETSIZE64,
972#else
973 BLKGETSIZE,
974#endif
975#elif __FreeBSD__
976 DIOCGMEDIASIZE,
977#endif
978 &s) != -1) {
979 close(fd);
980 // s>>11 works for older disks but not for newer ones
981 outvalB =
982#if linux
983#ifdef BLKGETSIZE64
984 s >> 20
985#else
986 s >> 11
987#endif
988#else
989 s >> 20
990#endif
991 ;
992 }
993 }
994
995 if (outvalB <= 0) {
996 log_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
997#if linux
998 fileid = open(drive, O_RDONLY);
999 if (fileid != -1) {
1000 if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
1001 if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
1002 cylindersleft = cylinders = hdgeo.cylinders;
1003 cylindersize = hdgeo.heads * hdgeo.sectors / 2;
1004 outvalA = cylindersize * cylinders / 1024;
1005 log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
1006 hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
1007 gotgeo = 1;
1008 } else {
1009 log_msg(1, "Harddisk geometry wrong");
1010 }
1011 } else {
1012 log_msg(1,
1013 "Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
1014 strerror(errno));
1015 }
1016 close(fileid);
1017 } else {
1018 log_msg(1, "Failed to open %s for reading: %s", drive,
1019 strerror(errno));
1020 }
1021 if (!gotgeo) {
1022 log_msg(1, "Failed to get harddisk geometry, using old mode");
1023 }
1024#endif
1025 }
1026// OLDER DISKS will give ridiculously low value for outvalB (so outvalA is returned) :)
1027// NEWER DISKS will give sane value for outvalB (close to outvalA, in other words) :)
1028
1029 outvalC = (outvalA > outvalB) ? outvalA : outvalB;
1030
1031// log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
1032// fatal_error ("GPSOD: Unable to get size of drive");
1033 log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
1034 outvalC);
1035
1036 return (outvalC);
1037}
1038
1039/**
1040 * Determine whether @p format is supported by the kernel. Uses /proc/filesystems
1041 * under Linux and @c lsvfs under FreeBSD.
1042 * @param format The format to test.
1043 * @return TRUE if the format is supported, FALSE if not.
1044 */
1045bool is_this_a_valid_disk_format(char *format)
1046{
1047 char *good_formats = NULL;
1048 char *command;
1049 char *format_sz;
1050
1051 FILE *pin;
1052 int retval;
1053 malloc_string(good_formats);
1054 malloc_string(command);
1055 malloc_string(format_sz);
1056
1057 assert_string_is_neither_NULL_nor_zerolength(format);
1058
1059 sprintf(format_sz, "%s ", format);
1060
1061#ifdef __FreeBSD__
1062 sprintf(command,
1063 "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
1064#else
1065 sprintf(command,
1066 "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
1067#endif
1068
1069 pin = popen(command, "r");
1070 if (!pin) {
1071 log_OS_error("Unable to read good formats");
1072 retval = 0;
1073 } else {
1074 strcpy(good_formats, " ");
1075 (void) fgets(good_formats + 1, MAX_STR_LEN - 1, pin);
1076 if (pclose(pin)) {
1077 log_OS_error("Cannot pclose good formats");
1078 }
1079 strip_spaces(good_formats);
1080 strcat(good_formats, " swap lvm raid ntfs-3g ntfs 7 "); // " ntfs 7 " -- um, cheating much? :)
1081 if (strstr(good_formats, format_sz)) {
1082 retval = 1;
1083 } else {
1084 retval = 0;
1085 }
1086 }
1087 paranoid_free(good_formats);
1088 paranoid_free(command);
1089 paranoid_free(format_sz);
1090 return (retval);
1091}
1092
1093
1094/** @def SWAPLIST_COMMAND The command to list the swap files/partitions in use. */
1095
1096/**
1097 * Determine whether @p device_raw is currently mounted.
1098 * @param device_raw The device to check.
1099 * @return TRUE if it's mounted, FALSE if not.
1100 */
1101bool is_this_device_mounted(char *device_raw)
1102{
1103
1104 /*@ pointers **************************************************** */
1105 FILE *fin;
1106
1107 /*@ buffers ***************************************************** */
1108 char *incoming;
1109 char *device_with_tab = NULL;
1110 char *device_with_space = NULL;
1111 char *tmp = NULL;
1112 bool retval = FALSE;
1113
1114#ifdef __FreeBSD__
1115#define SWAPLIST_COMMAND "swapinfo"
1116#else
1117#define SWAPLIST_COMMAND "cat /proc/swaps"
1118#endif
1119
1120 /*@ end vars **************************************************** */
1121
1122 malloc_string(incoming);
1123 assert(device_raw != NULL);
1124// assert_string_is_neither_NULL_nor_zerolength(device_raw);
1125 if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
1126 log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
1127 device_raw);
1128 mr_asprintf(&tmp, "/%s", device_raw);
1129 } else {
1130 mr_asprintf(&tmp, "%s", device_raw);
1131 }
1132 log_msg(1, "Is %s mounted?", tmp);
1133 if (!strcmp(tmp, "/proc") || !strcmp(tmp, "proc")) {
1134 log_msg(1,
1135 "I don't know how the heck /proc made it into the mountlist. I'll ignore it.");
1136 mr_free(tmp);
1137 return(FALSE);
1138 }
1139 mr_asprintf(&device_with_tab, "%s\t", tmp);
1140 mr_asprintf(&device_with_space, "%s ", tmp);
1141 mr_free(tmp);
1142
1143 if (!(fin = popen("mount", "r"))) {
1144 log_OS_error("Cannot popen 'mount'");
1145 return(FALSE);
1146 }
1147 for ((void)fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
1148 (void)fgets(incoming, MAX_STR_LEN - 1, fin)) {
1149 if (strstr(incoming, device_with_space) //> incoming
1150 || strstr(incoming, device_with_tab)) // > incoming)
1151 {
1152 paranoid_pclose(fin);
1153 paranoid_free(incoming);
1154 return(TRUE);
1155 }
1156 }
1157 mr_free(device_with_tab);
1158 paranoid_pclose(fin);
1159 mr_asprintf(&tmp, "%s | grep -E \"^%s\" > /dev/null 2> /dev/null", SWAPLIST_COMMAND, device_with_space);
1160 mr_free(device_with_space);
1161 log_msg(4, "tmp (command) = '%s'", tmp);
1162 if (!system(tmp)) {
1163 retval = TRUE;
1164 }
1165 mr_free(tmp);
1166 paranoid_free(incoming);
1167 return(retval);
1168}
1169
1170#ifdef __FreeBSD__
1171// CODE IS FREEBSD-SPECIFIC
1172/**
1173 * Create a loopback device for specified @p fname.
1174 * @param fname The file to associate with a device.
1175 * @return /dev entry for the device, or NULL if it couldn't be allocated.
1176 */
1177char *make_vn(char *fname)
1178{
1179 char *device = (char *) malloc(MAX_STR_LEN);
1180 char *mddevice = (char *) malloc(32);
1181 char command[MAX_STR_LEN];
1182 int vndev = 2;
1183 if (atoi
1184 (call_program_and_get_last_line_of_output
1185 ("/sbin/sysctl -n kern.osreldate")) < 500000) {
1186 do {
1187 sprintf(mddevice, "vn%ic", vndev++);
1188 sprintf(command, "vnconfig %s %s", mddevice, fname);
1189 if (vndev > 10) {
1190 return NULL;
1191 }
1192 }
1193 while (system(command));
1194 } else {
1195 sprintf(command, "mdconfig -a -t vnode -f %s", fname);
1196 mddevice = call_program_and_get_last_line_of_output(command);
1197 if (!strstr(mddevice, "md")) {
1198 return NULL;
1199 }
1200 }
1201 sprintf(device, "/dev/%s", mddevice);
1202 return device;
1203}
1204
1205
1206
1207// CODE IS FREEBSD-SPECIFIC
1208/**
1209 * Deallocate specified @p dname.
1210 * This should be called when you are done with the device created by make_vn(),
1211 * so the system does not run out of @c vn devices.
1212 * @param dname The device to deallocate.
1213 * @return 0 for success, nonzero for failure.
1214 */
1215int kick_vn(char *dname)
1216{
1217 char command[MAX_STR_LEN];
1218
1219 if (strncmp(dname, "/dev/", 5) == 0) {
1220 dname += 5;
1221 }
1222
1223 if (atoi
1224 (call_program_and_get_last_line_of_output
1225 ("/sbin/sysctl -n kern.osreldate")) < 500000) {
1226 sprintf(command, "vnconfig -d %s", dname);
1227 return system(command);
1228 } else {
1229 sprintf(command, "mdconfig -d -u %s", dname);
1230 return system(command);
1231 }
1232 /*NOTREACHED*/ return 255;
1233}
1234#endif
1235
1236
1237/**
1238 * Mount the CD-ROM at @p mountpoint.
1239 * @param device The device (or file if g_ISO_restore_mode) to mount.
1240 * @param mountpoint The place to mount it.
1241 * @return 0 for success, nonzero for failure.
1242 */
1243int mount_USB_here(char *device, char *mountpoint)
1244{
1245 /*@ buffer ****************************************************** */
1246 char *command;
1247 int retval;
1248
1249 malloc_string(command);
1250 assert_string_is_neither_NULL_nor_zerolength(device);
1251 assert_string_is_neither_NULL_nor_zerolength(mountpoint);
1252
1253 make_hole_for_dir(mountpoint);
1254 if (isdigit(device[0])) {
1255 return(1);
1256 }
1257 log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device,
1258 mountpoint);
1259
1260#ifdef __FreeBSD__
1261 sprintf(command, "mount_vfat %s %s 2>> %s",
1262 device, mountpoint, MONDO_LOGFILE);
1263
1264#else
1265 sprintf(command, "mount %s -t vfat %s 2>> %s",
1266 device, mountpoint, MONDO_LOGFILE);
1267#endif
1268
1269 log_msg(4, command);
1270 retval = system(command);
1271 log_msg(1, "system(%s) returned %d", command, retval);
1272
1273 paranoid_free(command);
1274 return (retval);
1275}
1276
1277/**
1278 * Mount the CD-ROM at @p mountpoint.
1279 * @param device The device (or file if g_ISO_restore_mode) to mount.
1280 * @param mountpoint The place to mount it.
1281 * @return 0 for success, nonzero for failure.
1282 */
1283int mount_CDROM_here(char *device, char *mountpoint)
1284{
1285 /*@ buffer ****************************************************** */
1286 char *command = NULL;
1287 int retval;
1288#ifdef __FreeBSD__
1289 char *dev = NULL;
1290#else
1291 char *options = NULL;
1292#endif
1293
1294 assert_string_is_neither_NULL_nor_zerolength(device);
1295 assert_string_is_neither_NULL_nor_zerolength(mountpoint);
1296
1297 make_hole_for_dir(mountpoint);
1298
1299 if (isdigit(device[0])) {
1300 find_cdrom_device(device, FALSE);
1301 }
1302#ifndef __FreeBSD__
1303 mr_asprintf(&options, "ro");
1304#endif
1305
1306 if (g_ISO_restore_mode) {
1307
1308#ifdef __FreeBSD__
1309 mr_asprintf(&dev, "%s", make_vn(device));
1310 if (!dev) {
1311 mr_asprintf(&command, "Unable to mount ISO (make_vn(%s) failed)", device);
1312 fatal_error(command);
1313 }
1314 strcpy(device, dev);
1315 paranoid_free(dev);
1316#else
1317 mr_strcat(options, ",loop");
1318#endif
1319
1320 }
1321 log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
1322 mountpoint);
1323 /*@ end vars *************************************************** */
1324
1325#ifdef __FreeBSD__
1326 mr_asprintf(&command, "mount_cd9660 -r %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
1327
1328#else
1329 mr_asprintf(&command, "mount %s -o %s -t iso9660 %s 2>> %s", device, options, mountpoint, MONDO_LOGFILE);
1330 paranoid_free(options);
1331#endif
1332
1333 log_msg(4, command);
1334 if (strncmp(device, "/dev/", 5) == 0) {
1335 retract_CD_tray_and_defeat_autorun();
1336 }
1337 retval = system(command);
1338 log_msg(1, "system(%s) returned %d", command, retval);
1339 paranoid_free(command);
1340
1341 return (retval);
1342}
1343
1344
1345/**
1346* Mount the CD-ROM or USB device at /mnt/cdrom.
1347* @param bkpinfo The backup information structure. Fields used:
1348* - @c bkpinfo->backup_media_type
1349* - @c bkpinfo->disaster_recovery
1350* - @c bkpinfo->isodir
1351* - @c bkpinfo->media_device
1352* @return 0 for success, nonzero for failure.
1353*/
1354int mount_media()
1355{
1356char *mount_cmd;
1357int i, res;
1358#ifdef __FreeBSD__
1359char mdd[32];
1360char *mddev = mdd;
1361#endif
1362
1363malloc_string(mount_cmd);
1364assert(bkpinfo != NULL);
1365
1366 if (bkpinfo->backup_media_type == tape
1367 || bkpinfo->backup_media_type == udev) {
1368 log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
1369 paranoid_free(mount_cmd);
1370 return 0;
1371 }
1372
1373 if (!run_program_and_log_output("mount | grep -F " MNT_CDROM, FALSE)) {
1374 log_msg(2, "mount_media() - media already mounted. Fair enough.");
1375 paranoid_free(mount_cmd);
1376 return (0);
1377 }
1378
1379 if (bkpinfo->backup_media_type == netfs) {
1380 log_msg(2, "Mounting for Network thingy");
1381 log_msg(2, "isodir = %s", bkpinfo->isodir);
1382 if ((!bkpinfo->isodir[0] || !strcmp(bkpinfo->isodir, "/"))
1383 && am_I_in_disaster_recovery_mode()) {
1384 strcpy(bkpinfo->isodir, "/tmp/isodir");
1385 log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
1386 }
1387#ifdef __FreeBSD__
1388 sprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
1389 bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
1390 mddev = make_vn(mount_cmd);
1391 sprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
1392#else
1393 sprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
1394 bkpinfo->isodir, bkpinfo->netfs_remote_dir,
1395 bkpinfo->prefix, g_current_media_number, MNT_CDROM);
1396#endif
1397
1398 } else if (bkpinfo->backup_media_type == iso) {
1399#ifdef __FreeBSD__
1400 sprintf(mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
1401 bkpinfo->prefix, g_current_media_number);
1402 mddev = make_vn(mount_cmd);
1403 sprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
1404#else
1405 sprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
1406 bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
1407#endif
1408 } else if (bkpinfo->backup_media_type == usb) {
1409 sprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, MNT_CDROM);
1410 } else if (strstr(bkpinfo->media_device, "/dev/")) {
1411#ifdef __FreeBSD__
1412 sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
1413 MNT_CDROM);
1414#else
1415 sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
1416 bkpinfo->media_device, MNT_CDROM);
1417#endif
1418 } else {
1419 if (bkpinfo->disaster_recovery
1420 && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
1421 strcpy(bkpinfo->media_device,
1422 last_line_of_file("/tmp/CDROM-LIVES-HERE"));
1423 } else {
1424 find_cdrom_device(bkpinfo->media_device, TRUE);
1425 }
1426
1427#ifdef __FreeBSD__
1428 sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
1429 MNT_CDROM);
1430#else
1431 sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
1432 bkpinfo->media_device, MNT_CDROM);
1433#endif
1434 }
1435
1436 log_msg(2, "(mount_media) --- command = %s", mount_cmd);
1437 for (i = 0; i < 2; i++) {
1438 res = run_program_and_log_output(mount_cmd, FALSE);
1439 if (!res) {
1440 break;
1441 } else {
1442 log_msg(2, "Failed to mount device.");
1443 sleep(5);
1444 run_program_and_log_output("sync", FALSE);
1445 }
1446 }
1447
1448 if (res) {
1449 log_msg(2, "Failed, despite %d attempts", i);
1450 } else {
1451 log_msg(2, "Mounted media drive OK");
1452 }
1453 paranoid_free(mount_cmd);
1454 return (res);
1455}
1456/**************************************************************************
1457*END_MOUNT_CDROM *
1458**************************************************************************/
1459
1460
1461
1462
1463/**
1464 * Ask the user for CD number @p cd_number_i_want.
1465 * Sets g_current_media_number once the correct CD is inserted.
1466 * @param bkpinfo The backup information structure. Fields used:
1467 * - @c bkpinfo->backup_media_type
1468 * - @c bkpinfo->prefix
1469 * - @c bkpinfo->isodir
1470 * - @c bkpinfo->media_device
1471 * - @c bkpinfo->please_dont_eject_when_restoring
1472 * @param cd_number_i_want The CD number to ask for.
1473 */
1474void
1475insist_on_this_cd_number(int cd_number_i_want)
1476{
1477
1478 /*@ int ************************************************************* */
1479 int res = 0;
1480
1481
1482 /*@ buffers ********************************************************* */
1483 char *tmp;
1484 char *mds = NULL;
1485 char *request;
1486
1487 assert(bkpinfo != NULL);
1488 assert(cd_number_i_want > 0);
1489
1490// log_msg(3, "Insisting on CD number %d", cd_number_i_want);
1491
1492 if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1493 log_msg(3,
1494 "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
1495 return;
1496 }
1497 malloc_string(tmp);
1498 malloc_string(request);
1499 sprintf(tmp, "mkdir -p " MNT_CDROM);
1500 run_program_and_log_output(tmp, 5);
1501 if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
1502 || bkpinfo->backup_media_type == netfs) {
1503 g_ISO_restore_mode = TRUE;
1504 if (!is_this_device_mounted(MNT_CDROM)) {
1505 log_msg(3, "Mounting media");
1506 g_current_media_number = cd_number_i_want;
1507 mount_media();
1508 }
1509 }
1510 if ((res = what_number_cd_is_this()) != cd_number_i_want) {
1511 log_msg(3, "Currently, we hold %d but we want %d", res,
1512 cd_number_i_want);
1513 mds = media_descriptor_string(bkpinfo->backup_media_type);
1514 sprintf(tmp, "Insisting on %s #%d", mds, cd_number_i_want);
1515 sprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
1516 mr_free(mds);
1517 log_msg(3, tmp);
1518 while (what_number_cd_is_this() != cd_number_i_want) {
1519 paranoid_system("sync");
1520 if (is_this_device_mounted(MNT_CDROM)) {
1521 res =
1522 run_program_and_log_output("umount " MNT_CDROM, FALSE);
1523 } else {
1524 res = 0;
1525 }
1526 if (res) {
1527 log_to_screen("WARNING - failed to unmount CD-ROM drive");
1528 }
1529 if (!bkpinfo->please_dont_eject) {
1530 res = eject_device(bkpinfo->media_device);
1531 } else {
1532 res = 0;
1533 }
1534 if (res) {
1535 log_to_screen("WARNING - failed to eject CD-ROM disk");
1536 }
1537 popup_and_OK(request);
1538 if (!bkpinfo->please_dont_eject) {
1539 inject_device(bkpinfo->media_device);
1540 }
1541 paranoid_system("sync");
1542 }
1543 log_msg(1, "Thankyou. Proceeding...");
1544 g_current_media_number = cd_number_i_want;
1545 }
1546 paranoid_free(tmp);
1547 paranoid_free(request);
1548}
1549
1550/* @} - end of deviceGroup */
1551
1552
1553
1554/**
1555 * Creates a singly linked list of all of the non-NETFS mounted file systems.
1556 * @param DSFptr A pointer to the structure MOUNTED_FS_STRUCT used to hold
1557 * the list of mounted file systems.
1558 * @return None.
1559 */
1560static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr)
1561{
1562 assert (DSFptr);
1563 if (DSF_Head == NULL) {
1564 DSF_Head = DSFptr;
1565 } else {
1566 DSF_Tail->next = DSFptr;
1567 }
1568 DSFptr->next = NULL;
1569 DSF_Tail = DSFptr;
1570}
1571
1572/**
1573 * Find the structure, in the singly linked list of all of the non-NETFS
1574 * mounted file systems, that contains the specified device.
1575 * @param device The device to find
1576 * @return NULL if it didn't find the device, a pointer to the
1577 * structure if it did.
1578 */
1579static MOUNTED_FS_STRUCT *find_device_in_list (char *device)
1580{
1581 MOUNTED_FS_STRUCT *DSFptr = NULL;
1582
1583 DSFptr = DSF_Head;
1584 while (DSFptr != NULL) {
1585 if (!strcmp(DSFptr->device, device)) {
1586 break;
1587 }
1588 DSFptr = DSFptr->next;
1589 }
1590 return (DSFptr);
1591}
1592
1593/**
1594 * Find the structure, in the singly linked list of all of the non-NETFS
1595 * mounted file systems, that contains the specified mount point.
1596 * @param mount_point The mount point to find
1597 * @return NULL is it didn't find the mount point, a pointer to the
1598 * structure if it did.
1599 */
1600static MOUNTED_FS_STRUCT *find_mount_point_in_list (char *mount_point)
1601{
1602 MOUNTED_FS_STRUCT *DSFptr = NULL;
1603
1604 DSFptr = DSF_Head;
1605 while (DSFptr != NULL) {
1606 if (!strcmp(DSFptr->mount_point, mount_point)) {
1607 break;
1608 }
1609 DSFptr = DSFptr->next;
1610 }
1611 return (DSFptr);
1612}
1613
1614/**
1615 * Frees the memory for all of the structures on the linked list of
1616 * all of the non-NETFS mounted file systems.
1617 */
1618static void free_mounted_fs_list (void) {
1619 MOUNTED_FS_STRUCT *DSFptr = NULL;
1620 MOUNTED_FS_STRUCT *DSFnext = NULL;
1621
1622 DSFptr = DSF_Head;
1623 while (DSFptr != NULL) {
1624 DSFnext = DSFptr->next;
1625 paranoid_free(DSFptr);
1626 DSFptr = DSFnext;
1627 }
1628 DSF_Head = NULL;
1629 DSF_Tail = NULL;
1630}
1631
1632
1633/**
1634 * Creates a linked list of all of the non-NETFS mounted file systems.
1635 * We use a linked list because we don't know how many mounted file
1636 * there are (and there can be a lot).
1637 * @return 0 on success and greated than 0 on failure.
1638 */
1639static int create_list_of_non_NETFS_mounted_file_systems (void)
1640{
1641 int i = 0;
1642 int mount_cnt = 0;
1643 int lastpos = 0;
1644 char *mounted_file_system = NULL;
1645 char *command = NULL;
1646 char *token = NULL;
1647 char token_chars[] =" :\t\r\f\a\0";
1648 MOUNTED_FS_STRUCT *DSFptr = NULL;
1649
1650 free_mounted_fs_list();
1651 /********
1652 * Find the number of mounted file system entries and their respective mount points.
1653 * I can't return all of the entries as one string because it's length can be longer
1654 * than MAX_STR_LEN which is used in call_program_and_get_last_line_of_output().
1655 * So start looping and get the number of mounted file systems and query them one by one.
1656 ********/
1657 /* Get the number of mounted file systems ((those that start with "/dev/" */
1658 mr_asprintf(&command, "mount 2>/dev/null | awk '{if($1 ~ \"^/dev/\"){print $0}}'|wc -l");
1659 log_msg(5, "Running: %s", command);
1660 mr_asprintf(&mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
1661 paranoid_free(command);
1662
1663 mount_cnt = atoi(mounted_file_system);
1664 log_msg (5, "mount_cnt: %d", mount_cnt);
1665 paranoid_free(mounted_file_system);
1666
1667 for (i=mount_cnt; i > 0; i--) {
1668 mr_asprintf(&command, "mount 2>/dev/null | awk '{if($1 ~ \"^/dev/\"){print $1,$3}}'|head -n %d", i);
1669 log_msg(5, "Running: %s", command);
1670 mr_asprintf(&mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
1671 paranoid_free(command);
1672
1673 log_msg (5, "mounted_file_system: %s", mounted_file_system);
1674 if ((token = mr_strtok(mounted_file_system, token_chars, &lastpos)) == NULL) {
1675 log_msg (4, "Could not get the list of mounted file systems");
1676 paranoid_free(mounted_file_system);
1677 mr_free(token);
1678 return (1);
1679 }
1680 if (token) {
1681 log_msg (5, "token: %s", token);
1682 }
1683 while (token != NULL) {
1684 log_msg (5, "token: %s", token);
1685 if ((DSFptr = (MOUNTED_FS_STRUCT *) calloc(1, sizeof(MOUNTED_FS_STRUCT))) == NULL) {
1686 fatal_error ("Cannot allocate memory");
1687 }
1688 add_mounted_fs_struct(DSFptr);
1689 strcpy(DSFptr->device, token);
1690 mr_free(token);
1691 if ((token = mr_strtok(mounted_file_system, token_chars, &lastpos)) == NULL) {
1692 log_msg (5, "Ran out of entries on the mounted file systems list");
1693 mr_free(mounted_file_system);
1694 mr_free(token);
1695 return (1);
1696 }
1697 log_msg (5, "token: %s", token);
1698 strcpy(DSFptr->mount_point, token);
1699 mr_free(token);
1700 token = mr_strtok(mounted_file_system, token_chars, &lastpos);
1701 }
1702 mr_free(mounted_file_system);
1703 }
1704 /********
1705 * DSFptr = DSF_Head;
1706 * while (DSFptr != NULL) {
1707 * printf ("Dev: %s MP: %s Check: %d\n", DSFptr->device, DSFptr->mount_point, DSFptr->check);
1708 * DSFptr = DSFptr->next;
1709 * }
1710 ********/
1711 return (0);
1712}
1713
1714
1715
1716/**
1717 * Given a whole disk device special file, determine which mounted file systems
1718 * are on the dsf's partitions and which mounted file systems are not.
1719 * @param dsf The whole disk device special file.
1720 * @param included_dsf_list A char pointer used to hold the list of mount points
1721 * that are on the dsf. Memory for the array will be allocated within the function.
1722 * @param excluded_dsf_list A char pointer used to hold the list of mount points
1723 * that are not on the dsf. Memory for the array will be allocated within the function.
1724 * @return 0 on success, -1 if no device special file was passed in, -2 if a device
1725 * special file was passed in but it has no partitions on it, or 1 on failure
1726 */
1727static int get_dsf_mount_list (const char *dsf, char **included_dsf_list, char **excluded_dsf_list) {
1728 int i = 0;
1729 int c = 0;
1730 int lastpos = 0;
1731 char VG[MAX_STR_LEN];
1732 char *tmp = NULL;
1733 char *command = NULL;
1734 char *partition_list = NULL;
1735 char partitions[64][MAX_STR_LEN];
1736 char *mount_list = NULL;
1737 char *token = NULL;
1738 char *ndsf = NULL;
1739 char token_chars[] =" \t\r\f\a\0";
1740 MOUNTED_FS_STRUCT *DSFptr = NULL;
1741
1742 memset((char *)partitions, 0, sizeof(partitions));
1743
1744 log_msg(5, "dsf: %s", dsf);
1745
1746 /********
1747 * See if a device special file was passed in (i.e. it must start with /dev/
1748 ********/
1749 if (strncmp(dsf, "/dev/", 5)) {
1750 log_msg (4, "%s does not start with /dev/ and (probably) is not a device special file", dsf);
1751 return (-1);
1752 }
1753 log_msg(4, " %s looks like a device special file", dsf);
1754 /* Verify that the dsf exists */
1755 mr_asprintf(&command, "ls -al %s 2>/dev/null | wc -l", dsf);
1756 log_msg(5, " Executing: %s", command);
1757 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1758 paranoid_free(command);
1759
1760 log_msg(5, " Return value: %s", tmp);
1761 c = atoi(tmp);
1762 paranoid_free(tmp);
1763
1764 if (!c) {
1765 log_to_screen("Cannot find device special file %s", dsf);
1766 return (1);
1767 }
1768 log_msg(4, " %s device special file exists", dsf);
1769
1770 /* Get a list of the mounted file systems */
1771 if (create_list_of_non_NETFS_mounted_file_systems()) {
1772 log_to_screen ("Could not get the list of mounted file systems");
1773 return (1);
1774 }
1775 log_msg (5, "Processing dsf: %s", dsf);
1776 /********
1777 * Get a list of the dsf's partitions. There could be no partitions on the disk
1778 * or a dsf of a partition was passed in (e.g. /dev/sda1 instead of /dev/sda).
1779 * Either way, it's an error.
1780 ********/
1781 mr_asprintf(&command, "parted2fdisk -l %s 2>/dev/null|grep -E \"^/dev/\"|awk '{printf(\"%%s \", $1)}END{print \"\"}'", dsf);
1782 log_msg(5, "Executing: %s", command);
1783 mr_asprintf(&partition_list, "%s", call_program_and_get_last_line_of_output(command));
1784 paranoid_free(command);
1785 log_msg(4, "Partition list for %s: %s", dsf, partition_list);
1786 if (!strlen(partition_list)) {
1787 /* There were no partitions on the disk */
1788 log_msg(4, "No partitions on device special file %s", dsf);
1789 log_msg(4, "I guess it's a partition itself");
1790 strcpy(partitions[0], dsf);
1791 ndsf = truncate_to_drive_name(dsf);
1792 } else {
1793 /* Fill the partition list */
1794 i = 0;
1795 lastpos = 0;
1796 while ((token = mr_strtok(partition_list, token_chars, &lastpos)) != NULL) {
1797 log_msg (4, "Found partition: %s", token);
1798 strcpy(partitions[i++], token);
1799 mr_free(token);
1800 }
1801 mr_asprintf(&ndsf, "%s", dsf);
1802 }
1803 mr_free(partition_list);
1804
1805 /* In any case we want to exclude the dsf itself from all MondRescue activities
1806 * at restore time (LVM, fdisk, ...) so we want it in our exclude_dev list */
1807 if ((DSFptr = (MOUNTED_FS_STRUCT *) calloc(1, sizeof(MOUNTED_FS_STRUCT))) == NULL) {
1808 fatal_error ("Cannot allocate memory");
1809 }
1810 add_mounted_fs_struct(DSFptr);
1811 strcpy(DSFptr->device, dsf);
1812 DSFptr->check = 1;
1813
1814 /* For the rest ndsf is the new dsf to deal with */
1815 /********
1816 * At this point, we have a list of all of the partitions on the dsf. Now try to
1817 * see which partitions have a file system on them.
1818 *
1819 * Loop through each partition on the disk and:
1820 *
1821 * - If the partition is swap, it ignores it.
1822 *
1823 * - If the partition is mounted (e.g. /dev/sda1 is mounted on /boot), it adds an entry
1824 * to the linked list, copies to it the device name and mount point, and sets check == 1.
1825 *
1826 * - If the partition is part of a Volume Group that has Logical Volumes mounted, it adds
1827 * an entry to the linked list for each mounted Logical Volume in that Volume Group, copying
1828 * to it the device name and mount point, and sets check == 1. Note that if the Volume Group
1829 * contains more than one disk, it will still add the entry even if the Logical Volume's
1830 * extents are not on the dsf that was passed in to the function. For example, Volume Group
1831 * VolGroup00 contains the disks /dev/sda1 and /dev/sdb1, and the Logical Volumes LogVol01,
1832 * which is mounted on /var and has all of its extents on /dev/sda1, and LogVol02, which is
1833 * mounted as /usr and has all of its extents on /dev/sdb1. If you pass /dev/sda into the
1834 * function, both /var and /usr will be archived even though /usr is actually on/dev/sdb.
1835 *
1836 * - If the partition is part of a Volume Group that has Logical Volumes used in a mounted
1837 * software raid device, it adds an entry to the linked list, copies to it the software raid
1838 * device name and mount point, and sets check == 1.
1839 *
1840 * - If the partition is part of a mounted software raid device, it adds an entry to the linked
1841 * list, copies to it the software raid device name and mount point, and sets check == 1.
1842 *
1843 ********/
1844 for (i=0; strlen(partitions[i]); i++) {
1845 log_msg(4, "Processing partition: %s", partitions[i]);
1846 /* See if it's swap. If it is, ignore it. */
1847 mr_asprintf(&command, "parted2fdisk -l %s 2>/dev/null | awk '{if(($1==\"%s\")&&(toupper($0) ~ \"SWAP\")){print $1;exit}}'",
1848 ndsf, partitions[i]);
1849 log_msg(5, " Running: %s", command);
1850 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1851 paranoid_free(command);
1852 log_msg(5, " Return value: %s", tmp);
1853 c = strlen(tmp);
1854 paranoid_free(tmp);
1855 if (c) {
1856 log_msg(4, "It's swap. Ignoring partition %s", partitions[i]);
1857 continue;
1858 }
1859 /* It's not swap. See if we can find the mount point from the mount command. */
1860 mr_asprintf(&command, "mount 2>/dev/null | awk '{if((NF>0)&&($1==\"%s\")){print $3}}'", partitions[i]);
1861 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1862 paranoid_free(command);
1863 if (strlen(tmp)) {
1864 log_msg(4, " %s is mounted: %s", partitions[i], tmp);
1865 if ((DSFptr = find_mount_point_in_list(tmp)) == NULL) {
1866 log_msg (4, "Can't find mount point %s in mounted file systems list", tmp);
1867 paranoid_free(tmp);
1868 return (1);
1869 }
1870 DSFptr->check = 1;
1871 paranoid_free(tmp);
1872 continue;
1873 }
1874 paranoid_free(tmp);
1875 /* It's not swap and it's not mounted. See if it's LVM */
1876 log_msg(4, " It's not mounted. Checking to see if it's LVM...");
1877 /* Check for LVM */
1878 mr_asprintf(&command, "pvdisplay -c %s | grep '%s:' 2> /dev/null", partitions[i], partitions[i]);
1879 log_msg(5, " Running: %s", command);
1880 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1881 paranoid_free(command);
1882 if (strlen(tmp)) {
1883 log_msg(4, "Found an LVM partition at %s. Find the VG it's in...", partitions[i]);
1884 /* It's LVM: Find the VG it's in */
1885 mr_asprintf(&command, "pvdisplay -v %s 2>/dev/null|grep \"VG Name\"|awk '{print $NF}'", partitions[i]);
1886 log_msg(5, " Running: %s", command);
1887 strcpy(VG, call_program_and_get_last_line_of_output(command));
1888 paranoid_free(command);
1889 log_msg(4, " Volume Group: %s", VG);
1890 if (strlen(VG)) {
1891 /* Found the Volume Group. Now find all of the VG's mount points */
1892 log_msg(4, " Found the Volume Group. Now find all of the VG's mount points");
1893 mr_asprintf(&command, "mount 2>/dev/null|grep -E \"/dev/mapper/%s-|/dev/%s/\"|awk '{printf(\"%%s \",$3)}END{print \"\"}'", VG, VG);
1894 log_msg(5, " Running: %s", command);
1895 mr_asprintf(&mount_list, "%s", call_program_and_get_last_line_of_output(command));
1896 paranoid_free(command);
1897 log_msg(4, " VG %s mount_list: %s", VG, mount_list);
1898 lastpos = 0;
1899 while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
1900 log_msg (5, "mount point token: %s", token);
1901 if ((DSFptr = find_mount_point_in_list(token)) == NULL) {
1902 log_msg (4, "Can't find mount point %s in mounted file systems list", token);
1903 paranoid_free(tmp);
1904 mr_free(token);
1905 return (1);
1906 }
1907 DSFptr->check = 1;
1908 mr_free(token);
1909 }
1910 /********
1911 * Now we want to see if there are any software raid devices using
1912 * any of the Logical Volumes on the Volume Group.
1913 *******/
1914 paranoid_free(mount_list);
1915
1916 mr_asprintf(&command, "%s", "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
1917 log_msg (5, "Running: %s", command);
1918 mr_asprintf(&mount_list, "%s", call_program_and_get_last_line_of_output(command));
1919 paranoid_free(command);
1920 log_msg(4, " Software raid device list: %s", mount_list);
1921 lastpos = 0;
1922 while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
1923 mr_asprintf(&command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, VG);
1924 log_msg (5, "Running: %s", command);
1925 paranoid_free(tmp);
1926 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1927 paranoid_free(command);
1928 log_msg(4, "Number of Software raid device: %s", tmp);
1929 if (atoi(tmp)) {
1930 /* This device is on our disk */
1931 if ((DSFptr = find_device_in_list(token)) == NULL) {
1932 log_msg (4, "Can't find device %s in mounted file systems list", token);
1933 paranoid_free(tmp);
1934 mr_free(token);
1935 return (1);
1936 }
1937 DSFptr->check = 1;
1938 }
1939 }
1940 mr_free(token);
1941 paranoid_free(mount_list);
1942 } else {
1943 log_msg (4, "Error finding Volume Group for partition %s", partitions[i]);
1944 paranoid_free(tmp);
1945 return (1);
1946 }
1947 paranoid_free(tmp);
1948 continue;
1949 } else {
1950 log_msg (4, "Error finding partition type for the partition %s", partitions[i]);
1951 }
1952 paranoid_free(tmp);
1953 /********
1954 * It's not swap, mounted, or LVM. See if it's used in a software raid device.
1955 ********/
1956 log_msg (5, "It's not swap, mounted, or LVM. See if it's used in a software raid device.");
1957 mr_asprintf(&command, "mdadm --examine %s 2>/dev/null | awk '{if($1 == \"UUID\"){print $3}}'", partitions[i]);
1958 log_msg(4, " Running: %s", command);
1959 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1960 paranoid_free(command);
1961 if (!strlen(tmp)) {
1962 log_msg(4, " Partition %s is not used in a non-LVM software raid device", partitions[i]);
1963 paranoid_free(tmp);
1964 continue;
1965 }
1966 log_msg (5, " UUID: %s", tmp);
1967 /* Get the Software raid device list */
1968 mr_asprintf(&command, "%s", "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
1969 log_msg (5, " Running: %s", command);
1970 mr_asprintf(&mount_list, "%s", call_program_and_get_last_line_of_output(command));
1971 paranoid_free(command);
1972 log_msg(4, " Software raid device list: %s", mount_list);
1973 /* Loop through the software raid device list to see if we can find the partition */
1974 lastpos = 0;
1975 while ((token = mr_strtok(mount_list, token_chars, &lastpos)) != NULL) {
1976 mr_asprintf(&command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, tmp);
1977 log_msg(4, " Running: %s", command);
1978 paranoid_free(tmp);
1979 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
1980 paranoid_free(command);
1981 if (!atoi(tmp)) {
1982 log_msg (4," Didn't find partition %s in software raid device %s", partitions[i], token);
1983 } else {
1984 if ((DSFptr = find_device_in_list(token)) == NULL) {
1985 log_msg (4, "Can't find device %s in mounted file systems list", token);
1986 paranoid_free(tmp);
1987 mr_free(token);
1988 return (1);
1989 }
1990 DSFptr->check = 1;
1991 break;
1992 }
1993 mr_free(token);
1994 }
1995 paranoid_free(tmp);
1996 paranoid_free(mount_list);
1997 }
1998
1999 /* Determine how much memory to allocate for included_dsf_list and excluded_dsf_list */
2000 i = 0;
2001 DSFptr= DSF_Head;
2002 while (DSFptr != NULL) {
2003 i += strlen(DSFptr->mount_point) + 1;
2004 DSFptr = DSFptr->next;
2005 }
2006 log_msg (5, "i: %d", i);
2007 if ((*included_dsf_list = (char *) calloc(i+100, sizeof(char))) == NULL) {
2008 fatal_error ("Cannot allocate memory");
2009 }
2010 if ((*excluded_dsf_list = (char *) calloc(i+100, sizeof(char))) == NULL) {
2011 fatal_error ("Cannot allocate memory");
2012 }
2013 DSFptr= DSF_Head;
2014 while (DSFptr != NULL) {
2015 if (DSFptr->check) {
2016 log_msg (4, "%s is mounted on %s and is on disk %s", DSFptr->device, DSFptr->mount_point, ndsf);
2017 strcat(*included_dsf_list, DSFptr->mount_point);
2018 strcat(*included_dsf_list, "|");
2019 } else {
2020 log_msg (4, "%s is mounted on %s and is NOT on disk %s", DSFptr->device, DSFptr->mount_point, ndsf);
2021 strcat(*excluded_dsf_list, DSFptr->mount_point);
2022 strcat(*excluded_dsf_list, "|");
2023 }
2024 DSFptr = DSFptr->next;
2025 }
2026 mr_free(ndsf);
2027
2028 log_msg (5, "included_dsf_list: %s", *included_dsf_list);
2029 log_msg (5, "excluded_dsf_list: %s", *excluded_dsf_list);
2030 return (0);
2031}
2032
2033
2034
2035
2036
2037/* Update the bkpinfo structure for exclude & include paths
2038 * in order to handle correctly paths corresponding to devices */
2039void mr_make_devlist_from_pathlist(char *pathlist, char mode) {
2040
2041char *token = NULL;
2042int lastpos = 0;
2043char *mounted_on_dsf = NULL;
2044char *not_mounted_on_dsf = NULL;
2045char token_chars[] ="|\t\r\f\a\0\n";
2046char *tmp = NULL;
2047char *tmp1 = NULL;
2048
2049if (pathlist == NULL) {
2050 return;
2051}
2052while ((token = mr_strtok(pathlist, token_chars, &lastpos)) != NULL) {
2053 switch (get_dsf_mount_list(token, &mounted_on_dsf, &not_mounted_on_dsf)) {
2054 case 1:
2055 if (mode == 'E') {
2056 log_msg(1, "WARNING ! %s doesn't exist in -E option", token);
2057 } else {
2058 log_msg(1, "ERROR ! %s doesn't exist in -I option", token);
2059 fatal_error("Error processing -I option");
2060 }
2061 break;
2062 /* Everything is OK; proceed to archive data */
2063 case 0:
2064 if (mode == 'E') {
2065 if (strlen(mounted_on_dsf)) {
2066 log_to_screen("Excluding the following file systems on %s:", token);
2067 log_to_screen("==> %s", mounted_on_dsf);
2068 log_msg (5, "Adding to bkpinfo->exclude_paths due to -E option: %s", mounted_on_dsf);
2069 if (bkpinfo->exclude_paths) {
2070 mr_strcat(bkpinfo->exclude_paths,"|%s",mounted_on_dsf);
2071 } else {
2072 mr_asprintf(bkpinfo->exclude_paths,"%s",mounted_on_dsf);
2073 }
2074 if (bkpinfo->exclude_devs) {
2075 mr_strcat(bkpinfo->exclude_devs,"|%s",token);
2076 } else {
2077 mr_asprintf(bkpinfo->exclude_devs,"%s",token);
2078 }
2079 }
2080 } else {
2081 log_to_screen("Archiving only the following file systems on %s:", token);
2082 log_to_screen("==> %s", mounted_on_dsf);
2083 strcpy(bkpinfo->include_paths, "/");
2084 if (strlen(not_mounted_on_dsf)) {
2085 log_msg (5, "Adding to bkpinfo->exclude_paths due to -I option: %s", not_mounted_on_dsf);
2086 log_to_screen("Not archiving the following file systems:");
2087 log_to_screen("==> %s", not_mounted_on_dsf);
2088 if (bkpinfo->exclude_paths) {
2089 mr_strcat(bkpinfo->exclude_paths, "|%s",not_mounted_on_dsf);
2090 } else {
2091 mr_asprintf(bkpinfo->exclude_paths,"%s",not_mounted_on_dsf);
2092 }
2093 }
2094 }
2095 break;
2096 /* It's a dsf but not a whole disk dsf */
2097 case -2:
2098 log_to_screen("Could %s be a partition instead of a whole disk device special file?\nIgnored.", token);
2099 break;
2100 /* A device special file was not passed in. Process it as a path. */
2101 case -1:
2102 /* Adds a | to ensure correct detection even at both ends */
2103 mr_asprintf(&tmp1,"|%s",token);
2104 if (mode == 'E') {
2105 /* Add the token if not already in the list */
2106 mr_asprintf(&tmp,"|%s|",bkpinfo->exclude_paths);
2107 if (strstr(tmp,tmp1) == NULL) {
2108 if (bkpinfo->exclude_paths) {
2109 mr_strcat(bkpinfo->exclude_paths,tmp1);
2110 mr_free(tmp1);
2111 } else {
2112 bkpinfo->exclude_paths = tmp1;
2113 }
2114 }
2115 } else {
2116 /* Add the token if not already in the list */
2117 mr_asprintf(&tmp,"|%s|",bkpinfo->include_paths);
2118 if (strstr(tmp,tmp1) == NULL) {
2119 strcat(bkpinfo->include_paths,tmp1);
2120 }
2121 mr_free(tmp1);
2122 }
2123 mr_free(tmp);
2124 break;
2125 }
2126 mr_free(token);
2127
2128 if (bkpinfo->include_paths != NULL) {
2129 log_msg(1, "include_paths is now '%s'", bkpinfo->include_paths);
2130 }
2131 if (bkpinfo->exclude_paths != NULL) {
2132 log_msg(1, "exclude_paths is now '%s'", bkpinfo->exclude_paths);
2133 }
2134 if (bkpinfo->exclude_devs != NULL) {
2135 log_msg(1, "exclude_devs is now '%s'", bkpinfo->exclude_devs);
2136 }
2137}
2138}
2139
2140
2141
2142
2143/**
2144 * Ask user for details of backup/restore information.
2145 * Called when @c mondoarchive doesn't get any parameters.
2146 * @param bkpinfo The backup information structure to fill out with the user's data.
2147 * @param archiving_to_media TRUE if archiving, FALSE if restoring.
2148 * @return 0, always.
2149 * @bug No point of `int' return value.
2150 * @ingroup archiveGroup
2151 */
2152int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
2153// archiving_to_media is TRUE if I'm being called by mondoarchive
2154// archiving_to_media is FALSE if I'm being called by mondorestore
2155{
2156 char *tmp = NULL;
2157 char *tmp1 = NULL;
2158 char *mds = NULL;
2159 char p[8*MAX_STR_LEN];
2160 char *sz_size;
2161 char *command;
2162 char *comment;
2163 char *prompt;
2164 int i;
2165 FILE *fin;
2166
2167 malloc_string(sz_size);
2168 malloc_string(command);
2169 malloc_string(comment);
2170 malloc_string(prompt);
2171 malloc_string(tmp1);
2172 assert(bkpinfo != NULL);
2173 sz_size[0] = '\0';
2174 bkpinfo->nonbootable_backup = FALSE;
2175
2176 // Tape, CD, NETFS, ...?
2177 srandom(getpid());
2178 bkpinfo->backup_media_type =
2179 (g_restoring_live_from_cd) ? cdr :
2180 which_backup_media_type(bkpinfo->restore_data);
2181 if (bkpinfo->backup_media_type == none) {
2182 log_to_screen("User has chosen not to backup the PC");
2183 finish(1);
2184 }
2185 /* Why asking to remove the media with tape ?
2186 if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
2187 popup_and_OK("Please remove media from drive(s)");
2188 }
2189 */
2190 log_msg(3, "media type = %s",
2191 bkptype_to_string(bkpinfo->backup_media_type));
2192 if (archiving_to_media) {
2193 sensibly_set_tmpdir_and_scratchdir();
2194 }
2195 bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
2196 bkpinfo->compression_level =
2197 (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
2198 bkpinfo->use_lzo =
2199 (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
2200 mvaddstr_and_log_it(2, 0, " ");
2201
2202 // Find device's /dev (or SCSI) entry
2203 switch (bkpinfo->backup_media_type) {
2204 case cdr:
2205 case cdrw:
2206 case dvd:
2207 case usb:
2208 /* Never try to eject a USB device */
2209 if (bkpinfo->backup_media_type == usb) {
2210 bkpinfo->please_dont_eject = TRUE;
2211 }
2212 if (archiving_to_media) {
2213 if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
2214 if (ask_me_yes_or_no
2215 ("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?"))
2216 {
2217 bkpinfo->manual_cd_tray = TRUE;
2218 }
2219 }
2220 if ((bkpinfo->compression_level =
2221 which_compression_level()) == -1) {
2222 log_to_screen("User has chosen not to backup the PC");
2223 finish(1);
2224 }
2225 mds = media_descriptor_string(bkpinfo->backup_media_type);
2226 sprintf(comment, "What speed is your %s (re)writer?", mds);
2227 if (bkpinfo->backup_media_type == dvd) {
2228 find_dvd_device(bkpinfo->media_device, FALSE);
2229 strcpy(tmp1, "1");
2230 sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2231 log_msg(1, "Setting to DVD defaults");
2232 } else {
2233 strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
2234 strcpy(tmp1, "4");
2235 strcpy(sz_size, "650");
2236 log_msg(1, "Setting to CD defaults");
2237 }
2238 if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
2239 if (!popup_and_get_string("Speed", comment, tmp1, 4)) {
2240 log_to_screen("User has chosen not to backup the PC");
2241 finish(1);
2242 }
2243 }
2244 bkpinfo->cdrw_speed = atoi(tmp1); // if DVD then this shouldn't ever be used anyway :)
2245
2246 sprintf(comment,
2247 "How much data (in Megabytes) will each %s store?", mds);
2248 mr_free(mds);
2249 if (!popup_and_get_string("Size", comment, sz_size, 5)) {
2250 log_to_screen("User has chosen not to backup the PC");
2251 finish(1);
2252 }
2253 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2254 bkpinfo->media_size[i] = atoi(sz_size);
2255 }
2256 if (bkpinfo->media_size[0] <= 0) {
2257 log_to_screen("User has chosen not to backup the PC");
2258 finish(1);
2259 }
2260 }
2261 /* No break because we continue even for usb */
2262 case cdstream:
2263 mds = media_descriptor_string(bkpinfo->backup_media_type);
2264
2265 if ((bkpinfo->disaster_recovery) && (bkpinfo->backup_media_type != usb)) {
2266 strcpy(bkpinfo->media_device, "/dev/cdrom");
2267 log_msg(2, "CD-ROM device assumed to be at %s",
2268 bkpinfo->media_device);
2269 } else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb))
2270 || bkpinfo->backup_media_type == dvd) {
2271 if (!bkpinfo->media_device[0]) {
2272 strcpy(bkpinfo->media_device, "/dev/cdrom");
2273 } // just for the heck of it :)
2274 log_msg(1, "bkpinfo->media_device = %s",
2275 bkpinfo->media_device);
2276 if (bkpinfo->backup_media_type == dvd
2277 || find_cdrom_device(bkpinfo->media_device, FALSE)) {
2278 log_msg(1, "bkpinfo->media_device = %s",
2279 bkpinfo->media_device);
2280 sprintf(comment,
2281 "Please specify your %s drive's /dev entry", mds);
2282 if (!popup_and_get_string
2283 ("Device?", comment, bkpinfo->media_device,
2284 MAX_STR_LEN / 4)) {
2285 log_to_screen("User has chosen not to backup the PC");
2286 finish(1);
2287 }
2288 }
2289 log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
2290 } else {
2291 if ((find_cdrw_device(bkpinfo->media_device)) && (bkpinfo->backup_media_type != usb)) {
2292 bkpinfo->media_device[0] = '\0';
2293 }
2294 if (bkpinfo->media_device[0]) {
2295 if (bkpinfo->backup_media_type == usb) {
2296 mr_asprintf(&tmp, "I think your %s media corresponds to %s. Is this correct?", mds, bkpinfo->media_device);
2297 } else {
2298 mr_asprintf(&tmp, "I think I've found your %s burner at SCSI node %s. Is this correct? (Say no if you have an IDE burner and you are running a 2.6 kernel. You will then be prompted for further details.)", mds, bkpinfo->media_device);
2299 }
2300 if (!ask_me_yes_or_no(tmp)) {
2301 bkpinfo->media_device[0] = '\0';
2302 }
2303 mr_free(tmp);
2304 }
2305 if (!bkpinfo->media_device[0]) {
2306 if (bkpinfo->backup_media_type == usb) {
2307 i = popup_and_get_string("/dev entry?",
2308 "What is the /dev entry of your USB Disk/Key, please?",
2309 bkpinfo->media_device,
2310 MAX_STR_LEN / 4);
2311 } else {
2312 if (g_kernel_version < 2.6) {
2313 i = popup_and_get_string("Device node?",
2314 "What is the SCSI node of your CD (re)writer, please?",
2315 bkpinfo->media_device,
2316 MAX_STR_LEN / 4);
2317 } else {
2318 i = popup_and_get_string("/dev entry?",
2319 "What is the /dev entry of your CD (re)writer, please?",
2320 bkpinfo->media_device,
2321 MAX_STR_LEN / 4);
2322 }
2323 }
2324 if (!i) {
2325 log_to_screen("User has chosen not to backup the PC");
2326 finish(1);
2327 }
2328 }
2329 }
2330 mr_free(mds);
2331
2332 if (bkpinfo->backup_media_type == cdstream) {
2333 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2334 bkpinfo->media_size[i] = 650;
2335 }
2336 }
2337 break;
2338 case udev:
2339 if (!ask_me_yes_or_no
2340 ("This option is for advanced users only. Are you sure?")) {
2341 log_to_screen("User has chosen not to backup the PC");
2342 finish(1);
2343 }
2344 case tape:
2345
2346 if ((!bkpinfo->restore_mode) && (find_tape_device_and_size(bkpinfo->media_device, sz_size))) {
2347 log_msg(3, "Ok, using vanilla scsi tape.");
2348 strcpy(bkpinfo->media_device, VANILLA_SCSI_TAPE);
2349 if ((fin = fopen(bkpinfo->media_device, "r"))) {
2350 paranoid_fclose(fin);
2351 } else {
2352 strcpy(bkpinfo->media_device, "/dev/osst0");
2353 }
2354 }
2355 if (bkpinfo->media_device[0]) {
2356 if ((fin = fopen(bkpinfo->media_device, "r"))) {
2357 paranoid_fclose(fin);
2358 } else {
2359 if (does_file_exist("/tmp/mondo-restore.cfg")) {
2360 read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
2361 bkpinfo->media_device);
2362 }
2363 }
2364 }
2365 if (bkpinfo->media_device[0]) {
2366 mr_asprintf(&tmp, "I think I've found your tape streamer at %s; am I right on the money?", bkpinfo->media_device);
2367 if (!ask_me_yes_or_no(tmp)) {
2368 bkpinfo->media_device[0] = '\0';
2369 }
2370 mr_free(tmp);
2371 }
2372 if (!bkpinfo->media_device[0]) {
2373 if (!popup_and_get_string
2374 ("Device name?",
2375 "What is the /dev entry of your tape streamer?",
2376 bkpinfo->media_device, MAX_STR_LEN / 4)) {
2377 log_to_screen("User has chosen not to backup the PC");
2378 finish(1);
2379 }
2380 }
2381 mr_asprintf(&tmp, "ls -l %s", bkpinfo->media_device);
2382 if (run_program_and_log_output(tmp, FALSE)) {
2383 log_to_screen("User has not specified a valid /dev entry");
2384 finish(1);
2385 }
2386 mr_free(tmp);
2387 log_msg(4, "sz_size = %s", sz_size);
2388 sz_size[0] = '\0';
2389
2390 bkpinfo->use_obdr = ask_me_yes_or_no
2391 ("Do you want to activate OBDR support for your tapes ?");
2392 if (sz_size[0] == '\0') {
2393 bkpinfo->media_size[0] = 0;
2394 } else {
2395 bkpinfo->media_size[0] =
2396 friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
2397 }
2398 log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
2399 if (bkpinfo->media_size[0] <= 0) {
2400 bkpinfo->media_size[0] = 0;
2401 }
2402 for (i = 1; i <= MAX_NOOF_MEDIA; i++) {
2403 bkpinfo->media_size[i] = bkpinfo->media_size[0];
2404 }
2405 if (archiving_to_media) {
2406 if ((bkpinfo->compression_level =
2407 which_compression_level()) == -1) {
2408 log_to_screen("User has chosen not to backup the PC");
2409 finish(1);
2410 }
2411 }
2412 break;
2413
2414
2415
2416 case netfs:
2417 /* Never try to eject a NETFS device */
2418 bkpinfo->please_dont_eject = TRUE;
2419
2420 /* Initiate bkpinfo netfs_mount path from running environment if not already done */
2421 if (!bkpinfo->netfs_mount[0]) {
2422 strcpy(bkpinfo->netfs_mount,
2423 call_program_and_get_last_line_of_output
2424 ("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
2425 }
2426#ifdef __FreeBSD__
2427 if (TRUE)
2428#else
2429 if (!bkpinfo->disaster_recovery)
2430#endif
2431 {
2432 if (!popup_and_get_string
2433 ("Network shared dir.",
2434 "Please enter path and directory where archives are stored remotely. (Mondo has taken a guess at the correct value. If it is incorrect, delete it and type the correct one.)",
2435 bkpinfo->netfs_mount, MAX_STR_LEN / 4)) {
2436 log_to_screen("User has chosen not to backup the PC");
2437 finish(1);
2438 }
2439 if (!bkpinfo->restore_data) {
2440 if ((bkpinfo->compression_level =
2441 which_compression_level()) == -1) {
2442 log_to_screen("User has chosen not to backup the PC");
2443 finish(1);
2444 }
2445 }
2446 // check whether already mounted - we better remove
2447 // surrounding spaces and trailing '/' for this
2448 strip_spaces(bkpinfo->netfs_mount);
2449 if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
2450 bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
2451 sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3",
2452 bkpinfo->netfs_mount);
2453 strcpy(bkpinfo->isodir,
2454 call_program_and_get_last_line_of_output(command));
2455
2456 if (!bkpinfo->restore_data) {
2457 sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2458 sprintf(comment,
2459 "How much data (in Megabytes) will each media store?");
2460 if (!popup_and_get_string("Size", comment, sz_size, 5)) {
2461 log_to_screen("User has chosen not to backup the PC");
2462 finish(1);
2463 }
2464 } else {
2465 strcpy(sz_size, "0");
2466 }
2467 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2468 bkpinfo->media_size[i] = atoi(sz_size);
2469 }
2470 if (bkpinfo->media_size[0] < 0) {
2471 log_to_screen("User has chosen not to backup the PC");
2472 finish(1);
2473 }
2474 }
2475 /* Force NFS to be the protocol by default */
2476 if (bkpinfo->netfs_proto == NULL) {
2477 mr_asprintf(&(bkpinfo->netfs_proto), "nfs");
2478 }
2479 if (bkpinfo->disaster_recovery) {
2480 sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
2481 (void)system(command);
2482 }
2483 strcpy(tmp1, bkpinfo->netfs_proto);
2484 if (!popup_and_get_string
2485 ("Network protocol", "Which protocol should I use (nfs/sshfs) ?",
2486 tmp1, MAX_STR_LEN)) {
2487 log_to_screen("User has chosen not to backup the PC");
2488 finish(1);
2489 }
2490 mr_free(bkpinfo->netfs_proto);
2491 mr_asprintf(&(bkpinfo->netfs_proto), "%s", tmp1);
2492 if (!popup_and_get_string
2493 ("Network share", "Which remote share should I mount?",
2494 bkpinfo->netfs_mount, MAX_STR_LEN)) {
2495 log_to_screen("User has chosen not to backup the PC");
2496 finish(1);
2497 }
2498
2499 /* Initiate bkpinfo isodir path from running environment if mount already done */
2500 if (is_this_device_mounted(bkpinfo->netfs_mount)) {
2501 strcpy(bkpinfo->isodir,
2502 call_program_and_get_last_line_of_output
2503 ("mount | grep \":\" | cut -d' ' -f3 | head -n1"));
2504 } else {
2505 sprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
2506 sprintf(command, "mkdir -p %s", bkpinfo->isodir);
2507 run_program_and_log_output(command, 5);
2508 if (bkpinfo->restore_data) {
2509 if (strstr(bkpinfo->netfs_proto, "sshfs")) {
2510 mr_asprintf(&tmp, "sshfs -o ro %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
2511 } else {
2512 mr_asprintf(&tmp, "mount -t %s -o nolock,ro %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
2513 }
2514 } else {
2515 if (strstr(bkpinfo->netfs_proto, "sshfs")) {
2516 mr_asprintf(&tmp, "sshfs %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
2517 } else {
2518 mr_asprintf(&tmp, "mount -t %s -o nolock %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
2519 }
2520 }
2521 run_program_and_log_output(tmp, 3);
2522 mr_free(tmp);
2523
2524 malloc_string(g_selfmounted_isodir);
2525 strcpy(g_selfmounted_isodir, bkpinfo->isodir);
2526 }
2527 if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
2528 popup_and_OK
2529 ("Please mount that partition before you try to backup to or restore from it.");
2530 finish(1);
2531 }
2532 strcpy(tmp1, bkpinfo->netfs_remote_dir);
2533 if (!popup_and_get_string
2534 ("Directory", "Which directory within that mountpoint?", tmp1,
2535 MAX_STR_LEN)) {
2536 log_to_screen("User has chosen not to backup the PC");
2537 finish(1);
2538 }
2539 strcpy(bkpinfo->netfs_remote_dir, tmp1);
2540
2541 // check whether writable - we better remove surrounding spaces for this
2542 strip_spaces(bkpinfo->netfs_remote_dir);
2543
2544 if (!popup_and_get_string
2545 ("Prefix.",
2546 "Please enter the prefix that will be prepended to your ISO filename. Example: machine1 to obtain machine1-[1-9]*.iso files",
2547 bkpinfo->prefix, MAX_STR_LEN / 4)) {
2548 log_to_screen("User has chosen not to backup the PC");
2549 finish(1);
2550 }
2551 log_msg(3, "prefix set to %s", bkpinfo->prefix);
2552
2553 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2554 bkpinfo->media_size[i] = 650;
2555 }
2556 log_msg(3, "Just set netfs_remote_dir to %s",
2557 bkpinfo->netfs_remote_dir);
2558 log_msg(3, "isodir is still %s", bkpinfo->isodir);
2559 break;
2560
2561 case iso:
2562 if (!bkpinfo->disaster_recovery) {
2563 if (!popup_and_get_string
2564 ("Storage dir.",
2565 "Please enter the full path name to the directory for your ISO images. Example: /mnt/raid0_0",
2566 bkpinfo->isodir, MAX_STR_LEN / 4)) {
2567 log_to_screen("User has chosen not to backup the PC");
2568 finish(1);
2569 }
2570 if (archiving_to_media) {
2571 if ((bkpinfo->compression_level =
2572 which_compression_level()) == -1) {
2573 log_to_screen("User has chosen not to backup the PC");
2574 finish(1);
2575 }
2576 sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2577 if (!popup_and_get_string
2578 ("ISO size.",
2579 "Please enter how big you want each ISO image to be (in megabytes). This should be less than or equal to the size of the CD-R[W]'s (700) or DVD's (4480) you plan to backup to.",
2580 sz_size, 16)) {
2581 log_to_screen("User has chosen not to backup the PC");
2582 finish(1);
2583 }
2584 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2585 bkpinfo->media_size[i] = atoi(sz_size);
2586 }
2587 } else {
2588 for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2589 bkpinfo->media_size[i] = 650;
2590 }
2591 }
2592 }
2593 if (!popup_and_get_string
2594 ("Prefix.",
2595 "Please enter the prefix that will be prepended to your ISO filename. Example: machine1 to obtain machine1-[1-9]*.iso files",
2596 bkpinfo->prefix, MAX_STR_LEN / 4)) {
2597 log_to_screen("User has chosen not to backup the PC");
2598 finish(1);
2599 }
2600 log_msg(3, "prefix set to %s", bkpinfo->prefix);
2601 break;
2602 default:
2603 fatal_error
2604 ("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
2605 }
2606
2607 if (archiving_to_media) {
2608
2609#ifdef __FreeBSD__
2610 strcpy(bkpinfo->boot_device,
2611 call_program_and_get_last_line_of_output
2612 ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
2613#else
2614 strcpy(bkpinfo->boot_device,
2615 call_program_and_get_last_line_of_output
2616 ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
2617#endif
2618 i = which_boot_loader(bkpinfo->boot_device);
2619 if (i == 'U') // unknown
2620 {
2621
2622#ifdef __FreeBSD__
2623 if (!popup_and_get_string
2624 ("Boot device",
2625 "What is your boot device? (e.g. /dev/ad0)",
2626 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2627 log_to_screen("User has chosen not to backup the PC");
2628 finish(1);
2629 }
2630 i = which_boot_loader(bkpinfo->boot_device);
2631#else
2632 if (!popup_and_get_string
2633 ("Boot device",
2634 "What is your boot device? (e.g. /dev/hda)",
2635 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2636 log_to_screen("User has chosen not to backup the PC");
2637 finish(1);
2638 }
2639 if (does_string_exist_in_boot_block
2640 (bkpinfo->boot_device, "LILO")) {
2641 i = 'L';
2642 } else
2643 if (does_string_exist_in_boot_block
2644 (bkpinfo->boot_device, "ELILO")) {
2645 i = 'E';
2646 } else
2647 if (does_string_exist_in_boot_block
2648 (bkpinfo->boot_device, "GRUB")) {
2649 i = 'G';
2650 } else {
2651 i = 'U';
2652 }
2653#endif
2654 if (i == 'U') {
2655 if (ask_me_yes_or_no
2656 ("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?"))
2657 {
2658 i = 'R'; // raw
2659 } else {
2660 log_to_screen
2661 ("I cannot find your boot loader. Please run mondoarchive with parameters.");
2662 finish(1);
2663 }
2664 }
2665 }
2666 bkpinfo->boot_loader = i;
2667 strcpy(bkpinfo->include_paths, "/");
2668 if (!popup_and_get_string
2669 ("Backup paths",
2670 "Please enter paths (separated by '|') which you want me to backup. The default is '/' (i.e. everything).",
2671 bkpinfo->include_paths, MAX_STR_LEN)) {
2672 log_to_screen("User has chosen not to backup the PC");
2673 finish(1);
2674 }
2675 tmp = list_of_NETFS_mounts_only();
2676 if (strlen(tmp) > 2) {
2677 mr_strcat(bkpinfo->exclude_paths, "|%s",tmp);
2678 }
2679 mr_free(tmp);
2680// NTFS
2681 strcpy(tmp1, call_program_and_get_last_line_of_output("parted2fdisk -l | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'"));
2682 if (strlen(tmp1) > 2) {
2683 if (!popup_and_get_string
2684 ("NTFS partitions",
2685 "Please enter/confirm the NTFS partitions you wish to backup as well.",
2686 tmp1, MAX_STR_LEN / 4)) {
2687 log_to_screen("User has chosen not to backup the PC");
2688 finish(1);
2689 }
2690 strncpy(bkpinfo->image_devs, tmp1, MAX_STR_LEN / 4);
2691 }
2692
2693 if (bkpinfo->exclude_paths != NULL ) {
2694 strncpy(p,bkpinfo->exclude_paths,(8*MAX_STR_LEN)-1);
2695 } else {
2696 p[0] = '\0';
2697 }
2698 popup_and_get_string("Exclude paths", "Please enter paths which you do NOT want to backup. Separate them with '|'. NB: /tmp and /proc are always excluded. :-) Just hit 'Enter' if you want to do a full system backup.", p, (8*MAX_STR_LEN)-1);
2699 if (p == NULL) {
2700 log_to_screen("User has chosen not to backup the PC");
2701 finish(1);
2702 }
2703 mr_free(bkpinfo->exclude_paths);
2704 mr_asprintf(&tmp, "%s", p);
2705 bkpinfo->exclude_paths = tmp;
2706
2707 if (!popup_and_get_string
2708 ("Temporary directory",
2709 "Please enter your temporary directory.",
2710 bkpinfo->tmpdir, (4*MAX_STR_LEN)-1)) {
2711 log_to_screen("User has chosen not to backup the PC");
2712 finish(1);
2713 }
2714 if (!popup_and_get_string
2715 ("Scratch directory",
2716 "Please enter your scratch directory.",
2717 bkpinfo->scratchdir, (4*MAX_STR_LEN)-1)) {
2718 log_to_screen("User has chosen not to backup the PC");
2719 finish(1);
2720 }
2721// Interactive mode:
2722#ifdef __IA64__
2723 bkpinfo->make_cd_use_lilo = TRUE;
2724#else
2725 bkpinfo->make_cd_use_lilo = FALSE;
2726#endif
2727 bkpinfo->backup_data = TRUE;
2728 bkpinfo->verify_data =
2729 ask_me_yes_or_no
2730 ("Will you want to verify your backups after Mondo has created them?");
2731
2732#ifndef __FreeBSD__
2733 if (!ask_me_yes_or_no
2734 ("Are you confident that your kernel is a sane, sensible, standard Linux kernel? Say 'no' if you are using a Gentoo <1.4 or Debian <3.0, please."))
2735#endif
2736 {
2737 strcpy(bkpinfo->kernel_path, "FAILSAFE");
2738 }
2739
2740 if (!ask_me_yes_or_no
2741 ("Are you sure you want to proceed? Hit 'no' to abort.")) {
2742 log_to_screen("User has chosen not to backup the PC");
2743 finish(1);
2744 }
2745 } else {
2746 bkpinfo->restore_data = TRUE; // probably...
2747 }
2748
2749 if (bkpinfo->backup_media_type == iso
2750 || bkpinfo->backup_media_type == netfs) {
2751 g_ISO_restore_mode = TRUE;
2752 }
2753#ifdef __FreeSD__
2754// skip
2755#else
2756 if (bkpinfo->backup_media_type == netfs) {
2757 log_msg(3, "I think the Remote mount is mounted at %s",
2758 bkpinfo->isodir);
2759 }
2760 log_it("isodir = %s", bkpinfo->isodir);
2761 log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
2762 if (bkpinfo->netfs_proto) {
2763 log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
2764 }
2765 if (bkpinfo->netfs_user) {
2766 log_it("netfs_user = '%s'", bkpinfo->netfs_user);
2767 }
2768#endif
2769
2770 log_it("media device = %s", bkpinfo->media_device);
2771 log_it("media size = %ld", bkpinfo->media_size[1]);
2772 log_it("media type = %s",
2773 bkptype_to_string(bkpinfo->backup_media_type));
2774 log_it("prefix = %s", bkpinfo->prefix);
2775 log_it("compression = %ld", bkpinfo->compression_level);
2776 log_it("exclude_path = %s", bkpinfo->exclude_paths);
2777 log_it("include_path = %s", bkpinfo->include_paths);
2778
2779 /* Handle devices passed in bkpinfo and print result */
2780 /* the mr_make_devlist_from_pathlist function appends
2781 * to the *_paths variables so copy before */
2782 mr_make_devlist_from_pathlist(bkpinfo->exclude_paths, 'E');
2783 mr_make_devlist_from_pathlist(bkpinfo->include_paths, 'I');
2784
2785 log_it("scratchdir = '%s'", bkpinfo->scratchdir);
2786 log_it("tmpdir = '%s'", bkpinfo->tmpdir);
2787 log_it("image_devs = '%s'", bkpinfo->image_devs);
2788 log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device,
2789 bkpinfo->boot_loader);
2790 if (bkpinfo->media_size[0] < 0) {
2791 if (archiving_to_media) {
2792 fatal_error("Media size is less than zero.");
2793 } else {
2794 log_msg(2, "Warning - media size is less than zero.");
2795 bkpinfo->media_size[0] = 0;
2796 }
2797 }
2798 paranoid_free(sz_size);
2799 paranoid_free(tmp1);
2800 paranoid_free(command);
2801 paranoid_free(comment);
2802 paranoid_free(prompt);
2803 return (0);
2804}
2805
2806
2807/**
2808 * Get a |-separated list of NETFS mounts.
2809 * @return The list created.
2810 * @note The return value points to allocated string that needs to be freed
2811 * @bug Even though we only want the mounts, the devices are still checked.
2812 */
2813char *list_of_NETFS_mounts_only(void)
2814{
2815 char *exclude_these_directories = NULL;
2816
2817 mr_asprintf(&exclude_these_directories,"%s", call_program_and_get_last_line_of_output("mount -t coda,ncpfs,fuse.sshfs,nfs,nfs4,vmhgfs,smbfs,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' '|' | awk '{print $0;}'"));
2818 log_msg(9,"list_of_NETFS_mounts_only returns %s\n",exclude_these_directories);
2819 return(exclude_these_directories);
2820}
2821
2822/* @} - end of utilityGroup */
2823
2824
2825
2826
2827
2828/**
2829 * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
2830 * [random] is a random number between 1 and 32767.
2831 * @param store_name_here Where to store the new filename.
2832 * @param stub A random number will be appended to this to make the FIFO's name.
2833 * @ingroup deviceGroup
2834 */
2835void make_fifo(char *store_name_here, char *stub)
2836{
2837 char *tmp;
2838
2839 malloc_string(tmp);
2840 assert_string_is_neither_NULL_nor_zerolength(stub);
2841
2842 sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
2843 (int) (random() % 32768));
2844 make_hole_for_file(store_name_here);
2845 mkfifo(store_name_here, S_IRWXU | S_IRWXG);
2846 sprintf(tmp, "chmod 770 %s", store_name_here);
2847 paranoid_system(tmp);
2848 paranoid_free(tmp);
2849}
2850
2851
2852
2853
2854
2855
2856/**
2857 * Set the tmpdir and scratchdir to reside on the partition with the most free space.
2858 * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
2859 * @param bkpinfo The backup information structure. @c bkpinfo->tmpdir and @c bkpinfo->scratchdir will be set.
2860 * @ingroup utilityGroup
2861 */
2862void sensibly_set_tmpdir_and_scratchdir()
2863{
2864 char *tmp = NULL;
2865 char *command = NULL;
2866 char *sz = NULL;
2867
2868 assert(bkpinfo != NULL);
2869
2870#ifdef __FreeBSD__
2871 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output("LANGUAGE=C df -m -P -t nonfs,msdosfs,ntfs,ntfs-3g,vmhgfs,smbfs,smb,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol | grep -vE \"none|Filesystem\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done"));
2872#else
2873 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output("LANGUAGE=C df -m -P -x nfs -x nfs4 -x fuse.sshfs -x fuse -x vfat -x ntfs -x ntfs-3g -x vmhgfs -x smbfs -x smb -x cifs -x afs -x gfs -x ocfs -x ocfs2 -x mvfs -x nsspool -x nssvol -x iso9660 | grep -vE \"none|Filesystem|/dev/shm\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done"));
2874#endif
2875
2876 if (tmp[0] != '/') {
2877 mr_asprintf(&sz, "%s", tmp);
2878 paranoid_free(tmp);
2879 mr_asprintf(&tmp, "/%s", sz);
2880 mr_free(sz);
2881 }
2882 if (!tmp[0]) {
2883 fatal_error("I couldn't figure out the tempdir!");
2884 }
2885 setup_tmpdir(tmp);
2886 log_it("bkpinfo->tmpdir is being set to %s", bkpinfo->tmpdir);
2887
2888 sprintf(bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp,
2889 (int) (random() % 32768));
2890 log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
2891
2892 mr_asprintf(&command, "rm -Rf %s/tmp.mondo.* %s/mondo.scratch.*", tmp, tmp);
2893 paranoid_free(tmp);
2894
2895 paranoid_system(command);
2896 mr_free(command);
2897}
2898
2899
2900
2901
2902
2903
2904/**
2905 * @addtogroup deviceGroup
2906 * @{
2907 */
2908/**
2909 * If we can read @p dev, set @p output to it.
2910 * If @p dev cannot be read, set @p output to "".
2911 * @param dev The device to check for.
2912 * @param output Set to @p dev if @p dev exists, "" otherwise.
2913 * @return TRUE if @p dev exists, FALSE if it doesn't.
2914 */
2915bool set_dev_to_this_if_rx_OK(char *output, char *dev)
2916{
2917 char *command;
2918
2919 malloc_string(command);
2920 if (!dev || dev[0] == '\0') {
2921 output[0] = '\0';
2922 return (FALSE);
2923 }
2924// assert_string_is_neither_NULL_nor_zerolength(dev);
2925 log_msg(10, "Injecting %s", dev);
2926 inject_device(dev);
2927 if (!does_file_exist(dev)) {
2928 log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
2929 return (FALSE);
2930 }
2931 sprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
2932 512L, dev);
2933 if (!run_program_and_log_output(command, FALSE)
2934 && !run_program_and_log_output(command, FALSE)) {
2935 strcpy(output, dev);
2936 log_msg(4, "Found it - %s", dev);
2937 return (TRUE);
2938 } else {
2939 output[0] = '\0';
2940 log_msg(4, "It's not %s", dev);
2941 return (FALSE);
2942 }
2943}
2944
2945
2946
2947
2948
2949/**
2950 * Find out what number CD is in the drive.
2951 * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
2952 * @return The current CD number, or -1 if it could not be found.
2953 * @note If the CD is not mounted, it will be mounted
2954 * (and remain mounted after this function returns).
2955 */
2956int what_number_cd_is_this()
2957{
2958 int cd_number = -1;
2959 char *mountdev = NULL;
2960 char *tmp = NULL;
2961
2962 assert(bkpinfo != NULL);
2963// log_it("Asking what_number_cd_is_this");
2964 if (g_ISO_restore_mode) {
2965 mr_asprintf(&tmp, "mount | grep iso9660 | awk '{print $3;}'");
2966
2967 mr_asprintf(&mountdev, "%s%s", call_program_and_get_last_line_of_output(tmp), "/archives/THIS-CD-NUMBER");
2968 cd_number = atoi(last_line_of_file(mountdev));
2969 paranoid_free(mountdev);
2970 paranoid_free(tmp);
2971
2972 return (cd_number);
2973 }
2974
2975 mr_asprintf(&mountdev, "%s", bkpinfo->media_device);
2976 if (!mountdev[0]) {
2977 log_it
2978 ("(what_number_cd_is_this) Warning - media_device unknown. Finding out...");
2979 find_cdrom_device(bkpinfo->media_device, FALSE);
2980 }
2981 if (!is_this_device_mounted(MNT_CDROM)) {
2982 if (bkpinfo->backup_media_type == usb) {
2983 mount_USB_here(mountdev, MNT_CDROM);
2984 } else {
2985 mount_CDROM_here(mountdev, MNT_CDROM);
2986 }
2987 }
2988 paranoid_free(mountdev);
2989
2990 cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
2991 return (cd_number);
2992}
2993
2994
2995
2996
2997
2998
2999
3000/**
3001 * Find out what device is mounted as root (/).
3002 * @return Root device.
3003 * @note The returned string points to static storage and will be overwritten with every call.
3004 * @bug A bit of a misnomer; it's actually finding out the root device.
3005 * The mountpoint (where it's mounted) will obviously be '/'.
3006 */
3007char *where_is_root_mounted()
3008{
3009 /*@ buffers **************** */
3010 static char tmp[MAX_STR_LEN];
3011
3012
3013#ifdef __FreeBSD__
3014 strcpy(tmp, call_program_and_get_last_line_of_output
3015 ("mount | grep \" on / \" | cut -d' ' -f1"));
3016#else
3017 strcpy(tmp, call_program_and_get_last_line_of_output
3018 ("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//"));
3019 if (strstr(tmp, "/dev/cciss/")) {
3020 strcpy(tmp, call_program_and_get_last_line_of_output
3021 ("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1"));
3022 }
3023 if (strstr(tmp, "/dev/md")) {
3024 strcpy(tmp,
3025 call_program_and_get_last_line_of_output
3026 ("mount | grep \" on / \" | cut -d' ' -f1"));
3027 }
3028#endif
3029
3030 return (tmp);
3031}
3032
3033
3034/**
3035 * Find out which boot loader is in use.
3036 * @param which_device Device to look for the boot loader on.
3037 * @return 'L' for LILO, 'E'for ELILO, 'G' for GRUB, 'B' or 'D' for FreeBSD boot loaders, or 'U' for Unknown.
3038 * @note Under Linux, all drives are examined, not just @p which_device.
3039 */
3040#ifdef __FreeBSD__
3041char which_boot_loader(char *which_device)
3042{
3043 int count_lilos = 0;
3044 int count_grubs = 0;
3045 int count_boot0s = 0;
3046 int count_dangerouslydedicated = 0;
3047
3048 log_it("looking at drive %s's MBR", which_device);
3049 if (does_string_exist_in_boot_block(which_device, "GRUB")) {
3050 count_grubs++;
3051 }
3052 if (does_string_exist_in_boot_block(which_device, "LILO")) {
3053 count_lilos++;
3054 }
3055 if (does_string_exist_in_boot_block(which_device, "Drive")) {
3056 count_boot0s++;
3057 }
3058 if (does_string_exist_in_first_N_blocks
3059 (which_device, "FreeBSD/i386", 17)) {
3060 count_dangerouslydedicated++;
3061 }
3062 log_it("%d grubs and %d lilos and %d elilos and %d boot0s and %d DD\n",
3063 count_grubs, count_lilos, count_elilos, count_boot0s,
3064 count_dangerouslydedicated);
3065
3066 if (count_grubs && !count_lilos) {
3067 return ('G');
3068 } else if (count_lilos && !count_grubs) {
3069 return ('L');
3070 } else if (count_grubs == 1 && count_lilos == 1) {
3071 log_it("I'll bet you used to use LILO but switched to GRUB...");
3072 return ('G');
3073 } else if (count_boot0s == 1) {
3074 return ('B');
3075 } else if (count_dangerouslydedicated) {
3076 return ('D');
3077 } else {
3078 log_it("Unknown boot loader");
3079 return ('U');
3080 }
3081}
3082
3083#else
3084
3085char which_boot_loader(char *which_device)
3086{
3087 /*@ buffer ***************************************************** */
3088 char *list_drives_cmd = NULL;
3089 char *current_drive;
3090
3091 /*@ pointers *************************************************** */
3092 FILE *pdrives;
3093
3094 /*@ int ******************************************************** */
3095 int count_lilos = 0;
3096 int count_grubs = 0;
3097
3098 /*@ end vars *************************************************** */
3099
3100 malloc_string(current_drive);
3101
3102#ifdef __IA64__
3103 /* No choice for it */
3104 return ('E');
3105#endif
3106 assert(which_device != NULL);
3107
3108 mr_asprintf(&list_drives_cmd, "parted2fdisk -l 2>/dev/null | grep \"/dev/.*:\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/; echo %s", where_is_root_mounted());
3109 log_it("list_drives_cmd = %s", list_drives_cmd);
3110
3111 if (!(pdrives = popen(list_drives_cmd, "r"))) {
3112 log_OS_error("Unable to open list of drives");
3113 mr_free(list_drives_cmd);
3114 paranoid_free(current_drive);
3115 return ('\0');
3116 }
3117 mr_free(list_drives_cmd);
3118
3119 for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
3120 (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
3121 strip_spaces(current_drive);
3122 log_it("looking at drive %s's MBR", current_drive);
3123 if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
3124 count_grubs++;
3125 strcpy(which_device, current_drive);
3126 break;
3127 }
3128 if (does_string_exist_in_boot_block(current_drive, "LILO")) {
3129 count_lilos++;
3130 strcpy(which_device, current_drive);
3131 break;
3132 }
3133 }
3134 if (pclose(pdrives)) {
3135 log_OS_error("Cannot pclose pdrives");
3136 }
3137 log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
3138 if (count_grubs && !count_lilos) {
3139 paranoid_free(current_drive);
3140 return ('G');
3141 } else if (count_lilos && !count_grubs) {
3142 paranoid_free(current_drive);
3143 return ('L');
3144 } else if (count_grubs == 1 && count_lilos == 1) {
3145 log_it("I'll bet you used to use LILO but switched to GRUB...");
3146 paranoid_free(current_drive);
3147 return ('G');
3148 } else {
3149 // We need to look on each partition then
3150 mr_asprintf(&list_drives_cmd, "parted2fdisk -l 2>/dev/null | grep -E \"^/dev/\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/");
3151 log_it("list_drives_cmd = %s", list_drives_cmd);
3152
3153 if (!(pdrives = popen(list_drives_cmd, "r"))) {
3154 log_OS_error("Unable to open list of drives");
3155 mr_free(list_drives_cmd);
3156 paranoid_free(current_drive);
3157 return ('\0');
3158 }
3159 mr_free(list_drives_cmd);
3160
3161 for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
3162 (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
3163 strip_spaces(current_drive);
3164 log_it("looking at partition %s's BR", current_drive);
3165 if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
3166 count_grubs++;
3167 strcpy(which_device, current_drive);
3168 break;
3169 }
3170 if (does_string_exist_in_boot_block(current_drive, "LILO")) {
3171 count_lilos++;
3172 strcpy(which_device, current_drive);
3173 break;
3174 }
3175 }
3176 if (pclose(pdrives)) {
3177 log_OS_error("Cannot pclose pdrives");
3178 }
3179 log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
3180 paranoid_free(current_drive);
3181 if (count_grubs && !count_lilos) {
3182 return ('G');
3183 } else if (count_lilos && !count_grubs) {
3184 return ('L');
3185 } else if (count_grubs == 1 && count_lilos == 1) {
3186 log_it("I'll bet you used to use LILO but switched to GRUB...");
3187 return ('G');
3188 } else {
3189 log_it("Unknown boot loader");
3190 return ('U');
3191 }
3192 }
3193}
3194#endif
3195
3196
3197
3198
3199/**
3200 * Write zeroes over the first 16K of @p device.
3201 * @param device The device to zero.
3202 * @return 0 for success, 1 for failure.
3203 */
3204int zero_out_a_device(char *device)
3205{
3206 FILE *fout;
3207 int i;
3208
3209 assert_string_is_neither_NULL_nor_zerolength(device);
3210
3211 log_it("Zeroing drive %s", device);
3212 if (!(fout = fopen(device, "w"))) {
3213 log_OS_error("Unable to open/write to device");
3214 return (1);
3215 }
3216 for (i = 0; i < 16384; i++) {
3217 fputc('\0', fout);
3218 }
3219 paranoid_fclose(fout);
3220 log_it("Device successfully zeroed.");
3221 return (0);
3222}
3223
3224/**
3225 * Return the device pointed to by @p incoming.
3226 * @param incoming The device to resolve symlinks for.
3227 * @return The path to the real device file.
3228 * @note The returned string points to static storage that will be overwritten with each call.
3229 * @bug Won't work with file v4.0; needs to be written in C.
3230 */
3231char *resolve_softlinks_to_get_to_actual_device_file(char *incoming)
3232{
3233 static char output[MAX_STR_LEN];
3234 char *command;
3235 char *curr_fname;
3236 char *scratch = NULL;
3237 char *tmp = NULL;
3238 char *p;
3239
3240 struct stat statbuf;
3241 command = malloc(1000);
3242 malloc_string(curr_fname);
3243 if (!does_file_exist(incoming)) {
3244 log_it
3245 ("resolve_softlinks_to_get_to_actual_device_file --- device not found");
3246 strcpy(output, incoming);
3247 } else {
3248 strcpy(curr_fname, incoming);
3249 lstat(curr_fname, &statbuf);
3250 while (S_ISLNK(statbuf.st_mode)) {
3251 log_msg(1, "curr_fname = %s", curr_fname);
3252 sprintf(command, "file %s", curr_fname);
3253 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
3254 for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
3255 p--);
3256 p++;
3257 mr_asprintf(&scratch, "%s", p);
3258 for (p = scratch; *p != '\0' && *p != '\''; p++);
3259 *p = '\0';
3260 log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp, scratch);
3261 mr_free(tmp);
3262
3263 if (scratch[0] == '/') {
3264 strcpy(curr_fname, scratch); // copy whole thing because it's an absolute softlink
3265 } else { // copy over the basename cos it's a relative softlink
3266 p = curr_fname + strlen(curr_fname);
3267 while (p != curr_fname && *p != '/') {
3268 p--;
3269 }
3270 if (*p == '/') {
3271 p++;
3272 }
3273 strcpy(p, scratch);
3274 }
3275 mr_free(scratch);
3276 lstat(curr_fname, &statbuf);
3277 }
3278 strcpy(output, curr_fname);
3279 log_it("resolved %s to %s", incoming, output);
3280 }
3281 paranoid_free(command);
3282 paranoid_free(curr_fname);
3283 return (output);
3284}
3285
3286/* @} - end of deviceGroup */
3287
3288/**
3289 * Return the type of partition format (GPT or MBR)
3290 */
3291char *which_partition_format(const char *drive)
3292{
3293 static char output[4];
3294 char *tmp = NULL;
3295 char *command;
3296 char *fdisk;
3297#ifdef __IA64__
3298 struct stat buf;
3299#endif
3300 malloc_string(command);
3301 malloc_string(fdisk);
3302 sprintf(fdisk, "/sbin/parted2fdisk");
3303 sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
3304 mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
3305 if (strstr(tmp, "GPT") == NULL) {
3306 strcpy(output, "MBR");
3307 } else {
3308 strcpy(output, "GPT");
3309 }
3310 mr_free(tmp);
3311
3312 log_msg(0, "Found %s partition table format type", output);
3313 paranoid_free(command);
3314 paranoid_free(fdisk);
3315 return (output);
3316}
3317/* @} - end of deviceGroup */
Note: See TracBrowser for help on using the repository browser.