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

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