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

Last change on this file since 497 was 497, checked in by bcornec, 14 years ago

Integration of a big patch from rene-marc dolhen <rmd_at_mecreant.org> to support internationalization with gettext.

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