source: branches/2.2.8/mondo/src/mondorestore/mondo-rstr-tools.c @ 2776

Last change on this file since 2776 was 2776, checked in by Bruno Cornec, 9 years ago

r2145@localhost (orig r2144): bruno | 2009-02-14 02:10:28 +0100
Ok, really fix the Ubuntu problem as we need first to umount /var and then create the dirs


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