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

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