source: MondoRescue/trunk/mondo/mondo/mondorestore/mondo-rstr-tools.c @ 794

Last change on this file since 794 was 794, checked in by Bruno Cornec, 14 years ago

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