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

Last change on this file since 1216 was 1216, checked in by Bruno Cornec, 13 years ago

First merge for mondo-rstr-tools.c

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