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

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

Use RESTORE consistently across mondo to restore without interaction (report from Takeshi Shoji t.shoji_at_tripodw.jp)

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