source: branches/2.05/mondo/mondo/common/libmondo-devices.c @ 152

Last change on this file since 152 was 152, checked in by andree, 14 years ago

Fix two compiler warnings:

  • intialise variable 'incoming' (mondo-rstr-tools.c)
  • only define structure 'buf' if architecture is IA64 (libmondo-devices.c)
  • Property svn:keywords set to Id
File size: 78.4 KB
Line 
1/* libmondo-devices.c                 Subroutines for handling devices
2   $Id: libmondo-devices.c 152 2005-12-07 11:46:15Z andree $
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 152 2005-12-07 11:46:15Z andree $";
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/' | egrep -qv '(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    }
1212#if linux
1213    fileid = open(drive, O_RDONLY);
1214    if (fileid) {
1215        if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
1216            if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
1217                cylindersleft = cylinders = hdgeo.cylinders;
1218                cylindersize = hdgeo.heads * hdgeo.sectors / 2;
1219                outvalA = cylindersize * cylinders / 1024;
1220                log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
1221                        hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
1222                gotgeo = 1;
1223            } else {
1224                log_msg(1, "Harddisk geometry wrong");
1225            }
1226        } else {
1227            log_msg(1,
1228                    "Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
1229                    strerror(errno));
1230        }
1231        close(fileid);
1232    } else {
1233        log_msg(1, "Failed to open %s for reading: %s", drive,
1234                strerror(errno));
1235    }
1236    if (!gotgeo) {
1237        log_msg(1, "Failed to get harddisk geometry, using old mode");
1238    }
1239/* 
1240  if ((fd = open (drive, O_RDONLY)) != -1) {
1241      if (ioctl (fd, HDIO_GETGEO, &hdgeo) != -1)  {
1242      close (fd);
1243      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));
1244      if ( hdgeo.cylinders && hdgeo.heads && hdgeo.sectors ) {
1245          outvalB = ((long) (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors / 2 / 1024));
1246      }
1247      }
1248      close (fd);
1249 */
1250#endif
1251
1252// OLDER DISKS will give ridiculously low value for outvalB (so outvalA is returned) :)
1253// NEWER DISKS will give sane value for outvalB (close to outvalA, in other words) :)
1254
1255    outvalC = (outvalA > outvalB) ? outvalA : outvalB;
1256
1257//  log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
1258//  fatal_error ("GPSOD: Unable to get size of drive");
1259    log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
1260            outvalC);
1261
1262    return (outvalC);
1263}
1264
1265/* The old version */
1266#if 0
1267long get_phys_size_of_drive(char *drive)
1268{
1269    /*@ pointers **************************************************** */
1270#if linux
1271    FILE *fin;
1272    char *p;
1273    char *q;
1274    char *r;
1275    /*@ buffers ***************************************************** */
1276    char *tmp;
1277    char *command;
1278
1279    /*@ long ******************************************************** */
1280    long outL;
1281    long tempLa;
1282    long tempLb;
1283    long tempLc;
1284
1285#endif
1286
1287    struct hd_geometry hdgeo;
1288    int fd;
1289
1290#ifdef __FreeBSD__
1291    off_t o;
1292
1293    if ((fd = open(drive, O_RDONLY)) != -1) {
1294        if (ioctl(fd, DIOCGMEDIASIZE, &o) != -1) {
1295            close(fd);
1296            return (long) (o / (off_t) (1024 * 1024));
1297        }
1298        close(fd);
1299    }
1300    log_msg(4, "drive = %s, error = %s", drive, strerror(errno));
1301    fatal_error("GPSOD: Unable to get size of drive");
1302#else
1303
1304    malloc_string(tmp);
1305    malloc_string(command);
1306
1307    if ((fd = open(drive, O_RDONLY)) != -1) {
1308        if (ioctl(fd, HDIO_GETGEO, &hdgeo) != -1) {
1309            close(fd);
1310            log_msg(2,
1311                    "Geometry of drive %s is C:%d, H:%d, S%d, its size is %d MB",
1312                    drive, hdgeo.cylinders, hdgeo.heads, hdgeo.sectors,
1313                    (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors / 2 /
1314                     1024));
1315            if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
1316                return ((long)
1317                        (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors /
1318                         2 / 1024));
1319            }
1320        }
1321        close(fd);
1322    }
1323
1324    assert_string_is_neither_NULL_nor_zerolength(drive);
1325
1326    sprintf(command,
1327            "parted2fdisk -l %s | head -n4 | tr -s '\n' '\t' | tr -s ' ' '\t' | cut -f8,14,16",
1328            drive);
1329    strcpy(tmp, call_program_and_get_last_line_of_output(command));
1330    if (tmp[0]) {
1331        p = tmp;
1332        q = strchr(p, ' ');
1333        if (q) {
1334            *(q++) = '\0';
1335            r = strchr(q, ' ');
1336            if (r) {
1337                *(r++) = '\0';
1338                tempLa = atol(p);
1339                tempLb = atol(q);
1340                tempLc = atol(r);
1341                outL = tempLa * tempLb / 1024 * tempLc / 1024;
1342                if (outL > 100) {
1343                    paranoid_free(tmp);
1344                    paranoid_free(command);
1345                    return (outL);
1346                }
1347            }
1348        }
1349    }
1350
1351    /* try to grep for 'Drive xxxx: yyy MB' */
1352    sprintf(command,
1353            "parted2fdisk -l %s | grep MB | tr -s ' ' '\t' | cut -f3",
1354            drive);
1355    strcpy(tmp, call_program_and_get_last_line_of_output(command));
1356    if (atol(tmp) > 0) {
1357        paranoid_free(tmp);
1358        paranoid_free(command);
1359        return (atol(tmp));
1360    }
1361
1362    /* else, do it the old-fashioned way */
1363    p = strrchr(drive, (int) '/');
1364    if (p) {
1365        strcpy(tmp, p + 1);
1366    } else {
1367        paranoid_free(tmp);
1368        paranoid_free(command);
1369        return (-1);
1370    }
1371    sprintf(command, "dmesg | grep %s 2> /dev/null", tmp);
1372    if (!(fin = popen(command, "r"))) {
1373        log_OS_error("Cannot popen dmesg command");
1374    } else {
1375        fgets(tmp, MAX_STR_LEN - 1, fin);
1376        while (!feof(fin) && !strstr(tmp, "GB") && !strstr(tmp, "MB")) {
1377            fgets(tmp, MAX_STR_LEN - 1, fin);
1378        }
1379        if (pclose(fin)) {
1380            log_OS_error("Cannot pclose dmesg fin");
1381        }
1382    }
1383    if (!(p = strstr(tmp, "GB")) && !(p = strstr(tmp, "MB"))) {
1384        log_msg(3, "Cannot find %s's size: dmesg isn't helping either.",
1385                drive);
1386        paranoid_free(tmp);
1387        paranoid_free(command);
1388        return (-1);
1389    }
1390    for (; !isdigit(*(p - 1)); p--);
1391    *p = '\0';
1392    for (p--; isdigit(*(p - 1)); p--);
1393    outL = atol(p);
1394    if (outL <= 0) {
1395        paranoid_free(tmp);
1396        paranoid_free(command);
1397        return (-1);
1398    }
1399    if (strstr(tmp, "GB")) {
1400        outL = outL * 1024;
1401    }
1402    paranoid_free(tmp);
1403    paranoid_free(command);
1404    return (outL * 19 / 20);
1405#endif
1406}
1407#endif                          /* 0 */
1408
1409
1410
1411
1412
1413/**
1414 * Determine whether @p format is supported by the kernel. Uses /proc/filesystems
1415 * under Linux and @c lsvfs under FreeBSD.
1416 * @param format The format to test.
1417 * @return TRUE if the format is supported, FALSE if not.
1418 */
1419bool is_this_a_valid_disk_format(char *format)
1420{
1421    char *good_formats;
1422    char *command;
1423    char *format_sz;
1424
1425    FILE *pin;
1426    int retval;
1427    malloc_string(good_formats);
1428    malloc_string(command);
1429    malloc_string(format_sz);
1430
1431    assert_string_is_neither_NULL_nor_zerolength(format);
1432
1433    sprintf(format_sz, "%s ", format);
1434
1435#ifdef __FreeBSD__
1436    sprintf(command,
1437            "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
1438#else
1439    sprintf(command,
1440            "cat /proc/filesystems | grep -v nodev | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
1441#endif
1442
1443    pin = popen(command, "r");
1444    if (!pin) {
1445        log_OS_error("Unable to read good formats");
1446        retval = 0;
1447    } else {
1448        strcpy(good_formats, " ");
1449        (void) fgets(good_formats + 1, MAX_STR_LEN, pin);
1450        if (pclose(pin)) {
1451            log_OS_error("Cannot pclose good formats");
1452        }
1453        strip_spaces(good_formats);
1454        strcat(good_formats, " swap lvm raid ntfs 7 "); // " ntfs 7 " -- um, cheating much? :)
1455        if (strstr(good_formats, format_sz)) {
1456            retval = 1;
1457        } else {
1458            retval = 0;
1459        }
1460    }
1461    paranoid_free(good_formats);
1462    paranoid_free(command);
1463    paranoid_free(format_sz);
1464    return (retval);
1465}
1466
1467
1468/** @def SWAPLIST_COMMAND The command to list the swap files/partitions in use. */
1469
1470/**
1471 * Determine whether @p device_raw is currently mounted.
1472 * @param device_raw The device to check.
1473 * @return TRUE if it's mounted, FALSE if not.
1474 */
1475bool is_this_device_mounted(char *device_raw)
1476{
1477
1478    /*@ pointers **************************************************** */
1479    FILE *fin;
1480
1481    /*@ buffers ***************************************************** */
1482    char *incoming;
1483    char *device_with_tab;
1484    char *device_with_space;
1485    char *tmp;
1486    int retval = 0;
1487
1488#ifdef __FreeBSD__
1489#define SWAPLIST_COMMAND "swapinfo"
1490#else
1491#define SWAPLIST_COMMAND "cat /proc/swaps"
1492#endif
1493
1494    /*@ end vars **************************************************** */
1495
1496    malloc_string(incoming);
1497    malloc_string(device_with_tab);
1498    malloc_string(device_with_space);
1499    malloc_string(tmp);
1500    assert(device_raw != NULL);
1501//  assert_string_is_neither_NULL_nor_zerolength(device_raw);
1502    if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
1503        log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
1504                device_raw);
1505        sprintf(tmp, "/%s", device_raw);
1506    } else {
1507        strcpy(tmp, device_raw);
1508    }
1509    log_msg(1, "Is %s mounted?", tmp);
1510    if (!strcmp(tmp, "/proc") || !strcmp(tmp, "proc")) {
1511        log_msg(1,
1512                "I don't know how the heck /proc made it into the mountlist. I'll ignore it.");
1513        return (0);
1514    }
1515    sprintf(device_with_tab, "%s\t", tmp);
1516    sprintf(device_with_space, "%s ", tmp);
1517
1518    if (!(fin = popen("mount", "r"))) {
1519        log_OS_error("Cannot popen 'mount'");
1520        return (FALSE);
1521    }
1522    for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
1523         fgets(incoming, MAX_STR_LEN - 1, fin)) {
1524        if (strstr(incoming, device_with_space) //> incoming
1525            || strstr(incoming, device_with_tab))   // > incoming)
1526        {
1527            paranoid_pclose(fin);
1528            retval = 1;
1529            goto end_of_func;
1530        }
1531    }
1532    paranoid_pclose(fin);
1533    sprintf(tmp, "%s | grep -w \"%s\" > /dev/null 2> /dev/null",
1534            SWAPLIST_COMMAND, device_with_space);
1535    log_msg(4, "tmp (command) = '%s'", tmp);
1536    if (!system(tmp)) {
1537        retval = 1;
1538        goto end_of_func;
1539    }
1540  end_of_func:
1541    paranoid_free(incoming);
1542    paranoid_free(device_with_tab);
1543    paranoid_free(device_with_space);
1544    paranoid_free(tmp);
1545    return (retval);
1546}
1547
1548#ifdef __FreeBSD__
1549//                       CODE IS FREEBSD-SPECIFIC
1550/**
1551 * Create a loopback device for specified @p fname.
1552 * @param fname The file to associate with a device.
1553 * @return /dev entry for the device, or NULL if it couldn't be allocated.
1554 */
1555char *make_vn(char *fname)
1556{
1557    char *device = (char *) malloc(MAX_STR_LEN);
1558    char *mddevice = (char *) malloc(32);
1559    char command[MAX_STR_LEN];
1560    int vndev = 2;
1561    if (atoi
1562        (call_program_and_get_last_line_of_output
1563         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
1564        do {
1565            sprintf(mddevice, "vn%ic", vndev++);
1566            sprintf(command, "vnconfig %s %s", mddevice, fname);
1567            if (vndev > 10) {
1568                return NULL;
1569            }
1570        }
1571        while (system(command));
1572    } else {
1573        sprintf(command, "mdconfig -a -t vnode -f %s", fname);
1574        mddevice = call_program_and_get_last_line_of_output(command);
1575        if (!strstr(mddevice, "md")) {
1576            return NULL;
1577        }
1578    }
1579    sprintf(device, "/dev/%s", mddevice);
1580    return device;
1581}
1582
1583
1584
1585//                       CODE IS FREEBSD-SPECIFIC
1586/**
1587 * Deallocate specified @p dname.
1588 * This should be called when you are done with the device created by make_vn(),
1589 * so the system does not run out of @c vn devices.
1590 * @param dname The device to deallocate.
1591 * @return 0 for success, nonzero for failure.
1592 */
1593int kick_vn(char *dname)
1594{
1595    char command[MAX_STR_LEN];
1596
1597    if (strncmp(dname, "/dev/", 5) == 0) {
1598        dname += 5;
1599    }
1600
1601    if (atoi
1602        (call_program_and_get_last_line_of_output
1603         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
1604        sprintf(command, "vnconfig -d %s", dname);
1605        return system(command);
1606    } else {
1607        sprintf(command, "mdconfig -d -u %s", dname);
1608        return system(command);
1609    }
1610     /*NOTREACHED*/ return 255;
1611}
1612#endif
1613
1614
1615/**
1616 * Mount the CD-ROM at @p mountpoint.
1617 * @param device The device (or file if g_ISO_restore_mode) to mount.
1618 * @param mountpoint The place to mount it.
1619 * @return 0 for success, nonzero for failure.
1620 */
1621int mount_CDROM_here(char *device, char *mountpoint)
1622{
1623    /*@ buffer ****************************************************** */
1624    char *command;
1625    char *dev;
1626    char *options;
1627    int retval;
1628
1629    malloc_string(command);
1630    malloc_string(dev);
1631    malloc_string(options);
1632    assert_string_is_neither_NULL_nor_zerolength(device);
1633    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
1634
1635    make_hole_for_dir(mountpoint);
1636    strcpy(options, "ro");
1637    if (isdigit(device[0])) {
1638        find_cdrom_device(device, FALSE);
1639    } else {
1640        strcpy(dev, device);
1641    }
1642    if (g_ISO_restore_mode) {
1643
1644#ifdef __FreeBSD__
1645        strcpy(dev, make_vn(device));
1646        if (!dev) {
1647            sprintf(command, "Unable to mount ISO (make_vn(%s) failed)",
1648                    device);
1649            fatal_error(command);
1650        }
1651        strcpy(device, dev);
1652#else
1653        strcat(options, ",loop");
1654#endif
1655
1656    }
1657    log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
1658            mountpoint);
1659    /*@ end vars *************************************************** */
1660
1661#ifdef __FreeBSD__
1662    sprintf(command, "mount_cd9660 -r %s %s 2>> %s",
1663            device, mountpoint, MONDO_LOGFILE);
1664
1665#else
1666    sprintf(command, "mount %s -o %s -t iso9660 %s 2>> %s",
1667            device, options, mountpoint, MONDO_LOGFILE);
1668#endif
1669
1670    log_msg(4, command);
1671    if (strncmp(device, "/dev/", 5) == 0) {
1672        retract_CD_tray_and_defeat_autorun();
1673    }
1674    retval = system(command);
1675    log_msg(1, "system(%s) returned %d", command, retval);
1676
1677    paranoid_free(command);
1678    paranoid_free(dev);
1679    paranoid_free(options);
1680    return (retval);
1681}
1682
1683
1684
1685
1686
1687
1688/**
1689 * Ask the user for CD number @p cd_number_i_want.
1690 * Sets g_current_media_number once the correct CD is inserted.
1691 * @param bkpinfo The backup information structure. Fields used:
1692 * - @c bkpinfo->backup_media_type
1693 * - @c bkpinfo->prefix
1694 * - @c bkpinfo->isodir
1695 * - @c bkpinfo->media_device
1696 * - @c bkpinfo->please_dont_eject_when_restoring
1697 * @param cd_number_i_want The CD number to ask for.
1698 */
1699void
1700insist_on_this_cd_number(struct s_bkpinfo *bkpinfo, int cd_number_i_want)
1701{
1702
1703    /*@ int ************************************************************* */
1704    int res = 0;
1705
1706
1707    /*@ buffers ********************************************************* */
1708    char *tmp;
1709    char *request;
1710
1711    assert(bkpinfo != NULL);
1712    assert(cd_number_i_want > 0);
1713
1714//  log_msg(3, "Insisting on CD number %d", cd_number_i_want);
1715
1716    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1717        log_msg(3,
1718                "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
1719        return;
1720    }
1721    malloc_string(tmp);
1722    malloc_string(request);
1723    sprintf(tmp, "mkdir -p " MNT_CDROM);
1724    run_program_and_log_output(tmp, 5);
1725    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
1726        || bkpinfo->backup_media_type == nfs) {
1727        log_msg(3, "Remounting CD");
1728        g_ISO_restore_mode = TRUE;
1729// FIXME --- I'm tempted to do something about this...
1730// Why unmount and remount again and again?
1731        if (is_this_device_mounted(MNT_CDROM)) {
1732            run_program_and_log_output("umount " MNT_CDROM, 5);
1733        }
1734        system("mkdir -p /tmp/isodir &> /dev/null");
1735        sprintf(tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
1736                bkpinfo->nfs_remote_dir, bkpinfo->prefix,
1737                cd_number_i_want);
1738        if (!does_file_exist(tmp)) {
1739            sprintf(tmp, "/tmp/isodir/%s/%s-%d.iso",
1740                    bkpinfo->nfs_remote_dir, bkpinfo->prefix,
1741                    cd_number_i_want);
1742            if (does_file_exist(tmp)) {
1743                log_msg(1,
1744                        "FIXME - hacking bkpinfo->isodir from '%s' to /tmp/isodir",
1745                        bkpinfo->isodir);
1746                strcpy(bkpinfo->isodir, "/tmp/isodir");
1747            }
1748        }
1749        log_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
1750        if (mount_CDROM_here(tmp, MNT_CDROM)) {
1751            fatal_error("Mommy!");
1752        }
1753//    g_current_media_number = cd_number_i_want;
1754//    return;
1755    }
1756    if ((res = what_number_cd_is_this(bkpinfo)) != cd_number_i_want) {
1757        log_msg(3, "Currently, we hold %d but we want %d", res,
1758                cd_number_i_want);
1759        sprintf(tmp, "Insisting on %s #%d",
1760                media_descriptor_string(bkpinfo->backup_media_type),
1761                cd_number_i_want);
1762        sprintf(request, "Please insert %s #%d and press Enter.",
1763                media_descriptor_string(bkpinfo->backup_media_type),
1764                cd_number_i_want);
1765        log_msg(3, tmp);
1766        while (what_number_cd_is_this(bkpinfo) != cd_number_i_want) {
1767            paranoid_system("sync");
1768            if (is_this_device_mounted(MNT_CDROM)) {
1769                res =
1770                    run_program_and_log_output("umount " MNT_CDROM, FALSE);
1771            } else {
1772                res = 0;
1773            }
1774            if (res) {
1775                log_to_screen("WARNING - failed to unmount CD-ROM drive");
1776            }
1777            if (!bkpinfo->please_dont_eject) {
1778                res = eject_device(bkpinfo->media_device);
1779            } else {
1780                res = 0;
1781            }
1782            if (res) {
1783                log_to_screen("WARNING - failed to eject CD-ROM disk");
1784            }
1785            popup_and_OK(request);
1786            if (!bkpinfo->please_dont_eject) {
1787                inject_device(bkpinfo->media_device);
1788            }
1789            paranoid_system("sync");
1790        }
1791        log_msg(1, "Thankyou. Proceeding...");
1792        g_current_media_number = cd_number_i_want;
1793    }
1794    paranoid_free(tmp);
1795    paranoid_free(request);
1796}
1797
1798/* @} - end of deviceGroup */
1799
1800
1801
1802
1803
1804
1805/**
1806 * Ask user for details of backup/restore information.
1807 * Called when @c mondoarchive doesn't get any parameters.
1808 * @param bkpinfo The backup information structure to fill out with the user's data.
1809 * @param archiving_to_media TRUE if archiving, FALSE if restoring.
1810 * @return 0, always.
1811 * @bug No point of `int' return value.
1812 * @ingroup archiveGroup
1813 */
1814int interactively_obtain_media_parameters_from_user(struct s_bkpinfo
1815                                                    *bkpinfo,
1816                                                    bool
1817                                                    archiving_to_media)
1818// archiving_to_media is TRUE if I'm being called by mondoarchive
1819// archiving_to_media is FALSE if I'm being called by mondorestore
1820{
1821    char *tmp;
1822    char *sz_size;
1823    char *command;
1824    char *comment;
1825    char *prompt;
1826    int i;
1827    FILE *fin;
1828
1829    malloc_string(tmp);
1830    malloc_string(sz_size);
1831    malloc_string(command);
1832    malloc_string(comment);
1833    malloc_string(prompt);
1834    assert(bkpinfo != NULL);
1835    sz_size[0] = '\0';
1836    bkpinfo->nonbootable_backup = FALSE;
1837
1838// Tape, CD, NFS, ...?
1839    srandom(getpid());
1840    bkpinfo->backup_media_type =
1841        (g_restoring_live_from_cd) ? cdr :
1842        which_backup_media_type(bkpinfo->restore_data);
1843    if (bkpinfo->backup_media_type == none) {
1844        log_to_screen("User has chosen not to backup the PC");
1845        finish(1);
1846    }
1847    if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
1848        popup_and_OK("Please remove CD/floppy from drive(s)");
1849    }
1850    log_msg(3, "media type = %s",
1851            bkptype_to_string(bkpinfo->backup_media_type));
1852    if (archiving_to_media) {
1853        sensibly_set_tmpdir_and_scratchdir(bkpinfo);
1854    }
1855    bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
1856    bkpinfo->compression_level =
1857        (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
1858    bkpinfo->use_lzo =
1859        (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
1860
1861/*
1862  if (find_home_of_exe("star") && (!find_home_of_exe("afio") || find_home_of_exe("selinuxenabled")))
1863    {
1864      bkpinfo->use_star = FALSE;   
1865      bkpinfo->use_lzo = FALSE;
1866      log_to_screen("Using star, not afio");
1867      if (!find_home_of_exe("afio"))
1868    { log_to_screen("...because afio not found"); }
1869      if (find_home_of_exe("selinuxenabled"))
1870    { log_to_screen("...because SELINUX found"); }
1871    }
1872*/
1873
1874    mvaddstr_and_log_it(2, 0, " ");
1875
1876// Find device's /dev (or SCSI) entry
1877    switch (bkpinfo->backup_media_type) {
1878    case cdr:
1879    case cdrw:
1880    case dvd:
1881        if (archiving_to_media) {
1882            if (ask_me_yes_or_no
1883                ("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?"))
1884            {
1885                bkpinfo->manual_cd_tray = TRUE;
1886            }
1887            if ((bkpinfo->compression_level =
1888                 which_compression_level()) == -1) {
1889                log_to_screen("User has chosen not to backup the PC");
1890                finish(1);
1891            }
1892            sprintf(comment, "What speed is your %s (re)writer?",
1893                    media_descriptor_string(bkpinfo->backup_media_type));
1894            if (bkpinfo->backup_media_type == dvd) {
1895                find_dvd_device(bkpinfo->media_device, FALSE);
1896                strcpy(tmp, "1");
1897                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4582 MB
1898                log_msg(1, "Setting to DVD defaults");
1899            } else {
1900                strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
1901                strcpy(tmp, "4");
1902                strcpy(sz_size, "650");
1903                log_msg(1, "Setting to CD defaults");
1904            }
1905            if (bkpinfo->backup_media_type != dvd) {
1906                if (!popup_and_get_string("Speed", comment, tmp, 4)) {
1907                    log_to_screen("User has chosen not to backup the PC");
1908                    finish(1);
1909                }
1910            }
1911            bkpinfo->cdrw_speed = atoi(tmp);    // if DVD then this shouldn't ever be used anyway :)
1912            sprintf(comment,
1913                    "How much data (in Megabytes) will each %s store?",
1914                    media_descriptor_string(bkpinfo->backup_media_type));
1915            if (!popup_and_get_string("Size", comment, sz_size, 5)) {
1916                log_to_screen("User has chosen not to backup the PC");
1917                finish(1);
1918            }
1919            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
1920                bkpinfo->media_size[i] = atoi(sz_size);
1921            }
1922            if (bkpinfo->media_size[0] <= 0) {
1923                log_to_screen("User has chosen not to backup the PC");
1924                finish(1);
1925            }
1926        }
1927    case cdstream:
1928        if (bkpinfo->disaster_recovery) {
1929            strcpy(bkpinfo->media_device, "/dev/cdrom");
1930            log_msg(2, "CD-ROM device assumed to be at %s",
1931                    bkpinfo->media_device);
1932        } else if (bkpinfo->restore_data
1933                   || bkpinfo->backup_media_type == dvd) {
1934            if (!bkpinfo->media_device[0]) {
1935                strcpy(bkpinfo->media_device, "/dev/cdrom");
1936            }                   // just for the heck of it :)
1937            log_msg(1, "bkpinfo->media_device = %s",
1938                    bkpinfo->media_device);
1939            if (bkpinfo->backup_media_type == dvd
1940                || find_cdrom_device(bkpinfo->media_device, FALSE)) {
1941                log_msg(1, "bkpinfo->media_device = %s",
1942                        bkpinfo->media_device);
1943                sprintf(comment,
1944                        "Please specify your %s drive's /dev entry",
1945                        media_descriptor_string(bkpinfo->
1946                                                backup_media_type));
1947                if (!popup_and_get_string
1948                    ("Device?", comment, bkpinfo->media_device,
1949                     MAX_STR_LEN / 4)) {
1950                    log_to_screen("User has chosen not to backup the PC");
1951                    finish(1);
1952                }
1953            }
1954            log_msg(2, "%s device found at %s",
1955                    media_descriptor_string(bkpinfo->backup_media_type),
1956                    bkpinfo->media_device);
1957        } else {
1958            if (find_cdrw_device(bkpinfo->media_device)) {
1959                bkpinfo->media_device[0] = '\0';
1960            }
1961            if (bkpinfo->media_device[0]) {
1962                sprintf(tmp,
1963                        "I think I've found your %s burner at SCSI node %s; am I right on the money?",
1964                        media_descriptor_string(bkpinfo->
1965                                                backup_media_type),
1966                        bkpinfo->media_device);
1967                if (!ask_me_yes_or_no(tmp)) {
1968                    bkpinfo->media_device[0] = '\0';
1969                }
1970            }
1971            if (!bkpinfo->media_device[0]) {
1972                if (g_kernel_version < 2.6) {
1973                    i = popup_and_get_string("Device node?",
1974                                             "What is the SCSI node of your CD (re)writer, please?",
1975                                             bkpinfo->media_device,
1976                                             MAX_STR_LEN / 4);
1977                } else {
1978                    i = popup_and_get_string("/dev entry?",
1979                                             "What is the /dev entry of your CD (re)writer, please?",
1980                                             bkpinfo->media_device,
1981                                             MAX_STR_LEN / 4);
1982                }
1983                if (!i) {
1984                    log_to_screen("User has chosen not to backup the PC");
1985                    finish(1);
1986                }
1987            }
1988        }
1989        if (bkpinfo->backup_media_type == cdstream) {
1990            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
1991                bkpinfo->media_size[i] = 650;
1992            }
1993        }
1994        break;
1995    case udev:
1996        if (!ask_me_yes_or_no
1997            ("This option is for advanced users only. Are you sure?")) {
1998            log_to_screen("User has chosen not to backup the PC");
1999            finish(1);
2000        }
2001    case tape:
2002
2003        if (find_tape_device_and_size(bkpinfo->media_device, sz_size)) {
2004            log_msg(3, "Ok, using vanilla scsi tape.");
2005            strcpy(bkpinfo->media_device, VANILLA_SCSI_TAPE);
2006            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2007                paranoid_fclose(fin);
2008            } else {
2009                strcpy(bkpinfo->media_device, "/dev/osst0");
2010            }
2011        }
2012        if (bkpinfo->media_device[0]) {
2013            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2014                paranoid_fclose(fin);
2015            } else {
2016                if (does_file_exist("/tmp/mondo-restore.cfg")) {
2017                    read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
2018                                 bkpinfo->media_device);
2019                }
2020            }
2021            sprintf(tmp,
2022                    "I think I've found your tape streamer at %s; am I right on the money?",
2023                    bkpinfo->media_device);
2024        }
2025        if (bkpinfo->media_device[0]) {
2026            sprintf(tmp,
2027                    "I think I've found your tape streamer at %s; am I right on the money?",
2028                    bkpinfo->media_device);
2029            if (!ask_me_yes_or_no(tmp)) {
2030                bkpinfo->media_device[0] = '\0';
2031            }
2032        }
2033        if (!bkpinfo->media_device[0]) {
2034            if (!popup_and_get_string
2035                ("Device name?",
2036                 "What is the /dev entry of your tape streamer?",
2037                 bkpinfo->media_device, MAX_STR_LEN / 4)) {
2038                log_to_screen("User has chosen not to backup the PC");
2039                finish(1);
2040            }
2041        }
2042        sprintf(tmp, "ls -l %s", bkpinfo->media_device);
2043        if (run_program_and_log_output(tmp, FALSE)) {
2044            log_to_screen("User has not specified a valid /dev entry");
2045            finish(1);
2046        }
2047        log_msg(4, "sz_size = %s", sz_size);
2048        sz_size[0] = '\0';
2049/*
2050    if ((size_sz[0]=='\0' || atol(size_sz)==0) && archiving_to_media)
2051      {
2052        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))
2053          { log_to_screen("User has chosen not to backup the PC"); finish(1); }
2054      }
2055*/
2056        if (sz_size[0] == '\0') {
2057            bkpinfo->media_size[0] = 0;
2058        } else {
2059            bkpinfo->media_size[0] =
2060                friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
2061        }
2062        log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
2063        if (bkpinfo->media_size[0] <= 0) {
2064            bkpinfo->media_size[0] = 0;
2065        }
2066        for (i = 1; i <= MAX_NOOF_MEDIA; i++) {
2067            bkpinfo->media_size[i] = bkpinfo->media_size[0];
2068        }
2069        if (archiving_to_media) {
2070            if ((bkpinfo->compression_level =
2071                 which_compression_level()) == -1) {
2072                log_to_screen("User has chosen not to backup the PC");
2073                finish(1);
2074            }
2075        }
2076        break;
2077
2078
2079
2080    case nfs:
2081        if (!bkpinfo->nfs_mount[0]) {
2082            strcpy(bkpinfo->nfs_mount,
2083                   call_program_and_get_last_line_of_output
2084                   ("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
2085        }
2086#ifdef __FreeBSD__
2087        if (TRUE)
2088#else
2089        if (!bkpinfo->disaster_recovery)
2090#endif
2091        {
2092            if (!popup_and_get_string
2093                ("NFS dir.",
2094                 "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.)",
2095                 bkpinfo->nfs_mount, MAX_STR_LEN / 4)) {
2096                log_to_screen("User has chosen not to backup the PC");
2097                finish(1);
2098            }
2099            if (!bkpinfo->restore_data) {
2100                if ((bkpinfo->compression_level =
2101                     which_compression_level()) == -1) {
2102                    log_to_screen("User has chosen not to backup the PC");
2103                    finish(1);
2104                }
2105            }
2106            // check whether already mounted - we better remove
2107            // surrounding spaces and trailing '/' for this
2108            strip_spaces(bkpinfo->nfs_mount);
2109            if (bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] == '/')
2110                bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] = '\0';
2111            sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3",
2112                    bkpinfo->nfs_mount);
2113            strcpy(bkpinfo->isodir,
2114                   call_program_and_get_last_line_of_output(command));
2115        }
2116        if (bkpinfo->disaster_recovery) {
2117            system("umount /tmp/isodir 2> /dev/null");
2118            if (!popup_and_get_string
2119                ("NFS share", "Which remote NFS share should I mount?",
2120                 bkpinfo->nfs_mount, MAX_STR_LEN)) {
2121                log_to_screen("User has chosen not to backup the PC");
2122                finish(1);
2123            }
2124        }
2125        if (!is_this_device_mounted(bkpinfo->nfs_mount)) {
2126            sprintf(bkpinfo->isodir, "/tmp/isodir.mondo.%d",
2127                    (int) (random() % 32768));
2128            sprintf(command, "mkdir -p %s", bkpinfo->isodir);
2129            run_program_and_log_output(command, 5);
2130            sprintf(tmp, "mount %s -t nfs %s", bkpinfo->nfs_mount,
2131                    bkpinfo->isodir);
2132            run_program_and_log_output(tmp, 5);
2133            malloc_string(g_selfmounted_isodir);
2134            strcpy(g_selfmounted_isodir, bkpinfo->isodir);
2135        }
2136        if (!is_this_device_mounted(bkpinfo->nfs_mount)) {
2137            popup_and_OK
2138                ("Please mount that partition before you try to backup to or restore from it.");
2139            finish(1);
2140        }
2141        strcpy(tmp, bkpinfo->nfs_remote_dir);
2142        if (!popup_and_get_string
2143            ("Directory", "Which directory within that mountpoint?", tmp,
2144             MAX_STR_LEN)) {
2145            log_to_screen("User has chosen not to backup the PC");
2146            finish(1);
2147        }
2148        strcpy(bkpinfo->nfs_remote_dir, tmp);
2149        // check whether writable - we better remove surrounding spaces for this
2150        strip_spaces(bkpinfo->nfs_remote_dir);
2151        sprintf(command, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir,
2152                bkpinfo->nfs_remote_dir);
2153        while (run_program_and_log_output(command, FALSE)) {
2154            strcpy(tmp, bkpinfo->nfs_remote_dir);
2155            sprintf(prompt,
2156                    "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.",
2157                    bkpinfo->nfs_remote_dir, bkpinfo->isodir);
2158            if (!popup_and_get_string
2159                ("Directory", prompt, tmp, MAX_STR_LEN)) {
2160                log_to_screen("User has chosen not to backup the PC");
2161                finish(1);
2162            }
2163            strcpy(bkpinfo->nfs_remote_dir, tmp);
2164            // check whether writable - we better remove surrounding space s for this
2165            strip_spaces(bkpinfo->nfs_remote_dir);
2166            sprintf(command, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir,
2167                    bkpinfo->nfs_remote_dir);
2168        }
2169
2170        for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2171            bkpinfo->media_size[i] = 650;
2172        }
2173        log_msg(3, "Just set nfs_remote_dir to %s",
2174                bkpinfo->nfs_remote_dir);
2175        log_msg(3, "isodir is still %s", bkpinfo->isodir);
2176        break;
2177
2178    case iso:
2179        if (!bkpinfo->disaster_recovery) {
2180            if (!popup_and_get_string
2181                ("Storage dir.",
2182                 "Please enter the full path that contains your ISO images.  Example: /mnt/raid0_0",
2183                 bkpinfo->isodir, MAX_STR_LEN / 4)) {
2184                log_to_screen("User has chosen not to backup the PC");
2185                finish(1);
2186            }
2187            if (archiving_to_media) {
2188                if ((bkpinfo->compression_level =
2189                     which_compression_level()) == -1) {
2190                    log_to_screen("User has chosen not to backup the PC");
2191                    finish(1);
2192                }
2193                if (!popup_and_get_string
2194                    ("ISO size.",
2195                     "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.",
2196                     sz_size, 16)) {
2197                    log_to_screen("User has chosen not to backup the PC");
2198                    finish(1);
2199                }
2200                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2201                    bkpinfo->media_size[i] = atoi(sz_size);
2202                }
2203                if (!popup_and_get_string
2204                    ("Prefix.",
2205                     "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files",
2206                     bkpinfo->prefix, MAX_STR_LEN / 4)) {
2207                    log_to_screen("User has chosen not to backup the PC");
2208                    finish(1);
2209                }
2210            } else {
2211                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2212                    bkpinfo->media_size[i] = 650;
2213                }
2214            }
2215        }
2216        break;
2217    default:
2218        fatal_error
2219            ("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
2220    }
2221
2222    if (archiving_to_media) {
2223
2224#ifdef __FreeBSD__
2225        strcpy(bkpinfo->boot_device,
2226               call_program_and_get_last_line_of_output
2227               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
2228#else
2229        strcpy(bkpinfo->boot_device,
2230               call_program_and_get_last_line_of_output
2231               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
2232#endif
2233        i = which_boot_loader(bkpinfo->boot_device);
2234        if (i == 'U')           // unknown
2235        {
2236
2237#ifdef __FreeBSD__
2238            if (!popup_and_get_string
2239                ("Boot device",
2240                 "What is your boot device? (e.g. /dev/ad0)",
2241                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2242                log_to_screen("User has chosen not to backup the PC");
2243                finish(1);
2244            }
2245            i = which_boot_loader(bkpinfo->boot_device);
2246#else
2247            if (!popup_and_get_string
2248                ("Boot device",
2249                 "What is your boot device? (e.g. /dev/hda)",
2250                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2251                log_to_screen("User has chosen not to backup the PC");
2252                finish(1);
2253            }
2254            if (does_string_exist_in_boot_block
2255                (bkpinfo->boot_device, "LILO")) {
2256                i = 'L';
2257            } else
2258                if (does_string_exist_in_boot_block
2259                    (bkpinfo->boot_device, "ELILO")) {
2260                i = 'E';
2261            } else
2262                if (does_string_exist_in_boot_block
2263                    (bkpinfo->boot_device, "GRUB")) {
2264                i = 'G';
2265            } else {
2266                i = 'U';
2267            }
2268#endif
2269            if (i == 'U') {
2270                if (ask_me_yes_or_no
2271                    ("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?"))
2272                {
2273                    i = 'R';    // raw
2274                } else {
2275                    log_to_screen
2276                        ("I cannot find your boot loader. Please run mondoarchive with parameters.");
2277                    finish(1);
2278                }
2279            }
2280        }
2281        bkpinfo->boot_loader = i;
2282        strcpy(bkpinfo->include_paths, "/");
2283        if (!popup_and_get_string
2284            ("Backup paths",
2285             "Please enter paths which you want me to backup. The default is '/' (i.e. everything).",
2286             bkpinfo->include_paths, MAX_STR_LEN)) {
2287            log_to_screen("User has chosen not to backup the PC");
2288            finish(1);
2289        }
2290        strcpy(tmp, list_of_NFS_mounts_only());
2291        if (strlen(tmp) > 2) {
2292            if (bkpinfo->exclude_paths[0]) {
2293                strcat(bkpinfo->exclude_paths, " ");
2294            }
2295            strncpy(bkpinfo->exclude_paths, tmp, MAX_STR_LEN);
2296        }
2297// NTFS
2298        strcpy(tmp,
2299               call_program_and_get_last_line_of_output
2300               ("parted2fdisk -l | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'"));
2301        if (strlen(tmp) > 2) {
2302            if (!popup_and_get_string
2303                ("NTFS partitions",
2304                 "Please enter/confirm the NTFS partitions you wish to backup as well.",
2305                 tmp, MAX_STR_LEN / 4)) {
2306                log_to_screen("User has chosen not to backup the PC");
2307                finish(1);
2308            }
2309            strncpy(bkpinfo->image_devs, tmp, MAX_STR_LEN / 4);
2310        }
2311
2312
2313        if (!popup_and_get_string
2314            ("Exclude paths",
2315             "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.",
2316             bkpinfo->exclude_paths, MAX_STR_LEN)) {
2317            log_to_screen("User has chosen not to backup the PC");
2318            finish(1);
2319        }
2320        bkpinfo->make_cd_use_lilo = FALSE;
2321        bkpinfo->backup_data = TRUE;
2322        bkpinfo->verify_data =
2323            ask_me_yes_or_no
2324            ("Will you want to verify your backups after Mondo has created them?");
2325
2326#ifndef __FreeBSD__
2327        if (!ask_me_yes_or_no
2328            ("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."))
2329#endif
2330        {
2331            strcpy(bkpinfo->kernel_path, "FAILSAFE");
2332        }
2333
2334        if (!ask_me_yes_or_no
2335            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
2336            log_to_screen("User has chosen not to backup the PC");
2337            finish(1);
2338        }
2339    } else {
2340        bkpinfo->restore_data = TRUE;   // probably...
2341    }
2342
2343    if (bkpinfo->backup_media_type == iso
2344        || bkpinfo->backup_media_type == nfs) {
2345        g_ISO_restore_mode = TRUE;
2346    }
2347#ifdef __FreeSD__
2348// skip
2349#else
2350    if (bkpinfo->backup_media_type == nfs) {
2351        sprintf(tmp, "mount | grep \"%s\" | cut -d' ' -f3",
2352                bkpinfo->nfs_mount);
2353//      strcpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(tmp));
2354        log_msg(3, "I think the NFS mount is mounted at %s",
2355                bkpinfo->isodir);
2356    }
2357    log_it("isodir = %s", bkpinfo->isodir);
2358    log_it("nfs_mount = '%s'", bkpinfo->nfs_mount);
2359#endif
2360
2361    log_it("media device = %s", bkpinfo->media_device);
2362    log_it("media size = %ld", bkpinfo->media_size[1]);
2363    log_it("media type = %s",
2364           bkptype_to_string(bkpinfo->backup_media_type));
2365    log_it("compression = %ld", bkpinfo->compression_level);
2366    log_it("include_paths = '%s'", bkpinfo->include_paths);
2367    log_it("exclude_paths = '%s'", bkpinfo->exclude_paths);
2368    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
2369    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
2370    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device,
2371           bkpinfo->boot_loader);
2372    if (bkpinfo->media_size[0] < 0) {
2373        if (archiving_to_media) {
2374            fatal_error("Media size is less than zero.");
2375        } else {
2376            log_msg(2, "Warning - media size is less than zero.");
2377            bkpinfo->media_size[0] = 0;
2378        }
2379    }
2380    paranoid_free(tmp);
2381    paranoid_free(sz_size);
2382    paranoid_free(command);
2383    paranoid_free(comment);
2384    paranoid_free(prompt);
2385    return (0);
2386}
2387
2388
2389
2390
2391/**
2392 * @addtogroup utilityGroup
2393 * @{
2394 */
2395/**
2396 * Get a space-separated list of NFS devices and mounts.
2397 * @return The list created.
2398 * @note The return value points to static data that will be overwritten with each call.
2399 */
2400char *list_of_NFS_devices_and_mounts(void)
2401{
2402    char *exclude_these_devices;
2403    char *exclude_these_directories;
2404    static char result_sz[512];
2405
2406    malloc_string(exclude_these_devices);
2407    malloc_string(exclude_these_directories);
2408    strcpy(exclude_these_directories,
2409           call_program_and_get_last_line_of_output
2410           ("mount -t coda,ncpfs,nfs,smbfs,cifs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
2411    strcpy(exclude_these_devices,
2412           call_program_and_get_last_line_of_output
2413           ("cat /etc/fstab | tr -s '\t' ' ' | grep -E '( (coda|ncpfs|nfs|smbfs|cifs) )' | cut -d' ' -f1 | tr -s '\n' ' ' | awk '{print $0;}'"));
2414    sprintf(result_sz, "%s %s", exclude_these_directories,
2415            exclude_these_devices);
2416    paranoid_free(exclude_these_devices);
2417    paranoid_free(exclude_these_directories);
2418    return (result_sz);
2419}
2420
2421
2422
2423
2424/**
2425 * Get a space-separated list of NFS mounts.
2426 * @return The list created.
2427 * @note The return value points to static data that will be overwritten with each call.
2428 * @bug Even though we only want the mounts, the devices are still checked.
2429 */
2430char *list_of_NFS_mounts_only(void)
2431{
2432    char *exclude_these_devices;
2433    char *exclude_these_directories;
2434    static char result_sz[512];
2435
2436    malloc_string(exclude_these_devices);
2437    malloc_string(exclude_these_directories);
2438    strcpy(exclude_these_directories,
2439           call_program_and_get_last_line_of_output
2440           ("mount -t coda,ncpfs,nfs,smbfs,cifs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
2441    strcpy(exclude_these_devices,
2442           call_program_and_get_last_line_of_output
2443           ("cat /etc/fstab | tr -s '\t' ' ' | grep -E '( (coda|ncpfs|nfs|smbfs|cifs) )' | cut -d' ' -f1 | tr -s '\n' ' ' | awk '{print $0;}'"));
2444    sprintf(result_sz, "%s", exclude_these_directories);
2445    paranoid_free(exclude_these_devices);
2446    paranoid_free(exclude_these_directories);
2447    return (result_sz);
2448}
2449
2450/* @} - end of utilityGroup */
2451
2452
2453
2454
2455
2456/**
2457 * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
2458 * [random] is a random number between 1 and 32767.
2459 * @param store_name_here Where to store the new filename.
2460 * @param stub A random number will be appended to this to make the FIFO's name.
2461 * @ingroup deviceGroup
2462 */
2463void make_fifo(char *store_name_here, char *stub)
2464{
2465    char *tmp;
2466
2467    malloc_string(tmp);
2468    assert_string_is_neither_NULL_nor_zerolength(stub);
2469
2470    sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
2471            (int) (random() % 32768));
2472    make_hole_for_file(store_name_here);
2473    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
2474    sprintf(tmp, "chmod 770 %s", store_name_here);
2475    paranoid_system(tmp);
2476    paranoid_free(tmp);
2477}
2478
2479
2480
2481
2482
2483
2484/**
2485 * Set the tmpdir and scratchdir to reside on the partition with the most free space.
2486 * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
2487 * @param bkpinfo The backup information structure. @c bkpinfo->tmpdir and @c bkpinfo->scratchdir will be set.
2488 * @ingroup utilityGroup
2489 */
2490void sensibly_set_tmpdir_and_scratchdir(struct s_bkpinfo *bkpinfo)
2491{
2492    char *tmp, *command, *sz;
2493
2494    malloc_string(tmp);
2495    malloc_string(command);
2496    malloc_string(sz);
2497    assert(bkpinfo != NULL);
2498
2499#ifdef __FreeBSD__
2500    strcpy(tmp,
2501           call_program_and_get_last_line_of_output
2502           ("df -m -t nonfs,msdosfs,ntfs,smbfs,smb,cifs | tr -s '\t' ' ' | grep -v none | grep -v Filesystem | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -n | tail -n1 | awk '{print $NF;}'"));
2503#else
2504    strcpy(tmp,
2505           call_program_and_get_last_line_of_output
2506           ("df -m -x nfs -x vfat -x ntfs -x smbfs -x smb -x cifs | sed 's/                  /devdev/' | tr -s '\t' ' ' | grep -v none | grep -v Filesystem | grep -v /dev/shm | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -n | tail -n1 | awk '{print $NF;}'"));
2507#endif
2508
2509    if (tmp[0] != '/') {
2510        strcpy(sz, tmp);
2511        strcpy(tmp, "/");
2512        strcat(tmp, sz);
2513    }
2514    if (!tmp[0]) {
2515        fatal_error("I couldn't figure out the tempdir!");
2516    }
2517    sprintf(bkpinfo->tmpdir, "%s/tmp.mondo.%d", tmp,
2518            (int) (random() % 32768));
2519    log_it("bkpinfo->tmpdir is being set to %s", bkpinfo->tmpdir);
2520
2521    sprintf(bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp,
2522            (int) (random() % 32768));
2523    log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
2524
2525    sprintf(g_erase_tmpdir_and_scratchdir, "rm -Rf %s %s", bkpinfo->tmpdir,
2526            bkpinfo->scratchdir);
2527
2528    sprintf(command, "rm -Rf %s/tmp.mondo.* %s/mondo.scratch.*", tmp, tmp);
2529    paranoid_system(command);
2530    paranoid_free(tmp);
2531    paranoid_free(command);
2532    paranoid_free(sz);
2533}
2534
2535
2536
2537
2538
2539
2540/**
2541 * @addtogroup deviceGroup
2542 * @{
2543 */
2544/**
2545 * If we can read @p dev, set @p output to it.
2546 * If @p dev cannot be read, set @p output to "".
2547 * @param dev The device to check for.
2548 * @param output Set to @p dev if @p dev exists, "" otherwise.
2549 * @return TRUE if @p dev exists, FALSE if it doesn't.
2550 */
2551bool set_dev_to_this_if_rx_OK(char *output, char *dev)
2552{
2553    char *command;
2554
2555    malloc_string(command);
2556    if (!dev || dev[0] == '\0') {
2557        output[0] = '\0';
2558        return (FALSE);
2559    }
2560//  assert_string_is_neither_NULL_nor_zerolength(dev);
2561    log_msg(10, "Injecting %s", dev);
2562    inject_device(dev);
2563    if (!does_file_exist(dev)) {
2564        log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
2565        return (FALSE);
2566    }
2567    sprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
2568            512L, dev);
2569    if (!run_program_and_log_output(command, FALSE)
2570        && !run_program_and_log_output(command, FALSE)) {
2571        strcpy(output, dev);
2572        log_msg(4, "Found it - %s", dev);
2573        return (TRUE);
2574    } else {
2575        output[0] = '\0';
2576        log_msg(4, "It's not %s", dev);
2577        return (FALSE);
2578    }
2579}
2580
2581
2582
2583
2584
2585/**
2586 * Find out what number CD is in the drive.
2587 * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
2588 * @return The current CD number, or -1 if it could not be found.
2589 * @note If the CD is not mounted, it will be mounted
2590 * (and remain mounted after this function returns).
2591 */
2592int what_number_cd_is_this(struct s_bkpinfo *bkpinfo)
2593{
2594    int cd_number = -1;
2595    char *mountdev;
2596    char *tmp;
2597
2598    malloc_string(mountdev);
2599    malloc_string(tmp);
2600    assert(bkpinfo != NULL);
2601//  log_it("Asking what_number_cd_is_this");
2602    if (g_ISO_restore_mode) {
2603        sprintf(tmp, "mount | grep iso9660 | awk '{print $3;}'");
2604//      log_it("tmp = %s", tmp);
2605
2606        strcpy(mountdev, call_program_and_get_last_line_of_output(tmp));
2607        strcat(mountdev, "/archives/THIS-CD-NUMBER");
2608//      log_it("mountdev = %s", mountdev);
2609        cd_number = atoi(last_line_of_file(mountdev));
2610//      log_it("cd_number = %d", cd_number);
2611        paranoid_free(mountdev);
2612        paranoid_free(tmp);
2613        return (cd_number);
2614    }
2615
2616    strcpy(mountdev, bkpinfo->media_device);
2617    if (!mountdev[0]) {
2618        log_it
2619            ("(what_number_cd_is_this) Warning - media_device unknown. Finding out...");
2620        find_cdrom_device(bkpinfo->media_device, FALSE);
2621    }
2622    if (!is_this_device_mounted(MNT_CDROM)) {
2623        mount_CDROM_here(mountdev, MNT_CDROM);
2624    }
2625    cd_number =
2626        atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
2627//  log_it("cd_number..later.. = %d", cd_number);
2628    paranoid_free(mountdev);
2629    paranoid_free(tmp);
2630    return (cd_number);
2631}
2632
2633
2634
2635
2636
2637
2638
2639/**
2640 * Find out what device is mounted as root (/).
2641 * @return Root device.
2642 * @note The returned string points to static storage and will be overwritten with every call.
2643 * @bug A bit of a misnomer; it's actually finding out the root device.
2644 * The mountpoint (where it's mounted) will obviously be '/'.
2645 */
2646char *where_is_root_mounted()
2647{
2648    /*@ buffers **************** */
2649    static char tmp[MAX_STR_LEN];
2650
2651
2652#ifdef __FreeBSD__
2653    strcpy(tmp, call_program_and_get_last_line_of_output
2654           ("mount | grep \" on / \" | cut -d' ' -f1"));
2655#else
2656    strcpy(tmp, call_program_and_get_last_line_of_output
2657           ("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//"));
2658    if (strstr(tmp, "/dev/cciss/")) {
2659        strcpy(tmp, call_program_and_get_last_line_of_output
2660               ("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1"));
2661    }
2662    if (strstr(tmp, "/dev/md")) {
2663        strcpy(tmp,
2664               call_program_and_get_last_line_of_output
2665               ("mount | grep \" on / \" | cut -d' ' -f1"));
2666    }
2667#endif
2668
2669    return (tmp);
2670}
2671
2672
2673/**
2674 * Find out which boot loader is in use.
2675 * @param which_device Device to look for the boot loader on.
2676 * @return 'L' for LILO, 'E'for ELILO, 'G' for GRUB, 'B' or 'D' for FreeBSD boot loaders, or 'U' for Unknown.
2677 * @note Under Linux, all drives are examined, not just @p which_device.
2678 */
2679#ifdef __FreeBSD__
2680char which_boot_loader(char *which_device)
2681{
2682    int count_lilos = 0;
2683    int count_grubs = 0;
2684    int count_boot0s = 0;
2685    int count_dangerouslydedicated = 0;
2686
2687    log_it("looking at drive %s's MBR", which_device);
2688    if (does_string_exist_in_boot_block(which_device, "GRUB")) {
2689        count_grubs++;
2690    }
2691    if (does_string_exist_in_boot_block(which_device, "LILO")) {
2692        count_lilos++;
2693    }
2694    if (does_string_exist_in_boot_block(which_device, "Drive")) {
2695        count_boot0s++;
2696    }
2697    if (does_string_exist_in_first_N_blocks
2698        (which_device, "FreeBSD/i386", 17)) {
2699        count_dangerouslydedicated++;
2700    }
2701    log_it("%d grubs and %d lilos and %d elilos and %d boot0s and %d DD\n",
2702           count_grubs, count_lilos, count_elilos, count_boot0s,
2703           count_dangerouslydedicated);
2704
2705    if (count_grubs && !count_lilos) {
2706        return ('G');
2707    } else if (count_lilos && !count_grubs) {
2708        return ('L');
2709    } else if (count_grubs == 1 && count_lilos == 1) {
2710        log_it("I'll bet you used to use LILO but switched to GRUB...");
2711        return ('G');
2712    } else if (count_boot0s == 1) {
2713        return ('B');
2714    } else if (count_dangerouslydedicated) {
2715        return ('D');
2716    } else {
2717        log_it("Unknown boot loader");
2718        return ('U');
2719    }
2720}
2721
2722#else
2723
2724char which_boot_loader(char *which_device)
2725{
2726    /*@ buffer ***************************************************** */
2727    char *list_drives_cmd;
2728    char *current_drive;
2729
2730    /*@ pointers *************************************************** */
2731    FILE *pdrives;
2732
2733    /*@ int ******************************************************** */
2734    int count_lilos = 0;
2735    int count_grubs = 0;
2736
2737    /*@ end vars *************************************************** */
2738
2739    malloc_string(list_drives_cmd);
2740    malloc_string(current_drive);
2741
2742#ifdef __IA64__
2743    /* No choice for it */
2744    return ('E');
2745#endif
2746    assert(which_device != NULL);
2747    //  sprintf (list_drives_cmd,
2748    //       "fdisk -l | grep /dev | grep cyl | tr ':' ' ' | cut -d' ' -f2");
2749
2750    sprintf(list_drives_cmd,
2751            // "parted2fdisk
2752            "fdisk -l 2>/dev/null | grep \"/dev/.*:\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/; echo %s",
2753            where_is_root_mounted());
2754    log_it("list_drives_cmd = %s", list_drives_cmd);
2755
2756    if (!(pdrives = popen(list_drives_cmd, "r"))) {
2757        log_OS_error("Unable to open list of drives");
2758        paranoid_free(list_drives_cmd);
2759        paranoid_free(current_drive);
2760        return ('\0');
2761    }
2762    for (fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
2763         fgets(current_drive, MAX_STR_LEN, pdrives)) {
2764        strip_spaces(current_drive);
2765        log_it("looking at drive %s's MBR", current_drive);
2766        if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
2767            count_grubs++;
2768            strcpy(which_device, current_drive);
2769            break;
2770        }
2771        if (does_string_exist_in_boot_block(current_drive, "LILO")) {
2772            count_lilos++;
2773            strcpy(which_device, current_drive);
2774            break;
2775        }
2776    }
2777    if (pclose(pdrives)) {
2778        log_OS_error("Cannot pclose pdrives");
2779    }
2780    log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
2781    paranoid_free(list_drives_cmd);
2782    paranoid_free(current_drive);
2783    if (count_grubs && !count_lilos) {
2784        return ('G');
2785    } else if (count_lilos && !count_grubs) {
2786        return ('L');
2787    } else if (count_grubs == 1 && count_lilos == 1) {
2788        log_it("I'll bet you used to use LILO but switched to GRUB...");
2789        return ('G');
2790    } else {
2791        log_it("Unknown boot loader");
2792        return ('U');
2793    }
2794}
2795#endif
2796
2797
2798
2799
2800/**
2801 * Write zeroes over the first 16K of @p device.
2802 * @param device The device to zero.
2803 * @return 0 for success, 1 for failure.
2804 */
2805int zero_out_a_device(char *device)
2806{
2807    FILE *fout;
2808    int i;
2809
2810    assert_string_is_neither_NULL_nor_zerolength(device);
2811
2812    log_it("Zeroing drive %s", device);
2813    if (!(fout = fopen(device, "w"))) {
2814        log_OS_error("Unable to open/write to device");
2815        return (1);
2816    }
2817    for (i = 0; i < 16384; i++) {
2818        fputc('\0', fout);
2819    }
2820    paranoid_fclose(fout);
2821    log_it("Device successfully zeroed.");
2822    return (0);
2823}
2824
2825/**
2826 * Return the device pointed to by @p incoming.
2827 * @param incoming The device to resolve symlinks for.
2828 * @return The path to the real device file.
2829 * @note The returned string points to static storage that will be overwritten with each call.
2830 * @bug Won't work with file v4.0; needs to be written in C.
2831 */
2832char *resolve_softlinks_to_get_to_actual_device_file(char *incoming)
2833{
2834    static char output[MAX_STR_LEN];
2835    char *command;
2836    char *curr_fname;
2837    char *scratch;
2838    char *tmp;
2839    char *p;
2840
2841    struct stat statbuf;
2842    command = malloc(1000);
2843    malloc_string(tmp);
2844    malloc_string(scratch);
2845    malloc_string(curr_fname);
2846    if (!does_file_exist(incoming)) {
2847        log_it
2848            ("resolve_softlinks_to_get_to_actual_device_file --- device not found");
2849        strcpy(output, incoming);
2850    } else {
2851        strcpy(curr_fname, incoming);
2852        lstat(curr_fname, &statbuf);
2853        while (S_ISLNK(statbuf.st_mode)) {
2854            log_msg(1, "curr_fname = %s", curr_fname);
2855            sprintf(command, "file %s", curr_fname);
2856            strcpy(tmp, call_program_and_get_last_line_of_output(command));
2857            for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
2858                 p--);
2859            p++;
2860            strcpy(scratch, p);
2861            for (p = scratch; *p != '\0' && *p != '\''; p++);
2862            *p = '\0';
2863            log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp,
2864                    scratch);
2865            if (scratch[0] == '/') {
2866                strcpy(curr_fname, scratch);    // copy whole thing because it's an absolute softlink
2867            } else {            // copy over the basename cos it's a relative softlink
2868                p = curr_fname + strlen(curr_fname);
2869                while (p != curr_fname && *p != '/') {
2870                    p--;
2871                }
2872                if (*p == '/') {
2873                    p++;
2874                }
2875                strcpy(p, scratch);
2876            }
2877            lstat(curr_fname, &statbuf);
2878        }
2879        strcpy(output, curr_fname);
2880        log_it("resolved %s to %s", incoming, output);
2881    }
2882    paranoid_free(command);
2883    paranoid_free(curr_fname);
2884    paranoid_free(tmp);
2885    return (output);
2886}
2887
2888/* @} - end of deviceGroup */
2889
2890
2891/**
2892 * Return the type of partition format (GPT or MBR)
2893 */
2894char *which_partition_format(const char *drive)
2895{
2896    static char output[4];
2897    char *tmp;
2898    char *command;
2899    char *fdisk;
2900#ifdef __IA64__
2901    struct stat buf;
2902#endif
2903
2904    malloc_string(tmp);
2905    malloc_string(command);
2906    malloc_string(fdisk);
2907    log_msg(0, "Looking for partition table format type");
2908// BERLIOS: Do that temporarily: we need to put back parted2fdisk everywhere
2909#ifdef __IA64__
2910    sprintf(fdisk, "/usr/local/bin/fdisk");
2911    if (stat(fdisk, &buf) != 0) {
2912#endif
2913        sprintf(fdisk, "/sbin/fdisk");
2914#ifdef __IA64__
2915    }
2916#endif
2917    log_msg(1, "Using %s", fdisk);
2918    sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
2919    strcpy(tmp, call_program_and_get_last_line_of_output(command));
2920    if (strstr(tmp, "GPT") == NULL) {
2921        strcpy(output, "MBR");
2922    } else {
2923        strcpy(output, "GPT");
2924    }
2925    log_msg(0, "Found %s partition table format type", output);
2926    paranoid_free(command);
2927    paranoid_free(tmp);
2928    paranoid_free(fdisk);
2929    return (output);
2930}
2931
2932/* @} - end of deviceGroup */
Note: See TracBrowser for help on using the repository browser.