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

Last change on this file since 1850 was 1850, checked in by bruno, 12 years ago

before killing a process test that there is a result to ps (avoid whom to kill messages)

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