source: branches/3.2/mondo/src/mondorestore/mondo-rstr-tools.c @ 3301

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