source: branches/2.2.5/mondo/src/mondorestore/mondo-rstr-tools.c @ 1843

Last change on this file since 1843 was 1843, checked in by bruno, 12 years ago
  • Format (tabs) improvements
  • Fix for #223 floppy detection improvement (Based on LazarusLong? patch proposal)
  • Property svn:keywords set to Id
File size: 78.7 KB
Line 
1/***************************************************************************
2mondo-rstr-tools.c  -  description
3-----------------
4
5begin: Sun Sep 21 16:40:35 EDT 2003
6copyright : (C) 2002 Mondo  Hugo Rabson
7email     : Hugo Rabson <hugorabson@msn.com>
8edited by : by Stan Benoit ?/2003
9email     : troff@nakedsoul.org
10cvsid     : $Id: mondo-rstr-tools.c
11***************************************************************************/
12
13/***************************************************************************
14*                                                                         *
15*   This program is free software; you can redistribute it and/or modify  *
16*   it under the terms of the GNU General Public License as published by  *
17*   the Free Software Foundation; either version 2 of the License, or     *
18*   (at your option) any later version.                                   *
19*                                                                         *
20***************************************************************************/
21/* mondo-rstr-tools.c               Hugo Rabson
22
23
2407/27
25- if the user is foolish enough to use /dev/md0 as boot device,
26call lilo -M /dev/hda to make sure lilo does its job properly
27- better NFS+nuke support
28
2907/20
30- use backup's i-want-my-lvm file
31- be sure to use archives' raidtab when restoring
32
3307/18
34- use /tmp/isodir for NFS if DR mode
35- better support of users who boot from LVM CD and nuke-restore non-LVM backups
36
3707/12
38- bugfix to allow user to burn ISOs to CDs and restore from CDs (not original src)
39
4006/29
41- mount ext3 partitions as ext2, just in case :)
42
4306/26
44- delete make_relevant_partition_bootable()
45
4606/19
47- futzed with the call to mount floppy, to stop it from locking up on my AMD64 system
48
4906/14
50- shell out to /mnt/RESTORING chroot in order to let user install GRUB
51manually if automatic GRUB installation fails
52
5306/15
54- Added check for different 'isodir' chosen by user than stored in the archive
55Conor Daly <conor.daly@met.ie>
56
5704/17
58- replaced INTERNAL_TAPE_BLK_SIZE with bkpinfo->internal_tape_block_size
59
6004/09
61- don't try to mount CD if tape bkp
62
6304/03
64- trying to copy tmp/mondo-restore.cfg to itself - silly! - fixed
65
6604/02
67- when extracting cfg file and mountlist from all.tar.gz (tape copy),
68use block size of INTERNAL_TAPE_BLK_SIZE, not TAPE_BLOCK_SIZE
69
7002/21
71- don't use 'mv -v' cos Busybox won't support it
72
7302/09
74- make hole for cfg file before moving it (line 2094 or so)
75
7602/03
77- changed a couple of refs to filelist.full, to filelist.full.gz
78
7901/16/2004
80- instead of copying filelist, use 'ln -sf' to link to original;
81saves space
82
8311/20/2003
84- also retrieve /tmp/mountlist.txt if user wants
85
8611/16
87- fixed NFS path bug affecting the extractions of filelist/biggielist
88during selective restore
89
9011/02
91- fixed mount_cdrom() to run properly w/ nfs restores
92- mount_device() returns 0 if swap mount fails cos swap isn't crucial
93
9410/17
95- run_grub() uses MNT_RESTORING instead of "/mnt/RESTORING"
96
9710/26
98- cleaned up run_grub()
99
10010/25
101- fixed mount_cdrom() to run properly w/ nfs restores
102
10310/21
104- mount_device() returns 0 if swap mount fails cos swap isn't crucial
105
10610/15
107- run_grub() now uses its initiative instead
108of calling grub-install
109
11010/10
111- don't leave copies of filelist.full lying around, clogging up
112the ramdisk, there's a good fellow :-)
113
11410/02
115- added 'dvd' to the range of media types I'll understand
116- fixed iso->cdr problem (thanks, Stan Benoit & Fred Beondo)
117
11809/24
119- try lots of tape devs if /dev/st0 fails
120
12109/23/2003
122- first incarnation
123*/
124
125
126#include <pthread.h>
127#include <fd.h>
128#include "../common/my-stuff.h"
129#include "../common/mondostructures.h"
130#include "../common/libmondo.h"
131#include "mr-externs.h"
132//#include "mondo-restore.h"
133//#include "mondo-rstr-compare-EXT.h"
134#include "mondo-rstr-tools.h"
135
136extern bool g_sigpipe_caught;
137extern bool g_ISO_restore_mode; /* are we in Iso Mode? */
138extern bool g_I_have_just_nuked;
139extern char *g_tmpfs_mountpt;
140extern char *g_isodir_device;
141extern char *g_isodir_format;
142extern long g_current_progress, g_maximum_progress;
143extern char *g_biggielist_txt;  // where 'biggielist.txt' is stored, on ramdisk / tempdir;
144                  // biggielist.txt is the list of big files stored on the
145                  // backup media set in question
146extern char *g_filelist_full;   // filelist.full.gz is the list of all regular files
147                  // (excluding big files) stored on the backup media set
148extern char *g_biggielist_pot;  // list of big files which _could_ be restored, if the
149                  // user chooses them
150extern char *g_filelist_imagedevs;  // list of devices (e.g. /dev/hda1, /dev/sda5) which
151                     // were archived as images, not just /dev entries
152                     // ... e.g. NTFS, BeOS partitions
153extern char *g_imagedevs_restthese; // of the imagedevs listed in FILELIST_IMAGEDEVS,
154                      // restore only these
155extern char *g_mondo_cfg_file;  // where m*ndo-restore.cfg (the config file) is stored
156extern char *g_mountlist_fname; // where mountlist.txt (the mountlist file) is stored
157extern char *g_mondo_home;      // homedir of Mondo; usually /usr/local/share/mondo
158
159extern t_bkptype g_backup_media_type;
160
161extern int g_partition_table_locked_up;
162extern char *MONDO_LOGFILE;
163
164/* Reference to global bkpinfo */
165extern struct s_bkpinfo *bkpinfo;
166
167/* Should we use or not extended attributes and acl when restoring */
168char *g_getfattr = NULL;
169char *g_getfacl = NULL;
170
171/**
172* @addtogroup restoreUtilityGroup
173* @{
174*/
175/**
176* Free the malloc()s for the filename variables.
177*/
178void free_MR_global_filenames()
179{
180paranoid_free(g_biggielist_txt);
181paranoid_free(g_filelist_full);
182paranoid_free(g_filelist_imagedevs);
183//  paranoid_free (g_imagedevs_pot );
184paranoid_free(g_imagedevs_restthese);
185paranoid_free(g_mondo_cfg_file);
186paranoid_free(g_mountlist_fname);
187paranoid_free(g_mondo_home);
188paranoid_free(g_tmpfs_mountpt);
189paranoid_free(g_isodir_device);
190paranoid_free(g_isodir_format);
191
192}
193
194
195
196/**
197* Ask the user which imagedevs from the list contained in @p infname should
198* actually be restored.
199* @param infname The file containing a list of all imagedevs.
200* @param outfname The location of the output file containing the imagedevs the user wanted to restore.
201* @ingroup restoreUtilityGroup
202*/
203void ask_about_these_imagedevs(char *infname, char *outfname)
204{
205FILE *fin;
206FILE *fout;
207/************************************************************************
208* allocate memory regions. test and set  -sab 16 feb 2003              *
209************************************************************************/
210char *incoming_ptr;
211char *question_ptr;
212
213char incoming[MAX_STR_LEN] = "\0";
214char question[MAX_STR_LEN];
215
216assert_string_is_neither_NULL_nor_zerolength(infname);
217assert_string_is_neither_NULL_nor_zerolength(outfname);
218
219incoming_ptr = malloc(sizeof(incoming));
220if (incoming_ptr == NULL) {
221fprintf(stderr, "Out of Memory\n");
222exit(EXIT_FAILURE);
223}
224
225question_ptr = malloc(sizeof(question));
226if (question_ptr == NULL) {
227fprintf(stderr, "Out of Memory\n");
228exit(EXIT_FAILURE);
229}
230
231memset(incoming_ptr, '\0', sizeof(incoming));
232memset(question_ptr, '\0', sizeof(question));
233
234
235
236if (!(fin = fopen(infname, "r"))) {
237fatal_error("Cannot openin infname");
238}
239if (!(fout = fopen(outfname, "w"))) {
240fatal_error("Cannot openin outfname");
241}
242for (fgets(incoming_ptr, MAX_STR_LEN, fin);
243 !feof(fin); fgets(incoming_ptr, MAX_STR_LEN, fin)) {
244strip_spaces(incoming_ptr);
245
246if (incoming[0] == '\0') {
247    continue;
248}
249
250sprintf(question_ptr,
251        "Should I restore the image of %s ?", incoming_ptr);
252
253if (ask_me_yes_or_no(question_ptr)) {
254    fprintf(fout, "%s\n", incoming_ptr);
255}
256}
257
258/*** free memory ***********/
259paranoid_free(incoming_ptr);
260incoming_ptr = NULL;
261paranoid_free(question_ptr);
262question_ptr = NULL;
263
264
265paranoid_fclose(fout);
266paranoid_fclose(fin);
267}
268
269/**************************************************************************
270*ASK_ABOUT_THESE_IMAGEDEVS                                               *
271**************************************************************************/
272
273
274
275
276
277
278
279
280/**
281* Extract @c mondo-restore.cfg and @c mountlist.txt from @p ramdisk_fname.
282* @param bkpinfo The backup information structure. @c tmpdir is the only field used.
283* @param ramdisk_fname The filename of the @b compressed ramdisk to look in.
284* @param output_cfg_file Where to put the configuration file extracted.
285* @param output_mountlist_file Where to put the mountlist file extracted.
286* @return 0 for success, nonzero for failure.
287* @ingroup restoreUtilityGroup
288*/
289int
290extract_config_file_from_ramdisk(char *ramdisk_fname,
291                         char *output_cfg_file,
292                         char *output_mountlist_file)
293{
294char *mountpt;
295char *command;
296char *orig_fname;
297int retval = 0;
298
299assert(bkpinfo != NULL);
300malloc_string(mountpt);
301malloc_string(command);
302malloc_string(orig_fname);
303assert_string_is_neither_NULL_nor_zerolength(ramdisk_fname);
304assert_string_is_neither_NULL_nor_zerolength(output_cfg_file);
305assert_string_is_neither_NULL_nor_zerolength(output_mountlist_file);
306sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
307sprintf(command, "mkdir -p %s", mountpt);
308run_program_and_log_output(command, FALSE);
309sprintf(command, "gzip -dc %s > %s/mindi.rd 2> /dev/null",
310    ramdisk_fname, bkpinfo->tmpdir);
311
312run_program_and_log_output(command, FALSE);
313sprintf(command, "umount %s", mountpt);
314
315run_program_and_log_output(command, FALSE);
316
317sprintf(command, "mount -o loop %s/mindi.rd -t ext2 %s",
318    bkpinfo->tmpdir, mountpt);
319
320run_program_and_log_output(command, FALSE);
321
322sprintf(command, "mkdir -p %s/tmp", bkpinfo->tmpdir);
323
324run_program_and_log_output(command, FALSE);
325
326sprintf(command, "cp -f %s/%s %s",  // %s/%s becomes {mountpt}/tmp/m*ndo-restore.cfg
327    mountpt, g_mondo_cfg_file, output_cfg_file);
328run_program_and_log_output(command, FALSE);
329
330sprintf(orig_fname, "%s/%s", mountpt, g_mountlist_fname);
331if (does_file_exist(orig_fname)) {
332sprintf(command, "cp -f %s %s", orig_fname, output_mountlist_file);
333run_program_and_log_output(command, FALSE);
334}
335sprintf(command, "umount %s", mountpt);
336run_program_and_log_output(command, FALSE);
337if (!does_file_exist(output_cfg_file)
338|| (!does_file_exist(output_mountlist_file)
339    && does_file_exist(orig_fname))) {
340log_msg(2, "Failed to extract %s and/or %s from ramdisk",
341        output_cfg_file, output_mountlist_file);
342retval = 1;
343} else {
344retval = 0;
345}
346paranoid_free(mountpt);
347paranoid_free(command);
348paranoid_free(orig_fname);
349return (retval);
350
351}
352
353
354
355
356/**
357* Keep trying to get mondo-restore.cfg from the archive, until the user gives up.
358*/
359void get_cfg_file_from_archive_or_bust()
360{
361while (get_cfg_file_from_archive()) {
362if (!ask_me_yes_or_no
363    ("Failed to find config file/archives. Choose another source?"))
364{
365    fatal_error("Could not find config file/archives. Aborting.");
366}
367interactively_obtain_media_parameters_from_user(FALSE);
368}
369}
370
371
372/**
373* Determine whether @p list_fname contains a line containing @p f.
374* @param f The line to search for.
375* @param list_fname The file to search in.
376* @param preamble Ignore this beginning part of @p f ("" to disable).
377* @return TRUE if it's in the list, FALSE if it's not.
378*/
379bool is_file_in_list(char *f, char *list_fname, char *preamble)
380{
381
382/** needs malloc **/
383char *command;
384char *file;
385char *tmp;
386int res;
387
388malloc_string(command);
389malloc_string(file);
390malloc_string(tmp);
391assert_string_is_neither_NULL_nor_zerolength(f);
392assert_string_is_neither_NULL_nor_zerolength(list_fname);
393assert(preamble != NULL);
394
395if (strncmp(preamble, f, strlen(preamble)) == 0) {
396strcpy(file, f + strlen(preamble));
397} else {
398strcpy(file, f);
399}
400if (file[0] == '/' && file[1] == '/') {
401strcpy(tmp, file);
402strcpy(file, tmp + 1);
403}
404sprintf(tmp,
405    "Checking to see if f=%s, file=%s, is in the list of biggiefiles",
406    f, file);
407log_msg(2, tmp);
408sprintf(command, "grep -E '^%s$' %s", file, list_fname);
409res = run_program_and_log_output(command, FALSE);
410paranoid_free(command);
411paranoid_free(file);
412paranoid_free(tmp);
413if (res) {
414return (FALSE);
415} else {
416return (TRUE);
417}
418}
419
420/**************************************************************************
421*END_IS_FILE_IN_LIST                                                     *
422**************************************************************************/
423
424
425
426/**
427* Set up an ISO backup.
428* @param bkpinfo The backup information structure. Fields used:
429* - @c bkpinfo->backup_media_type
430* - @c bkpinfo->disaster_recovery
431* - @c bkpinfo->isodir
432* @param nuke_me_please If TRUE, we're in nuke mode; if FALSE we're in interactive mode.
433* @return 0 for success, nonzero for failure.
434*/
435int iso_fiddly_bits(bool nuke_me_please)
436{
437char *mount_isodir_command, *tmp, *command;
438int retval = 0, i;
439bool already_mounted = FALSE;
440
441assert(bkpinfo != NULL);
442malloc_string(mount_isodir_command);
443malloc_string(tmp);
444malloc_string(command);
445g_ISO_restore_mode = TRUE;
446read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
447if (bkpinfo->disaster_recovery) {
448/* Patch Conor Daly 26-june-2004
449* Don't let this clobber an existing bkpinfo->isodir */
450if (!bkpinfo->isodir[0]) {
451    strcpy(bkpinfo->isodir, "/tmp/isodir");
452}
453/* End patch */
454sprintf(command, "mkdir -p %s", bkpinfo->isodir);
455run_program_and_log_output(command, 5);
456log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
457}
458
459if (!get_isodir_info
460(g_isodir_device, g_isodir_format, bkpinfo->isodir,
461 nuke_me_please)) {
462return (1);
463}
464paranoid_system("umount " MNT_CDROM " 2> /dev/null");   /* just in case */
465
466if (is_this_device_mounted(g_isodir_device)) {
467log_to_screen("WARNING - isodir is already mounted");
468already_mounted = TRUE;
469} else {
470sprintf(mount_isodir_command, "mount %s", g_isodir_device);
471if (strlen(g_isodir_format) > 1) {
472    sprintf(mount_isodir_command + strlen(mount_isodir_command),
473            " -t %s", g_isodir_format);
474}
475strcat(mount_isodir_command, " -o ro ");
476strcat(mount_isodir_command, bkpinfo->isodir);
477run_program_and_log_output("df -m", FALSE);
478sprintf(tmp,
479        "The 'mount' command is '%s'. PLEASE report this command to be if you have problems, ok?",
480        mount_isodir_command);
481log_msg(1, tmp);
482if (run_program_and_log_output(mount_isodir_command, FALSE)) {
483    popup_and_OK
484        ("Cannot mount the device where the ISO files are stored.");
485    return (1);
486}
487log_to_screen
488    ("I have mounted the device where the ISO files are stored.");
489}
490if (!IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
491    mount_media();
492}
493i = what_number_cd_is_this();   /* has the side-effect of calling mount_media() */
494sprintf(tmp, "%s #%d has been mounted via loopback mount",
495    media_descriptor_string(bkpinfo->backup_media_type), i);
496log_msg(1, tmp);
497if (i < 0) {
498popup_and_OK
499    ("Cannot find ISO images in the directory you specified.");
500retval = 1;
501}
502log_msg(2, "%ld: bkpinfo->isodir is now %s", __LINE__,
503    bkpinfo->isodir);
504paranoid_free(mount_isodir_command);
505paranoid_free(tmp);
506paranoid_free(command);
507return (retval);
508}
509
510
511
512
513/**
514* Kill all Petris processes.
515*/
516void kill_petris(void)
517{
518char *command;
519malloc_string(command);
520sprintf(command,
521    "kill `ps 2> /dev/null | grep petris 2> /dev/null | grep -v grep | cut -d' ' -f2` 2> /dev/null");
522paranoid_system(command);
523paranoid_free(command);
524}
525
526/**************************************************************************
527*END_KILL_PETRIS                                                         *
528**************************************************************************/
529
530
531/**
532 * Mount @p device at @p mpt as @p format.
533 * @param device The device (/dev entry) to mount.
534 * @param mpt The directory to mount it on.
535 * @param format The filesystem type of @p device.
536 * @param writeable If TRUE, mount read-write; if FALSE, mount read-only.
537 * @return 0 for success, nonzero for failure.
538 */
539int mount_device(char *device, char *mpt, char *format, bool writeable)
540{
541int res = 0;
542
543/** malloc **/
544char *tmp, *command, *mountdir, *mountpoint, *additional_parameters;
545
546assert_string_is_neither_NULL_nor_zerolength(device);
547assert_string_is_neither_NULL_nor_zerolength(mpt);
548assert(format != NULL);
549malloc_string(tmp);
550malloc_string(command);
551malloc_string(mountdir);
552malloc_string(mountpoint);
553malloc_string(additional_parameters);
554
555    if (!strcmp(mpt, "/1")) {
556        strcpy(mountpoint, "/");
557        log_msg(3, "Mommm! SME is being a dildo!");
558    } else {
559        strcpy(mountpoint, mpt);
560    }
561
562    if (!strcmp(mountpoint, "lvm")) {
563        return (0);
564    }
565    if (!strcmp(mountpoint, "image")) {
566        return (0);
567    }
568    sprintf(tmp, "Mounting device %s   ", device);
569    log_msg(1, tmp);
570    if (writeable) {
571        strcpy(additional_parameters, "-o rw");
572    } else {
573        strcpy(additional_parameters, "-o ro");
574    }
575    if (find_home_of_exe("setfattr")) {
576        strcat(additional_parameters, ",user_xattr");
577    }
578    if (find_home_of_exe("setfacl")) {
579        strcat(additional_parameters, ",acl");
580    }
581
582    if (!strcmp(mountpoint, "swap")) {
583        sprintf(command, "swapon %s", device);
584    } else {
585        if (!strcmp(mountpoint, "/")) {
586            strcpy(mountdir, MNT_RESTORING);
587        } else {
588            sprintf(mountdir, "%s%s", MNT_RESTORING, mountpoint);
589        }
590        sprintf(command, "mkdir -p %s", mountdir);
591        run_program_and_log_output(command, FALSE);
592        sprintf(command, "mount -t %s %s %s %s 2>> %s", format, device,
593                additional_parameters, mountdir, MONDO_LOGFILE);
594        log_msg(2, "command='%s'", command);
595    }
596
597    res = run_program_and_log_output(command, TRUE);
598    if (res && (strstr(command, "xattr") || strstr(command, "acl"))) {
599        log_msg(1, "Re-trying without the fancy extra parameters");
600        sprintf(command, "mount -t %s %s %s 2>> %s", format, device,
601            mountdir, MONDO_LOGFILE);
602        res = run_program_and_log_output(command, TRUE);
603    }
604    if (res) {
605        log_msg(1, "Unable to mount device %s (type %s) at %s", device,
606                format, mountdir);
607        log_msg(1, "command was '%s'", command);
608        if (!strcmp(mountpoint, "swap")) {
609            log_to_screen(tmp);
610        } else {
611            log_msg(2, "Retrying w/o the '-t' switch");
612            sprintf(command, "mount %s %s 2>> %s", device, mountdir,
613                MONDO_LOGFILE);
614            log_msg(2, "2nd command = '%s'", command);
615            res = run_program_and_log_output(command, TRUE);
616            if (res == 0) {
617                log_msg(1,
618                    "That's OK. I called mount w/o a filesystem type and it worked fine in the end.");
619            } else {
620                log_to_screen(tmp);
621            }
622        }
623    }
624
625    if (res && !strcmp(mountpoint, "swap")) {
626        log_msg(2, "That's ok. It's just a swap partition.");
627        log_msg(2, "Non-fatal error. Returning 0.");
628        res = 0;
629    }
630
631paranoid_free(tmp);
632paranoid_free(command);
633paranoid_free(mountdir);
634paranoid_free(mountpoint);
635paranoid_free(additional_parameters);
636
637    return (res);
638}
639/**************************************************************************
640 *END_MOUNT_DEVICE                                                        *
641**************************************************************************/
642
643
644/**
645 * Mount all devices in @p p_external_copy_of_mountlist on @p MNT_RESTORING.
646 * @param p_external_copy_of_mountlist The mountlist containing devices to be mounted.
647 * @param writeable If TRUE, then mount read-write; if FALSE mount read-only.
648 * @return The number of errors encountered (0 for success).
649 */
650int mount_all_devices(struct mountlist_itself
651                      *p_external_copy_of_mountlist, bool writeable)
652{
653int retval = 0, lino, res;
654char *tmp, *these_failed, *format;
655    struct mountlist_itself *mountlist = NULL;
656
657malloc_string(tmp);
658malloc_string(format);
659malloc_string(these_failed);
660/** menset **/
661these_failed[0] = '\0';
662
663assert(p_external_copy_of_mountlist != NULL);
664mountlist = malloc(sizeof(struct mountlist_itself));
665memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
666   sizeof(struct mountlist_itself));
667    sort_mountlist_by_mountpoint(mountlist, 0);
668
669
670    mvaddstr_and_log_it(g_currentY, 0, "Mounting devices         ");
671    open_progress_form("Mounting devices",
672               "I am now mounting all the drives.",
673               "This should not take long.",
674               "", mountlist->entries);
675
676    for (lino = 0; lino < mountlist->entries; lino++) {
677        if (!strcmp(mountlist->el[lino].device, "/proc")) {
678            log_msg(1,
679                "Again with the /proc - why is this in your mountlist?");
680        } else if (is_this_device_mounted(mountlist->el[lino].device)) {
681            sprintf(tmp, "%s is already mounted",
682                mountlist->el[lino].device);
683            log_to_screen(tmp);
684        } else if (strcmp(mountlist->el[lino].mountpoint, "none")
685           && strcmp(mountlist->el[lino].mountpoint, "lvm")
686           && strcmp(mountlist->el[lino].mountpoint, "raid")
687           && strcmp(mountlist->el[lino].mountpoint, "image")) {
688            sprintf(tmp, "Mounting %s", mountlist->el[lino].device);
689            update_progress_form(tmp);
690            strcpy(format, mountlist->el[lino].format);
691            /* BERLIOS: removed as it doen't make sens to not mount ext3 partitions as ext3
692            if (!strcmp(format, "ext3")) {
693                strcpy(format, "ext2");
694            }
695            */
696            res = mount_device(mountlist->el[lino].device,
697                       mountlist->el[lino].mountpoint,
698                       format, writeable);
699            retval += res;
700            if (res) {
701                strcat(these_failed, mountlist->el[lino].device);
702                strcat(these_failed, " ");
703            }
704        }
705        g_current_progress++;
706    }
707    close_progress_form();
708    if (retval) {
709        if (g_partition_table_locked_up > 0) {
710            log_to_screen
711                ("fdisk's ictol() call to refresh its copy of the partition table causes the kernel to");
712            log_to_screen
713                ("lock up the partition table. You might have to reboot and use Interactive Mode to");
714            log_to_screen
715                ("format and restore *without* partitioning first. Sorry for the inconvenience.");
716        }
717        sprintf(tmp, "Could not mount device(s) %s- shall I abort?",
718                these_failed);
719
720        if (!ask_me_yes_or_no(tmp)) {
721            retval = 0;
722            log_to_screen
723                ("Continuing, although some device(s) failed to be mounted");
724            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
725        } else {
726            mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
727            log_to_screen
728        ("Unable to mount some or all of your partitions.");
729        }
730    } else {
731        log_to_screen("All partitions were mounted OK.");
732        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
733    }
734    run_program_and_log_output("df -m", 3);
735    paranoid_free(mountlist);
736    paranoid_free(tmp);
737    paranoid_free(format);
738    paranoid_free(these_failed);
739    return (retval);
740}
741/**************************************************************************
742*END_MOUNT_ALL_DEVICES                                                   *
743**************************************************************************/
744
745
746/**
747* Mount the CD-ROM or USB device at /mnt/cdrom.
748* @param bkpinfo The backup information structure. Fields used:
749* - @c bkpinfo->backup_media_type
750* - @c bkpinfo->disaster_recovery
751* - @c bkpinfo->isodir
752* - @c bkpinfo->media_device
753* @return 0 for success, nonzero for failure.
754*/
755int mount_media()
756{
757char *mount_cmd;
758int i, res;
759#ifdef __FreeBSD__
760char mdd[32];
761char *mddev = mdd;
762#endif
763
764malloc_string(mount_cmd);
765assert(bkpinfo != NULL);
766
767    if (bkpinfo->backup_media_type == tape
768        || bkpinfo->backup_media_type == udev) {
769        log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
770        paranoid_free(mount_cmd);
771        return 0;
772    }
773
774    if (!run_program_and_log_output("mount | grep -F " MNT_CDROM, FALSE)) {
775        log_msg(2, "mount_media() - media already mounted. Fair enough.");
776        paranoid_free(mount_cmd);
777        return (0);
778    }
779
780    if (bkpinfo->backup_media_type == nfs) {
781        log_msg(2, "Mounting for NFS thingy");
782        log_msg(2, "isodir = %s", bkpinfo->isodir);
783        if ((!bkpinfo->isodir[0] || !strcmp(bkpinfo->isodir, "/"))
784            && am_I_in_disaster_recovery_mode()) {
785            strcpy(bkpinfo->isodir, "/tmp/isodir");
786            log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
787        }
788#ifdef __FreeBSD__
789        sprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
790            bkpinfo->nfs_remote_dir, bkpinfo->prefix, g_current_media_number);
791        mddev = make_vn(mount_cmd);
792        sprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
793#else
794        sprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
795            bkpinfo->isodir, bkpinfo->nfs_remote_dir,
796            bkpinfo->prefix, g_current_media_number, MNT_CDROM);
797#endif
798
799    } else if (bkpinfo->backup_media_type == iso) {
800#ifdef __FreeBSD__
801        sprintf(mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
802            bkpinfo->prefix, g_current_media_number);
803        mddev = make_vn(mount_cmd);
804        sprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
805#else
806        sprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
807            bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
808#endif
809    } else if (bkpinfo->backup_media_type == usb) {
810        sprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, MNT_CDROM);
811    } else if (strstr(bkpinfo->media_device, "/dev/")) {
812#ifdef __FreeBSD__
813        sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
814        MNT_CDROM);
815#else
816        sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
817        bkpinfo->media_device, MNT_CDROM);
818#endif
819    } else {
820        if (bkpinfo->disaster_recovery
821            && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
822            strcpy(bkpinfo->media_device,
823                last_line_of_file("/tmp/CDROM-LIVES-HERE"));
824        } else {
825            find_cdrom_device(bkpinfo->media_device, TRUE);
826        }
827
828#ifdef __FreeBSD__
829    sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
830        MNT_CDROM);
831#else
832    sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
833        bkpinfo->media_device, MNT_CDROM);
834#endif
835    }
836
837    log_msg(2, "(mount_media) --- command = %s", mount_cmd);
838    for (i = 0; i < 2; i++) {
839        res = run_program_and_log_output(mount_cmd, FALSE);
840        if (!res) {
841            break;
842        } else {
843            log_msg(2, "Failed to mount device.");
844            sleep(5);
845            run_program_and_log_output("sync", FALSE);
846        }
847    }
848
849    if (res) {
850        log_msg(2, "Failed, despite %d attempts", i);
851    } else {
852        log_msg(2, "Mounted media drive OK");
853    }
854    paranoid_free(mount_cmd);
855    return (res);
856}
857/**************************************************************************
858*END_MOUNT_CDROM                                                         *
859**************************************************************************/
860
861
862
863/**
864* Fix some miscellaneous things in the filesystem so the system will come
865* up correctly on the first boot.
866*/
867void protect_against_braindead_sysadmins()
868{
869run_program_and_log_output("touch " MNT_RESTORING "/var/log/pacct",
870                       FALSE);
871run_program_and_log_output("touch " MNT_RESTORING "/var/account/pacct",
872                       FALSE);
873if (run_program_and_log_output("ls " MNT_RESTORING " /tmp", FALSE)) {
874run_program_and_log_output("chmod 1777 " MNT_RESTORING "/tmp",
875                           FALSE);
876}
877run_program_and_log_output("mkdir -p " MNT_RESTORING
878                       "/var/run/console", FALSE);
879run_program_and_log_output("chmod 777 " MNT_RESTORING "/dev/null",
880                       FALSE);
881run_program_and_log_output("cd " MNT_RESTORING
882                       "; for i in `ls home/`; do echo \"Moving $i's spurious files to $i/.disabled\"; mkdir \"$i\"/.disabled ; mv -f \"$i\"/.DCOP* \"$i\"/.MCOP* \"$i\"/.*authority \"$i\"/.kde/tmp* \"$i\"/.kde/socket* \"$i\"/.disabled/ ; done",
883                       TRUE);
884run_program_and_log_output("rm -f " MNT_RESTORING "/var/run/*.pid",
885                       TRUE);
886run_program_and_log_output("rm -f " MNT_RESTORING "/var/lock/subsys/*",
887                       TRUE);
888}
889
890/**************************************************************************
891*END_PROTECT_AGAINST_BRAINDEAD_SYSADMINS                                 *
892**************************************************************************/
893
894
895
896
897/**
898* Fill out @p bkpinfo based on @p cfg_file.
899* @param cfg_file The mondo-restore.cfg file to read into @p bkpinfo.
900* @param bkpinfo The backup information structure to fill out with information
901* from @p cfg_file.
902* @return 0 for success, nonzero for failure.
903*/
904int read_cfg_file_into_bkpinfo(char *cfgf)
905{
906/** add mallocs **/
907char *value = NULL;
908char *tmp = NULL;
909char *envtmp1 = NULL;
910char *envtmp2 = NULL;
911char *command = NULL;
912char *iso_mnt = NULL;
913char *iso_path = NULL;
914char *old_isodir = NULL;
915char cfg_file[100];
916t_bkptype media_specified_by_user;
917
918malloc_string(command);
919malloc_string(iso_mnt);
920malloc_string(iso_path);
921malloc_string(old_isodir);
922malloc_string(value);
923malloc_string(tmp);
924//  assert_string_is_neither_NULL_nor_zerolength(cfg_file);
925assert(bkpinfo != NULL);
926
927if (!cfgf) {
928strcpy(cfg_file, g_mondo_cfg_file);
929} else {
930strcpy(cfg_file, cfgf);
931}
932
933media_specified_by_user = bkpinfo->backup_media_type;   // or 'none', if not specified
934
935if (0 == read_cfg_var(cfg_file, "backup-media-type", value)) {
936if (!strcmp(value, "cdstream")) {
937    bkpinfo->backup_media_type = cdstream;
938} else if (!strcmp(value, "cdr")) {
939    bkpinfo->backup_media_type = cdr;
940} else if (!strcmp(value, "cdrw")) {
941    bkpinfo->backup_media_type = cdrw;
942} else if (!strcmp(value, "dvd")) {
943    bkpinfo->backup_media_type = dvd;
944} else if (!strcmp(value, "usb")) {
945    bkpinfo->backup_media_type = usb;
946    bkpinfo->please_dont_eject = TRUE;
947} else if (!strcmp(value, "iso")) {
948/*
949if (am_I_in_disaster_recovery_mode()
950&& !run_program_and_log_output("mount /dev/cdrom "MNT_CDROM, 1)
951&& does_file_exist(MNT_CDROM"/archives/filelist.0"))
952*/
953
954// Patch by Conor Daly - 2004/07/12
955    bkpinfo->backup_media_type = iso;
956    if (am_I_in_disaster_recovery_mode()) {
957        /* Check to see if CD is already mounted before mounting it... */
958        if (!is_this_device_mounted("/dev/cdrom")) {
959            log_msg(2,
960                    "NB: CDROM device not mounted, mounting...");
961            run_program_and_log_output("mount /dev/cdrom "
962                                       MNT_CDROM, 1);
963        }
964        if (does_file_exist(MNT_CDROM "/archives/filelist.0")) {
965            bkpinfo->backup_media_type = cdr;
966            run_program_and_log_output("umount " MNT_CDROM, 1);
967            log_it
968                ("Re-jigging configuration AGAIN. CD-R, not ISO.");
969        }
970    }
971    if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
972            strcpy(bkpinfo->prefix,value);
973    } else {
974            strcpy(bkpinfo->prefix,STD_PREFIX);
975    }
976} else if (!strcmp(value, "nfs")) {
977    bkpinfo->backup_media_type = nfs;
978    if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
979            strcpy(bkpinfo->prefix,value);
980    } else {
981            strcpy(bkpinfo->prefix,STD_PREFIX);
982    }
983    if (strstr(call_program_and_get_last_line_of_output
984       ("cat /proc/cmdline"), "pxe")) {
985        /* We need to override prefix value in PXE mode as it's
986        * already done in start-nfs */
987        envtmp1 = getenv("imgname");
988        if (envtmp1 == NULL) {
989            fatal_error("no imgname variable in environment");
990        }
991        strcpy(bkpinfo->prefix,envtmp1);
992    }
993
994} else if (!strcmp(value, "tape")) {
995    bkpinfo->backup_media_type = tape;
996} else if (!strcmp(value, "udev")) {
997    bkpinfo->backup_media_type = udev;
998} else {
999    fatal_error("UNKNOWN bkp-media-type");
1000}
1001} else {
1002fatal_error("backup-media-type not specified!");
1003}
1004if (bkpinfo->disaster_recovery) {
1005    if (bkpinfo->backup_media_type == cdstream) {
1006        sprintf(bkpinfo->media_device, "/dev/cdrom");
1007//          bkpinfo->media_size[0] = -1;
1008        bkpinfo->media_size[0] = 1999 * 1024;
1009        bkpinfo->media_size[1] = 650;   /* good guess */
1010    } else if (bkpinfo->backup_media_type == usb) {
1011        if (read_cfg_var(cfg_file, "usb-dev", value)) {
1012            fatal_error("Cannot get USB device name from cfg file");
1013        }
1014        sprintf(bkpinfo->media_device, "%s1", value);
1015        sprintf(tmp, "Backup medium is USB --- dev=%s", bkpinfo->media_device);
1016        log_msg(2, tmp);
1017    } else if (bkpinfo->backup_media_type == tape
1018            || bkpinfo->backup_media_type == udev) {
1019        if (read_cfg_var(cfg_file, "media-dev", value)) {
1020            fatal_error("Cannot get tape device name from cfg file");
1021        }
1022        strcpy(bkpinfo->media_device, value);
1023        read_cfg_var(cfg_file, "media-size", value);
1024        bkpinfo->media_size[1] = atol(value);
1025        sprintf(tmp, "Backup medium is TAPE --- dev=%s",
1026                bkpinfo->media_device);
1027        log_msg(2, tmp);
1028    } else {
1029        strcpy(bkpinfo->media_device, "/dev/cdrom");    /* we don't really need this var */
1030        bkpinfo->media_size[0] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
1031        bkpinfo->media_size[1] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
1032        log_msg(2, "Backup medium is CD-R[W]");
1033    }
1034} else {
1035    log_msg(2,
1036        "Not in Disaster Recovery Mode. No need to derive device name from config file.");
1037}
1038
1039read_cfg_var(cfg_file, "use-star", value);
1040if (strstr(value, "yes")) {
1041bkpinfo->use_star = TRUE;
1042log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
1043}
1044
1045read_cfg_var(cfg_file, "acl", value);
1046if (strstr(value, "TRUE")) {
1047asprintf(&g_getfacl,"setfacl");
1048log_msg(1, "We will restore ACLs");
1049if (! find_home_of_exe("setfacl")) {
1050    log_msg(1, "Unable to restore ACLs as no setfacl found");
1051}
1052}
1053read_cfg_var(cfg_file, "xattr", value);
1054if (strstr(value, "TRUE")) {
1055asprintf(&g_getfattr,"setfattr");
1056log_msg(1, "We will restore XATTRs");
1057if (! find_home_of_exe("setfattr")) {
1058    log_msg(1, "Unable to restore XATTRs as no setfattr found");
1059}
1060}
1061
1062if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
1063bkpinfo->internal_tape_block_size = atol(value);
1064log_msg(1, "Internal tape block size has been custom-set to %ld",
1065        bkpinfo->internal_tape_block_size);
1066} else {
1067bkpinfo->internal_tape_block_size =
1068    DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
1069log_msg(1, "Internal tape block size = default (%ld)",
1070        DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
1071}
1072
1073read_cfg_var(cfg_file, "use-lzo", value);
1074if (strstr(value, "yes")) {
1075bkpinfo->use_lzo = TRUE;
1076bkpinfo->use_gzip = FALSE;
1077strcpy(bkpinfo->zip_exe, "lzop");
1078strcpy(bkpinfo->zip_suffix, "lzo");
1079} else {
1080read_cfg_var(cfg_file, "use-gzip", value);
1081if (strstr(value, "yes")) {
1082    bkpinfo->use_lzo = FALSE;
1083    bkpinfo->use_gzip = TRUE;
1084    strcpy(bkpinfo->zip_exe, "gzip");
1085    strcpy(bkpinfo->zip_suffix, "gz");
1086} else {
1087    read_cfg_var(cfg_file, "use-comp", value);
1088    if (strstr(value, "yes")) {
1089        bkpinfo->use_lzo = FALSE;
1090        bkpinfo->use_gzip = FALSE;
1091        strcpy(bkpinfo->zip_exe, "bzip2");
1092        strcpy(bkpinfo->zip_suffix, "bz2");
1093    } else {
1094        bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
1095    }
1096}
1097}
1098
1099value[0] = '\0';
1100read_cfg_var(cfg_file, "differential", value);
1101if (!strcmp(value, "yes") || !strcmp(value, "1")) {
1102bkpinfo->differential = TRUE;
1103}
1104log_msg(2, "differential var = '%s'", value);
1105if (bkpinfo->differential) {
1106log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
1107} else {
1108log_msg(2, "This is a regular (full) backup");
1109}
1110
1111read_cfg_var(g_mondo_cfg_file, "please-dont-eject", tmp);
1112if (tmp[0]
1113||
1114strstr(call_program_and_get_last_line_of_output
1115       ("cat /proc/cmdline"), "donteject")) {
1116bkpinfo->please_dont_eject = TRUE;
1117log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
1118}
1119
1120if (bkpinfo->backup_media_type == nfs) {
1121    if (!cfgf) {
1122        log_msg(2, "nfs_mount remains %s", bkpinfo->nfs_mount);
1123        log_msg(2, "nfs_remote_dir remains %s",
1124                bkpinfo->nfs_remote_dir);
1125        log_msg(2,
1126                "...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
1127    } else {
1128        read_cfg_var(g_mondo_cfg_file, "nfs-server-mount",
1129                    bkpinfo->nfs_mount);
1130        read_cfg_var(g_mondo_cfg_file, "nfs-server-path",
1131                    bkpinfo->nfs_remote_dir);
1132        log_msg(2, "nfs_mount is %s", bkpinfo->nfs_mount);
1133        log_msg(2, "nfs_remote_dir is %s", bkpinfo->nfs_remote_dir);
1134    }
1135    if (strstr(call_program_and_get_last_line_of_output
1136        ("cat /proc/cmdline"), "pxe")) {
1137        /* We need to override values in PXE mode as it's
1138        * already done in start-nfs */
1139        envtmp1 = getenv("nfsmount");
1140        if (envtmp1 == NULL) {
1141            fatal_error("no nfsmount variable in environment");
1142        }
1143        envtmp2 = getenv("dirimg");
1144        if (envtmp2 == NULL) {
1145            fatal_error("no dirimg variable in environment");
1146        }
1147        strcpy(bkpinfo->nfs_mount,envtmp1);
1148        strcpy(bkpinfo->nfs_remote_dir,envtmp2);
1149    }
1150} else if (bkpinfo->backup_media_type == iso) {
1151    /* Patch by Conor Daly 23-june-2004
1152    * to correctly mount iso-dev and set a sensible
1153    * isodir in disaster recovery mode
1154    */
1155    strcpy(old_isodir, bkpinfo->isodir);
1156    read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
1157    read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
1158    sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
1159    if (!bkpinfo->isodir[0]) {
1160        strcpy(bkpinfo->isodir, old_isodir);
1161    }
1162    if (!bkpinfo->disaster_recovery) {
1163        if (strcmp(old_isodir, bkpinfo->isodir)) {
1164            log_it
1165                ("user nominated isodir differs from archive, keeping user's choice: %s %s\n",
1166                old_isodir, bkpinfo->isodir);
1167            strcpy(bkpinfo->isodir, old_isodir);
1168        }
1169    }
1170    read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
1171    log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir,
1172            g_isodir_device);
1173    if (bkpinfo->disaster_recovery) {
1174        if (is_this_device_mounted(g_isodir_device)) {
1175            log_msg(2, "NB: isodir is already mounted");
1176            /* Find out where it's mounted */
1177            sprintf(command,
1178                    "mount | grep -E '^%s' | tail -n1 | cut -d' ' -f3",
1179                    g_isodir_device);
1180            log_it("command = %s", command);
1181            log_it("res of it = %s",
1182                call_program_and_get_last_line_of_output(command));
1183            sprintf(iso_mnt, "%s",
1184                    call_program_and_get_last_line_of_output(command));
1185        } else {
1186            sprintf(iso_mnt, "/tmp/isodir");
1187            sprintf(tmp, "mkdir -p %s", iso_mnt);
1188            run_program_and_log_output(tmp, 5);
1189            sprintf(tmp, "mount %s %s", g_isodir_device, iso_mnt);
1190            if (run_program_and_log_output(tmp, 3)) {
1191                log_msg(1,
1192                        "Unable to mount isodir. Perhaps this is really a CD backup?");
1193                bkpinfo->backup_media_type = cdr;
1194                strcpy(bkpinfo->media_device, "/dev/cdrom");    /* superfluous */
1195                bkpinfo->isodir[0] = iso_mnt[0] = iso_path[0] = '\0';
1196                if (mount_media()) {
1197                    fatal_error
1198                        ("Unable to mount isodir. Failed to mount CD-ROM as well.");
1199                } else {
1200                    log_msg(1,
1201                            "You backed up to disk, then burned some CDs.");
1202                }
1203            }
1204        }
1205        /* bkpinfo->isodir should now be the true path to prefix-1.iso etc... */
1206        if (bkpinfo->backup_media_type == iso) {
1207            sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
1208        }
1209    }
1210}
1211
1212if (media_specified_by_user != none) {
1213    if (g_restoring_live_from_cd) {
1214        if (bkpinfo->backup_media_type != media_specified_by_user) {
1215            log_msg(2,
1216                    "bkpinfo->backup_media_type != media_specified_by_user, so I'd better ask :)");
1217            interactively_obtain_media_parameters_from_user(FALSE);
1218            media_specified_by_user = bkpinfo->backup_media_type;
1219            get_cfg_file_from_archive();
1220    /*
1221        if (media_specified_by_user != cdr && media_specified_by_user == cdrw)
1222            { g_restoring_live_from_cd = FALSE; }
1223    */
1224        }
1225    }
1226    bkpinfo->backup_media_type = media_specified_by_user;
1227}
1228g_backup_media_type = bkpinfo->backup_media_type;
1229paranoid_free(value);
1230paranoid_free(tmp);
1231paranoid_free(command);
1232paranoid_free(iso_mnt);
1233paranoid_free(iso_path);
1234paranoid_free(old_isodir);
1235return (0);
1236
1237}
1238
1239/**************************************************************************
1240*END_READ_CFG_FILE_INTO_BKPINFO                                          *
1241**************************************************************************/
1242
1243
1244
1245
1246/**
1247 * Allow the user to edit the filelist and biggielist.
1248 * The filelist is unlinked after it is read.
1249 * @param bkpinfo The backup information structure. Fields used:
1250 * - @c bkpinfo->backup_media_type
1251 * - @c bkpinfo->isodir
1252 * - @c bkpinfo->media_device
1253 * - @c bkpinfo->tmpdir
1254 * @return The filelist structure containing the information read from disk.
1255 */
1256struct
1257s_node *process_filelist_and_biggielist()
1258{
1259struct s_node *filelist;
1260
1261/** add mallocs**/
1262char *command;
1263char *tmp;
1264int res = 0;
1265pid_t pid;
1266
1267assert(bkpinfo != NULL);
1268malloc_string(command);
1269malloc_string(tmp);
1270
1271if (does_file_exist(g_filelist_full)
1272&& does_file_exist(g_biggielist_txt)) {
1273log_msg(1, "%s exists", g_filelist_full);
1274log_msg(1, "%s exists", g_biggielist_txt);
1275log_msg(2,
1276        "Filelist and biggielist already recovered from media. Yay!");
1277} else {
1278getcwd(tmp, MAX_STR_LEN);
1279chdir(bkpinfo->tmpdir);
1280log_msg(1, "chdir(%s)", bkpinfo->tmpdir);
1281log_to_screen("Extracting filelist and biggielist from media...");
1282unlink("/tmp/filelist.full");
1283unlink("/" FILELIST_FULL_STUB);
1284unlink("/tmp/i-want-my-lvm");
1285if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1286    sprintf(command,
1287            "tar -b %ld -zxf %s %s %s %s %s %s",
1288            bkpinfo->internal_tape_block_size,
1289            bkpinfo->media_device,
1290            MOUNTLIST_FNAME_STUB,
1291            BIGGIELIST_TXT_STUB,
1292            FILELIST_FULL_STUB,
1293            "tmp/i-want-my-lvm", MONDO_CFG_FILE_STUB);
1294    log_msg(1, "tarcommand = %s", command);
1295    run_program_and_log_output(command, 1);
1296} else {
1297    log_msg(2,
1298            "Calling insist_on_this_cd_number; bkpinfo->isodir=%s",
1299            bkpinfo->isodir);
1300    insist_on_this_cd_number(1);
1301    log_msg(2, "Back from iotcn");
1302    run_program_and_log_output("mount", 1);
1303    sprintf(command,
1304            "tar -zxf %s/images/all.tar.gz %s %s %s %s %s",
1305            MNT_CDROM,
1306            MOUNTLIST_FNAME_STUB,
1307            BIGGIELIST_TXT_STUB,
1308            FILELIST_FULL_STUB,
1309            "tmp/i-want-my-lvm", MONDO_CFG_FILE_STUB);
1310
1311    log_msg(1, "tarcommand = %s", command);
1312    run_program_and_log_output(command, 1);
1313//    popup_and_OK("Press ENTER to continue");
1314    if (!does_file_exist(BIGGIELIST_TXT_STUB)) {
1315        fatal_error
1316            ("all.tar.gz did not include tmp/biggielist.txt");
1317    }
1318    if (!does_file_exist(FILELIST_FULL_STUB)) {
1319        fatal_error
1320            ("all.tar.gz did not include tmp/filelist.full.gz");
1321    }
1322}
1323sprintf(command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
1324        g_mondo_cfg_file);
1325run_program_and_log_output(command, FALSE);
1326
1327sprintf(command, "cp -f %s/%s %s", bkpinfo->tmpdir,
1328        BIGGIELIST_TXT_STUB, g_biggielist_txt);
1329log_msg(1, "command = %s", command);
1330paranoid_system(command);
1331sprintf(command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
1332        FILELIST_FULL_STUB, g_filelist_full);
1333log_msg(1, "command = %s", command);
1334paranoid_system(command);
1335}
1336
1337if (am_I_in_disaster_recovery_mode()
1338&&
1339ask_me_yes_or_no("Do you want to retrieve the mountlist as well?"))
1340{
1341//      sprintf(command, "cp -f tmp/mountlist.txt /tmp");
1342sprintf(command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
1343        bkpinfo->tmpdir);
1344paranoid_system(command);
1345}
1346
1347chdir(tmp);
1348
1349if (!does_file_exist(g_biggielist_txt)) {
1350log_msg(1, "Warning - %s not found", g_biggielist_txt);
1351}
1352if (!does_file_exist(g_filelist_full)) {
1353log_msg(1, "Warning - %s does not exist", g_filelist_full);
1354}
1355//  popup_and_OK("Wonderful.");
1356
1357log_msg(2, "Forking");
1358pid = fork();
1359switch (pid) {
1360case -1:
1361fatal_error("Forking error");
1362break;
1363
1364case 0:
1365log_to_screen("Pre-processing filelist");
1366if (!does_file_exist(g_biggielist_txt)) {
1367            sprintf(command, "echo -n > %s", g_biggielist_txt);
1368            paranoid_system(command);
1369        }
1370        sprintf(command, "grep -E '^/dev/.*' %s > %s",
1371                g_biggielist_txt, g_filelist_imagedevs);
1372        paranoid_system(command);
1373        exit(0);
1374        break;
1375
1376    default:
1377        open_evalcall_form("Pre-processing filelist");
1378        while (!waitpid(pid, (int *) 0, WNOHANG)) {
1379            usleep(100000);
1380            update_evalcall_form(0);
1381        }
1382    }
1383    close_evalcall_form();
1384
1385    log_msg(3, "loading filelist");
1386    filelist = load_filelist(g_filelist_full);
1387    log_msg(3, "deleting original filelist");
1388    unlink(g_filelist_full);
1389    if (g_text_mode) {
1390        printf("Restore which directory? --> ");
1391        fgets(tmp, sizeof(tmp), stdin);
1392        toggle_path_selection(filelist, tmp, TRUE);
1393        if (strlen(tmp) == 0) {
1394            res = 1;
1395        } else {
1396            res = 0;
1397        }
1398    } else {
1399        res = edit_filelist(filelist);
1400    }
1401    if (res) {
1402        log_msg(2, "User hit 'cancel'. Freeing filelist and aborting.");
1403        free_filelist(filelist);
1404        return (NULL);
1405    }
1406    ask_about_these_imagedevs(g_filelist_imagedevs, g_imagedevs_restthese);
1407    close_evalcall_form();
1408
1409    // NB: It's not necessary to add g_biggielist_txt to the filelist.full
1410    // file. The filelist.full file already contains the filename of EVERY
1411    // file backed up - regular and biggie files.
1412
1413    // However, we do want to make sure the imagedevs selected by the user
1414    // are flagged for restoring.
1415    if (length_of_file(g_imagedevs_restthese) > 2) {
1416        add_list_of_files_to_filelist(filelist, g_imagedevs_restthese,
1417                                      TRUE);
1418    }
1419
1420    paranoid_free(command);
1421    paranoid_free(tmp);
1422    return (filelist);
1423}
1424
1425/**************************************************************************
1426 *END_ PROCESS_FILELIST_AND_BIGGIELIST                                    *
1427 **************************************************************************/
1428
1429
1430
1431
1432/**
1433 * Make a backup copy of <tt>path_root</tt>/<tt>filename</tt>.
1434 * The backup filename is the filename of the original with ".pristine" added.
1435 * @param path_root The place where the filesystem is mounted (e.g. MNT_RESTORING).
1436 * @param filename The filename (absolute path) within @p path_root.
1437 * @return 0 for success, nonzero for failure.
1438 */
1439int backup_crucial_file(char *path_root, char *filename)
1440{
1441    char *tmp;
1442    char *command;
1443    int res;
1444
1445    malloc_string(tmp);
1446    malloc_string(command);
1447    assert(path_root != NULL);
1448    assert_string_is_neither_NULL_nor_zerolength(filename);
1449
1450    sprintf(tmp, "%s/%s", path_root, filename);
1451    sprintf(command, "cp -f %s %s.pristine", tmp, tmp);
1452
1453    res = run_program_and_log_output(command, 5);
1454    paranoid_free(tmp);
1455    paranoid_free(command);
1456    return (res);
1457}
1458
1459
1460/**
1461 * Install the user's boot loader in the MBR.
1462 * Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
1463 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1464 * @return 0 for success, nonzero for failure.
1465 */
1466int run_boot_loader(bool offer_to_hack_scripts)
1467{
1468    int res;
1469    int retval = 0;
1470
1471  /** malloc *******/
1472    char *device;
1473    char *tmp;
1474    char *name;
1475
1476    malloc_string(device);
1477    malloc_string(tmp);
1478    malloc_string(name);
1479    backup_crucial_file(MNT_RESTORING, "/etc/fstab");
1480    backup_crucial_file(MNT_RESTORING, "/etc/grub.conf");
1481    backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
1482    backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
1483    read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
1484    read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
1485    sprintf(tmp, "run_boot_loader: device='%s', name='%s'", device, name);
1486    log_msg(2, tmp);
1487    system("sync");
1488    if (!strcmp(name, "LILO")) {
1489        res = run_lilo(offer_to_hack_scripts);
1490    } else if (!strcmp(name, "ELILO")) {
1491        res = run_elilo(offer_to_hack_scripts);
1492    } else if (!strcmp(name, "GRUB")) {
1493//      if ( does_file_exist(DO_MBR_PLEASE) || (offer_to_hack_scripts && ask_me_yes_or_no("Because of bugs in GRUB, you're much better off running mondorestore --mbr after this program terminates. Are you sure you want to install GRUB right now?")))
1494//        {
1495        res = run_grub(offer_to_hack_scripts, device);
1496//    unlink(DO_MBR_PLEASE);
1497//  }
1498//      else
1499//        {
1500//    log_msg(1, "Not running run_grub(). Was a bad idea anyway.");
1501//    res = 1;
1502//  }
1503    } else if (!strcmp(name, "RAW")) {
1504        res = run_raw_mbr(offer_to_hack_scripts, device);
1505    }
1506#ifdef __FreeBSD__
1507    else if (!strcmp(name, "BOOT0")) {
1508        sprintf(tmp, "boot0cfg -B %s", device);
1509        res = run_program_and_log_output(tmp, FALSE);
1510    } else {
1511        sprintf(tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
1512        if (!system(tmp)) {
1513            sprintf(tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
1514            res = run_program_and_log_output(tmp, 3);
1515        } else {
1516            log_msg(1,
1517                    "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
1518        }
1519    }
1520#else
1521    else {
1522        log_to_screen
1523            ("Unable to determine type of boot loader. Defaulting to LILO.");
1524        res = run_lilo(offer_to_hack_scripts);
1525    }
1526#endif
1527    retval += res;
1528    if (res) {
1529        log_to_screen("Your boot loader returned an error");
1530    } else {
1531        log_to_screen("Your boot loader ran OK");
1532    }
1533    paranoid_free(device);
1534    paranoid_free(tmp);
1535    paranoid_free(name);
1536    return (retval);
1537}
1538
1539/**************************************************************************
1540 *END_ RUN_BOOT_LOADER                                                    *
1541 **************************************************************************/
1542
1543
1544
1545/**
1546 * Attempt to find the user's editor.
1547 * @return The editor found ("vi" if none could be found).
1548 * @note The returned string points to static storage that will be overwritten with each call.
1549 */
1550char *find_my_editor(void)
1551{
1552    static char output[MAX_STR_LEN];
1553    if (find_home_of_exe("pico")) {
1554        strcpy(output, "pico");
1555    } else if (find_home_of_exe("nano")) {
1556        strcpy(output, "nano");
1557    } else if (find_home_of_exe("e3em")) {
1558        strcpy(output, "e3em");
1559    } else if (find_home_of_exe("e3vi")) {
1560        strcpy(output, "e3vi");
1561    } else {
1562        strcpy(output, "vi");
1563    }
1564    if (!find_home_of_exe(output)) {
1565        log_msg(2, " (find_my_editor) --- warning - %s not found", output);
1566    }
1567    return (output);
1568}
1569
1570
1571/**
1572 * Install GRUB on @p bd.
1573 * @param offer_to_run_stabgrub If TRUE, then offer to hack the user's fstab for them.
1574 * @param bd The boot device where GRUB is installed.
1575 * @return 0 for success, nonzero for failure.
1576 */
1577int run_grub(bool offer_to_run_stabgrub, char *bd)
1578{
1579  /** malloc **/
1580    char *command;
1581    char *boot_device;
1582    char *rootdev;
1583    char *rootdrive;
1584    char *conffile;
1585    char *tmp;
1586    char *editor;
1587
1588    int res;
1589    int done;
1590
1591    malloc_string(command);
1592    malloc_string(boot_device);
1593    malloc_string(tmp);
1594    malloc_string(editor);
1595    malloc_string(rootdev);
1596    malloc_string(rootdrive);
1597    malloc_string(conffile);
1598    assert_string_is_neither_NULL_nor_zerolength(bd);
1599    strcpy(editor, find_my_editor());
1600    strcpy(boot_device, bd);
1601
1602    if (!run_program_and_log_output("which grub-MR", FALSE)) {
1603        log_msg(1, "Yay! grub-MR found...");
1604        sprintf(command, "grub-MR %s /tmp/mountlist.txt", boot_device);
1605        log_msg(1, "command = %s", command);
1606    } else {
1607        sprintf(command, "chroot " MNT_RESTORING " grub-install %s",
1608                boot_device);
1609        log_msg(1, "WARNING - grub-MR not found; using grub-install");
1610    }
1611    if (offer_to_run_stabgrub
1612        && ask_me_yes_or_no("Did you change the mountlist?"))
1613        /* interactive mode */
1614    {
1615        mvaddstr_and_log_it(g_currentY,
1616                            0,
1617                            "Modifying fstab, mtab, device.map and grub.conf, and running GRUB...                             ");
1618        for (done = FALSE; !done;) {
1619            popup_and_get_string("Boot device",
1620                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1621                                 boot_device, MAX_STR_LEN / 4);
1622            sprintf(command, "stabgrub-me %s", boot_device);
1623            res = run_program_and_log_output(command, 1);
1624            if (res) {
1625                popup_and_OK
1626                    ("GRUB installation failed. Please install manually using 'grub-install' or similar command. You are now chroot()'ed to your restored system. Please type 'exit' when you are done.");
1627                newtSuspend();
1628                system("chroot " MNT_RESTORING);
1629                newtResume();
1630                popup_and_OK("Thank you.");
1631            } else {
1632                done = TRUE;
1633            }
1634            popup_and_OK("You will now edit fstab, mtab, device.map and grub.conf");
1635            if (!g_text_mode) {
1636                newtSuspend();
1637            }
1638            sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
1639            paranoid_system(tmp);
1640            sprintf(tmp, "chroot %s %s /etc/mtab", MNT_RESTORING, editor);
1641            paranoid_system(tmp);
1642            sprintf(tmp, "chroot %s %s /etc/grub.conf", MNT_RESTORING, editor);
1643            paranoid_system(tmp);
1644            sprintf(tmp, "chroot %s %s /boot/grub/device.map", MNT_RESTORING, editor);
1645            paranoid_system(tmp);
1646            if (!g_text_mode) {
1647                newtResume();
1648            }
1649        }
1650    } else
1651        /* nuke mode */
1652    {
1653        mvaddstr_and_log_it(g_currentY,
1654                            0,
1655                            "Running GRUB...                                                 ");
1656        iamhere(command);
1657        res = run_program_and_log_output(command, 1);
1658        if (res) {
1659            popup_and_OK
1660                ("Because of bugs in GRUB's own installer, GRUB was not installed properly. Please install the boot loader manually now, using this chroot()'ed shell prompt. Type 'exit' when you have finished.");
1661            newtSuspend();
1662            system("chroot " MNT_RESTORING);
1663            newtResume();
1664            popup_and_OK("Thank you.");
1665        }
1666    }
1667    if (res) {
1668        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1669        log_to_screen
1670            ("GRUB ran w/error(s). See %s for more info.", MONDO_LOGFILE);
1671        log_msg(1, "Type:-");
1672        log_msg(1, "    mount-me");
1673        log_msg(1, "    chroot " MNT_RESTORING);
1674        log_msg(1, "    mount /boot");
1675        log_msg(1, "    grub-install '(hd0)'");
1676        log_msg(1, "    exit");
1677        log_msg(1, "    unmount-me");
1678        log_msg(1,
1679                "If you're really stuck, please e-mail the mailing list.");
1680    } else {
1681        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1682    }
1683    paranoid_free(rootdev);
1684    paranoid_free(rootdrive);
1685    paranoid_free(conffile);
1686    paranoid_free(command);
1687    paranoid_free(boot_device);
1688    paranoid_free(tmp);
1689    paranoid_free(editor);
1690
1691    return (res);
1692}
1693
1694/**************************************************************************
1695 *END_RUN_GRUB                                                            *
1696 **************************************************************************/
1697
1698
1699/**
1700 * Install ELILO on the user's boot drive (determined by elilo.conf).
1701 * @param offer_to_run_stabelilo If TRUE, then offer to hack the user's fstab for them.
1702 * @return 0 for success, nonzero for failure.
1703 */
1704int run_elilo(bool offer_to_run_stabelilo)
1705{
1706  /** malloc **/
1707    char *command;
1708    char *tmp;
1709    char *editor;
1710
1711    int res;
1712    int done;
1713
1714    malloc_string(command);
1715    malloc_string(tmp);
1716    malloc_string(editor);
1717    strcpy(editor, find_my_editor());
1718    if (offer_to_run_stabelilo
1719        && ask_me_yes_or_no("Did you change the mountlist?"))
1720
1721        /* interactive mode */
1722    {
1723        mvaddstr_and_log_it(g_currentY,
1724                            0,
1725                            "Modifying fstab and elilo.conf...                             ");
1726        sprintf(command, "stabelilo-me");
1727        res = run_program_and_log_output(command, 3);
1728        if (res) {
1729            popup_and_OK
1730                ("You will now edit fstab and elilo.conf, to make sure they match your new mountlist.");
1731            for (done = FALSE; !done;) {
1732                if (!g_text_mode) {
1733                    newtSuspend();
1734                }
1735                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1736                paranoid_system(tmp);
1737                sprintf(tmp, "%s " MNT_RESTORING "/etc/elilo.conf",
1738                        editor);
1739                paranoid_system(tmp);
1740                if (!g_text_mode) {
1741                    newtResume();
1742                }
1743//              newtCls();
1744                if (ask_me_yes_or_no("Edit them again?")) {
1745                    continue;
1746                }
1747                done = TRUE;
1748            }
1749        } else {
1750            log_to_screen("elilo.conf and fstab were modified OK");
1751        }
1752    } else
1753        /* nuke mode */
1754    {
1755        res = TRUE;
1756    }
1757    paranoid_free(command);
1758    paranoid_free(tmp);
1759    paranoid_free(editor);
1760    return (res);
1761}
1762
1763/**************************************************************************
1764 *END_RUN_ELILO                                                            *
1765 **************************************************************************/
1766
1767
1768/**
1769 * Install LILO on the user's boot drive (determined by /etc/lilo.conf).
1770 * @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
1771 * @return 0 for success, nonzero for failure.
1772 */
1773int run_lilo(bool offer_to_run_stablilo)
1774{
1775  /** malloc **/
1776    char *command;
1777    char *tmp;
1778    char *editor;
1779
1780    int res;
1781    int done;
1782    bool run_lilo_M = FALSE;
1783    malloc_string(command);
1784    malloc_string(tmp);
1785    malloc_string(editor);
1786
1787    if (!run_program_and_log_output
1788        ("grep \"boot.*=.*/dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
1789        run_lilo_M = TRUE;
1790    }
1791
1792    strcpy(editor, find_my_editor());
1793    if (offer_to_run_stablilo
1794        && ask_me_yes_or_no("Did you change the mountlist?"))
1795
1796        /* interactive mode */
1797    {
1798        mvaddstr_and_log_it(g_currentY,
1799                            0,
1800                            "Modifying fstab and lilo.conf, and running LILO...                             ");
1801        sprintf(command, "stablilo-me");
1802        res = run_program_and_log_output(command, 3);
1803        if (res) {
1804            popup_and_OK
1805                ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
1806            for (done = FALSE; !done;) {
1807                if (!g_text_mode) {
1808                    newtSuspend();
1809                }
1810                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1811                paranoid_system(tmp);
1812                sprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
1813                paranoid_system(tmp);
1814                if (!g_text_mode) {
1815                    newtResume();
1816                }
1817//              newtCls();
1818                if (ask_me_yes_or_no("Edit them again?")) {
1819                    continue;
1820                }
1821                res =
1822                    run_program_and_log_output("chroot " MNT_RESTORING
1823                                               " lilo -L", 3);
1824                if (res) {
1825                    res =
1826                        run_program_and_log_output("chroot " MNT_RESTORING
1827                                                   " lilo", 3);
1828                }
1829                if (res) {
1830                    done =
1831                        ask_me_yes_or_no
1832                        ("LILO failed. Re-edit system files?");
1833                } else {
1834                    done = TRUE;
1835                }
1836            }
1837        } else {
1838            log_to_screen("lilo.conf and fstab were modified OK");
1839        }
1840    } else
1841        /* nuke mode */
1842    {
1843        mvaddstr_and_log_it(g_currentY,
1844                            0,
1845                            "Running LILO...                                                 ");
1846        res =
1847            run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
1848                                       3);
1849        if (res) {
1850            res =
1851                run_program_and_log_output("chroot " MNT_RESTORING " lilo",
1852                                           3);
1853        }
1854        if (res) {
1855            mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1856            log_to_screen
1857                ("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
1858        } else {
1859            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1860        }
1861    }
1862    if (run_lilo_M) {
1863        run_program_and_log_output("chroot " MNT_RESTORING
1864                                   " lilo -M /dev/hda", 3);
1865        run_program_and_log_output("chroot " MNT_RESTORING
1866                                   " lilo -M /dev/sda", 3);
1867    }
1868    paranoid_free(command);
1869    paranoid_free(tmp);
1870    paranoid_free(editor);
1871    return (res);
1872}
1873
1874/**************************************************************************
1875 *END_RUN_LILO                                                            *
1876 **************************************************************************/
1877
1878
1879/**
1880 * Install a raw MBR onto @p bd.
1881 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1882 * @param bd The device to copy the stored MBR to.
1883 * @return 0 for success, nonzero for failure.
1884 */
1885int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
1886{
1887  /** malloc **/
1888    char *command;
1889    char *boot_device;
1890    char *tmp;
1891    char *editor;
1892    int res;
1893    int done;
1894
1895    malloc_string(command);
1896    malloc_string(boot_device);
1897    malloc_string(tmp);
1898    malloc_string(editor);
1899    assert_string_is_neither_NULL_nor_zerolength(bd);
1900
1901    strcpy(editor, find_my_editor());
1902    strcpy(boot_device, bd);
1903    sprintf(command, "raw-MR %s /tmp/mountlist.txt", boot_device);
1904    log_msg(2, "run_raw_mbr() --- command='%s'", command);
1905
1906    if (offer_to_hack_scripts
1907        && ask_me_yes_or_no("Did you change the mountlist?"))
1908        /* interactive mode */
1909    {
1910        mvaddstr_and_log_it(g_currentY, 0,
1911                            "Modifying fstab and restoring MBR...                           ");
1912        for (done = FALSE; !done;) {
1913            if (!run_program_and_log_output("which vi", FALSE)) {
1914                popup_and_OK("You will now edit fstab");
1915                if (!g_text_mode) {
1916                    newtSuspend();
1917                }
1918                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1919                paranoid_system(tmp);
1920                if (!g_text_mode) {
1921                    newtResume();
1922                }
1923//              newtCls();
1924            }
1925            popup_and_get_string("Boot device",
1926                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1927                                 boot_device, MAX_STR_LEN / 4);
1928            sprintf(command, "stabraw-me %s", boot_device);
1929            res = run_program_and_log_output(command, 3);
1930            if (res) {
1931                done = ask_me_yes_or_no("Modifications failed. Re-try?");
1932            } else {
1933                done = TRUE;
1934            }
1935        }
1936    } else
1937        /* nuke mode */
1938    {
1939        mvaddstr_and_log_it(g_currentY, 0,
1940                            "Restoring MBR...                                               ");
1941        res = run_program_and_log_output(command, 3);
1942    }
1943    if (res) {
1944        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1945        log_to_screen
1946            ("MBR+fstab processed w/error(s). See %s for more info.", MONDO_LOGFILE);
1947    } else {
1948        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1949    }
1950    paranoid_free(command);
1951    paranoid_free(boot_device);
1952    paranoid_free(tmp);
1953    paranoid_free(editor);
1954    return (res);
1955}
1956
1957/**************************************************************************
1958 *END_RUN_RAW_MBR                                                         *
1959 **************************************************************************/
1960
1961
1962
1963
1964
1965/**
1966 * Turn signal trapping on or off.
1967 * @param on If TRUE, then do full cleanup when we receive a signal; if FALSE, then
1968 * print a message and exit immediately.
1969 */
1970void set_signals(int on)
1971{
1972    int signals[] =
1973        { SIGKILL, SIGPIPE, SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT,
1974SIGSTOP, 0 };
1975    int i;
1976    for (i = 0; signals[i]; i++) {
1977        if (on) {
1978            signal(signals[i], terminate_daemon);
1979        } else {
1980            signal(signals[i], termination_in_progress);
1981        }
1982    }
1983}
1984
1985/**************************************************************************
1986 *END_SET_SIGNALS                                                         *
1987 **************************************************************************/
1988
1989
1990/**
1991 * malloc() and set sensible defaults for the mondorestore filename variables.
1992 * @param bkpinfo The backup information structure. Fields used:
1993 * - @c bkpinfo->tmpdir
1994 * - @c bkpinfo->disaster_recovery
1995 */
1996void setup_MR_global_filenames()
1997{
1998    char *temppath;
1999
2000    assert(bkpinfo != NULL);
2001
2002    malloc_string(g_biggielist_txt);
2003    malloc_string(g_filelist_full);
2004    malloc_string(g_filelist_imagedevs);
2005    malloc_string(g_imagedevs_restthese);
2006    malloc_string(g_mondo_cfg_file);
2007    malloc_string(g_mountlist_fname);
2008    malloc_string(g_mondo_home);
2009    malloc_string(g_tmpfs_mountpt);
2010    malloc_string(g_isodir_device);
2011    malloc_string(g_isodir_format);
2012
2013    temppath = bkpinfo->tmpdir;
2014
2015    sprintf(g_biggielist_txt, "%s/%s", temppath, BIGGIELIST_TXT_STUB);
2016    sprintf(g_filelist_full, "%s/%s", temppath, FILELIST_FULL_STUB);
2017    sprintf(g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", temppath);
2018//  sprintf(g_imagedevs_pot, "%s/tmp/imagedevs.pot", temppath);
2019    sprintf(g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
2020            temppath);
2021    if (bkpinfo->disaster_recovery) {
2022        sprintf(g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
2023        sprintf(g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
2024    } else {
2025        sprintf(g_mondo_cfg_file, "%s/%s", temppath, MONDO_CFG_FILE_STUB);
2026        sprintf(g_mountlist_fname, "%s/%s", temppath,
2027                MOUNTLIST_FNAME_STUB);
2028    }
2029}
2030
2031/**************************************************************************
2032 *END_SET_GLOBAL_FILENAME                                                 *
2033 **************************************************************************/
2034
2035
2036/**
2037 * Copy @p input_file (containing the result of a compare) to @p output_file,
2038 * deleting spurious "changes" along the way.
2039 * @param output_file The output file to write with spurious changes removed.
2040 * @param input_file The input file, a list of changed files created by a compare.
2041 */
2042void streamline_changes_file(char *output_file, char *input_file)
2043{
2044    FILE *fin;
2045    FILE *fout;
2046  /** malloc **/
2047    char *incoming;
2048
2049    assert_string_is_neither_NULL_nor_zerolength(output_file);
2050    assert_string_is_neither_NULL_nor_zerolength(input_file);
2051    malloc_string(incoming);
2052
2053    if (!(fin = fopen(input_file, "r"))) {
2054        log_OS_error(input_file);
2055        return;
2056    }
2057    if (!(fout = fopen(output_file, "w"))) {
2058        fatal_error("cannot open output_file");
2059    }
2060    for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
2061         fgets(incoming, MAX_STR_LEN - 1, fin)) {
2062        if (strncmp(incoming, "etc/adjtime", 11)
2063            && strncmp(incoming, "etc/mtab", 8)
2064            && strncmp(incoming, "tmp/", 4)
2065            && strncmp(incoming, "boot/map", 8)
2066            && !strstr(incoming, "incheckentry")
2067            && strncmp(incoming, "etc/mail/statistics", 19)
2068            && strncmp(incoming, "var/", 4))
2069            fprintf(fout, "%s", incoming);  /* don't need \n here, for some reason.. */
2070    }
2071    paranoid_fclose(fout);
2072    paranoid_fclose(fin);
2073    paranoid_free(incoming);
2074}
2075
2076/**************************************************************************
2077 *END_STREAMLINE_CHANGES_FILE                                             *
2078 **************************************************************************/
2079
2080
2081/**
2082 * Exit due to a signal (normal cleanup).
2083 * @param sig The signal we're exiting due to.
2084 */
2085void terminate_daemon(int sig)
2086{
2087    log_to_screen
2088        ("Mondorestore is terminating in response to a signal from the OS");
2089    paranoid_MR_finish(254);
2090}
2091
2092/**************************************************************************
2093 *END_TERMINATE_DAEMON                                                    *
2094 **************************************************************************/
2095
2096
2097/**
2098 * Give the user twenty seconds to press Ctrl-Alt-Del before we nuke their drives.
2099 */
2100void twenty_seconds_til_yikes()
2101{
2102    int i;
2103    /* MALLOC * */
2104    char *tmp;
2105
2106    malloc_string(tmp);
2107    if (does_file_exist("/tmp/NOPAUSE")) {
2108        return;
2109    }
2110    open_progress_form("CAUTION",
2111                       "Be advised: I am about to ERASE your hard disk(s)!",
2112                       "You may press Ctrl+Alt+Del to abort safely.",
2113                       "", 20);
2114    for (i = 0; i < 20; i++) {
2115        g_current_progress = i;
2116        sprintf(tmp, "You have %d seconds left to abort.", 20 - i);
2117        update_progress_form(tmp);
2118        sleep(1);
2119    }
2120    close_progress_form();
2121    paranoid_free(tmp);
2122}
2123
2124/**************************************************************************
2125 *END_TWENTY_SECONDS_TIL_YIKES                                            *
2126 **************************************************************************/
2127
2128
2129
2130
2131
2132/**
2133 * Exit due to a signal (no cleanup).
2134 * @param sig The signal we're exiting due to.
2135 */
2136void termination_in_progress(int sig)
2137{
2138    log_msg(1, "Termination in progress");
2139    usleep(1000);
2140    pthread_exit(0);
2141}
2142
2143/**************************************************************************
2144 *END_TERMINATION_IN_PROGRESS                                             *
2145 **************************************************************************/
2146
2147
2148
2149/**
2150 * Unmount all devices in @p p_external_copy_of_mountlist.
2151 * @param p_external_copy_of_mountlist The mountlist to guide the devices to unmount.
2152 * @return 0 for success, nonzero for failure.
2153 */
2154int unmount_all_devices(struct mountlist_itself
2155                        *p_external_copy_of_mountlist)
2156{
2157    struct mountlist_itself *mountlist;
2158    int retval = 0, lino, res = 0, i;
2159    char *command;
2160    char *tmp;
2161
2162    malloc_string(command);
2163    malloc_string(tmp);
2164    assert(p_external_copy_of_mountlist != NULL);
2165
2166    mountlist = malloc(sizeof(struct mountlist_itself));
2167    memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
2168           sizeof(struct mountlist_itself));
2169    sort_mountlist_by_mountpoint(mountlist, 0);
2170
2171    run_program_and_log_output("df -m", 3);
2172    mvaddstr_and_log_it(g_currentY, 0, "Unmounting devices      ");
2173    open_progress_form("Unmounting devices",
2174                       "Unmounting all devices that were mounted,",
2175                       "in preparation for the post-restoration reboot.",
2176                       "", mountlist->entries);
2177    chdir("/");
2178    for (i = 0;
2179         i < 10
2180         &&
2181         run_program_and_log_output
2182         ("ps | grep buffer | grep -v \"grep buffer\"", TRUE) == 0;
2183         i++) {
2184        sleep(1);
2185        log_msg(2, "Waiting for buffer() to finish");
2186    }
2187
2188    paranoid_system("sync");
2189
2190    sprintf(tmp, "cp -f %s " MNT_RESTORING "/var/log", MONDO_LOGFILE);
2191    if (run_program_and_log_output(tmp, FALSE)) {
2192        log_msg(1,
2193                "Error. Failed to copy log to PC's /var/log dir. (Mounted read-only?)");
2194    }
2195    if (does_file_exist("/tmp/DUMBASS-GENTOO")) {
2196        run_program_and_log_output("mkdir -p " MNT_RESTORING
2197                                   "/mnt/.boot.d", 5);
2198    }
2199    for (lino = mountlist->entries - 1; lino >= 0; lino--) {
2200        if (!strcmp(mountlist->el[lino].mountpoint, "lvm")) {
2201            continue;
2202        }
2203        sprintf(tmp, "Unmounting device %s  ", mountlist->el[lino].device);
2204
2205        update_progress_form(tmp);
2206        if (is_this_device_mounted(mountlist->el[lino].device)) {
2207            if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
2208                sprintf(command, "swapoff %s", mountlist->el[lino].device);
2209            } else {
2210                if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
2211                    sprintf(command, "umount %s/", MNT_RESTORING);
2212                    log_msg(3,
2213                            "Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
2214                } else {
2215                    sprintf(command, "umount " MNT_RESTORING "%s",
2216                            mountlist->el[lino].mountpoint);
2217                }
2218            }
2219            log_msg(10, "The 'umount' command is '%s'", command);
2220            res = run_program_and_log_output(command, 3);
2221        } else {
2222            strcat(tmp, "...not mounted anyway :-) OK");
2223            res = 0;
2224        }
2225        g_current_progress++;
2226        if (res) {
2227            strcat(tmp, "...Failed");
2228            retval++;
2229            log_to_screen(tmp);
2230        } else {
2231            log_msg(2, tmp);
2232        }
2233    }
2234    close_progress_form();
2235    if (retval) {
2236        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
2237    } else {
2238        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2239    }
2240    if (retval) {
2241        log_to_screen("Unable to unmount some of your partitions.");
2242    } else {
2243        log_to_screen("All partitions were unmounted OK.");
2244    }
2245    free(mountlist);
2246    paranoid_free(command);
2247    paranoid_free(tmp);
2248    return (retval);
2249}
2250
2251/**************************************************************************
2252 *END_UNMOUNT_ALL_DEVICES                                                 *
2253 **************************************************************************/
2254
2255
2256
2257/**
2258 * Extract mondo-restore.cfg and the mountlist from the tape inserted
2259 * to the ./tmp/ directory.
2260 * @param dev The tape device to read from.
2261 * @return 0 for success, nonzero for failure.
2262 */
2263int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
2264{
2265    char *command;
2266    int res = 0;
2267    // BCO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
2268    long tape_block_size = 32768;
2269
2270    malloc_string(command);
2271
2272    // tar -zxvf-
2273    sprintf(command,
2274            "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s",
2275            dev,
2276            tape_block_size,
2277            1024L * 1024 * 32 / tape_block_size,
2278            MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
2279            BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");
2280    log_msg(2, "command = '%s'", command);
2281    res = run_program_and_log_output(command, -1);
2282    if (res != 0 && does_file_exist(MONDO_CFG_FILE_STUB)) {
2283        res = 0;
2284    }
2285    paranoid_free(command);
2286    return (res);
2287}
2288
2289
2290
2291/**
2292 * Get the configuration file from the floppy, tape, or CD.
2293 * @param bkpinfo The backup information structure. Fields used:
2294 * - @c bkpinfo->backup_media_type
2295 * - @c bkpinfo->media_device
2296 * - @c bkpinfo->tmpdir
2297 * @return 0 for success, nonzero for failure.
2298 */
2299int get_cfg_file_from_archive()
2300{
2301    int retval = 0;
2302
2303   /** malloc *****/
2304    char *device;
2305    char *command;
2306    char *cfg_file;
2307    char *mounted_cfgf_path;
2308    char *tmp;
2309    char *mountpt;
2310    char *ramdisk_fname;
2311    char *mountlist_file;
2312    int res = 0;
2313    int fd = 0;
2314    struct floppy_struct fdprms;
2315
2316    bool try_plan_B;
2317
2318    assert(bkpinfo != NULL);
2319    malloc_string(cfg_file);
2320    malloc_string(mounted_cfgf_path);
2321    malloc_string(mountpt);
2322    malloc_string(ramdisk_fname);
2323    malloc_string(mountlist_file);
2324    malloc_string(device);
2325    malloc_string(command);
2326    malloc_string(tmp);
2327    log_msg(2, "gcffa --- starting");
2328    log_to_screen("I'm thinking...");
2329    sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
2330    device[0] = '\0';
2331    chdir(bkpinfo->tmpdir);
2332    strcpy(cfg_file, MONDO_CFG_FILE_STUB);
2333    unlink(cfg_file);           // cfg_file[] is missing the '/' at the start, FYI, by intent
2334    unlink(FILELIST_FULL_STUB);
2335    unlink(BIGGIELIST_TXT_STUB);
2336    unlink("tmp/i-want-my-lvm");
2337    sprintf(command, "mkdir -p %s", mountpt);
2338    run_program_and_log_output(command, FALSE);
2339
2340//   unlink( "tmp/mondo-restore.cfg" ); // superfluous, surely?
2341
2342    sprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
2343    sprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir,
2344            MOUNTLIST_FNAME_STUB);
2345    //   make_hole_for_file( cfg_file );
2346    //   make_hole_for_file( mountlist_file);
2347    log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
2348
2349    /* Floppy? */
2350    sprintf(tmp, "mkdir -p %s", mountpt);
2351    run_program_and_log_output(tmp, FALSE);
2352    sprintf(tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
2353    run_program_and_log_output(tmp, FALSE);
2354
2355    /* Is there a floppy drive detected */
2356    fd = open("/dev/fd0u1722", O_RDONLY);
2357    if (fd > 0) {
2358        // open OK
2359        res = ioctl(fd, FDGETPRM, &fdprms);
2360        if (res >= 0) {
2361            // media OK to mount
2362            sprintf(command, "mount /dev/fd0u1722 %s", mountpt);
2363            res = run_program_and_log_output(command, FALSE);
2364        } else {
2365            //skip mount
2366            res = 1;
2367        } 
2368    } else { 
2369        fd = open("/dev/fd0H1440", O_RDONLY);
2370        if (fd > 0) {
2371            // open OK
2372            res = ioctl(fd, FDGETPRM, &fdprms);
2373            if (res >= 0) {
2374                // media OK to mount
2375                sprintf(command, "mount /dev/fd0H1440 %s", mountpt);
2376                res = run_program_and_log_output(command, FALSE);
2377            } else {
2378                //skip mount
2379                res = 1;
2380            } 
2381        }
2382    }
2383    if (res) {
2384        try_plan_B = TRUE;
2385    } else {
2386        try_plan_B = TRUE;
2387        log_msg(2,
2388                "Mounted floppy OK but I don't trust it because the archives might contain more up-to-date config file than the floppy does.");
2389        // NB: If busybox does not support 'mount -o loop' then Plan A WILL NOT WORK.
2390        log_msg(2, "Processing floppy (plan A?)");
2391        sprintf(ramdisk_fname, "%s/mindi.rdz", mountpt);
2392        if (!does_file_exist(ramdisk_fname)) {
2393            sprintf(ramdisk_fname, "%s/initrd.img", mountpt);
2394        }
2395        if (!does_file_exist(ramdisk_fname)) {
2396            log_msg(2,
2397                    "Cannot find ramdisk file on mountpoint. Are you sure that's a boot disk in the drive?");
2398        }
2399        if (extract_config_file_from_ramdisk(ramdisk_fname, cfg_file, mountlist_file)) {
2400            log_msg(2,
2401                    "Warning - failed to extract config file from ramdisk. I think this boot disk is mangled.");
2402        }
2403        sprintf(command, "umount %s", mountpt);
2404        run_program_and_log_output(command, 5);
2405        unlink(ramdisk_fname);
2406    }
2407    if (!does_file_exist(cfg_file)) {
2408        log_msg(2, "gcffa --- we don't have cfg file yet.");
2409        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2410            try_plan_B = TRUE;
2411        } else {
2412            log_msg(2, "gcffa --- calling mount_media now :)");
2413            if (!mount_media()) {
2414                log_msg(2,
2415                        "gcffa --- managed to mount CD; so, no need for Plan B");
2416                try_plan_B = FALSE;
2417            } else {
2418                try_plan_B = TRUE;
2419            }
2420            if (what_number_cd_is_this() > 1) {
2421                insist_on_this_cd_number((g_current_media_number = 1));
2422            }
2423        }
2424        if (try_plan_B) {
2425            log_msg(2, "gcffa --- OK, switching to Plan B");
2426            chdir(bkpinfo->tmpdir);
2427            run_program_and_log_output("mkdir -p tmp", FALSE);
2428
2429            if (strlen(bkpinfo->media_device) == 0) {
2430                strcpy(bkpinfo->media_device, "/dev/st0");
2431                log_msg(2, "media_device is blank; assuming %s");
2432            }
2433            strcpy(tmp, bkpinfo->media_device);
2434            if (extract_cfg_file_and_mountlist_from_tape_dev
2435                (bkpinfo->media_device)) {
2436                strcpy(bkpinfo->media_device, "/dev/st0");
2437                if (extract_cfg_file_and_mountlist_from_tape_dev
2438                    (bkpinfo->media_device)) {
2439                    strcpy(bkpinfo->media_device, "/dev/osst0");
2440                    if (extract_cfg_file_and_mountlist_from_tape_dev
2441                        (bkpinfo->media_device)) {
2442                        strcpy(bkpinfo->media_device, "/dev/ht0");
2443                        if (extract_cfg_file_and_mountlist_from_tape_dev
2444                            (bkpinfo->media_device)) {
2445                            log_msg(3,
2446                                    "I tried lots of devices but none worked.");
2447                            strcpy(bkpinfo->media_device, tmp);
2448                        }
2449                    }
2450                }
2451            }
2452
2453            if (!does_file_exist("tmp/mondo-restore.cfg")) {
2454                log_to_screen("Cannot find config info on tape/CD/floppy");
2455                return (1);
2456            }
2457        } else {
2458            /* That boot imae doesn't always exist where the following method always works
2459            log_msg(2,
2460                    "gcffa --- looking at mounted CD for mindi-boot.2880.img");
2461            sprintf(command,
2462                    "mount " MNT_CDROM
2463                    "/images/mindi-boot.2880.img -o loop %s", mountpt);
2464            sprintf(mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
2465            if (!does_file_exist(mounted_cfgf_path)) {
2466            */
2467                log_msg(2,
2468                        "gcffa --- Plan B, a.k.a. untarring some file from all.tar.gz");
2469                sprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");  // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
2470                run_program_and_log_output(command, TRUE);
2471                if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
2472                    fatal_error
2473                        ("Please reinsert the disk/CD and try again.");
2474                }
2475                    /*
2476            }
2477                */
2478        }
2479    }
2480    if (does_file_exist(MONDO_CFG_FILE_STUB)) {
2481        log_msg(1, "gcffa --- great! We've got the config file");
2482        sprintf(tmp, "%s/%s",
2483                call_program_and_get_last_line_of_output("pwd"),
2484                MONDO_CFG_FILE_STUB);
2485        sprintf(command, "cp -f %s %s", tmp, cfg_file);
2486        iamhere(command);
2487        if (strcmp(tmp, cfg_file)
2488            && run_program_and_log_output(command, 1)) {
2489            log_msg(1,
2490                    "... but an error occurred when I tried to move it to %s",
2491                    cfg_file);
2492        } else {
2493            log_msg(1, "... and I moved it successfully to %s", cfg_file);
2494        }
2495        sprintf(command, "cp -f %s/%s %s",
2496                call_program_and_get_last_line_of_output("pwd"),
2497                MOUNTLIST_FNAME_STUB, mountlist_file);
2498        iamhere(command);
2499        if (strcmp(tmp, cfg_file)
2500            && run_program_and_log_output(command, 1)) {
2501            log_msg(1, "Failed to get mountlist");
2502        } else {
2503            log_msg(1, "Got mountlist too");
2504            sprintf(command, "cp -f %s %s", mountlist_file,
2505                    g_mountlist_fname);
2506            if (run_program_and_log_output(command, 1)) {
2507                log_msg(1, "Failed to copy mountlist to /tmp");
2508            } else {
2509                log_msg(1, "Copied mountlist to /tmp as well OK");
2510                sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
2511                run_program_and_log_output(command, 1);
2512/*        sprintf(command, "grep \" lvm \" %s", g_mountlist_fname);
2513          if (!run_program_and_log_output(command, 5) && !does_file_exist("/tmp/i-want-my-lvm"))
2514            {
2515          log_msg(1, "Warning. You want LVM but I don't have i-want-my-lvm. FIXME.");
2516        }
2517              else if (run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
2518                {
2519          log_msg(1, "Warning. You don't want LVM but i-want-my-lvm exists. I'll delete it. Cool.");
2520              do_my_funky_lvm_stuff(TRUE, FALSE); // ...after I stop any LVMs :)
2521          stop_raid_device("/dev/md0");
2522          stop_raid_device("/dev/md1");
2523          stop_raid_device("/dev/md2");
2524          unlink("/tmp/i-want-my-lvm");
2525        }
2526          else if (!run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
2527            {
2528          log_msg(1, "You had better pray that i-want-my-lvm patches your mountlist. FIXME.");
2529        }
2530*/
2531            }
2532        }
2533    }
2534    run_program_and_log_output("umount " MNT_CDROM, FALSE);
2535    if (!does_file_exist(cfg_file)) {
2536        iamhere(cfg_file);
2537        log_msg(1, "%s not found", cfg_file);
2538        log_to_screen
2539            ("Oh dear. Unable to recover configuration file from boot disk");
2540        return (1);
2541    }
2542
2543    log_to_screen("Recovered mondo-restore.cfg");
2544    if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
2545        log_to_screen("...but not mountlist.txt - a pity, really...");
2546    }
2547/* start SAH */
2548    else {
2549        sprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
2550                bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
2551        run_program_and_log_output(command, FALSE);
2552    }
2553/*--commented out by SAH
2554  sprintf( command, "cp -f %s %s/%s", cfg_file, bkpinfo->tmpdir, MONDO_CFG_FILE_STUB );
2555  run_program_and_log_output( command, FALSE );
2556  sprintf( command, "cp -f %s %s/%s", mountlist_file, bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB );
2557  run_program_and_log_output( command, FALSE );
2558*/
2559/* end SAH */
2560
2561    sprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
2562    run_program_and_log_output(command, FALSE);
2563    sprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
2564    run_program_and_log_output(command, FALSE);
2565    sprintf(command, "cp -f etc/raidtab /etc/");
2566    run_program_and_log_output(command, FALSE);
2567    sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
2568    run_program_and_log_output(command, FALSE);
2569    g_backup_media_type = bkpinfo->backup_media_type;
2570    paranoid_free(device);
2571    paranoid_free(command);
2572    paranoid_free(tmp);
2573    paranoid_free(cfg_file);
2574    paranoid_free(mounted_cfgf_path);
2575    paranoid_free(mountpt);
2576    paranoid_free(ramdisk_fname);
2577    paranoid_free(mountlist_file);
2578    return (retval);
2579}
2580
2581/**************************************************************************
2582 *END_GET_CFG_FILE_FROM_ARCHIVE                                           *
2583 **************************************************************************/
2584
2585/* @} - end restoreUtilityGroup */
2586
2587
2588/***************************************************************************
2589 * F@                                                                      *
2590 * () -- Hugo Rabson                                  *
2591 *                                                                         *
2592 * Purpose:                                                                *
2593 *                                                                         *
2594 * Called by:                                                              *
2595 * Params:    -                      -                                     *
2596 * Returns:   0=success; nonzero=failure                                   *
2597 ***************************************************************************/
2598
2599
2600
2601void wait_until_software_raids_are_prepped(char *mdstat_file,
2602                                           int wait_for_percentage)
2603{
2604    struct raidlist_itself *raidlist;
2605    int unfinished_mdstat_devices = 9999, i;
2606    char *screen_message;
2607
2608    malloc_string(screen_message);
2609    raidlist = malloc(sizeof(struct raidlist_itself));
2610
2611    assert(wait_for_percentage <= 100);
2612    iamhere("wait_until_software_raids_are_prepped");
2613    while (unfinished_mdstat_devices > 0) {
2614            // FIXME: Prefix '/dev/' should really be dynamic!
2615        if (parse_mdstat(raidlist, "/dev/")) {
2616            log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
2617            log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
2618            return;
2619        }
2620        for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
2621            if (raidlist->el[i].progress < wait_for_percentage) {
2622                unfinished_mdstat_devices++;
2623                if (raidlist->el[i].progress == -1) // delayed while another partition inits
2624                {
2625                    continue;
2626                }
2627                log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
2628                sprintf(screen_message, "Sync'ing %s",
2629                        raidlist->el[i].raid_device);
2630                open_evalcall_form(screen_message);
2631                while (raidlist->el[i].progress < wait_for_percentage) {
2632                    log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
2633                    update_evalcall_form(raidlist->el[i].progress);
2634                    sleep(2);
2635                    // FIXME: Prefix '/dev/' should really be dynamic!
2636                    if (parse_mdstat(raidlist, "/dev/")) {
2637                        break;
2638                    }
2639                }
2640                close_evalcall_form();
2641            }
2642        }
2643    }
2644    paranoid_free(screen_message);
2645    paranoid_free(raidlist);
2646}
Note: See TracBrowser for help on using the repository browser.