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

Last change on this file since 2697 was 2697, checked in by bruno, 9 years ago
  • Backport from 2.2.10 the support of a dynamic exclude_path variable. Should help fix #366, #421, #368, #443. To be tested.
  • Property svn:keywords set to Id
File size: 95.4 KB
Line 
1/* libmondo-devices.c                 Subroutines for handling devices
2   $Id: libmondo-devices.c 2697 2011-01-25 09:44:33Z 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 2697 2011-01-25 09:44:33Z 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
2049while ((token = mr_strtok(pathlist, token_chars, &lastpos)) != NULL) {
2050    switch (get_dsf_mount_list(token, &mounted_on_dsf, &not_mounted_on_dsf)) {
2051    case 1: 
2052        if (mode == 'E') {
2053            log_msg(1, "WARNING ! %s doesn't exist in -E option", token);
2054        } else {
2055            log_msg(1, "ERROR ! %s doesn't exist in -I option", token);
2056            fatal_error("Error processing -I option");
2057        }
2058        break;
2059    /* Everything is OK; proceed to archive data */
2060    case 0:
2061        if (mode == 'E') {
2062            if (strlen(mounted_on_dsf)) {
2063                log_to_screen("Excluding the following file systems on %s:", token);
2064                log_to_screen("==> %s", mounted_on_dsf);
2065                log_msg (5, "Adding to bkpinfo->exclude_paths due to -E option: %s", mounted_on_dsf);
2066                mr_strcat(bkpinfo->exclude_paths, " %s ",mounted_on_dsf);
2067                mr_strcat(bkpinfo->exclude_devs, " %s ",token);
2068            }
2069        } else {
2070            log_to_screen("Archiving only the following file systems on %s:", token);
2071            log_to_screen("==> %s", mounted_on_dsf);
2072            strcpy(bkpinfo->include_paths, "/");
2073            if (strlen(not_mounted_on_dsf)) {
2074                log_msg (5, "Adding to bkpinfo->exclude_paths due to -I option: %s", not_mounted_on_dsf);
2075                log_to_screen("Not archiving the following file systems:");
2076                log_to_screen("==> %s", not_mounted_on_dsf);
2077                mr_strcat(bkpinfo->exclude_paths, " %s ", not_mounted_on_dsf);
2078            }
2079        }
2080        break;
2081    /* It's a dsf but not a whole disk dsf */
2082    case -2:
2083        log_to_screen("Could %s be a partition instead of a whole disk device special file?\nIgnored.", token);
2084        break;
2085    /* A device special file was not passed in. Process it as a path. */
2086    case -1:
2087        /* we need to add a space efore and after token to be sure our strstr test works correctly */
2088        mr_asprintf(&tmp1," %s ",token);
2089        if (mode == 'E') {
2090            /*  Add the token if not already in the list */
2091            mr_asprintf(&tmp," %s ",bkpinfo->exclude_paths);
2092            if (strstr(tmp,tmp1) == NULL) {
2093                mr_strcat(bkpinfo->exclude_paths, tmp1);
2094            }
2095        } else {
2096            /*  Add the token if not already in the list */
2097            mr_asprintf(&tmp," %s ",bkpinfo->include_paths);
2098            if (strstr(tmp,tmp1) == NULL) {
2099                strcat(bkpinfo->include_paths, tmp1);
2100            }
2101        }
2102        mr_free(tmp);
2103        mr_free(tmp1);
2104        break;
2105    }
2106    mr_free(token);
2107
2108    if (bkpinfo->include_paths != NULL) {
2109        log_msg(1, "include_paths is now '%s'", bkpinfo->include_paths);
2110    }
2111    if (bkpinfo->exclude_paths != NULL) {
2112        log_msg(1, "exclude_paths is now '%s'", bkpinfo->exclude_paths);
2113    }
2114    if (bkpinfo->exclude_devs != NULL) {
2115        log_msg(1, "exclude_devs is now '%s'", bkpinfo->exclude_devs);
2116    }
2117}
2118}
2119
2120
2121
2122
2123/**
2124 * Ask user for details of backup/restore information.
2125 * Called when @c mondoarchive doesn't get any parameters.
2126 * @param bkpinfo The backup information structure to fill out with the user's data.
2127 * @param archiving_to_media TRUE if archiving, FALSE if restoring.
2128 * @return 0, always.
2129 * @bug No point of `int' return value.
2130 * @ingroup archiveGroup
2131 */
2132int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
2133// archiving_to_media is TRUE if I'm being called by mondoarchive
2134// archiving_to_media is FALSE if I'm being called by mondorestore
2135{
2136    char *tmp = NULL;
2137    char *tmp1 = NULL;
2138    char *mds = NULL;
2139    char p[8*MAX_STR_LEN];
2140    char *sz_size;
2141    char *command;
2142    char *comment;
2143    char *prompt;
2144    int i;
2145    FILE *fin;
2146
2147    malloc_string(sz_size);
2148    malloc_string(command);
2149    malloc_string(comment);
2150    malloc_string(prompt);
2151    malloc_string(tmp1);
2152    assert(bkpinfo != NULL);
2153    sz_size[0] = '\0';
2154    bkpinfo->nonbootable_backup = FALSE;
2155
2156    // Tape, CD, NETFS, ...?
2157    srandom(getpid());
2158    bkpinfo->backup_media_type =
2159        (g_restoring_live_from_cd) ? cdr :
2160        which_backup_media_type(bkpinfo->restore_data);
2161    if (bkpinfo->backup_media_type == none) {
2162        log_to_screen("User has chosen not to backup the PC");
2163        finish(1);
2164    }
2165    /* Why asking to remove the media with tape ?
2166    if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
2167        popup_and_OK("Please remove media from drive(s)");
2168    }
2169    */
2170    log_msg(3, "media type = %s",
2171            bkptype_to_string(bkpinfo->backup_media_type));
2172    if (archiving_to_media) {
2173        sensibly_set_tmpdir_and_scratchdir();
2174    }
2175    bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
2176    bkpinfo->compression_level =
2177        (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
2178    bkpinfo->use_lzo =
2179        (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
2180    mvaddstr_and_log_it(2, 0, " ");
2181
2182    // Find device's /dev (or SCSI) entry
2183    switch (bkpinfo->backup_media_type) {
2184    case cdr:
2185    case cdrw:
2186    case dvd:
2187    case usb:
2188        /* Never try to eject a USB device */
2189        if (bkpinfo->backup_media_type == usb) {
2190            bkpinfo->please_dont_eject = TRUE;
2191        }
2192        if (archiving_to_media) {
2193            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
2194                if (ask_me_yes_or_no
2195                    ("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?"))
2196                {
2197                    bkpinfo->manual_cd_tray = TRUE;
2198                }
2199            }
2200            if ((bkpinfo->compression_level =
2201                 which_compression_level()) == -1) {
2202                log_to_screen("User has chosen not to backup the PC");
2203                finish(1);
2204            }
2205            mds = media_descriptor_string(bkpinfo->backup_media_type);
2206            sprintf(comment, "What speed is your %s (re)writer?", mds);
2207            if (bkpinfo->backup_media_type == dvd) {
2208                find_dvd_device(bkpinfo->media_device, FALSE);
2209                strcpy(tmp1, "1");
2210                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2211                log_msg(1, "Setting to DVD defaults");
2212            } else {
2213                strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
2214                strcpy(tmp1, "4");
2215                strcpy(sz_size, "650");
2216                log_msg(1, "Setting to CD defaults");
2217            }
2218            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
2219                if (!popup_and_get_string("Speed", comment, tmp1, 4)) {
2220                    log_to_screen("User has chosen not to backup the PC");
2221                    finish(1);
2222                }
2223            }
2224            bkpinfo->cdrw_speed = atoi(tmp1);   // if DVD then this shouldn't ever be used anyway :)
2225
2226            sprintf(comment,
2227                    "How much data (in Megabytes) will each %s store?", mds);
2228            mr_free(mds);
2229            if (!popup_and_get_string("Size", comment, sz_size, 5)) {
2230                log_to_screen("User has chosen not to backup the PC");
2231                finish(1);
2232            }
2233            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2234                bkpinfo->media_size[i] = atoi(sz_size);
2235            }
2236            if (bkpinfo->media_size[0] <= 0) {
2237                log_to_screen("User has chosen not to backup the PC");
2238                finish(1);
2239            }
2240        }
2241        /* No break because we continue even for usb */
2242    case cdstream:
2243        mds = media_descriptor_string(bkpinfo->backup_media_type);
2244
2245        if ((bkpinfo->disaster_recovery) && (bkpinfo->backup_media_type != usb)) {
2246            strcpy(bkpinfo->media_device, "/dev/cdrom");
2247            log_msg(2, "CD-ROM device assumed to be at %s",
2248                    bkpinfo->media_device);
2249        } else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb))
2250                   || bkpinfo->backup_media_type == dvd) {
2251            if (!bkpinfo->media_device[0]) {
2252                strcpy(bkpinfo->media_device, "/dev/cdrom");
2253            }                   // just for the heck of it :)
2254            log_msg(1, "bkpinfo->media_device = %s",
2255                    bkpinfo->media_device);
2256            if (bkpinfo->backup_media_type == dvd
2257                || find_cdrom_device(bkpinfo->media_device, FALSE)) {
2258                log_msg(1, "bkpinfo->media_device = %s",
2259                        bkpinfo->media_device);
2260                sprintf(comment,
2261                        "Please specify your %s drive's /dev entry", mds);
2262                if (!popup_and_get_string
2263                    ("Device?", comment, bkpinfo->media_device,
2264                     MAX_STR_LEN / 4)) {
2265                    log_to_screen("User has chosen not to backup the PC");
2266                    finish(1);
2267                }
2268            }
2269            log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
2270        } else {
2271            if ((find_cdrw_device(bkpinfo->media_device)) && (bkpinfo->backup_media_type != usb)) {
2272                bkpinfo->media_device[0] = '\0';
2273            }
2274            if (bkpinfo->media_device[0]) {
2275                if (bkpinfo->backup_media_type == usb) {
2276                    mr_asprintf(&tmp, "I think your %s media corresponds to %s. Is this correct?", mds, bkpinfo->media_device);
2277                } else {
2278                    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);
2279                }
2280                if (!ask_me_yes_or_no(tmp)) {
2281                    bkpinfo->media_device[0] = '\0';
2282                }
2283                mr_free(tmp);
2284            }
2285            if (!bkpinfo->media_device[0]) {
2286                if (bkpinfo->backup_media_type == usb) {
2287                    i = popup_and_get_string("/dev entry?",
2288                                         "What is the /dev entry of your USB Disk/Key, please?",
2289                                         bkpinfo->media_device,
2290                                         MAX_STR_LEN / 4);
2291                } else {
2292                    if (g_kernel_version < 2.6) {
2293                        i = popup_and_get_string("Device node?",
2294                                             "What is the SCSI node of your CD (re)writer, please?",
2295                                             bkpinfo->media_device,
2296                                             MAX_STR_LEN / 4);
2297                    } else {
2298                        i = popup_and_get_string("/dev entry?",
2299                                             "What is the /dev entry of your CD (re)writer, please?",
2300                                             bkpinfo->media_device,
2301                                             MAX_STR_LEN / 4);
2302                    }
2303                }
2304                if (!i) {
2305                    log_to_screen("User has chosen not to backup the PC");
2306                    finish(1);
2307                }
2308            }
2309        }
2310        mr_free(mds);
2311
2312        if (bkpinfo->backup_media_type == cdstream) {
2313            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2314                bkpinfo->media_size[i] = 650;
2315            }
2316        }
2317        break;
2318    case udev:
2319        if (!ask_me_yes_or_no
2320            ("This option is for advanced users only. Are you sure?")) {
2321            log_to_screen("User has chosen not to backup the PC");
2322            finish(1);
2323        }
2324    case tape:
2325
2326        if ((!bkpinfo->restore_mode) && (find_tape_device_and_size(bkpinfo->media_device, sz_size))) {
2327            log_msg(3, "Ok, using vanilla scsi tape.");
2328            strcpy(bkpinfo->media_device, VANILLA_SCSI_TAPE);
2329            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2330                paranoid_fclose(fin);
2331            } else {
2332                strcpy(bkpinfo->media_device, "/dev/osst0");
2333            }
2334        }
2335        if (bkpinfo->media_device[0]) {
2336            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2337                paranoid_fclose(fin);
2338            } else {
2339                if (does_file_exist("/tmp/mondo-restore.cfg")) {
2340                    read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
2341                                 bkpinfo->media_device);
2342                }
2343            }
2344        }
2345        if (bkpinfo->media_device[0]) {
2346            mr_asprintf(&tmp, "I think I've found your tape streamer at %s; am I right on the money?", bkpinfo->media_device);
2347            if (!ask_me_yes_or_no(tmp)) {
2348                bkpinfo->media_device[0] = '\0';
2349            }
2350            mr_free(tmp);
2351        }
2352        if (!bkpinfo->media_device[0]) {
2353            if (!popup_and_get_string
2354                ("Device name?",
2355                 "What is the /dev entry of your tape streamer?",
2356                 bkpinfo->media_device, MAX_STR_LEN / 4)) {
2357                log_to_screen("User has chosen not to backup the PC");
2358                finish(1);
2359            }
2360        }
2361        mr_asprintf(&tmp, "ls -l %s", bkpinfo->media_device);
2362        if (run_program_and_log_output(tmp, FALSE)) {
2363            log_to_screen("User has not specified a valid /dev entry");
2364            finish(1);
2365        }
2366        mr_free(tmp);
2367        log_msg(4, "sz_size = %s", sz_size);
2368        sz_size[0] = '\0';
2369
2370        bkpinfo->use_obdr = ask_me_yes_or_no
2371            ("Do you want to activate OBDR support for your tapes ?");
2372        if (sz_size[0] == '\0') {
2373            bkpinfo->media_size[0] = 0;
2374        } else {
2375            bkpinfo->media_size[0] =
2376                friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
2377        }
2378        log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
2379        if (bkpinfo->media_size[0] <= 0) {
2380            bkpinfo->media_size[0] = 0;
2381        }
2382        for (i = 1; i <= MAX_NOOF_MEDIA; i++) {
2383            bkpinfo->media_size[i] = bkpinfo->media_size[0];
2384        }
2385        if (archiving_to_media) {
2386            if ((bkpinfo->compression_level =
2387                 which_compression_level()) == -1) {
2388                log_to_screen("User has chosen not to backup the PC");
2389                finish(1);
2390            }
2391        }
2392        break;
2393
2394
2395
2396    case netfs:
2397        /* Never try to eject a NETFS device */
2398        bkpinfo->please_dont_eject = TRUE;
2399
2400        /* Initiate bkpinfo netfs_mount path from running environment if not already done */
2401        if (!bkpinfo->netfs_mount[0]) {
2402            strcpy(bkpinfo->netfs_mount,
2403                   call_program_and_get_last_line_of_output
2404                   ("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
2405        }
2406#ifdef __FreeBSD__
2407        if (TRUE)
2408#else
2409        if (!bkpinfo->disaster_recovery)
2410#endif
2411        {
2412            if (!popup_and_get_string
2413                ("Network shared dir.",
2414                 "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.)",
2415                 bkpinfo->netfs_mount, MAX_STR_LEN / 4)) {
2416                log_to_screen("User has chosen not to backup the PC");
2417                finish(1);
2418            }
2419            if (!bkpinfo->restore_data) {
2420                if ((bkpinfo->compression_level =
2421                     which_compression_level()) == -1) {
2422                    log_to_screen("User has chosen not to backup the PC");
2423                    finish(1);
2424                }
2425            }
2426            // check whether already mounted - we better remove
2427            // surrounding spaces and trailing '/' for this
2428            strip_spaces(bkpinfo->netfs_mount);
2429            if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
2430                bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
2431            sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3",
2432                    bkpinfo->netfs_mount);
2433            strcpy(bkpinfo->isodir,
2434                   call_program_and_get_last_line_of_output(command));
2435
2436            if (!bkpinfo->restore_data) {
2437                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2438                sprintf(comment,
2439                    "How much data (in Megabytes) will each media store?");
2440                if (!popup_and_get_string("Size", comment, sz_size, 5)) {
2441                    log_to_screen("User has chosen not to backup the PC");
2442                    finish(1);
2443                }
2444            } else {
2445                strcpy(sz_size, "0");
2446            }
2447            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2448                bkpinfo->media_size[i] = atoi(sz_size);
2449            }
2450            if (bkpinfo->media_size[0] < 0) {
2451                log_to_screen("User has chosen not to backup the PC");
2452                finish(1);
2453            }
2454        }
2455        /*  Force NFS to be the protocol by default */
2456        if (bkpinfo->netfs_proto == NULL) {
2457            mr_asprintf(&(bkpinfo->netfs_proto), "nfs");
2458        }
2459        if (bkpinfo->disaster_recovery) {
2460            sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
2461            (void)system(command);
2462        }
2463        strcpy(tmp1, bkpinfo->netfs_proto);
2464        if (!popup_and_get_string
2465            ("Network protocol", "Which protocol should I use (nfs/sshfs) ?",
2466             tmp1, MAX_STR_LEN)) {
2467            log_to_screen("User has chosen not to backup the PC");
2468            finish(1);
2469        }
2470        mr_free(bkpinfo->netfs_proto);
2471        mr_asprintf(&(bkpinfo->netfs_proto), "%s", tmp1);
2472        if (!popup_and_get_string
2473            ("Network share", "Which remote share should I mount?",
2474             bkpinfo->netfs_mount, MAX_STR_LEN)) {
2475            log_to_screen("User has chosen not to backup the PC");
2476            finish(1);
2477        }
2478
2479        /* Initiate bkpinfo isodir path from running environment if mount already done */
2480        if (is_this_device_mounted(bkpinfo->netfs_mount)) {
2481            strcpy(bkpinfo->isodir,
2482                   call_program_and_get_last_line_of_output
2483                   ("mount | grep \":\" | cut -d' ' -f3 | head -n1"));
2484        } else {
2485            sprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
2486            sprintf(command, "mkdir -p %s", bkpinfo->isodir);
2487            run_program_and_log_output(command, 5);
2488            if (bkpinfo->restore_data) {
2489                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
2490                    mr_asprintf(&tmp, "sshfs -o ro %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
2491                } else {
2492                    mr_asprintf(&tmp, "mount -t %s -o nolock,ro %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
2493                }
2494            } else {
2495                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
2496                    mr_asprintf(&tmp, "sshfs %s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
2497                } else {
2498                    mr_asprintf(&tmp, "mount -t %s -o nolock %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount, bkpinfo->isodir);
2499                }
2500            }
2501            run_program_and_log_output(tmp, 3);
2502            mr_free(tmp);
2503
2504            malloc_string(g_selfmounted_isodir);
2505            strcpy(g_selfmounted_isodir, bkpinfo->isodir);
2506        }
2507        if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
2508            popup_and_OK
2509                ("Please mount that partition before you try to backup to or restore from it.");
2510            finish(1);
2511        }
2512        strcpy(tmp1, bkpinfo->netfs_remote_dir);
2513        if (!popup_and_get_string
2514            ("Directory", "Which directory within that mountpoint?", tmp1,
2515             MAX_STR_LEN)) {
2516            log_to_screen("User has chosen not to backup the PC");
2517            finish(1);
2518        }
2519        strcpy(bkpinfo->netfs_remote_dir, tmp1);
2520
2521        // check whether writable - we better remove surrounding spaces for this
2522        strip_spaces(bkpinfo->netfs_remote_dir);
2523
2524        if (!popup_and_get_string
2525            ("Prefix.",
2526             "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files",
2527            bkpinfo->prefix, MAX_STR_LEN / 4)) {
2528            log_to_screen("User has chosen not to backup the PC");
2529            finish(1);
2530        }
2531        log_msg(3, "prefix set to %s", bkpinfo->prefix);
2532
2533        for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2534            bkpinfo->media_size[i] = 650;
2535        }
2536        log_msg(3, "Just set netfs_remote_dir to %s",
2537                bkpinfo->netfs_remote_dir);
2538        log_msg(3, "isodir is still %s", bkpinfo->isodir);
2539        break;
2540
2541    case iso:
2542        if (!bkpinfo->disaster_recovery) {
2543            if (!popup_and_get_string
2544                ("Storage dir.",
2545                 "Please enter the full path name to the directory for your ISO images.  Example: /mnt/raid0_0",
2546                 bkpinfo->isodir, MAX_STR_LEN / 4)) {
2547                log_to_screen("User has chosen not to backup the PC");
2548                finish(1);
2549            }
2550            if (archiving_to_media) {
2551                if ((bkpinfo->compression_level =
2552                     which_compression_level()) == -1) {
2553                    log_to_screen("User has chosen not to backup the PC");
2554                    finish(1);
2555                }
2556                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
2557                if (!popup_and_get_string
2558                    ("ISO size.",
2559                     "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.",
2560                     sz_size, 16)) {
2561                    log_to_screen("User has chosen not to backup the PC");
2562                    finish(1);
2563                }
2564                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2565                    bkpinfo->media_size[i] = atoi(sz_size);
2566                }
2567            } else {
2568                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2569                    bkpinfo->media_size[i] = 650;
2570                }
2571            }
2572        }
2573        if (!popup_and_get_string
2574            ("Prefix.",
2575             "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files",
2576             bkpinfo->prefix, MAX_STR_LEN / 4)) {
2577            log_to_screen("User has chosen not to backup the PC");
2578            finish(1);
2579        }
2580        log_msg(3, "prefix set to %s", bkpinfo->prefix);
2581        break;
2582    default:
2583        fatal_error
2584            ("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
2585    }
2586
2587    if (archiving_to_media) {
2588
2589#ifdef __FreeBSD__
2590        strcpy(bkpinfo->boot_device,
2591               call_program_and_get_last_line_of_output
2592               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
2593#else
2594        strcpy(bkpinfo->boot_device,
2595               call_program_and_get_last_line_of_output
2596               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
2597#endif
2598        i = which_boot_loader(bkpinfo->boot_device);
2599        if (i == 'U')           // unknown
2600        {
2601
2602#ifdef __FreeBSD__
2603            if (!popup_and_get_string
2604                ("Boot device",
2605                 "What is your boot device? (e.g. /dev/ad0)",
2606                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2607                log_to_screen("User has chosen not to backup the PC");
2608                finish(1);
2609            }
2610            i = which_boot_loader(bkpinfo->boot_device);
2611#else
2612            if (!popup_and_get_string
2613                ("Boot device",
2614                 "What is your boot device? (e.g. /dev/hda)",
2615                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2616                log_to_screen("User has chosen not to backup the PC");
2617                finish(1);
2618            }
2619            if (does_string_exist_in_boot_block
2620                (bkpinfo->boot_device, "LILO")) {
2621                i = 'L';
2622            } else
2623                if (does_string_exist_in_boot_block
2624                    (bkpinfo->boot_device, "ELILO")) {
2625                i = 'E';
2626            } else
2627                if (does_string_exist_in_boot_block
2628                    (bkpinfo->boot_device, "GRUB")) {
2629                i = 'G';
2630            } else {
2631                i = 'U';
2632            }
2633#endif
2634            if (i == 'U') {
2635                if (ask_me_yes_or_no
2636                    ("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?"))
2637                {
2638                    i = 'R';    // raw
2639                } else {
2640                    log_to_screen
2641                        ("I cannot find your boot loader. Please run mondoarchive with parameters.");
2642                    finish(1);
2643                }
2644            }
2645        }
2646        bkpinfo->boot_loader = i;
2647        strcpy(bkpinfo->include_paths, "/");
2648        if (!popup_and_get_string
2649            ("Backup paths",
2650             "Please enter paths which you want me to backup. The default is '/' (i.e. everything).",
2651             bkpinfo->include_paths, MAX_STR_LEN)) {
2652            log_to_screen("User has chosen not to backup the PC");
2653            finish(1);
2654        }
2655        mr_asprintf(&tmp, "%s", list_of_NETFS_mounts_only());
2656        if (strlen(tmp) > 2) {
2657            mr_strcat(bkpinfo->exclude_paths, " %s",tmp);
2658        }
2659        mr_free(tmp);
2660// NTFS
2661        strcpy(tmp1, call_program_and_get_last_line_of_output("parted2fdisk -l | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'"));
2662        if (strlen(tmp1) > 2) {
2663            if (!popup_and_get_string
2664                ("NTFS partitions",
2665                 "Please enter/confirm the NTFS partitions you wish to backup as well.",
2666                 tmp1, MAX_STR_LEN / 4)) {
2667                log_to_screen("User has chosen not to backup the PC");
2668                finish(1);
2669            }
2670            strncpy(bkpinfo->image_devs, tmp1, MAX_STR_LEN / 4);
2671        }
2672
2673        strncpy(p,bkpinfo->exclude_paths,(8*MAX_STR_LEN)-1);
2674        popup_and_get_string("Exclude paths", "Please enter paths which you do NOT want to backup. Separate them with spaces. 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);
2675        if (p == NULL) {
2676            log_to_screen("User has chosen not to backup the PC");
2677            finish(1);
2678        }
2679        mr_free(bkpinfo->exclude_paths);
2680        mr_asprintf(&tmp, "%s", p);
2681        bkpinfo->exclude_paths = tmp;
2682
2683        if (!popup_and_get_string
2684            ("Temporary directory",
2685             "Please enter your temporary directory.",
2686             bkpinfo->tmpdir, (4*MAX_STR_LEN)-1)) {
2687            log_to_screen("User has chosen not to backup the PC");
2688            finish(1);
2689        }
2690        if (!popup_and_get_string
2691            ("Scratch directory",
2692             "Please enter your scratch directory.",
2693             bkpinfo->scratchdir, (4*MAX_STR_LEN)-1)) {
2694            log_to_screen("User has chosen not to backup the PC");
2695            finish(1);
2696        }
2697// Interactive mode:
2698#ifdef __IA64__
2699        bkpinfo->make_cd_use_lilo = TRUE;
2700#else
2701        bkpinfo->make_cd_use_lilo = FALSE;
2702#endif
2703        bkpinfo->backup_data = TRUE;
2704        bkpinfo->verify_data =
2705            ask_me_yes_or_no
2706            ("Will you want to verify your backups after Mondo has created them?");
2707
2708#ifndef __FreeBSD__
2709        if (!ask_me_yes_or_no
2710            ("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."))
2711#endif
2712        {
2713            strcpy(bkpinfo->kernel_path, "FAILSAFE");
2714        }
2715
2716        if (!ask_me_yes_or_no
2717            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
2718            log_to_screen("User has chosen not to backup the PC");
2719            finish(1);
2720        }
2721    } else {
2722        bkpinfo->restore_data = TRUE;   // probably...
2723    }
2724
2725    if (bkpinfo->backup_media_type == iso
2726        || bkpinfo->backup_media_type == netfs) {
2727        g_ISO_restore_mode = TRUE;
2728    }
2729#ifdef __FreeSD__
2730// skip
2731#else
2732    if (bkpinfo->backup_media_type == netfs) {
2733        log_msg(3, "I think the Remote mount is mounted at %s",
2734                bkpinfo->isodir);
2735    }
2736    log_it("isodir = %s", bkpinfo->isodir);
2737    log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
2738    if (bkpinfo->netfs_proto) {
2739        log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
2740    }
2741    if (bkpinfo->netfs_user) {
2742        log_it("netfs_user = '%s'", bkpinfo->netfs_user);
2743    }
2744#endif
2745
2746    log_it("media device = %s", bkpinfo->media_device);
2747    log_it("media size = %ld", bkpinfo->media_size[1]);
2748    log_it("media type = %s",
2749           bkptype_to_string(bkpinfo->backup_media_type));
2750    log_it("prefix = %s", bkpinfo->prefix);
2751    log_it("compression = %ld", bkpinfo->compression_level);
2752    log_it("exclude_path = %s", bkpinfo->exclude_paths);
2753    log_it("include_path = %s", bkpinfo->include_paths);
2754
2755    /* Handle devices passed in bkpinfo and print result */
2756    /*  the mr_make_devlist_from_pathlist function appends
2757     *  to the *_paths variables so copy before */
2758    mr_asprintf(&tmp, "%s ", bkpinfo->exclude_paths);
2759    mr_make_devlist_from_pathlist(tmp, 'E');
2760    mr_free(tmp);
2761    mr_asprintf(&tmp, "%s ", bkpinfo->include_paths);
2762    mr_make_devlist_from_pathlist(tmp, 'I');
2763    mr_free(tmp);
2764
2765    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
2766    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
2767    log_it("image_devs = '%s'", bkpinfo->image_devs);
2768    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device,
2769           bkpinfo->boot_loader);
2770    if (bkpinfo->media_size[0] < 0) {
2771        if (archiving_to_media) {
2772            fatal_error("Media size is less than zero.");
2773        } else {
2774            log_msg(2, "Warning - media size is less than zero.");
2775            bkpinfo->media_size[0] = 0;
2776        }
2777    }
2778    paranoid_free(sz_size);
2779    paranoid_free(tmp1);
2780    paranoid_free(command);
2781    paranoid_free(comment);
2782    paranoid_free(prompt);
2783    return (0);
2784}
2785
2786
2787
2788
2789/**
2790 * @addtogroup utilityGroup
2791 * @{
2792 */
2793/**
2794 * Get a space-separated list of NETFS devices and mounts.
2795 * @return The list created.
2796 * @note The return value points to static data that will be overwritten with each call.
2797 */
2798char *list_of_NETFS_devices_and_mounts(void)
2799{
2800    char *exclude_these_devices = NULL;
2801    char *exclude_these_directories = NULL;
2802    static char result_sz[1024];
2803
2804    mr_asprintf(&exclude_these_directories,"%s",list_of_NETFS_mounts_only());
2805    mr_asprintf(&exclude_these_devices,"%s", call_program_and_get_last_line_of_output("tr -s '\t' ' ' < /etc/fstab | grep -E '( (coda|ncpfs|sshfs|nfs|nfs4|smbfs|cifs|afs|gfs|ocfs|ocfs2|mvfs|nsspool|nsvol) )' | cut -d' ' -f1 | tr -s '\n' ' ' | awk '{print $0;}'"));
2806    snprintf(result_sz, 1023, "%s %s", exclude_these_directories, exclude_these_devices);
2807    mr_free(exclude_these_devices);
2808    mr_free(exclude_these_directories);
2809    return (result_sz);
2810}
2811
2812
2813
2814
2815/**
2816 * Get a space-separated list of NETFS mounts.
2817 * @return The list created.
2818 * @note The return value points to static data that will be overwritten with each call.
2819 * @bug Even though we only want the mounts, the devices are still checked.
2820 */
2821char *list_of_NETFS_mounts_only(void)
2822{
2823    char *exclude_these_directories = NULL;
2824    static char result_sz[512];
2825
2826    mr_asprintf(&exclude_these_directories,"%s", call_program_and_get_last_line_of_output("mount -t coda,ncpfs,fuse.sshfs,nfs,nfs4,smbfs,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
2827    snprintf(result_sz, 511, "%s", exclude_these_directories);
2828    mr_free(exclude_these_directories);
2829    return (result_sz);
2830}
2831
2832/* @} - end of utilityGroup */
2833
2834
2835
2836
2837
2838/**
2839 * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
2840 * [random] is a random number between 1 and 32767.
2841 * @param store_name_here Where to store the new filename.
2842 * @param stub A random number will be appended to this to make the FIFO's name.
2843 * @ingroup deviceGroup
2844 */
2845void make_fifo(char *store_name_here, char *stub)
2846{
2847    char *tmp;
2848
2849    malloc_string(tmp);
2850    assert_string_is_neither_NULL_nor_zerolength(stub);
2851
2852    sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
2853            (int) (random() % 32768));
2854    make_hole_for_file(store_name_here);
2855    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
2856    sprintf(tmp, "chmod 770 %s", store_name_here);
2857    paranoid_system(tmp);
2858    paranoid_free(tmp);
2859}
2860
2861
2862
2863
2864
2865
2866/**
2867 * Set the tmpdir and scratchdir to reside on the partition with the most free space.
2868 * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
2869 * @param bkpinfo The backup information structure. @c bkpinfo->tmpdir and @c bkpinfo->scratchdir will be set.
2870 * @ingroup utilityGroup
2871 */
2872void sensibly_set_tmpdir_and_scratchdir()
2873{
2874    char *tmp = NULL; 
2875    char *command = NULL;
2876    char *sz = NULL;
2877
2878    assert(bkpinfo != NULL);
2879
2880#ifdef __FreeBSD__
2881    mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output("LANGUAGE=C df -m -P -t nonfs,msdosfs,ntfs,ntfs-3g,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"));
2882#else
2883    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 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"));
2884#endif
2885
2886    if (tmp[0] != '/') {
2887        mr_asprintf(&sz, "%s", tmp);
2888        paranoid_free(tmp);
2889        mr_asprintf(&tmp, "/%s", sz);
2890        mr_free(sz);
2891    }
2892    if (!tmp[0]) {
2893        fatal_error("I couldn't figure out the tempdir!");
2894    }
2895    setup_tmpdir(tmp);
2896    log_it("bkpinfo->tmpdir is being set to %s", bkpinfo->tmpdir);
2897
2898    sprintf(bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp,
2899            (int) (random() % 32768));
2900    log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
2901
2902    mr_asprintf(&command, "rm -Rf %s/tmp.mondo.* %s/mondo.scratch.*", tmp, tmp);
2903    paranoid_free(tmp);
2904
2905    paranoid_system(command);
2906    mr_free(command);
2907}
2908
2909
2910
2911
2912
2913
2914/**
2915 * @addtogroup deviceGroup
2916 * @{
2917 */
2918/**
2919 * If we can read @p dev, set @p output to it.
2920 * If @p dev cannot be read, set @p output to "".
2921 * @param dev The device to check for.
2922 * @param output Set to @p dev if @p dev exists, "" otherwise.
2923 * @return TRUE if @p dev exists, FALSE if it doesn't.
2924 */
2925bool set_dev_to_this_if_rx_OK(char *output, char *dev)
2926{
2927    char *command;
2928
2929    malloc_string(command);
2930    if (!dev || dev[0] == '\0') {
2931        output[0] = '\0';
2932        return (FALSE);
2933    }
2934//  assert_string_is_neither_NULL_nor_zerolength(dev);
2935    log_msg(10, "Injecting %s", dev);
2936    inject_device(dev);
2937    if (!does_file_exist(dev)) {
2938        log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
2939        return (FALSE);
2940    }
2941    sprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
2942            512L, dev);
2943    if (!run_program_and_log_output(command, FALSE)
2944        && !run_program_and_log_output(command, FALSE)) {
2945        strcpy(output, dev);
2946        log_msg(4, "Found it - %s", dev);
2947        return (TRUE);
2948    } else {
2949        output[0] = '\0';
2950        log_msg(4, "It's not %s", dev);
2951        return (FALSE);
2952    }
2953}
2954
2955
2956
2957
2958
2959/**
2960 * Find out what number CD is in the drive.
2961 * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
2962 * @return The current CD number, or -1 if it could not be found.
2963 * @note If the CD is not mounted, it will be mounted
2964 * (and remain mounted after this function returns).
2965 */
2966int what_number_cd_is_this()
2967{
2968    int cd_number = -1;
2969    char *mountdev = NULL;
2970    char *tmp = NULL;
2971
2972    assert(bkpinfo != NULL);
2973//  log_it("Asking what_number_cd_is_this");
2974    if (g_ISO_restore_mode) {
2975        mr_asprintf(&tmp, "mount | grep iso9660 | awk '{print $3;}'");
2976
2977        mr_asprintf(&mountdev, "%s%s", call_program_and_get_last_line_of_output(tmp), "/archives/THIS-CD-NUMBER");
2978        cd_number = atoi(last_line_of_file(mountdev));
2979        paranoid_free(mountdev);
2980        paranoid_free(tmp);
2981
2982        return (cd_number);
2983    }
2984
2985    mr_asprintf(&mountdev, "%s", bkpinfo->media_device);
2986    if (!mountdev[0]) {
2987        log_it
2988            ("(what_number_cd_is_this) Warning - media_device unknown. Finding out...");
2989        find_cdrom_device(bkpinfo->media_device, FALSE);
2990    }
2991    if (!is_this_device_mounted(MNT_CDROM)) {
2992        if (bkpinfo->backup_media_type == usb) {
2993            mount_USB_here(mountdev, MNT_CDROM);
2994        } else {
2995            mount_CDROM_here(mountdev, MNT_CDROM);
2996        }
2997    }
2998    paranoid_free(mountdev);
2999
3000    cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
3001    return (cd_number);
3002}
3003
3004
3005
3006
3007
3008
3009
3010/**
3011 * Find out what device is mounted as root (/).
3012 * @return Root device.
3013 * @note The returned string points to static storage and will be overwritten with every call.
3014 * @bug A bit of a misnomer; it's actually finding out the root device.
3015 * The mountpoint (where it's mounted) will obviously be '/'.
3016 */
3017char *where_is_root_mounted()
3018{
3019    /*@ buffers **************** */
3020    static char tmp[MAX_STR_LEN];
3021
3022
3023#ifdef __FreeBSD__
3024    strcpy(tmp, call_program_and_get_last_line_of_output
3025           ("mount | grep \" on / \" | cut -d' ' -f1"));
3026#else
3027    strcpy(tmp, call_program_and_get_last_line_of_output
3028           ("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//"));
3029    if (strstr(tmp, "/dev/cciss/")) {
3030        strcpy(tmp, call_program_and_get_last_line_of_output
3031               ("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1"));
3032    }
3033    if (strstr(tmp, "/dev/md")) {
3034        strcpy(tmp,
3035               call_program_and_get_last_line_of_output
3036               ("mount | grep \" on / \" | cut -d' ' -f1"));
3037    }
3038#endif
3039
3040    return (tmp);
3041}
3042
3043
3044/**
3045 * Find out which boot loader is in use.
3046 * @param which_device Device to look for the boot loader on.
3047 * @return 'L' for LILO, 'E'for ELILO, 'G' for GRUB, 'B' or 'D' for FreeBSD boot loaders, or 'U' for Unknown.
3048 * @note Under Linux, all drives are examined, not just @p which_device.
3049 */
3050#ifdef __FreeBSD__
3051char which_boot_loader(char *which_device)
3052{
3053    int count_lilos = 0;
3054    int count_grubs = 0;
3055    int count_boot0s = 0;
3056    int count_dangerouslydedicated = 0;
3057
3058    log_it("looking at drive %s's MBR", which_device);
3059    if (does_string_exist_in_boot_block(which_device, "GRUB")) {
3060        count_grubs++;
3061    }
3062    if (does_string_exist_in_boot_block(which_device, "LILO")) {
3063        count_lilos++;
3064    }
3065    if (does_string_exist_in_boot_block(which_device, "Drive")) {
3066        count_boot0s++;
3067    }
3068    if (does_string_exist_in_first_N_blocks
3069        (which_device, "FreeBSD/i386", 17)) {
3070        count_dangerouslydedicated++;
3071    }
3072    log_it("%d grubs and %d lilos and %d elilos and %d boot0s and %d DD\n",
3073           count_grubs, count_lilos, count_elilos, count_boot0s,
3074           count_dangerouslydedicated);
3075
3076    if (count_grubs && !count_lilos) {
3077        return ('G');
3078    } else if (count_lilos && !count_grubs) {
3079        return ('L');
3080    } else if (count_grubs == 1 && count_lilos == 1) {
3081        log_it("I'll bet you used to use LILO but switched to GRUB...");
3082        return ('G');
3083    } else if (count_boot0s == 1) {
3084        return ('B');
3085    } else if (count_dangerouslydedicated) {
3086        return ('D');
3087    } else {
3088        log_it("Unknown boot loader");
3089        return ('U');
3090    }
3091}
3092
3093#else
3094
3095char which_boot_loader(char *which_device)
3096{
3097    /*@ buffer ***************************************************** */
3098    char *list_drives_cmd = NULL;
3099    char *current_drive;
3100
3101    /*@ pointers *************************************************** */
3102    FILE *pdrives;
3103
3104    /*@ int ******************************************************** */
3105    int count_lilos = 0;
3106    int count_grubs = 0;
3107
3108    /*@ end vars *************************************************** */
3109
3110    malloc_string(current_drive);
3111
3112#ifdef __IA64__
3113    /* No choice for it */
3114    return ('E');
3115#endif
3116    assert(which_device != NULL);
3117
3118    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());
3119    log_it("list_drives_cmd = %s", list_drives_cmd);
3120
3121    if (!(pdrives = popen(list_drives_cmd, "r"))) {
3122        log_OS_error("Unable to open list of drives");
3123        mr_free(list_drives_cmd);
3124        paranoid_free(current_drive);
3125        return ('\0');
3126    }
3127    mr_free(list_drives_cmd);
3128
3129    for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
3130         (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
3131        strip_spaces(current_drive);
3132        log_it("looking at drive %s's MBR", current_drive);
3133        if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
3134            count_grubs++;
3135            strcpy(which_device, current_drive);
3136            break;
3137        }
3138        if (does_string_exist_in_boot_block(current_drive, "LILO")) {
3139            count_lilos++;
3140            strcpy(which_device, current_drive);
3141            break;
3142        }
3143    }
3144    if (pclose(pdrives)) {
3145        log_OS_error("Cannot pclose pdrives");
3146    }
3147    log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
3148    if (count_grubs && !count_lilos) {
3149        paranoid_free(current_drive);
3150        return ('G');
3151    } else if (count_lilos && !count_grubs) {
3152        paranoid_free(current_drive);
3153        return ('L');
3154    } else if (count_grubs == 1 && count_lilos == 1) {
3155        log_it("I'll bet you used to use LILO but switched to GRUB...");
3156        paranoid_free(current_drive);
3157        return ('G');
3158    } else {
3159        // We need to look on each partition then
3160        mr_asprintf(&list_drives_cmd, "parted2fdisk -l 2>/dev/null | grep -E \"^/dev/\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/");
3161        log_it("list_drives_cmd = %s", list_drives_cmd);
3162
3163        if (!(pdrives = popen(list_drives_cmd, "r"))) {
3164            log_OS_error("Unable to open list of drives");
3165            mr_free(list_drives_cmd);
3166            paranoid_free(current_drive);
3167            return ('\0');
3168        }
3169        mr_free(list_drives_cmd);
3170
3171        for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
3172            (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
3173            strip_spaces(current_drive);
3174            log_it("looking at partition %s's BR", current_drive);
3175            if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
3176                count_grubs++;
3177                strcpy(which_device, current_drive);
3178                break;
3179            }
3180            if (does_string_exist_in_boot_block(current_drive, "LILO")) {
3181                count_lilos++;
3182                strcpy(which_device, current_drive);
3183                break;
3184            }
3185        }
3186        if (pclose(pdrives)) {
3187            log_OS_error("Cannot pclose pdrives");
3188        }
3189        log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
3190        paranoid_free(current_drive);
3191        if (count_grubs && !count_lilos) {
3192            return ('G');
3193        } else if (count_lilos && !count_grubs) {
3194            return ('L');
3195        } else if (count_grubs == 1 && count_lilos == 1) {
3196            log_it("I'll bet you used to use LILO but switched to GRUB...");
3197            return ('G');
3198        } else {
3199            log_it("Unknown boot loader");
3200            return ('U');
3201        }
3202    }
3203}
3204#endif
3205
3206
3207
3208
3209/**
3210 * Write zeroes over the first 16K of @p device.
3211 * @param device The device to zero.
3212 * @return 0 for success, 1 for failure.
3213 */
3214int zero_out_a_device(char *device)
3215{
3216    FILE *fout;
3217    int i;
3218
3219    assert_string_is_neither_NULL_nor_zerolength(device);
3220
3221    log_it("Zeroing drive %s", device);
3222    if (!(fout = fopen(device, "w"))) {
3223        log_OS_error("Unable to open/write to device");
3224        return (1);
3225    }
3226    for (i = 0; i < 16384; i++) {
3227        fputc('\0', fout);
3228    }
3229    paranoid_fclose(fout);
3230    log_it("Device successfully zeroed.");
3231    return (0);
3232}
3233
3234/**
3235 * Return the device pointed to by @p incoming.
3236 * @param incoming The device to resolve symlinks for.
3237 * @return The path to the real device file.
3238 * @note The returned string points to static storage that will be overwritten with each call.
3239 * @bug Won't work with file v4.0; needs to be written in C.
3240 */
3241char *resolve_softlinks_to_get_to_actual_device_file(char *incoming)
3242{
3243    static char output[MAX_STR_LEN];
3244    char *command;
3245    char *curr_fname;
3246    char *scratch = NULL;
3247    char *tmp = NULL;
3248    char *p;
3249
3250    struct stat statbuf;
3251    command = malloc(1000);
3252    malloc_string(curr_fname);
3253    if (!does_file_exist(incoming)) {
3254        log_it
3255            ("resolve_softlinks_to_get_to_actual_device_file --- device not found");
3256        strcpy(output, incoming);
3257    } else {
3258        strcpy(curr_fname, incoming);
3259        lstat(curr_fname, &statbuf);
3260        while (S_ISLNK(statbuf.st_mode)) {
3261            log_msg(1, "curr_fname = %s", curr_fname);
3262            sprintf(command, "file %s", curr_fname);
3263            mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
3264            for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
3265                 p--);
3266            p++;
3267            mr_asprintf(&scratch, "%s", p);
3268            for (p = scratch; *p != '\0' && *p != '\''; p++);
3269            *p = '\0';
3270            log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp, scratch);
3271            mr_free(tmp);
3272
3273            if (scratch[0] == '/') {
3274                strcpy(curr_fname, scratch);    // copy whole thing because it's an absolute softlink
3275            } else {            // copy over the basename cos it's a relative softlink
3276                p = curr_fname + strlen(curr_fname);
3277                while (p != curr_fname && *p != '/') {
3278                    p--;
3279                }
3280                if (*p == '/') {
3281                    p++;
3282                }
3283                strcpy(p, scratch);
3284            }
3285            mr_free(scratch);
3286            lstat(curr_fname, &statbuf);
3287        }
3288        strcpy(output, curr_fname);
3289        log_it("resolved %s to %s", incoming, output);
3290    }
3291    paranoid_free(command);
3292    paranoid_free(curr_fname);
3293    return (output);
3294}
3295
3296/* @} - end of deviceGroup */
3297
3298/**
3299 * Return the type of partition format (GPT or MBR)
3300 */
3301char *which_partition_format(const char *drive)
3302{
3303    static char output[4];
3304    char *tmp = NULL;
3305    char *command;
3306    char *fdisk;
3307#ifdef __IA64__
3308    struct stat buf;
3309#endif
3310    malloc_string(command);
3311    malloc_string(fdisk);
3312    sprintf(fdisk, "/sbin/parted2fdisk");
3313    sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
3314    mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
3315    if (strstr(tmp, "GPT") == NULL) {
3316        strcpy(output, "MBR");
3317    } else {
3318        strcpy(output, "GPT");
3319    }
3320    mr_free(tmp);
3321
3322    log_msg(0, "Found %s partition table format type", output);
3323    paranoid_free(command);
3324    paranoid_free(fdisk);
3325    return (output);
3326}
3327/* @} - end of deviceGroup */
Note: See TracBrowser for help on using the repository browser.