source: branches/stable/mondo/src/mondorestore/mondo-rstr-tools.c @ 1267

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

typo

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