source: branches/stable/mondo/src/common/libmondo-devices.c @ 1063

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