source: MondoRescue/branches/2.2.5/mondo/src/common/libmondo-devices.c @ 1644

Last change on this file since 1644 was 1644, checked in by Bruno Cornec, 12 years ago

Apply patch from Andree Leidenfrost, modified a bit to use bkpinfo->tmpdir instead of /tmp
or MINDI_CACHE when appropriate. Fix security issues in mondo
Thanks al ot Andree for catching all those issues.
Will not compile needs more work as bkpinfo->tmpdir isn't available everywhere
Should become a global in 3.x when only containing pointers.

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