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

Last change on this file since 1885 was 1885, checked in by bruno, 11 years ago
  • Remove floppy support from mindi and mondo and adapt docs
  • Align more mindi with the version from stable
  • Property svn:keywords set to Id
File size: 82.6 KB
Line 
1/* libmondo-devices.c                 Subroutines for handling devices
2   $Id: libmondo-devices.c 1885 2008-03-01 23:38:35Z 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 1885 2008-03-01 23:38:35Z bruno $";
255
256extern int g_current_media_number;
257extern double g_kernel_version;
258
259extern bool g_ISO_restore_mode;
260extern char *g_selfmounted_isodir;
261extern char *MONDO_LOGFILE;
262
263extern void setup_tmpdir(char *path);
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/* Reference to global bkpinfo */
279extern struct s_bkpinfo *bkpinfo;
280
281
282
283
284void set_g_cdrom_and_g_dvd_to_bkpinfo_value()
285{
286    strcpy(g_cdrom_drive_is_here, bkpinfo->media_device);   // just in case
287    strcpy(g_dvd_drive_is_here, bkpinfo->media_device); // just in case
288}
289
290
291
292/**
293 * Retract all CD trays and wait for autorun to complete.
294 * @ingroup deviceGroup
295 */
296void retract_CD_tray_and_defeat_autorun(void)
297{
298//  log_it("rctada: Retracting all CD trays", __LINE__);
299    if (strlen(g_cdrom_drive_is_here) > 0) {
300        inject_device(g_cdrom_drive_is_here);
301    }
302    if (strlen(g_dvd_drive_is_here) > 0) {
303        inject_device(g_dvd_drive_is_here);
304    }
305    if (strlen(g_cdrw_drive_is_here) > 0) {
306        inject_device(g_cdrw_drive_is_here);
307    }
308//  log_it("rctada: killing autorun");
309//  run_program_and_log_output("killall autorun", TRUE);
310    if (!run_program_and_log_output("ps | grep autorun | grep -v grep", 5)) {
311        log_it("autorun detected; sleeping for 2 seconds");
312        sleep(2);
313    }
314    log_it("rctada: Unmounting all CD drives", __LINE__);
315    run_program_and_log_output("umount /dev/cdr* /dev/dvd*", 5);
316}
317
318
319
320/**
321 * Determine whether we're booted off a ramdisk.
322 * @return @c TRUE (we are) or @c FALSE (we aren't).
323 * @ingroup utilityGroup
324 */
325bool am_I_in_disaster_recovery_mode(void)
326{
327    char *tmp, *comment;
328    bool is_this_a_ramdisk = FALSE;
329
330    malloc_string(tmp);
331    malloc_string(comment);
332    strcpy(tmp, where_is_root_mounted());
333    sprintf(comment, "root is mounted at %s\n", tmp);
334    log_msg(0, comment);
335    log_msg(0,
336            "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().",
337            tmp);
338
339#ifdef __FreeBSD__
340    if (strstr(tmp, "/dev/md")) {
341        is_this_a_ramdisk = TRUE;
342    }
343#else
344    if (!strncmp(tmp, "/dev/ram", 8)
345        || (!strncmp(tmp, "/dev/rd", 7) && !strcmp(tmp, "/dev/rd/")
346            && strncmp(tmp, "/dev/rd/cd", 10)) || strstr(tmp, "rootfs")
347        || !strcmp(tmp, "/dev/root")) {
348        is_this_a_ramdisk = TRUE;
349    } else {
350        is_this_a_ramdisk = FALSE;
351    }
352#endif
353
354    if (is_this_a_ramdisk) {
355        if (!does_file_exist("/THIS-IS-A-RAMDISK")
356            && !does_file_exist("/tmp/mountlist.txt.sample")) {
357            log_to_screen
358                ("Using /dev/root is stupid of you but I'll forgive you.");
359            is_this_a_ramdisk = FALSE;
360        }
361    }
362    if (does_file_exist("/THIS-IS-A-RAMDISK")) {
363        is_this_a_ramdisk = TRUE;
364    }
365    paranoid_free(tmp);
366    paranoid_free(comment);
367    log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
368    return (is_this_a_ramdisk);
369}
370
371
372
373
374
375/**
376 * Turn @c bkpinfo->backup_media_type into a human-readable string.
377 * @return The human readable string (e.g. @c cdr becomes <tt>"cdr"</tt>).
378 * @note The returned string points to static storage that will be overwritten with each call.
379 * @ingroup stringGroup
380 */
381static char *bkptype_to_string(t_bkptype bt)
382{
383    static char output[MAX_STR_LEN / 4];
384    switch (bt) {
385    case none:
386        strcpy(output, "none");
387        break;
388    case iso:
389        strcpy(output, "iso");
390        break;
391    case cdr:
392        strcpy(output, "cdr");
393        break;
394    case cdrw:
395        strcpy(output, "cdrw");
396        break;
397    case cdstream:
398        strcpy(output, "cdstream");
399        break;
400    case nfs:
401        strcpy(output, "nfs");
402        break;
403    case tape:
404        strcpy(output, "tape");
405        break;
406    case udev:
407        strcpy(output, "udev");
408        break;
409    case usb:
410        strcpy(output, "usb");
411        break;
412    default:
413        strcpy(output, "default");
414    }
415    return (output);
416}
417
418
419
420/**
421 * @addtogroup deviceGroup
422 * @{
423 */
424/**
425 * Eject the tray of the specified CD device.
426 * @param dev The device to eject.
427 * @return the return value of the @c eject command. (0=success, nonzero=failure)
428 */
429int eject_device(char *dev)
430{
431    char *command;
432    int res1 = 0, res2 = 0;
433
434    malloc_string(command);
435
436    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
437        && g_backup_media_type != udev) {
438        sprintf(command, "mt -f %s offline", dev);
439        res1 = run_program_and_log_output(command, 1);
440    } else {
441        res1 = 0;
442    }
443
444#ifdef __FreeBSD__
445    if (strstr(dev, "acd")) {
446        sprintf(command, "cdcontrol -f %s eject", dev);
447    } else {
448        sprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
449                dev);
450    }
451#else
452    sprintf(command, "eject %s", dev);
453#endif
454
455    log_msg(3, "Ejecting %s", dev);
456    res2 = run_program_and_log_output(command, 1);
457    paranoid_free(command);
458    if (res1 && res2) {
459        return (1);
460    } else {
461        return (0);
462    }
463}
464
465/**
466 * Load (inject) the tray of the specified CD device.
467 * @param dev The device to load/inject.
468 * @return 0 for success, nonzero for failure.
469 */
470int inject_device(char *dev)
471{
472    char *command;
473    int i;
474
475    malloc_string(command);
476
477
478#ifdef __FreeBSD__
479    if (strstr(dev, "acd")) {
480        sprintf(command, "cdcontrol -f %s close", dev);
481    } else {
482        sprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`",
483                dev);
484    }
485#else
486    sprintf(command, "eject -t %s", dev);
487#endif
488    i = run_program_and_log_output(command, FALSE);
489    paranoid_free(command);
490    return (i);
491}
492
493
494/**
495 * Determine whether the specified @p device (really, you can use any file)
496 * exists.
497 * @return TRUE if it exists, FALSE if it doesn't.
498 */
499bool does_device_exist(char *device)
500{
501
502    /*@ buffers *********************************************************** */
503    char *tmp;
504    bool ret;
505
506    malloc_string(tmp);
507    assert_string_is_neither_NULL_nor_zerolength(device);
508
509    sprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
510
511    if (system(tmp)) {
512        ret = FALSE;
513    } else {
514        ret = TRUE;
515    }
516    paranoid_free(tmp);
517    return (ret);
518}
519
520
521/**
522 * Determine whether a non-Microsoft partition exists on any connected hard drive.
523 * @return TRUE (there's a Linux/FreeBSD partition) or FALSE (Microsoft has taken over yet another innocent PC).
524 */
525bool does_nonMS_partition_exist(void)
526{
527#if __FreeBSD__
528    return
529        !system
530        ("for drive in /dev/ad? /dev/da?; do fdisk $drive | grep -q FreeBSD && exit 0; done; false");
531#else
532    return
533        !system
534        ("parted2fdisk -l 2>/dev/null | grep '^/dev/' | grep -Eqv '(MS|DOS|FAT|NTFS)'");
535#endif
536}
537
538/**
539 * Determine whether the specified @p partno exists on the specified @p drive.
540 * @param drive The drive to search for the partition in.
541 * @param partno The partition number to look for.
542 * @return 0 if it exists, nonzero otherwise.
543 */
544int does_partition_exist(const char *drive, int partno)
545{
546    /*@ buffers **************************************************** */
547    char *program;
548    char *incoming;
549    char *searchstr;
550    char *tmp;
551
552    /*@ ints ******************************************************* */
553    int res = 0;
554
555    /*@ pointers *************************************************** */
556    FILE *fin;
557
558
559    /*@ end vars *************************************************** */
560    assert_string_is_neither_NULL_nor_zerolength(drive);
561    assert(partno >= 0 && partno < 999);
562
563    malloc_string(program);
564    malloc_string(incoming);
565    malloc_string(searchstr);
566    malloc_string(tmp);
567
568#ifdef __FreeBSD__
569    // We assume here that this is running from mondorestore. (It is.)
570    sprintf(program, "ls %s %s >/dev/null 2>&1", drive,
571            build_partition_name(tmp, drive, partno));
572    return system(program);
573#else
574    tmp[0] = '\0';
575#endif
576
577    sprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
578    fin = popen(program, "r");
579    if (!fin) {
580        log_it("program=%s", program);
581        log_OS_error("Cannot popen-in program");
582        return (0);
583    }
584    (void) build_partition_name(searchstr, drive, partno);
585    strcat(searchstr, " ");
586    for (res = 0; !res && fgets(incoming, MAX_STR_LEN - 1, fin);) {
587        if (strstr(incoming, searchstr)) {
588            res = 1;
589        }
590    }
591    if (pclose(fin)) {
592        log_OS_error("Cannot pclose fin");
593    }
594    paranoid_free(program);
595    paranoid_free(incoming);
596    paranoid_free(searchstr);
597    paranoid_free(tmp);
598    return (res);
599}
600
601
602
603
604
605/**
606 * Determine whether given NULL-terminated @p str exists in the MBR of @p dev.
607 * @param dev The device to look in.
608 * @param str The string to look for.
609 * @return TRUE if it exists, FALSE if it doesn't.
610 */
611bool does_string_exist_in_boot_block(char *dev, char *str)
612{
613    /*@ buffers **************************************************** */
614    char *command;
615
616    /*@ end vars *************************************************** */
617    int i;
618
619    assert_string_is_neither_NULL_nor_zerolength(dev);
620    assert_string_is_neither_NULL_nor_zerolength(str);
621
622    malloc_string(command);
623    sprintf(command,
624            "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
625            dev, str);
626    i = system(command);
627    paranoid_free(command);
628    if (i) {
629        return (FALSE);
630    } else {
631        return (TRUE);
632    }
633}
634
635/**
636 * Determine whether specified @p str exists in the first @p n sectors of
637 * @p dev.
638 * @param dev The device to look in.
639 * @param str The string to look for.
640 * @param n The number of 512-byte sectors to search.
641 */
642bool does_string_exist_in_first_N_blocks(char *dev, char *str, int n)
643{
644    /*@ buffers **************************************************** */
645    char *command;
646    /*@ end vars *************************************************** */
647    int i;
648
649    malloc_string(command);
650    sprintf(command,
651            "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
652            dev, n, str);
653    i = system(command);
654    paranoid_free(command);
655    if (i) {
656        return (FALSE);
657    } else {
658        return (TRUE);
659    }
660}
661
662
663
664/**
665 * Try to mount CD-ROM at @p mountpoint. If the CD-ROM is not found or has
666 * not been specified, call find_cdrom_device() to find it.
667 * @param bkpinfo The backup information structure. The only field used is @c bkpinfo->media_device.
668 * @param mountpoint Where to mount the CD-ROM.
669 * @return 0 for success, nonzero for failure.
670 * @see mount_CDROM_here
671 */
672int find_and_mount_actual_cd(char *mountpoint)
673{
674    /*@ buffers ***************************************************** */
675
676    /*@ int's  ****************************************************** */
677    int res;
678    char *dev;
679
680    /*@ end vars **************************************************** */
681
682    malloc_string(dev);
683    assert(bkpinfo != NULL);
684    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
685
686    if (g_backup_media_type == dvd) {
687        strcpy(dev, g_dvd_drive_is_here);
688        if (!dev[0]) {
689            find_dvd_device(dev, FALSE);
690        }
691    } else {
692        strcpy(dev, g_cdrom_drive_is_here);
693        if (!dev[0]) {
694            find_cdrom_device(dev, FALSE);
695        }
696    }
697
698    if (bkpinfo->backup_media_type != iso) {
699        retract_CD_tray_and_defeat_autorun();
700    }
701
702    if (!dev[0] || (res = mount_CDROM_here(dev, mountpoint))) {
703        if (!popup_and_get_string
704            ("CD-ROM device", "Please enter your CD-ROM's /dev device",
705             dev, MAX_STR_LEN / 4)) {
706            res = 1;
707        } else {
708            res = mount_CDROM_here(dev, mountpoint);
709        }
710    }
711    if (res) {
712        log_msg(1, "mount failed");
713    } else {
714        log_msg(1, "mount succeeded with %s", dev);
715    }
716    paranoid_free(dev);
717    return (res);
718}
719
720
721
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_USB_here(char *device, char *mountpoint)
1622{
1623    /*@ buffer ****************************************************** */
1624    char *command;
1625    char *dev;
1626    int retval;
1627
1628    malloc_string(command);
1629    malloc_string(dev);
1630    assert_string_is_neither_NULL_nor_zerolength(device);
1631    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
1632
1633    make_hole_for_dir(mountpoint);
1634    if (isdigit(device[0])) {
1635        return(1);
1636    } else {
1637        strcpy(dev, device);
1638    }
1639    log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device,
1640            mountpoint);
1641
1642#ifdef __FreeBSD__
1643    sprintf(command, "mount_vfat %s %s 2>> %s",
1644            device, mountpoint, MONDO_LOGFILE);
1645
1646#else
1647    sprintf(command, "mount %s -t vfat %s 2>> %s",
1648            device, mountpoint, MONDO_LOGFILE);
1649#endif
1650
1651    log_msg(4, command);
1652    retval = system(command);
1653    log_msg(1, "system(%s) returned %d", command, retval);
1654
1655    paranoid_free(command);
1656    paranoid_free(dev);
1657    return (retval);
1658}
1659
1660/**
1661 * Mount the CD-ROM at @p mountpoint.
1662 * @param device The device (or file if g_ISO_restore_mode) to mount.
1663 * @param mountpoint The place to mount it.
1664 * @return 0 for success, nonzero for failure.
1665 */
1666int mount_CDROM_here(char *device, char *mountpoint)
1667{
1668    /*@ buffer ****************************************************** */
1669    char *command;
1670    char *dev;
1671    char *options;
1672    int retval;
1673
1674    malloc_string(command);
1675    malloc_string(dev);
1676    malloc_string(options);
1677    assert_string_is_neither_NULL_nor_zerolength(device);
1678    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
1679
1680    make_hole_for_dir(mountpoint);
1681    strcpy(options, "ro");
1682    if (isdigit(device[0])) {
1683        find_cdrom_device(device, FALSE);
1684    } else {
1685        strcpy(dev, device);
1686    }
1687    if (g_ISO_restore_mode) {
1688
1689#ifdef __FreeBSD__
1690        strcpy(dev, make_vn(device));
1691        if (!dev) {
1692            sprintf(command, "Unable to mount ISO (make_vn(%s) failed)",
1693                    device);
1694            fatal_error(command);
1695        }
1696        strcpy(device, dev);
1697#else
1698        strcat(options, ",loop");
1699#endif
1700
1701    }
1702    log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
1703            mountpoint);
1704    /*@ end vars *************************************************** */
1705
1706#ifdef __FreeBSD__
1707    sprintf(command, "mount_cd9660 -r %s %s 2>> %s",
1708            device, mountpoint, MONDO_LOGFILE);
1709
1710#else
1711    sprintf(command, "mount %s -o %s -t iso9660 %s 2>> %s",
1712            device, options, mountpoint, MONDO_LOGFILE);
1713#endif
1714
1715    log_msg(4, command);
1716    if (strncmp(device, "/dev/", 5) == 0) {
1717        retract_CD_tray_and_defeat_autorun();
1718    }
1719    retval = system(command);
1720    log_msg(1, "system(%s) returned %d", command, retval);
1721
1722    paranoid_free(command);
1723    paranoid_free(dev);
1724    paranoid_free(options);
1725    return (retval);
1726}
1727
1728
1729
1730
1731
1732
1733/**
1734 * Ask the user for CD number @p cd_number_i_want.
1735 * Sets g_current_media_number once the correct CD is inserted.
1736 * @param bkpinfo The backup information structure. Fields used:
1737 * - @c bkpinfo->backup_media_type
1738 * - @c bkpinfo->prefix
1739 * - @c bkpinfo->isodir
1740 * - @c bkpinfo->media_device
1741 * - @c bkpinfo->please_dont_eject_when_restoring
1742 * @param cd_number_i_want The CD number to ask for.
1743 */
1744void
1745insist_on_this_cd_number(int cd_number_i_want)
1746{
1747
1748    /*@ int ************************************************************* */
1749    int res = 0;
1750
1751
1752    /*@ buffers ********************************************************* */
1753    char *tmp;
1754    char *request;
1755
1756    assert(bkpinfo != NULL);
1757    assert(cd_number_i_want > 0);
1758
1759//  log_msg(3, "Insisting on CD number %d", cd_number_i_want);
1760
1761    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1762        log_msg(3,
1763                "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
1764        return;
1765    }
1766    malloc_string(tmp);
1767    malloc_string(request);
1768    sprintf(tmp, "mkdir -p " MNT_CDROM);
1769    run_program_and_log_output(tmp, 5);
1770    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
1771        || bkpinfo->backup_media_type == nfs) {
1772        log_msg(3, "Remounting CD");
1773        g_ISO_restore_mode = TRUE;
1774// FIXME --- I'm tempted to do something about this...
1775// Why unmount and remount again and again?
1776        if (is_this_device_mounted(MNT_CDROM)) {
1777            run_program_and_log_output("umount " MNT_CDROM, 5);
1778        }
1779        sprintf(tmp, "mkdir -p %s/isodir &> /dev/null", bkpinfo->tmpdir);
1780        system(tmp);
1781        sprintf(tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
1782                bkpinfo->nfs_remote_dir, bkpinfo->prefix,
1783                cd_number_i_want);
1784        if (!does_file_exist(tmp)) {
1785            sprintf(tmp, "%s/isodir/%s/%s-%d.iso", bkpinfo->tmpdir,
1786                    bkpinfo->nfs_remote_dir, bkpinfo->prefix,
1787                    cd_number_i_want);
1788            if (does_file_exist(tmp)) {
1789                log_msg(1,
1790                        "FIXME - hacking bkpinfo->isodir from '%s' to %s/isodir",
1791                        bkpinfo->isodir, bkpinfo->tmpdir);
1792                sprintf(bkpinfo->isodir, "%s/isodir", bkpinfo->tmpdir);
1793            }
1794        }
1795        log_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
1796        if (mount_CDROM_here(tmp, MNT_CDROM)) {
1797            fatal_error("Mommy!");
1798        }
1799//    g_current_media_number = cd_number_i_want;
1800//    return;
1801    }
1802    if ((res = what_number_cd_is_this()) != cd_number_i_want) {
1803        log_msg(3, "Currently, we hold %d but we want %d", res,
1804                cd_number_i_want);
1805        sprintf(tmp, "Insisting on %s #%d",
1806                media_descriptor_string(bkpinfo->backup_media_type),
1807                cd_number_i_want);
1808        sprintf(request, "Please insert %s #%d and press Enter.",
1809                media_descriptor_string(bkpinfo->backup_media_type),
1810                cd_number_i_want);
1811        log_msg(3, tmp);
1812        while (what_number_cd_is_this() != cd_number_i_want) {
1813            paranoid_system("sync");
1814            if (is_this_device_mounted(MNT_CDROM)) {
1815                res =
1816                    run_program_and_log_output("umount " MNT_CDROM, FALSE);
1817            } else {
1818                res = 0;
1819            }
1820            if (res) {
1821                log_to_screen("WARNING - failed to unmount CD-ROM drive");
1822            }
1823            if (!bkpinfo->please_dont_eject) {
1824                res = eject_device(bkpinfo->media_device);
1825            } else {
1826                res = 0;
1827            }
1828            if (res) {
1829                log_to_screen("WARNING - failed to eject CD-ROM disk");
1830            }
1831            popup_and_OK(request);
1832            if (!bkpinfo->please_dont_eject) {
1833                inject_device(bkpinfo->media_device);
1834            }
1835            paranoid_system("sync");
1836        }
1837        log_msg(1, "Thankyou. Proceeding...");
1838        g_current_media_number = cd_number_i_want;
1839    }
1840    paranoid_free(tmp);
1841    paranoid_free(request);
1842}
1843
1844/* @} - end of deviceGroup */
1845
1846
1847
1848
1849
1850
1851/**
1852 * Ask user for details of backup/restore information.
1853 * Called when @c mondoarchive doesn't get any parameters.
1854 * @param bkpinfo The backup information structure to fill out with the user's data.
1855 * @param archiving_to_media TRUE if archiving, FALSE if restoring.
1856 * @return 0, always.
1857 * @bug No point of `int' return value.
1858 * @ingroup archiveGroup
1859 */
1860int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
1861// archiving_to_media is TRUE if I'm being called by mondoarchive
1862// archiving_to_media is FALSE if I'm being called by mondorestore
1863{
1864    char *tmp;
1865    char *tmp1 = NULL;
1866    char *sz_size;
1867    char *command;
1868    char *comment;
1869    char *prompt;
1870    int i;
1871    FILE *fin;
1872
1873    malloc_string(tmp);
1874    malloc_string(sz_size);
1875    malloc_string(command);
1876    malloc_string(comment);
1877    malloc_string(prompt);
1878    assert(bkpinfo != NULL);
1879    sz_size[0] = '\0';
1880    bkpinfo->nonbootable_backup = FALSE;
1881
1882// Tape, CD, NFS, ...?
1883    srandom(getpid());
1884    bkpinfo->backup_media_type =
1885        (g_restoring_live_from_cd) ? cdr :
1886        which_backup_media_type(bkpinfo->restore_data);
1887    if (bkpinfo->backup_media_type == none) {
1888        log_to_screen("User has chosen not to backup the PC");
1889        finish(1);
1890    }
1891    if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
1892        popup_and_OK("Please remove media from drive(s)");
1893    }
1894    log_msg(3, "media type = %s",
1895            bkptype_to_string(bkpinfo->backup_media_type));
1896    if (archiving_to_media) {
1897        sensibly_set_tmpdir_and_scratchdir();
1898    }
1899    bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
1900    bkpinfo->compression_level =
1901        (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
1902    bkpinfo->use_lzo =
1903        (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
1904    mvaddstr_and_log_it(2, 0, " ");
1905
1906// Find device's /dev (or SCSI) entry
1907    switch (bkpinfo->backup_media_type) {
1908    case cdr:
1909    case cdrw:
1910    case dvd:
1911    case usb:
1912        /* Never try to eject a USB device */
1913        if (bkpinfo->backup_media_type == usb) {
1914            bkpinfo->please_dont_eject = TRUE;
1915        }
1916        if (archiving_to_media) {
1917            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
1918                if (ask_me_yes_or_no
1919                    ("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?"))
1920                {
1921                    bkpinfo->manual_cd_tray = TRUE;
1922                }
1923            }
1924            if ((bkpinfo->compression_level =
1925                 which_compression_level()) == -1) {
1926                log_to_screen("User has chosen not to backup the PC");
1927                finish(1);
1928            }
1929            sprintf(comment, "What speed is your %s (re)writer?",
1930                    media_descriptor_string(bkpinfo->backup_media_type));
1931            if (bkpinfo->backup_media_type == dvd) {
1932                find_dvd_device(bkpinfo->media_device, FALSE);
1933                strcpy(tmp, "1");
1934                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
1935                log_msg(1, "Setting to DVD defaults");
1936            } else {
1937                strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
1938                strcpy(tmp, "4");
1939                strcpy(sz_size, "650");
1940                log_msg(1, "Setting to CD defaults");
1941            }
1942            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
1943                if (!popup_and_get_string("Speed", comment, tmp, 4)) {
1944                    log_to_screen("User has chosen not to backup the PC");
1945                    finish(1);
1946                }
1947            }
1948            bkpinfo->cdrw_speed = atoi(tmp);    // if DVD then this shouldn't ever be used anyway :)
1949            sprintf(comment,
1950                    "How much data (in Megabytes) will each %s store?",
1951                    media_descriptor_string(bkpinfo->backup_media_type));
1952            if (!popup_and_get_string("Size", comment, sz_size, 5)) {
1953                log_to_screen("User has chosen not to backup the PC");
1954                finish(1);
1955            }
1956            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
1957                bkpinfo->media_size[i] = atoi(sz_size);
1958            }
1959            if (bkpinfo->media_size[0] <= 0) {
1960                log_to_screen("User has chosen not to backup the PC");
1961                finish(1);
1962            }
1963        }
1964        /* No break because we continue even for usb */
1965    case cdstream:
1966        if ((bkpinfo->disaster_recovery) && (bkpinfo->backup_media_type != usb)) {
1967            strcpy(bkpinfo->media_device, "/dev/cdrom");
1968            log_msg(2, "CD-ROM device assumed to be at %s",
1969                    bkpinfo->media_device);
1970        } else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb))
1971                   || bkpinfo->backup_media_type == dvd) {
1972            if (!bkpinfo->media_device[0]) {
1973                strcpy(bkpinfo->media_device, "/dev/cdrom");
1974            }                   // just for the heck of it :)
1975            log_msg(1, "bkpinfo->media_device = %s",
1976                    bkpinfo->media_device);
1977            if (bkpinfo->backup_media_type == dvd
1978                || find_cdrom_device(bkpinfo->media_device, FALSE)) {
1979                log_msg(1, "bkpinfo->media_device = %s",
1980                        bkpinfo->media_device);
1981                sprintf(comment,
1982                        "Please specify your %s drive's /dev entry",
1983                        media_descriptor_string(bkpinfo->backup_media_type));
1984                if (!popup_and_get_string
1985                    ("Device?", comment, bkpinfo->media_device,
1986                     MAX_STR_LEN / 4)) {
1987                    log_to_screen("User has chosen not to backup the PC");
1988                    finish(1);
1989                }
1990            }
1991            log_msg(2, "%s device found at %s",
1992                    media_descriptor_string(bkpinfo->backup_media_type),
1993                    bkpinfo->media_device);
1994        } else {
1995            if ((find_cdrw_device(bkpinfo->media_device)) && (bkpinfo->backup_media_type != usb)) {
1996                bkpinfo->media_device[0] = '\0';
1997            }
1998            if (bkpinfo->media_device[0]) {
1999                if (bkpinfo->backup_media_type == usb) {
2000                    sprintf(tmp,
2001                        "I think your %s media corresponds to %s. Is this correct?",
2002                        media_descriptor_string(bkpinfo->backup_media_type),
2003                        bkpinfo->media_device);
2004                } else {
2005                    sprintf(tmp,
2006                        "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.)",
2007                        media_descriptor_string(bkpinfo->backup_media_type),
2008                        bkpinfo->media_device);
2009                }
2010                if (!ask_me_yes_or_no(tmp)) {
2011                    bkpinfo->media_device[0] = '\0';
2012                }
2013            }
2014            if (!bkpinfo->media_device[0]) {
2015                if (bkpinfo->backup_media_type == usb) {
2016                    i = popup_and_get_string("/dev entry?",
2017                                         "What is the /dev entry of your USB Disk/Key, please?",
2018                                         bkpinfo->media_device,
2019                                         MAX_STR_LEN / 4);
2020                } else {
2021                    if (g_kernel_version < 2.6) {
2022                        i = popup_and_get_string("Device node?",
2023                                             "What is the SCSI node of your CD (re)writer, please?",
2024                                             bkpinfo->media_device,
2025                                             MAX_STR_LEN / 4);
2026                    } else {
2027                        i = popup_and_get_string("/dev entry?",
2028                                             "What is the /dev entry of your CD (re)writer, please?",
2029                                             bkpinfo->media_device,
2030                                             MAX_STR_LEN / 4);
2031                    }
2032                }
2033                if (!i) {
2034                    log_to_screen("User has chosen not to backup the PC");
2035                    finish(1);
2036                }
2037            }
2038        }
2039        if (bkpinfo->backup_media_type == cdstream) {
2040            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2041                bkpinfo->media_size[i] = 650;
2042            }
2043        }
2044        break;
2045    case udev:
2046        if (!ask_me_yes_or_no
2047            ("This option is for advanced users only. Are you sure?")) {
2048            log_to_screen("User has chosen not to backup the PC");
2049            finish(1);
2050        }
2051    case tape:
2052
2053        if (find_tape_device_and_size(bkpinfo->media_device, sz_size)) {
2054            log_msg(3, "Ok, using vanilla scsi tape.");
2055            strcpy(bkpinfo->media_device, VANILLA_SCSI_TAPE);
2056            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2057                paranoid_fclose(fin);
2058            } else {
2059                strcpy(bkpinfo->media_device, "/dev/osst0");
2060            }
2061        }
2062        if (bkpinfo->media_device[0]) {
2063            if ((fin = fopen(bkpinfo->media_device, "r"))) {
2064                paranoid_fclose(fin);
2065            } else {
2066                if (does_file_exist("/tmp/mondo-restore.cfg")) {
2067                    read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
2068                                 bkpinfo->media_device);
2069                }
2070            }
2071            sprintf(tmp,
2072                    "I think I've found your tape streamer at %s; am I right on the money?",
2073                    bkpinfo->media_device);
2074        }
2075        if (bkpinfo->media_device[0]) {
2076            sprintf(tmp,
2077                    "I think I've found your tape streamer at %s; am I right on the money?",
2078                    bkpinfo->media_device);
2079            if (!ask_me_yes_or_no(tmp)) {
2080                bkpinfo->media_device[0] = '\0';
2081            }
2082        }
2083        if (!bkpinfo->media_device[0]) {
2084            if (!popup_and_get_string
2085                ("Device name?",
2086                 "What is the /dev entry of your tape streamer?",
2087                 bkpinfo->media_device, MAX_STR_LEN / 4)) {
2088                log_to_screen("User has chosen not to backup the PC");
2089                finish(1);
2090            }
2091        }
2092        sprintf(tmp, "ls -l %s", bkpinfo->media_device);
2093        if (run_program_and_log_output(tmp, FALSE)) {
2094            log_to_screen("User has not specified a valid /dev entry");
2095            finish(1);
2096        }
2097        log_msg(4, "sz_size = %s", sz_size);
2098        sz_size[0] = '\0';
2099/*
2100    if ((size_sz[0]=='\0' || atol(size_sz)==0) && archiving_to_media)
2101      {
2102        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))
2103          { log_to_screen("User has chosen not to backup the PC"); finish(1); }
2104      }
2105*/
2106        if (sz_size[0] == '\0') {
2107            bkpinfo->media_size[0] = 0;
2108        } else {
2109            bkpinfo->media_size[0] =
2110                friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
2111        }
2112        log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
2113        if (bkpinfo->media_size[0] <= 0) {
2114            bkpinfo->media_size[0] = 0;
2115        }
2116        for (i = 1; i <= MAX_NOOF_MEDIA; i++) {
2117            bkpinfo->media_size[i] = bkpinfo->media_size[0];
2118        }
2119        if (archiving_to_media) {
2120            if ((bkpinfo->compression_level =
2121                 which_compression_level()) == -1) {
2122                log_to_screen("User has chosen not to backup the PC");
2123                finish(1);
2124            }
2125        }
2126        break;
2127
2128
2129
2130    case nfs:
2131        /* Never try to eject a NFS device */
2132        bkpinfo->please_dont_eject = TRUE;
2133
2134        /* Initiate bkpinfo nfs_mount path from running environment if not already done */
2135        if (!bkpinfo->nfs_mount[0]) {
2136            strcpy(bkpinfo->nfs_mount,
2137                   call_program_and_get_last_line_of_output
2138                   ("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
2139        }
2140#ifdef __FreeBSD__
2141        if (TRUE)
2142#else
2143        if (!bkpinfo->disaster_recovery)
2144#endif
2145        {
2146            if (!popup_and_get_string
2147                ("NFS dir.",
2148                 "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.)",
2149                 bkpinfo->nfs_mount, MAX_STR_LEN / 4)) {
2150                log_to_screen("User has chosen not to backup the PC");
2151                finish(1);
2152            }
2153            if (!bkpinfo->restore_data) {
2154                if ((bkpinfo->compression_level =
2155                     which_compression_level()) == -1) {
2156                    log_to_screen("User has chosen not to backup the PC");
2157                    finish(1);
2158                }
2159            }
2160            // check whether already mounted - we better remove
2161            // surrounding spaces and trailing '/' for this
2162            strip_spaces(bkpinfo->nfs_mount);
2163            if (bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] == '/')
2164                bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] = '\0';
2165            sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3",
2166                    bkpinfo->nfs_mount);
2167            strcpy(bkpinfo->isodir,
2168                   call_program_and_get_last_line_of_output(command));
2169
2170            if (!bkpinfo->restore_data) {
2171                sprintf(comment,
2172                    "How much data (in Megabytes) will each media store?");
2173                if (!popup_and_get_string("Size", comment, sz_size, 5)) {
2174                    log_to_screen("User has chosen not to backup the PC");
2175                    finish(1);
2176                }
2177            } else {
2178                sz_size = 0;
2179            }
2180            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2181                bkpinfo->media_size[i] = atoi(sz_size);
2182            }
2183            if (bkpinfo->media_size[0] <= 0) {
2184                log_to_screen("User has chosen not to backup the PC");
2185                finish(1);
2186            }
2187        }
2188        if (bkpinfo->disaster_recovery) {
2189            sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
2190            system(command);
2191            if (!popup_and_get_string
2192                ("NFS share", "Which remote NFS share should I mount?",
2193                 bkpinfo->nfs_mount, MAX_STR_LEN)) {
2194                log_to_screen("User has chosen not to backup the PC");
2195                finish(1);
2196            }
2197        }
2198        /* Initiate bkpinfo isodir path from running environment if mount already done */
2199        if (is_this_device_mounted(bkpinfo->nfs_mount)) {
2200            strcpy(bkpinfo->isodir,
2201                   call_program_and_get_last_line_of_output
2202                   ("mount | grep \":\" | cut -d' ' -f3 | head -n1"));
2203        } else {
2204            sprintf(bkpinfo->isodir, "%s/nfsdir", bkpinfo->tmpdir);
2205            sprintf(command, "mkdir -p %s", bkpinfo->isodir);
2206            run_program_and_log_output(command, 5);
2207            sprintf(tmp, "mount -t nfs -o nolock %s %s", bkpinfo->nfs_mount,
2208                    bkpinfo->isodir);
2209            run_program_and_log_output(tmp, 3);
2210            malloc_string(g_selfmounted_isodir);
2211            strcpy(g_selfmounted_isodir, bkpinfo->isodir);
2212        }
2213        if (!is_this_device_mounted(bkpinfo->nfs_mount)) {
2214            popup_and_OK
2215                ("Please mount that partition before you try to backup to or restore from it.");
2216            finish(1);
2217        }
2218        strcpy(tmp, bkpinfo->nfs_remote_dir);
2219        if (!popup_and_get_string
2220            ("Directory", "Which directory within that mountpoint?", tmp,
2221             MAX_STR_LEN)) {
2222            log_to_screen("User has chosen not to backup the PC");
2223            finish(1);
2224        }
2225        strcpy(bkpinfo->nfs_remote_dir, tmp);
2226        // check whether writable - we better remove surrounding spaces for this
2227        strip_spaces(bkpinfo->nfs_remote_dir);
2228        asprintf(&tmp1,"%s/%s/.dummy.txt", bkpinfo->isodir,bkpinfo->nfs_remote_dir);
2229        sprintf(command, "echo hi > %s", tmp1);
2230        while (run_program_and_log_output(command, FALSE)) {
2231            strcpy(tmp, bkpinfo->nfs_remote_dir);
2232            sprintf(prompt,
2233                    "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.",
2234                    bkpinfo->nfs_remote_dir, bkpinfo->isodir);
2235            if (!popup_and_get_string
2236                ("Directory", prompt, tmp, MAX_STR_LEN)) {
2237                log_to_screen("User has chosen not to backup the PC");
2238                finish(1);
2239            }
2240            strcpy(bkpinfo->nfs_remote_dir, tmp);
2241            // check whether writable - we better remove surrounding space s for this
2242            strip_spaces(bkpinfo->nfs_remote_dir);
2243            paranoid_free(tmp1);
2244            asprintf(&tmp1,"%s/%s/.dummy.txt", bkpinfo->isodir,bkpinfo->nfs_remote_dir);
2245            sprintf(command, "echo hi > %s", tmp1);
2246        }
2247        unlink(tmp1);
2248        paranoid_free(tmp1);
2249
2250        if (!popup_and_get_string
2251            ("Prefix.",
2252             "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files",
2253            bkpinfo->prefix, MAX_STR_LEN / 4)) {
2254            log_to_screen("User has chosen not to backup the PC");
2255            finish(1);
2256        }
2257        log_msg(3, "prefix set to %s", bkpinfo->prefix);
2258
2259        for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2260            bkpinfo->media_size[i] = 650;
2261        }
2262        log_msg(3, "Just set nfs_remote_dir to %s",
2263                bkpinfo->nfs_remote_dir);
2264        log_msg(3, "isodir is still %s", bkpinfo->isodir);
2265        break;
2266
2267    case iso:
2268        if (!bkpinfo->disaster_recovery) {
2269            if (!popup_and_get_string
2270                ("Storage dir.",
2271                 "Please enter the full path name to the directory for your ISO images.  Example: /mnt/raid0_0",
2272                 bkpinfo->isodir, MAX_STR_LEN / 4)) {
2273                log_to_screen("User has chosen not to backup the PC");
2274                finish(1);
2275            }
2276            if (archiving_to_media) {
2277                if ((bkpinfo->compression_level =
2278                     which_compression_level()) == -1) {
2279                    log_to_screen("User has chosen not to backup the PC");
2280                    finish(1);
2281                }
2282                if (!popup_and_get_string
2283                    ("ISO size.",
2284                     "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.",
2285                     sz_size, 16)) {
2286                    log_to_screen("User has chosen not to backup the PC");
2287                    finish(1);
2288                }
2289                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2290                    bkpinfo->media_size[i] = atoi(sz_size);
2291                }
2292            } else {
2293                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
2294                    bkpinfo->media_size[i] = 650;
2295                }
2296            }
2297        }
2298        if (!popup_and_get_string
2299            ("Prefix.",
2300             "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files",
2301             bkpinfo->prefix, MAX_STR_LEN / 4)) {
2302            log_to_screen("User has chosen not to backup the PC");
2303            finish(1);
2304        }
2305        log_msg(3, "prefix set to %s", bkpinfo->prefix);
2306        break;
2307    default:
2308        fatal_error
2309            ("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
2310    }
2311
2312    if (archiving_to_media) {
2313
2314#ifdef __FreeBSD__
2315        strcpy(bkpinfo->boot_device,
2316               call_program_and_get_last_line_of_output
2317               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
2318#else
2319        strcpy(bkpinfo->boot_device,
2320               call_program_and_get_last_line_of_output
2321               ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
2322#endif
2323        i = which_boot_loader(bkpinfo->boot_device);
2324        if (i == 'U')           // unknown
2325        {
2326
2327#ifdef __FreeBSD__
2328            if (!popup_and_get_string
2329                ("Boot device",
2330                 "What is your boot device? (e.g. /dev/ad0)",
2331                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2332                log_to_screen("User has chosen not to backup the PC");
2333                finish(1);
2334            }
2335            i = which_boot_loader(bkpinfo->boot_device);
2336#else
2337            if (!popup_and_get_string
2338                ("Boot device",
2339                 "What is your boot device? (e.g. /dev/hda)",
2340                 bkpinfo->boot_device, MAX_STR_LEN / 4)) {
2341                log_to_screen("User has chosen not to backup the PC");
2342                finish(1);
2343            }
2344            if (does_string_exist_in_boot_block
2345                (bkpinfo->boot_device, "LILO")) {
2346                i = 'L';
2347            } else
2348                if (does_string_exist_in_boot_block
2349                    (bkpinfo->boot_device, "ELILO")) {
2350                i = 'E';
2351            } else
2352                if (does_string_exist_in_boot_block
2353                    (bkpinfo->boot_device, "GRUB")) {
2354                i = 'G';
2355            } else {
2356                i = 'U';
2357            }
2358#endif
2359            if (i == 'U') {
2360                if (ask_me_yes_or_no
2361                    ("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?"))
2362                {
2363                    i = 'R';    // raw
2364                } else {
2365                    log_to_screen
2366                        ("I cannot find your boot loader. Please run mondoarchive with parameters.");
2367                    finish(1);
2368                }
2369            }
2370        }
2371        bkpinfo->boot_loader = i;
2372        strcpy(bkpinfo->include_paths, "/");
2373        if (!popup_and_get_string
2374            ("Backup paths",
2375             "Please enter paths which you want me to backup. The default is '/' (i.e. everything).",
2376             bkpinfo->include_paths, MAX_STR_LEN)) {
2377            log_to_screen("User has chosen not to backup the PC");
2378            finish(1);
2379        }
2380        strcpy(tmp, list_of_NFS_mounts_only());
2381        if (strlen(tmp) > 2) {
2382            if (bkpinfo->exclude_paths[0]) {
2383                strcat(bkpinfo->exclude_paths, " ");
2384            }
2385            strncpy(bkpinfo->exclude_paths, tmp, MAX_STR_LEN);
2386        }
2387// NTFS
2388        strcpy(tmp,
2389               call_program_and_get_last_line_of_output
2390               ("parted2fdisk -l | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'"));
2391        if (strlen(tmp) > 2) {
2392            if (!popup_and_get_string
2393                ("NTFS partitions",
2394                 "Please enter/confirm the NTFS partitions you wish to backup as well.",
2395                 tmp, MAX_STR_LEN / 4)) {
2396                log_to_screen("User has chosen not to backup the PC");
2397                finish(1);
2398            }
2399            strncpy(bkpinfo->image_devs, tmp, MAX_STR_LEN / 4);
2400        }
2401
2402
2403        if (!popup_and_get_string
2404            ("Exclude paths",
2405             "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.",
2406             bkpinfo->exclude_paths, (4*MAX_STR_LEN)-1)) {
2407            log_to_screen("User has chosen not to backup the PC");
2408            finish(1);
2409        }
2410// Interactive mode:
2411#ifdef __IA64__
2412        bkpinfo->make_cd_use_lilo = TRUE;
2413#else
2414        bkpinfo->make_cd_use_lilo = FALSE;
2415#endif
2416        bkpinfo->backup_data = TRUE;
2417        bkpinfo->verify_data =
2418            ask_me_yes_or_no
2419            ("Will you want to verify your backups after Mondo has created them?");
2420
2421#ifndef __FreeBSD__
2422        if (!ask_me_yes_or_no
2423            ("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."))
2424#endif
2425        {
2426            strcpy(bkpinfo->kernel_path, "FAILSAFE");
2427        }
2428
2429        if (!ask_me_yes_or_no
2430            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
2431            log_to_screen("User has chosen not to backup the PC");
2432            finish(1);
2433        }
2434    } else {
2435        bkpinfo->restore_data = TRUE;   // probably...
2436    }
2437
2438    if (bkpinfo->backup_media_type == iso
2439        || bkpinfo->backup_media_type == nfs) {
2440        g_ISO_restore_mode = TRUE;
2441    }
2442#ifdef __FreeSD__
2443// skip
2444#else
2445    if (bkpinfo->backup_media_type == nfs) {
2446        sprintf(tmp, "mount | grep \"%s\" | cut -d' ' -f3",
2447                bkpinfo->nfs_mount);
2448//      strcpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(tmp));
2449        log_msg(3, "I think the NFS mount is mounted at %s",
2450                bkpinfo->isodir);
2451    }
2452    log_it("isodir = %s", bkpinfo->isodir);
2453    log_it("nfs_mount = '%s'", bkpinfo->nfs_mount);
2454#endif
2455
2456    log_it("media device = %s", bkpinfo->media_device);
2457    log_it("media size = %ld", bkpinfo->media_size[1]);
2458    log_it("media type = %s",
2459           bkptype_to_string(bkpinfo->backup_media_type));
2460    log_it("prefix = %s", bkpinfo->prefix);
2461    log_it("compression = %ld", bkpinfo->compression_level);
2462    log_it("include_paths = '%s'", bkpinfo->include_paths);
2463    log_it("exclude_paths = '%s'", bkpinfo->exclude_paths);
2464    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
2465    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
2466    log_it("image_devs = '%s'", bkpinfo->image_devs);
2467    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device,
2468           bkpinfo->boot_loader);
2469    if (bkpinfo->media_size[0] < 0) {
2470        if (archiving_to_media) {
2471            fatal_error("Media size is less than zero.");
2472        } else {
2473            log_msg(2, "Warning - media size is less than zero.");
2474            bkpinfo->media_size[0] = 0;
2475        }
2476    }
2477    paranoid_free(tmp);
2478    paranoid_free(sz_size);
2479    paranoid_free(command);
2480    paranoid_free(comment);
2481    paranoid_free(prompt);
2482    return (0);
2483}
2484
2485
2486
2487
2488/**
2489 * @addtogroup utilityGroup
2490 * @{
2491 */
2492/**
2493 * Get a space-separated list of NFS devices and mounts.
2494 * @return The list created.
2495 * @note The return value points to static data that will be overwritten with each call.
2496 */
2497char *list_of_NFS_devices_and_mounts(void)
2498{
2499    char *exclude_these_devices;
2500    char *exclude_these_directories;
2501    static char result_sz[512];
2502
2503    malloc_string(exclude_these_devices);
2504    malloc_string(exclude_these_directories);
2505    strcpy(exclude_these_directories,
2506           call_program_and_get_last_line_of_output
2507           ("mount -t coda,ncpfs,nfs,smbfs,cifs,afs,ocfs,ocfs2,mvfs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
2508    strcpy(exclude_these_devices,
2509           call_program_and_get_last_line_of_output
2510           ("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;}'"));
2511    sprintf(result_sz, "%s %s", exclude_these_directories,
2512            exclude_these_devices);
2513    paranoid_free(exclude_these_devices);
2514    paranoid_free(exclude_these_directories);
2515    return (result_sz);
2516}
2517
2518
2519
2520
2521/**
2522 * Get a space-separated list of NFS mounts.
2523 * @return The list created.
2524 * @note The return value points to static data that will be overwritten with each call.
2525 * @bug Even though we only want the mounts, the devices are still checked.
2526 */
2527char *list_of_NFS_mounts_only(void)
2528{
2529    char *exclude_these_devices;
2530    char *exclude_these_directories;
2531    static char result_sz[512];
2532
2533    malloc_string(exclude_these_devices);
2534    malloc_string(exclude_these_directories);
2535    strcpy(exclude_these_directories,
2536           call_program_and_get_last_line_of_output
2537           ("mount -t coda,ncpfs,nfs,smbfs,cifs,afs,ocfs,ocfs2,mvfs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
2538    strcpy(exclude_these_devices,
2539           call_program_and_get_last_line_of_output
2540           ("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;}'"));
2541    sprintf(result_sz, "%s", exclude_these_directories);
2542    paranoid_free(exclude_these_devices);
2543    paranoid_free(exclude_these_directories);
2544    return (result_sz);
2545}
2546
2547/* @} - end of utilityGroup */
2548
2549
2550
2551
2552
2553/**
2554 * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
2555 * [random] is a random number between 1 and 32767.
2556 * @param store_name_here Where to store the new filename.
2557 * @param stub A random number will be appended to this to make the FIFO's name.
2558 * @ingroup deviceGroup
2559 */
2560void make_fifo(char *store_name_here, char *stub)
2561{
2562    char *tmp;
2563
2564    malloc_string(tmp);
2565    assert_string_is_neither_NULL_nor_zerolength(stub);
2566
2567    sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
2568            (int) (random() % 32768));
2569    make_hole_for_file(store_name_here);
2570    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
2571    sprintf(tmp, "chmod 770 %s", store_name_here);
2572    paranoid_system(tmp);
2573    paranoid_free(tmp);
2574}
2575
2576
2577
2578
2579
2580
2581/**
2582 * Set the tmpdir and scratchdir to reside on the partition with the most free space.
2583 * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
2584 * @param bkpinfo The backup information structure. @c bkpinfo->tmpdir and @c bkpinfo->scratchdir will be set.
2585 * @ingroup utilityGroup
2586 */
2587void sensibly_set_tmpdir_and_scratchdir()
2588{
2589    char *tmp, *command, *sz;
2590
2591    malloc_string(tmp);
2592    malloc_string(command);
2593    malloc_string(sz);
2594    assert(bkpinfo != NULL);
2595
2596#ifdef __FreeBSD__
2597    strcpy(tmp,
2598           call_program_and_get_last_line_of_output
2599           ("LANGUAGE=C 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;}'"));
2600#else
2601    strcpy(tmp,
2602           call_program_and_get_last_line_of_output
2603           ("LANGUAGE=C 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;}'"));
2604#endif
2605
2606    if (tmp[0] != '/') {
2607        strcpy(sz, tmp);
2608        strcpy(tmp, "/");
2609        strcat(tmp, sz);
2610    }
2611    if (!tmp[0]) {
2612        fatal_error("I couldn't figure out the tempdir!");
2613    }
2614    setup_tmpdir(tmp);
2615    log_it("bkpinfo->tmpdir is being set to %s", bkpinfo->tmpdir);
2616
2617    sprintf(bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp,
2618            (int) (random() % 32768));
2619    log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
2620
2621    sprintf(command, "rm -Rf %s/tmp.mondo.* %s/mondo.scratch.*", tmp, tmp);
2622    paranoid_system(command);
2623    paranoid_free(tmp);
2624    paranoid_free(command);
2625    paranoid_free(sz);
2626}
2627
2628
2629
2630
2631
2632
2633/**
2634 * @addtogroup deviceGroup
2635 * @{
2636 */
2637/**
2638 * If we can read @p dev, set @p output to it.
2639 * If @p dev cannot be read, set @p output to "".
2640 * @param dev The device to check for.
2641 * @param output Set to @p dev if @p dev exists, "" otherwise.
2642 * @return TRUE if @p dev exists, FALSE if it doesn't.
2643 */
2644bool set_dev_to_this_if_rx_OK(char *output, char *dev)
2645{
2646    char *command;
2647
2648    malloc_string(command);
2649    if (!dev || dev[0] == '\0') {
2650        output[0] = '\0';
2651        return (FALSE);
2652    }
2653//  assert_string_is_neither_NULL_nor_zerolength(dev);
2654    log_msg(10, "Injecting %s", dev);
2655    inject_device(dev);
2656    if (!does_file_exist(dev)) {
2657        log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
2658        return (FALSE);
2659    }
2660    sprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
2661            512L, dev);
2662    if (!run_program_and_log_output(command, FALSE)
2663        && !run_program_and_log_output(command, FALSE)) {
2664        strcpy(output, dev);
2665        log_msg(4, "Found it - %s", dev);
2666        return (TRUE);
2667    } else {
2668        output[0] = '\0';
2669        log_msg(4, "It's not %s", dev);
2670        return (FALSE);
2671    }
2672}
2673
2674
2675
2676
2677
2678/**
2679 * Find out what number CD is in the drive.
2680 * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
2681 * @return The current CD number, or -1 if it could not be found.
2682 * @note If the CD is not mounted, it will be mounted
2683 * (and remain mounted after this function returns).
2684 */
2685int what_number_cd_is_this()
2686{
2687    int cd_number = -1;
2688    char *mountdev;
2689    char *tmp;
2690
2691    malloc_string(mountdev);
2692    malloc_string(tmp);
2693    assert(bkpinfo != NULL);
2694//  log_it("Asking what_number_cd_is_this");
2695    if (g_ISO_restore_mode) {
2696        sprintf(tmp, "mount | grep iso9660 | awk '{print $3;}'");
2697//      log_it("tmp = %s", tmp);
2698
2699        strcpy(mountdev, call_program_and_get_last_line_of_output(tmp));
2700        strcat(mountdev, "/archives/THIS-CD-NUMBER");
2701//      log_it("mountdev = %s", mountdev);
2702        cd_number = atoi(last_line_of_file(mountdev));
2703//      log_it("cd_number = %d", cd_number);
2704        paranoid_free(mountdev);
2705        paranoid_free(tmp);
2706        return (cd_number);
2707    }
2708
2709    strcpy(mountdev, bkpinfo->media_device);
2710    if (!mountdev[0]) {
2711        log_it
2712            ("(what_number_cd_is_this) Warning - media_device unknown. Finding out...");
2713        find_cdrom_device(bkpinfo->media_device, FALSE);
2714    }
2715    if (!is_this_device_mounted(MNT_CDROM)) {
2716        if (bkpinfo->backup_media_type == usb) {
2717            mount_USB_here(mountdev, MNT_CDROM);
2718        } else {
2719            mount_CDROM_here(mountdev, MNT_CDROM);
2720        }
2721    }
2722    cd_number =
2723        atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
2724//  log_it("cd_number..later.. = %d", cd_number);
2725    paranoid_free(mountdev);
2726    paranoid_free(tmp);
2727    return (cd_number);
2728}
2729
2730
2731
2732
2733
2734
2735
2736/**
2737 * Find out what device is mounted as root (/).
2738 * @return Root device.
2739 * @note The returned string points to static storage and will be overwritten with every call.
2740 * @bug A bit of a misnomer; it's actually finding out the root device.
2741 * The mountpoint (where it's mounted) will obviously be '/'.
2742 */
2743char *where_is_root_mounted()
2744{
2745    /*@ buffers **************** */
2746    static char tmp[MAX_STR_LEN];
2747
2748
2749#ifdef __FreeBSD__
2750    strcpy(tmp, call_program_and_get_last_line_of_output
2751           ("mount | grep \" on / \" | cut -d' ' -f1"));
2752#else
2753    strcpy(tmp, call_program_and_get_last_line_of_output
2754           ("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//"));
2755    if (strstr(tmp, "/dev/cciss/")) {
2756        strcpy(tmp, call_program_and_get_last_line_of_output
2757               ("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1"));
2758    }
2759    if (strstr(tmp, "/dev/md")) {
2760        strcpy(tmp,
2761               call_program_and_get_last_line_of_output
2762               ("mount | grep \" on / \" | cut -d' ' -f1"));
2763    }
2764#endif
2765
2766    return (tmp);
2767}
2768
2769
2770/**
2771 * Find out which boot loader is in use.
2772 * @param which_device Device to look for the boot loader on.
2773 * @return 'L' for LILO, 'E'for ELILO, 'G' for GRUB, 'B' or 'D' for FreeBSD boot loaders, or 'U' for Unknown.
2774 * @note Under Linux, all drives are examined, not just @p which_device.
2775 */
2776#ifdef __FreeBSD__
2777char which_boot_loader(char *which_device)
2778{
2779    int count_lilos = 0;
2780    int count_grubs = 0;
2781    int count_boot0s = 0;
2782    int count_dangerouslydedicated = 0;
2783
2784    log_it("looking at drive %s's MBR", which_device);
2785    if (does_string_exist_in_boot_block(which_device, "GRUB")) {
2786        count_grubs++;
2787    }
2788    if (does_string_exist_in_boot_block(which_device, "LILO")) {
2789        count_lilos++;
2790    }
2791    if (does_string_exist_in_boot_block(which_device, "Drive")) {
2792        count_boot0s++;
2793    }
2794    if (does_string_exist_in_first_N_blocks
2795        (which_device, "FreeBSD/i386", 17)) {
2796        count_dangerouslydedicated++;
2797    }
2798    log_it("%d grubs and %d lilos and %d elilos and %d boot0s and %d DD\n",
2799           count_grubs, count_lilos, count_elilos, count_boot0s,
2800           count_dangerouslydedicated);
2801
2802    if (count_grubs && !count_lilos) {
2803        return ('G');
2804    } else if (count_lilos && !count_grubs) {
2805        return ('L');
2806    } else if (count_grubs == 1 && count_lilos == 1) {
2807        log_it("I'll bet you used to use LILO but switched to GRUB...");
2808        return ('G');
2809    } else if (count_boot0s == 1) {
2810        return ('B');
2811    } else if (count_dangerouslydedicated) {
2812        return ('D');
2813    } else {
2814        log_it("Unknown boot loader");
2815        return ('U');
2816    }
2817}
2818
2819#else
2820
2821char which_boot_loader(char *which_device)
2822{
2823    /*@ buffer ***************************************************** */
2824    char *list_drives_cmd;
2825    char *current_drive;
2826
2827    /*@ pointers *************************************************** */
2828    FILE *pdrives;
2829
2830    /*@ int ******************************************************** */
2831    int count_lilos = 0;
2832    int count_grubs = 0;
2833
2834    /*@ end vars *************************************************** */
2835
2836    malloc_string(list_drives_cmd);
2837    malloc_string(current_drive);
2838
2839#ifdef __IA64__
2840    /* No choice for it */
2841    return ('E');
2842#endif
2843    assert(which_device != NULL);
2844    //  sprintf (list_drives_cmd,
2845    //       "fdisk -l | grep /dev | grep cyl | tr ':' ' ' | cut -d' ' -f2");
2846
2847    sprintf(list_drives_cmd,
2848            "parted2fdisk -l 2>/dev/null | grep \"/dev/.*:\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/; echo %s",
2849            where_is_root_mounted());
2850    log_it("list_drives_cmd = %s", list_drives_cmd);
2851
2852    if (!(pdrives = popen(list_drives_cmd, "r"))) {
2853        log_OS_error("Unable to open list of drives");
2854        paranoid_free(list_drives_cmd);
2855        paranoid_free(current_drive);
2856        return ('\0');
2857    }
2858    for (fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
2859         fgets(current_drive, MAX_STR_LEN, pdrives)) {
2860        strip_spaces(current_drive);
2861        log_it("looking at drive %s's MBR", current_drive);
2862        if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
2863            count_grubs++;
2864            strcpy(which_device, current_drive);
2865            break;
2866        }
2867        if (does_string_exist_in_boot_block(current_drive, "LILO")) {
2868            count_lilos++;
2869            strcpy(which_device, current_drive);
2870            break;
2871        }
2872    }
2873    if (pclose(pdrives)) {
2874        log_OS_error("Cannot pclose pdrives");
2875    }
2876    log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
2877    if (count_grubs && !count_lilos) {
2878        return ('G');
2879    } else if (count_lilos && !count_grubs) {
2880        return ('L');
2881    } else if (count_grubs == 1 && count_lilos == 1) {
2882        log_it("I'll bet you used to use LILO but switched to GRUB...");
2883        return ('G');
2884    } else {
2885        // We need to look on each partition then
2886        sprintf(list_drives_cmd,
2887            "parted2fdisk -l 2>/dev/null | grep -E \"^/dev/\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/");
2888        log_it("list_drives_cmd = %s", list_drives_cmd);
2889
2890        if (!(pdrives = popen(list_drives_cmd, "r"))) {
2891            log_OS_error("Unable to open list of drives");
2892            paranoid_free(list_drives_cmd);
2893            paranoid_free(current_drive);
2894            return ('\0');
2895        }
2896        for (fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
2897            fgets(current_drive, MAX_STR_LEN, pdrives)) {
2898            strip_spaces(current_drive);
2899            log_it("looking at partition %s's BR", current_drive);
2900            if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
2901                count_grubs++;
2902                strcpy(which_device, current_drive);
2903                break;
2904            }
2905            if (does_string_exist_in_boot_block(current_drive, "LILO")) {
2906                count_lilos++;
2907                strcpy(which_device, current_drive);
2908                break;
2909            }
2910        }
2911        if (pclose(pdrives)) {
2912            log_OS_error("Cannot pclose pdrives");
2913        }
2914        log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
2915        paranoid_free(list_drives_cmd);
2916        paranoid_free(current_drive);
2917        if (count_grubs && !count_lilos) {
2918            return ('G');
2919        } else if (count_lilos && !count_grubs) {
2920            return ('L');
2921        } else if (count_grubs == 1 && count_lilos == 1) {
2922            log_it("I'll bet you used to use LILO but switched to GRUB...");
2923            return ('G');
2924        } else {
2925            log_it("Unknown boot loader");
2926            return ('U');
2927        }
2928    }
2929}
2930#endif
2931
2932
2933
2934
2935/**
2936 * Write zeroes over the first 16K of @p device.
2937 * @param device The device to zero.
2938 * @return 0 for success, 1 for failure.
2939 */
2940int zero_out_a_device(char *device)
2941{
2942    FILE *fout;
2943    int i;
2944
2945    assert_string_is_neither_NULL_nor_zerolength(device);
2946
2947    log_it("Zeroing drive %s", device);
2948    if (!(fout = fopen(device, "w"))) {
2949        log_OS_error("Unable to open/write to device");
2950        return (1);
2951    }
2952    for (i = 0; i < 16384; i++) {
2953        fputc('\0', fout);
2954    }
2955    paranoid_fclose(fout);
2956    log_it("Device successfully zeroed.");
2957    return (0);
2958}
2959
2960/**
2961 * Return the device pointed to by @p incoming.
2962 * @param incoming The device to resolve symlinks for.
2963 * @return The path to the real device file.
2964 * @note The returned string points to static storage that will be overwritten with each call.
2965 * @bug Won't work with file v4.0; needs to be written in C.
2966 */
2967char *resolve_softlinks_to_get_to_actual_device_file(char *incoming)
2968{
2969    static char output[MAX_STR_LEN];
2970    char *command;
2971    char *curr_fname;
2972    char *scratch;
2973    char *tmp;
2974    char *p;
2975
2976    struct stat statbuf;
2977    command = malloc(1000);
2978    malloc_string(tmp);
2979    malloc_string(scratch);
2980    malloc_string(curr_fname);
2981    if (!does_file_exist(incoming)) {
2982        log_it
2983            ("resolve_softlinks_to_get_to_actual_device_file --- device not found");
2984        strcpy(output, incoming);
2985    } else {
2986        strcpy(curr_fname, incoming);
2987        lstat(curr_fname, &statbuf);
2988        while (S_ISLNK(statbuf.st_mode)) {
2989            log_msg(1, "curr_fname = %s", curr_fname);
2990            sprintf(command, "file %s", curr_fname);
2991            strcpy(tmp, call_program_and_get_last_line_of_output(command));
2992            for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
2993                 p--);
2994            p++;
2995            strcpy(scratch, p);
2996            for (p = scratch; *p != '\0' && *p != '\''; p++);
2997            *p = '\0';
2998            log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp,
2999                    scratch);
3000            if (scratch[0] == '/') {
3001                strcpy(curr_fname, scratch);    // copy whole thing because it's an absolute softlink
3002            } else {            // copy over the basename cos it's a relative softlink
3003                p = curr_fname + strlen(curr_fname);
3004                while (p != curr_fname && *p != '/') {
3005                    p--;
3006                }
3007                if (*p == '/') {
3008                    p++;
3009                }
3010                strcpy(p, scratch);
3011            }
3012            lstat(curr_fname, &statbuf);
3013        }
3014        strcpy(output, curr_fname);
3015        log_it("resolved %s to %s", incoming, output);
3016    }
3017    paranoid_free(command);
3018    paranoid_free(curr_fname);
3019    paranoid_free(tmp);
3020    return (output);
3021}
3022
3023/* @} - end of deviceGroup */
3024
3025
3026/**
3027 * Return the type of partition format (GPT or MBR)
3028 */
3029char *which_partition_format(const char *drive)
3030{
3031    static char output[4];
3032    char *tmp;
3033    char *command;
3034    char *fdisk;
3035#ifdef __IA64__
3036    struct stat buf;
3037#endif
3038    malloc_string(tmp);
3039    malloc_string(command);
3040    malloc_string(fdisk);
3041    log_msg(0, "Looking for partition table format type");
3042    sprintf(fdisk, "/sbin/parted2fdisk");
3043    log_msg(1, "Using %s", fdisk);
3044    sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
3045    strcpy(tmp, call_program_and_get_last_line_of_output(command));
3046    if (strstr(tmp, "GPT") == NULL) {
3047        strcpy(output, "MBR");
3048    } else {
3049        strcpy(output, "GPT");
3050    }
3051    log_msg(0, "Found %s partition table format type", output);
3052    paranoid_free(command);
3053    paranoid_free(tmp);
3054    paranoid_free(fdisk);
3055    return (output);
3056}
3057
3058/* @} - end of deviceGroup */
Note: See TracBrowser for help on using the repository browser.