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

Last change on this file since 2110 was 2110, checked in by Bruno Cornec, 15 years ago

Improve call to offer_to_make_initrd which is timeouting right now
  • Property svn:keywords set to Id
File size: 74.1 KB
Line 
1/***************************************************************************
2$Id: mondo-rstr-tools.c 2110 2009-01-08 09:15:19Z 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 is especially useful if you changed of hardware configuration, cloned, made P2V, used multipath...\nDo you need to do it ?")) {
1355 mvaddstr_and_log_it(g_currentY, 0, "Modifying initrd...");
1356 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.");
1357 if (!g_text_mode) {
1358 newtSuspend();
1359 }
1360 (void)system("chroot " MNT_RESTORING);
1361 if (!g_text_mode) {
1362 newtResume();
1363 }
1364 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1365 } else {
1366 return;
1367 }
1368} else {
1369 log_to_screen("Non-interactive mode: no way to give you the keyboard so that you re-generate your initrd. Hope it's OK");
1370 log_msg(1,"Non-interactive mode: no way to give you the keyboard so that you re-generate your initrd. Hope it's OK");
1371}
1372}
1373
1374
1375/**
1376 * Install the user's boot loader in the MBR.
1377 * Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
1378 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1379 * @return 0 for success, nonzero for failure.
1380 */
1381int run_boot_loader(bool offer_to_hack_scripts)
1382{
1383 int res;
1384 int retval = 0;
1385
1386 /** malloc *******/
1387 char *device;
1388 char *tmp = NULL;
1389 char *name;
1390 char *cmd = NULL;
1391
1392 malloc_string(device);
1393 malloc_string(name);
1394
1395 /* In order to have a working bootloader, we need to have all devices
1396 * ready in the chroot. If they are not there (udev) then copy them from
1397 * the current /dev location
1398 */
1399 asprintf(&cmd,"tar cf - /dev | ( cd %s ; tar xf - )",MNT_RESTORING);
1400 run_program_and_log_output(cmd, 3);
1401 paranoid_free(cmd);
1402
1403 backup_crucial_file(MNT_RESTORING, "/etc/fstab");
1404 backup_crucial_file(MNT_RESTORING, "/boot/grub/menu.lst");
1405 backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
1406 backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
1407 backup_crucial_file(MNT_RESTORING, "/boot/grub/device.map");
1408 backup_crucial_file(MNT_RESTORING, "/etc/mtab");
1409 read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
1410 read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
1411 asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
1412 log_msg(2, tmp);
1413 paranoid_free(tmp);
1414 system("sync");
1415
1416 offer_to_make_initrd();
1417 if (!strcmp(name, "LILO")) {
1418 res = run_lilo(offer_to_hack_scripts);
1419 } else if (!strcmp(name, "ELILO")) {
1420 res = run_elilo(offer_to_hack_scripts);
1421 } else if (!strcmp(name, "GRUB")) {
1422 res = run_grub(offer_to_hack_scripts, device);
1423 } else if (!strcmp(name, "RAW")) {
1424 res = run_raw_mbr(offer_to_hack_scripts, device);
1425 }
1426#ifdef __FreeBSD__
1427 else if (!strcmp(name, "BOOT0")) {
1428 asprintf(&tmp, "boot0cfg -B %s", device);
1429 res = run_program_and_log_output(tmp, FALSE);
1430 paranoid_free(tmp);
1431 } else {
1432 asprintf(&tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
1433 if (!system(tmp)) {
1434 paranoid_free(tmp);
1435 asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
1436 res = run_program_and_log_output(tmp, 3);
1437 } else {
1438 log_msg(1,
1439 "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
1440 }
1441 paranoid_free(tmp);
1442 }
1443#else
1444 else {
1445 log_to_screen
1446 ("Unable to determine type of boot loader. Defaulting to LILO.");
1447 res = run_lilo(offer_to_hack_scripts);
1448 }
1449#endif
1450 retval += res;
1451 if (res) {
1452 log_to_screen("Your boot loader returned an error");
1453 } else {
1454 log_to_screen("Your boot loader ran OK");
1455 }
1456 paranoid_free(device);
1457 paranoid_free(name);
1458 return (retval);
1459}
1460
1461/**************************************************************************
1462 *END_ RUN_BOOT_LOADER *
1463 **************************************************************************/
1464
1465
1466
1467/**
1468 * Attempt to find the user's editor.
1469 * @return The editor found ("vi" if none could be found).
1470 * @note The returned string points to static storage that will be overwritten with each call.
1471 */
1472char *find_my_editor(void)
1473{
1474 static char output[MAX_STR_LEN];
1475 if (find_home_of_exe("pico")) {
1476 strcpy(output, "pico");
1477 } else if (find_home_of_exe("nano")) {
1478 strcpy(output, "nano");
1479 } else if (find_home_of_exe("e3em")) {
1480 strcpy(output, "e3em");
1481 } else if (find_home_of_exe("e3vi")) {
1482 strcpy(output, "e3vi");
1483 } else {
1484 strcpy(output, "vi");
1485 }
1486 if (!find_home_of_exe(output)) {
1487 log_msg(2, " (find_my_editor) --- warning - %s not found", output);
1488 }
1489 return (output);
1490}
1491
1492
1493/**
1494 * Install GRUB on @p bd.
1495 * @param offer_to_run_stabgrub If TRUE, then offer to hack the user's fstab for them.
1496 * @param bd The boot device where GRUB is installed.
1497 * @return 0 for success, nonzero for failure.
1498 */
1499int run_grub(bool offer_to_run_stabgrub, char *bd)
1500{
1501 /** malloc **/
1502 char *command;
1503 char *boot_device;
1504 char *rootdev;
1505 char *rootdrive;
1506 char *conffile;
1507 char *tmp;
1508 char *editor;
1509
1510 int res;
1511 int done;
1512
1513 malloc_string(command);
1514 malloc_string(boot_device);
1515 malloc_string(tmp);
1516 malloc_string(editor);
1517 malloc_string(rootdev);
1518 malloc_string(rootdrive);
1519 malloc_string(conffile);
1520 assert_string_is_neither_NULL_nor_zerolength(bd);
1521 strcpy(editor, find_my_editor());
1522 strcpy(boot_device, bd);
1523
1524 if (!run_program_and_log_output("which grub-MR", FALSE)) {
1525 log_msg(1, "Yay! grub-MR found...");
1526 sprintf(command, "grub-MR %s /tmp/mountlist.txt", boot_device);
1527 log_msg(1, "command = %s", command);
1528 } else {
1529 sprintf(command, "chroot " MNT_RESTORING " grub-install %s",
1530 boot_device);
1531 log_msg(1, "WARNING - grub-MR not found; using grub-install");
1532 }
1533 if (offer_to_run_stabgrub
1534 && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
1535 /* interactive mode */
1536 {
1537 mvaddstr_and_log_it(g_currentY,
1538 0,
1539 "Modifying fstab, mtab, device.map and menu.lst, and running GRUB... ");
1540 for (done = FALSE; !done;) {
1541 popup_and_get_string("Boot device",
1542 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1543 boot_device, MAX_STR_LEN / 4);
1544 sprintf(command, "stabgrub-me %s", boot_device);
1545 res = run_program_and_log_output(command, 1);
1546 if (res) {
1547 popup_and_OK
1548 ("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.");
1549 newtSuspend();
1550 system("chroot " MNT_RESTORING);
1551 newtResume();
1552 popup_and_OK("Thank you.");
1553 } else {
1554 done = TRUE;
1555 }
1556 popup_and_OK("You will now edit fstab, mtab, device.map and menu.lst");
1557 if (!g_text_mode) {
1558 newtSuspend();
1559 }
1560 sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
1561 paranoid_system(tmp);
1562 sprintf(tmp, "chroot %s %s /etc/mtab", MNT_RESTORING, editor);
1563 paranoid_system(tmp);
1564 sprintf(tmp, "chroot %s %s /boot/grub/menu.lst", MNT_RESTORING, editor);
1565 paranoid_system(tmp);
1566 sprintf(tmp, "chroot %s %s /boot/grub/device.map", MNT_RESTORING, editor);
1567 paranoid_system(tmp);
1568 if (!g_text_mode) {
1569 newtResume();
1570 }
1571 }
1572 } else
1573 /* nuke mode */
1574 {
1575 mvaddstr_and_log_it(g_currentY,
1576 0,
1577 "Running GRUB... ");
1578 iamhere(command);
1579 res = run_program_and_log_output(command, 1);
1580 if (res) {
1581 popup_and_OK
1582 ("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.");
1583 newtSuspend();
1584 system("chroot " MNT_RESTORING);
1585 newtResume();
1586 popup_and_OK("Thank you.");
1587 }
1588 }
1589 if (res) {
1590 mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1591 log_to_screen
1592 ("GRUB ran w/error(s). See %s for more info.", MONDO_LOGFILE);
1593 log_msg(1, "Type:-");
1594 log_msg(1, " mount-me");
1595 log_msg(1, " chroot " MNT_RESTORING);
1596 log_msg(1, " mount /boot");
1597 log_msg(1, " grub-install '(hd0)'");
1598 log_msg(1, " exit");
1599 log_msg(1, " unmount-me");
1600 log_msg(1,
1601 "If you're really stuck, please e-mail the mailing list.");
1602 } else {
1603 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1604 }
1605 paranoid_free(rootdev);
1606 paranoid_free(rootdrive);
1607 paranoid_free(conffile);
1608 paranoid_free(command);
1609 paranoid_free(boot_device);
1610 paranoid_free(tmp);
1611 paranoid_free(editor);
1612
1613 return (res);
1614}
1615
1616/**************************************************************************
1617 *END_RUN_GRUB *
1618 **************************************************************************/
1619
1620
1621/**
1622 * Install ELILO on the user's boot drive (determined by elilo.conf).
1623 * @param offer_to_run_stabelilo If TRUE, then offer to hack the user's fstab for them.
1624 * @return 0 for success, nonzero for failure.
1625 */
1626int run_elilo(bool offer_to_run_stabelilo)
1627{
1628 /** malloc **/
1629 char *command;
1630 char *tmp;
1631 char *editor;
1632
1633 int res;
1634 int done;
1635
1636 malloc_string(command);
1637 malloc_string(tmp);
1638 malloc_string(editor);
1639 strcpy(editor, find_my_editor());
1640 if (offer_to_run_stabelilo
1641 && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
1642
1643 /* interactive mode */
1644 {
1645 mvaddstr_and_log_it(g_currentY,
1646 0,
1647 "Modifying fstab and elilo.conf... ");
1648 sprintf(command, "stabelilo-me");
1649 res = run_program_and_log_output(command, 3);
1650 if (res) {
1651 popup_and_OK
1652 ("You will now edit fstab and elilo.conf, to make sure they match your new mountlist.");
1653 for (done = FALSE; !done;) {
1654 if (!g_text_mode) {
1655 newtSuspend();
1656 }
1657 sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
1658 paranoid_system(tmp);
1659 sprintf(tmp, "chroot %s %s /etc/elilo.conf", MNT_RESTORING, editor);
1660 paranoid_system(tmp);
1661 if (!g_text_mode) {
1662 newtResume();
1663 }
1664// newtCls();
1665 if (ask_me_yes_or_no("Edit them again?")) {
1666 continue;
1667 }
1668 done = TRUE;
1669 }
1670 } else {
1671 log_to_screen("elilo.conf and fstab were modified OK");
1672 }
1673 } else
1674 /* nuke mode */
1675 {
1676 res = TRUE;
1677 }
1678 paranoid_free(command);
1679 paranoid_free(tmp);
1680 paranoid_free(editor);
1681 return (res);
1682}
1683
1684/**************************************************************************
1685 *END_RUN_ELILO *
1686 **************************************************************************/
1687
1688
1689/**
1690 * Install LILO on the user's boot drive (determined by /etc/lilo.conf).
1691 * @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
1692 * @return 0 for success, nonzero for failure.
1693 */
1694int run_lilo(bool offer_to_run_stablilo)
1695{
1696 /** malloc **/
1697 char *command;
1698 char *tmp;
1699 char *editor;
1700
1701 int res;
1702 int done;
1703 bool run_lilo_M = FALSE;
1704 malloc_string(command);
1705 malloc_string(tmp);
1706 malloc_string(editor);
1707
1708 if (!run_program_and_log_output
1709 ("grep \"boot.*=.*/dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
1710 run_lilo_M = TRUE;
1711 }
1712
1713 strcpy(editor, find_my_editor());
1714 if (offer_to_run_stablilo
1715 && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
1716
1717 /* interactive mode */
1718 {
1719 mvaddstr_and_log_it(g_currentY,
1720 0,
1721 "Modifying fstab and lilo.conf, and running LILO... ");
1722 sprintf(command, "stablilo-me");
1723 res = run_program_and_log_output(command, 3);
1724 if (res) {
1725 popup_and_OK
1726 ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
1727 for (done = FALSE; !done;) {
1728 if (!g_text_mode) {
1729 newtSuspend();
1730 }
1731 sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1732 paranoid_system(tmp);
1733 sprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
1734 paranoid_system(tmp);
1735 if (!g_text_mode) {
1736 newtResume();
1737 }
1738// newtCls();
1739 if (ask_me_yes_or_no("Edit them again?")) {
1740 continue;
1741 }
1742 res =
1743 run_program_and_log_output("chroot " MNT_RESTORING
1744 " lilo -L", 3);
1745 if (res) {
1746 res =
1747 run_program_and_log_output("chroot " MNT_RESTORING
1748 " lilo", 3);
1749 }
1750 if (res) {
1751 done =
1752 ask_me_yes_or_no
1753 ("LILO failed. Re-edit system files?");
1754 } else {
1755 done = TRUE;
1756 }
1757 }
1758 } else {
1759 log_to_screen("lilo.conf and fstab were modified OK");
1760 }
1761 } else
1762 /* nuke mode */
1763 {
1764 mvaddstr_and_log_it(g_currentY,
1765 0,
1766 "Running LILO... ");
1767 res =
1768 run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
1769 3);
1770 if (res) {
1771 res =
1772 run_program_and_log_output("chroot " MNT_RESTORING " lilo",
1773 3);
1774 }
1775 if (res) {
1776 mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1777 log_to_screen
1778 ("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
1779 } else {
1780 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1781 }
1782 }
1783 if (run_lilo_M) {
1784 run_program_and_log_output("chroot " MNT_RESTORING
1785 " lilo -M /dev/hda", 3);
1786 run_program_and_log_output("chroot " MNT_RESTORING
1787 " lilo -M /dev/sda", 3);
1788 }
1789 paranoid_free(command);
1790 paranoid_free(tmp);
1791 paranoid_free(editor);
1792 return (res);
1793}
1794
1795/**************************************************************************
1796 *END_RUN_LILO *
1797 **************************************************************************/
1798
1799
1800/**
1801 * Install a raw MBR onto @p bd.
1802 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1803 * @param bd The device to copy the stored MBR to.
1804 * @return 0 for success, nonzero for failure.
1805 */
1806int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
1807{
1808 /** malloc **/
1809 char *command;
1810 char *boot_device;
1811 char *tmp;
1812 char *editor;
1813 int res;
1814 int done;
1815
1816 malloc_string(command);
1817 malloc_string(boot_device);
1818 malloc_string(tmp);
1819 malloc_string(editor);
1820 assert_string_is_neither_NULL_nor_zerolength(bd);
1821
1822 strcpy(editor, find_my_editor());
1823 strcpy(boot_device, bd);
1824 sprintf(command, "raw-MR %s /tmp/mountlist.txt", boot_device);
1825 log_msg(2, "run_raw_mbr() --- command='%s'", command);
1826
1827 if (offer_to_hack_scripts
1828 && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
1829 /* interactive mode */
1830 {
1831 mvaddstr_and_log_it(g_currentY, 0,
1832 "Modifying fstab and restoring MBR... ");
1833 for (done = FALSE; !done;) {
1834 if (!run_program_and_log_output("which vi", FALSE)) {
1835 popup_and_OK("You will now edit fstab");
1836 if (!g_text_mode) {
1837 newtSuspend();
1838 }
1839 sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1840 paranoid_system(tmp);
1841 if (!g_text_mode) {
1842 newtResume();
1843 }
1844// newtCls();
1845 }
1846 popup_and_get_string("Boot device",
1847 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1848 boot_device, MAX_STR_LEN / 4);
1849 sprintf(command, "stabraw-me %s", boot_device);
1850 res = run_program_and_log_output(command, 3);
1851 if (res) {
1852 done = ask_me_yes_or_no("Modifications failed. Re-try?");
1853 } else {
1854 done = TRUE;
1855 }
1856 }
1857 } else
1858 /* nuke mode */
1859 {
1860 mvaddstr_and_log_it(g_currentY, 0,
1861 "Restoring MBR... ");
1862 res = run_program_and_log_output(command, 3);
1863 }
1864 if (res) {
1865 mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1866 log_to_screen
1867 ("MBR+fstab processed w/error(s). See %s for more info.", MONDO_LOGFILE);
1868 } else {
1869 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1870 }
1871 paranoid_free(command);
1872 paranoid_free(boot_device);
1873 paranoid_free(tmp);
1874 paranoid_free(editor);
1875 return (res);
1876}
1877
1878/**************************************************************************
1879 *END_RUN_RAW_MBR *
1880 **************************************************************************/
1881
1882
1883
1884/**
1885 * malloc() and set sensible defaults for the mondorestore filename variables.
1886 * @param bkpinfo The backup information structure. Fields used:
1887 * - @c bkpinfo->tmpdir
1888 * - @c bkpinfo->disaster_recovery
1889 */
1890void setup_MR_global_filenames()
1891{
1892 char *temppath;
1893
1894 assert(bkpinfo != NULL);
1895
1896 malloc_string(g_biggielist_txt);
1897 malloc_string(g_filelist_full);
1898 malloc_string(g_filelist_imagedevs);
1899 malloc_string(g_imagedevs_restthese);
1900 malloc_string(g_mondo_cfg_file);
1901 malloc_string(g_mountlist_fname);
1902 malloc_string(g_mondo_home);
1903 /*
1904 malloc_string(g_tmpfs_mountpt);
1905 */
1906 malloc_string(g_isodir_device);
1907 malloc_string(g_isodir_format);
1908
1909 temppath = bkpinfo->tmpdir;
1910
1911 sprintf(g_biggielist_txt, "%s/%s", temppath, BIGGIELIST_TXT_STUB);
1912 sprintf(g_filelist_full, "%s/%s", temppath, FILELIST_FULL_STUB);
1913 sprintf(g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", temppath);
1914// sprintf(g_imagedevs_pot, "%s/tmp/imagedevs.pot", temppath);
1915 sprintf(g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
1916 temppath);
1917 if (bkpinfo->disaster_recovery) {
1918 sprintf(g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
1919 sprintf(g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
1920 } else {
1921 sprintf(g_mondo_cfg_file, "%s/%s", temppath, MONDO_CFG_FILE_STUB);
1922 sprintf(g_mountlist_fname, "%s/%s", temppath,
1923 MOUNTLIST_FNAME_STUB);
1924 }
1925}
1926
1927/**************************************************************************
1928 *END_SET_GLOBAL_FILENAME *
1929 **************************************************************************/
1930
1931
1932/**
1933 * Copy @p input_file (containing the result of a compare) to @p output_file,
1934 * deleting spurious "changes" along the way.
1935 * @param output_file The output file to write with spurious changes removed.
1936 * @param input_file The input file, a list of changed files created by a compare.
1937 */
1938void streamline_changes_file(char *output_file, char *input_file)
1939{
1940 FILE *fin;
1941 FILE *fout;
1942 /** malloc **/
1943 char *incoming;
1944
1945 assert_string_is_neither_NULL_nor_zerolength(output_file);
1946 assert_string_is_neither_NULL_nor_zerolength(input_file);
1947 malloc_string(incoming);
1948
1949 if (!(fin = fopen(input_file, "r"))) {
1950 log_OS_error(input_file);
1951 return;
1952 }
1953 if (!(fout = fopen(output_file, "w"))) {
1954 fatal_error("cannot open output_file");
1955 }
1956 for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
1957 fgets(incoming, MAX_STR_LEN - 1, fin)) {
1958 if (strncmp(incoming, "etc/adjtime", 11)
1959 && strncmp(incoming, "etc/mtab", 8)
1960 && strncmp(incoming, "tmp/", 4)
1961 && strncmp(incoming, "boot/map", 8)
1962 && !strstr(incoming, "incheckentry")
1963 && strncmp(incoming, "etc/mail/statistics", 19)
1964 && strncmp(incoming, "var/", 4))
1965 fprintf(fout, "%s", incoming); /* don't need \n here, for some reason.. */
1966 }
1967 paranoid_fclose(fout);
1968 paranoid_fclose(fin);
1969 paranoid_free(incoming);
1970}
1971
1972/**************************************************************************
1973 *END_STREAMLINE_CHANGES_FILE *
1974 **************************************************************************/
1975
1976
1977/**
1978 * Give the user twenty seconds to press Ctrl-Alt-Del before we nuke their drives.
1979 */
1980void twenty_seconds_til_yikes()
1981{
1982 int i;
1983 /* MALLOC * */
1984 char *tmp;
1985
1986 malloc_string(tmp);
1987 if (does_file_exist("/tmp/NOPAUSE")) {
1988 return;
1989 }
1990 open_progress_form("CAUTION",
1991 "Be advised: I am about to ERASE your hard disk(s)!",
1992 "You may press Ctrl+Alt+Del to abort safely.",
1993 "", 20);
1994 for (i = 0; i < 20; i++) {
1995 g_current_progress = i;
1996 sprintf(tmp, "You have %d seconds left to abort.", 20 - i);
1997 update_progress_form(tmp);
1998 sleep(1);
1999 }
2000 close_progress_form();
2001 paranoid_free(tmp);
2002}
2003
2004/**************************************************************************
2005 *END_TWENTY_SECONDS_TIL_YIKES *
2006 **************************************************************************/
2007
2008
2009/**
2010 * Unmount all devices in @p p_external_copy_of_mountlist.
2011 * @param p_external_copy_of_mountlist The mountlist to guide the devices to unmount.
2012 * @return 0 for success, nonzero for failure.
2013 */
2014int unmount_all_devices(struct mountlist_itself
2015 *p_external_copy_of_mountlist)
2016{
2017 struct mountlist_itself *mountlist;
2018 int retval = 0, lino, res = 0, i;
2019 char *command;
2020 char *tmp;
2021
2022 malloc_string(command);
2023 malloc_string(tmp);
2024 assert(p_external_copy_of_mountlist != NULL);
2025
2026 mountlist = malloc(sizeof(struct mountlist_itself));
2027 memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
2028 sizeof(struct mountlist_itself));
2029 sort_mountlist_by_mountpoint(mountlist, 0);
2030
2031 run_program_and_log_output("df -m", 3);
2032 mvaddstr_and_log_it(g_currentY, 0, "Unmounting devices ");
2033 open_progress_form("Unmounting devices",
2034 "Unmounting all devices that were mounted,",
2035 "in preparation for the post-restoration reboot.",
2036 "", mountlist->entries);
2037 chdir("/");
2038 for (i = 0;
2039 i < 10
2040 &&
2041 run_program_and_log_output
2042 ("ps | grep buffer | grep -v \"grep buffer\"", TRUE) == 0;
2043 i++) {
2044 sleep(1);
2045 log_msg(2, "Waiting for buffer() to finish");
2046 }
2047
2048 paranoid_system("sync");
2049
2050 sprintf(tmp, "cp -f %s " MNT_RESTORING "/var/log", MONDO_LOGFILE);
2051 if (run_program_and_log_output(tmp, FALSE)) {
2052 log_msg(1,
2053 "Error. Failed to copy log to PC's /var/log dir. (Mounted read-only?)");
2054 }
2055 if (does_file_exist("/tmp/DUMBASS-GENTOO")) {
2056 run_program_and_log_output("mkdir -p " MNT_RESTORING
2057 "/mnt/.boot.d", 5);
2058 }
2059
2060 /* Unmounting the local /proc and /sys first */
2061 run_program_and_log_output("umount " MNT_RESTORING "/proc",3);
2062 run_program_and_log_output("umount " MNT_RESTORING "/sys",3);
2063
2064 for (lino = mountlist->entries - 1; lino >= 0; lino--) {
2065 if (!strcmp(mountlist->el[lino].mountpoint, "lvm")) {
2066 continue;
2067 }
2068 sprintf(tmp, "Unmounting device %s ", mountlist->el[lino].device);
2069
2070 update_progress_form(tmp);
2071 if (is_this_device_mounted(mountlist->el[lino].device)) {
2072 if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
2073 sprintf(command, "swapoff %s", mountlist->el[lino].device);
2074 } else {
2075 if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
2076 sprintf(command, "umount %s/", MNT_RESTORING);
2077 log_msg(3,
2078 "Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
2079 } else {
2080 sprintf(command, "umount " MNT_RESTORING "%s",
2081 mountlist->el[lino].mountpoint);
2082 }
2083 }
2084 log_msg(10, "The 'umount' command is '%s'", command);
2085 res = run_program_and_log_output(command, 3);
2086 } else {
2087 strcat(tmp, "...not mounted anyway :-) OK");
2088 res = 0;
2089 }
2090 g_current_progress++;
2091 if (res) {
2092 strcat(tmp, "...Failed");
2093 retval++;
2094 log_to_screen(tmp);
2095 } else {
2096 log_msg(2, tmp);
2097 }
2098 }
2099 close_progress_form();
2100 if (retval) {
2101 mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
2102 } else {
2103 mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2104 }
2105 if (retval) {
2106 log_to_screen("Unable to unmount some of your partitions.");
2107 } else {
2108 log_to_screen("All partitions were unmounted OK.");
2109 }
2110 free(mountlist);
2111 paranoid_free(command);
2112 paranoid_free(tmp);
2113 return (retval);
2114}
2115
2116/**************************************************************************
2117 *END_UNMOUNT_ALL_DEVICES *
2118 **************************************************************************/
2119
2120
2121
2122/**
2123 * Extract mondo-restore.cfg and the mountlist from the tape inserted
2124 * to the ./tmp/ directory.
2125 * @param dev The tape device to read from.
2126 * @return 0 for success, nonzero for failure.
2127 */
2128int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
2129{
2130 char *command;
2131 int res = 0;
2132
2133 malloc_string(command);
2134
2135 if (bkpinfo->use_obdr) {
2136 skip_obdr();
2137 } else {
2138 // BCO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
2139 set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
2140 }
2141
2142 sprintf(command,
2143 "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx ./%s ./%s ./%s ./%s ./%s",
2144 dev,
2145 bkpinfo->internal_tape_block_size,
2146 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size,
2147 MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
2148 BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
2149 log_msg(2, "command = '%s'", command);
2150 res = run_program_and_log_output(command, -1);
2151 if (res != 0) {
2152 if (does_file_exist(MONDO_CFG_FILE_STUB)) {
2153 res = 0;
2154 } else {
2155 /* Doing that allow us to remain compatible with pre-2.2.5 versions */
2156 log_msg(2, "pre-2.2.4 compatible mode on");
2157 sprintf(command,
2158 "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s",
2159 dev,
2160 bkpinfo->internal_tape_block_size,
2161 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size,
2162 MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
2163 BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
2164 log_msg(2, "command = '%s'", command);
2165 res = run_program_and_log_output(command, -1);
2166 if ((res != 0) && (does_file_exist(MONDO_CFG_FILE_STUB))) {
2167 res = 0;
2168 }
2169 }
2170 }
2171 paranoid_free(command);
2172 return (res);
2173}
2174
2175
2176
2177/**
2178 * Get the configuration file from the floppy, tape, or CD.
2179 * @param bkpinfo The backup information structure. Fields used:
2180 * - @c bkpinfo->backup_media_type
2181 * - @c bkpinfo->media_device
2182 * - @c bkpinfo->tmpdir
2183 * @return 0 for success, nonzero for failure.
2184 */
2185int get_cfg_file_from_archive()
2186{
2187 int retval = 0;
2188
2189 /** malloc *****/
2190 char *device;
2191 char *command;
2192 char *cfg_file;
2193 char *mounted_cfgf_path;
2194 char *tmp;
2195 char *mountpt;
2196 char *ramdisk_fname;
2197 char *mountlist_file;
2198 bool extract_mountlist_stub;
2199 bool extract_i_want_my_lvm;
2200
2201 bool try_plan_B;
2202
2203 assert(bkpinfo != NULL);
2204 malloc_string(cfg_file);
2205 malloc_string(mounted_cfgf_path);
2206 malloc_string(mountpt);
2207 malloc_string(ramdisk_fname);
2208 malloc_string(mountlist_file);
2209 malloc_string(device);
2210 malloc_string(command);
2211 malloc_string(tmp);
2212 log_msg(2, "gcffa --- starting");
2213 log_to_screen("I'm thinking...");
2214 sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
2215 device[0] = '\0';
2216 chdir(bkpinfo->tmpdir);
2217 strcpy(cfg_file, MONDO_CFG_FILE_STUB);
2218 unlink(cfg_file); // cfg_file[] is missing the '/' at the start, FYI, by intent
2219 unlink(FILELIST_FULL_STUB);
2220 unlink(BIGGIELIST_TXT_STUB);
2221 sprintf(command, "mkdir -p %s", mountpt);
2222 run_program_and_log_output(command, FALSE);
2223
2224 sprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
2225 sprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
2226 // make_hole_for_file( cfg_file );
2227 // make_hole_for_file( mountlist_file);
2228 log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
2229
2230 if (!does_file_exist(cfg_file)) {
2231 log_msg(2, "gcffa --- we don't have cfg file yet.");
2232 if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2233 try_plan_B = TRUE;
2234 } else {
2235 log_msg(2, "gcffa --- calling mount_media now :)");
2236 if (!mount_media()) {
2237 log_msg(2,
2238 "gcffa --- managed to mount CD; so, no need for Plan B");
2239 try_plan_B = FALSE;
2240 } else {
2241 try_plan_B = TRUE;
2242 }
2243 if (what_number_cd_is_this() > 1) {
2244 insist_on_this_cd_number((g_current_media_number = 1));
2245 }
2246 }
2247 if (try_plan_B) {
2248 log_msg(2, "gcffa --- OK, switching to Plan B");
2249 chdir(bkpinfo->tmpdir);
2250 run_program_and_log_output("mkdir -p tmp", FALSE);
2251
2252 if (strlen(bkpinfo->media_device) == 0) {
2253 strcpy(bkpinfo->media_device, "/dev/st0");
2254 log_msg(2, "media_device is blank; assuming %s");
2255 }
2256 strcpy(tmp, bkpinfo->media_device);
2257 if (extract_cfg_file_and_mountlist_from_tape_dev
2258 (bkpinfo->media_device)) {
2259 strcpy(bkpinfo->media_device, "/dev/st0");
2260 if (extract_cfg_file_and_mountlist_from_tape_dev
2261 (bkpinfo->media_device)) {
2262 strcpy(bkpinfo->media_device, "/dev/osst0");
2263 if (extract_cfg_file_and_mountlist_from_tape_dev
2264 (bkpinfo->media_device)) {
2265 strcpy(bkpinfo->media_device, "/dev/ht0");
2266 if (extract_cfg_file_and_mountlist_from_tape_dev
2267 (bkpinfo->media_device)) {
2268 log_msg(3,
2269 "I tried lots of devices but none worked.");
2270 strcpy(bkpinfo->media_device, tmp);
2271 }
2272 }
2273 }
2274 }
2275
2276 if (!does_file_exist("tmp/mondo-restore.cfg")) {
2277 log_to_screen("Cannot find config info on media");
2278 return (1);
2279 }
2280 } else {
2281 if (does_file_exist("/"MOUNTLIST_FNAME_STUB)) {
2282 extract_mountlist_stub = FALSE;
2283 } else {
2284 extract_mountlist_stub = TRUE;
2285 }
2286 if (does_file_exist("/"IWANTMYLVM_STUB)) {
2287 extract_i_want_my_lvm = FALSE;
2288 } else {
2289 extract_i_want_my_lvm = TRUE;
2290 }
2291
2292 log_msg(2,
2293 "gcffa --- Plan B, a.k.a. untarring some file from all.tar.gz");
2294 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
2295 run_program_and_log_output(command, TRUE);
2296 if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
2297 /* Doing that allow us to remain compatible with pre-2.2.5 versions */
2298 log_msg(2, "pre-2.2.4 compatible mode on");
2299 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
2300 run_program_and_log_output(command, TRUE);
2301 if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
2302 fatal_error
2303 ("Please reinsert the disk/CD and try again.");
2304 }
2305 }
2306 }
2307 }
2308 if (does_file_exist(MONDO_CFG_FILE_STUB)) {
2309 log_msg(1, "gcffa --- great! We've got the config file");
2310 sprintf(tmp, "%s/%s",
2311 call_program_and_get_last_line_of_output("pwd"),
2312 MONDO_CFG_FILE_STUB);
2313 sprintf(command, "cp -f %s %s", tmp, cfg_file);
2314 iamhere(command);
2315 if (strcmp(tmp, cfg_file)
2316 && run_program_and_log_output(command, 1)) {
2317 log_msg(1,
2318 "... but an error occurred when I tried to move it to %s",
2319 cfg_file);
2320 } else {
2321 log_msg(1, "... and I moved it successfully to %s", cfg_file);
2322 }
2323 sprintf(command, "cp -f %s/%s %s",
2324 call_program_and_get_last_line_of_output("pwd"),
2325 MOUNTLIST_FNAME_STUB, mountlist_file);
2326 iamhere(command);
2327 if (extract_mountlist_stub) {
2328 if (strcmp(tmp, cfg_file)
2329 && run_program_and_log_output(command, 1)) {
2330 log_msg(1, "Failed to get mountlist");
2331 } else {
2332 log_msg(1, "Got mountlist too");
2333 sprintf(command, "cp -f %s %s", mountlist_file,
2334 g_mountlist_fname);
2335 if (run_program_and_log_output(command, 1)) {
2336 log_msg(1, "Failed to copy mountlist to /tmp");
2337 } else {
2338 log_msg(1, "Copied mountlist to /tmp as well OK");
2339 sprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
2340 run_program_and_log_output(command, 1);
2341 }
2342 }
2343 }
2344 }
2345 run_program_and_log_output("umount " MNT_CDROM, FALSE);
2346 if (!does_file_exist(cfg_file)) {
2347 iamhere(cfg_file);
2348 log_msg(1, "%s not found", cfg_file);
2349 log_to_screen
2350 ("Oh dear. Unable to recover configuration file from boot disk");
2351 return (1);
2352 }
2353
2354 log_to_screen("Recovered mondo-restore.cfg");
2355 if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
2356 log_to_screen("...but not mountlist.txt - a pity, really...");
2357 }
2358 else {
2359 /* Is this code really useful ??? */
2360 if (extract_mountlist_stub) {
2361 sprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
2362 bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
2363 run_program_and_log_output(command, FALSE);
2364 }
2365 }
2366
2367 sprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
2368 run_program_and_log_output(command, FALSE);
2369 if (extract_mountlist_stub) {
2370 sprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
2371 run_program_and_log_output(command, FALSE);
2372 }
2373 sprintf(command, "cp -f etc/raidtab /etc/");
2374 run_program_and_log_output(command, FALSE);
2375 if (extract_i_want_my_lvm) {
2376 sprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
2377 run_program_and_log_output(command, FALSE);
2378 }
2379 g_backup_media_type = bkpinfo->backup_media_type;
2380 paranoid_free(device);
2381 paranoid_free(command);
2382 paranoid_free(tmp);
2383 paranoid_free(cfg_file);
2384 paranoid_free(mounted_cfgf_path);
2385 paranoid_free(mountpt);
2386 paranoid_free(ramdisk_fname);
2387 paranoid_free(mountlist_file);
2388 return (retval);
2389}
2390
2391/**************************************************************************
2392 *END_GET_CFG_FILE_FROM_ARCHIVE *
2393 **************************************************************************/
2394
2395/* @} - end restoreUtilityGroup */
2396
2397
2398/***************************************************************************
2399 * F@ *
2400 * () -- Hugo Rabson *
2401 * *
2402 * Purpose: *
2403 * *
2404 * Called by: *
2405 * Params: - - *
2406 * Returns: 0=success; nonzero=failure *
2407 ***************************************************************************/
2408
2409
2410
2411void wait_until_software_raids_are_prepped(char *mdstat_file,
2412 int wait_for_percentage)
2413{
2414 struct raidlist_itself *raidlist;
2415 int unfinished_mdstat_devices = 9999, i;
2416 char *screen_message;
2417
2418 malloc_string(screen_message);
2419 raidlist = malloc(sizeof(struct raidlist_itself));
2420
2421 assert(wait_for_percentage <= 100);
2422 iamhere("wait_until_software_raids_are_prepped");
2423 while (unfinished_mdstat_devices > 0) {
2424 // FIXME: Prefix '/dev/' should really be dynamic!
2425 if (parse_mdstat(raidlist, "/dev/")) {
2426 log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
2427 log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
2428 return;
2429 }
2430 for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
2431 if (raidlist->el[i].progress < wait_for_percentage) {
2432 unfinished_mdstat_devices++;
2433 if (raidlist->el[i].progress == -1) // delayed while another partition inits
2434 {
2435 continue;
2436 }
2437 log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
2438 sprintf(screen_message, "Sync'ing %s",
2439 raidlist->el[i].raid_device);
2440 open_evalcall_form(screen_message);
2441 while (raidlist->el[i].progress < wait_for_percentage) {
2442 log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
2443 update_evalcall_form(raidlist->el[i].progress);
2444 sleep(2);
2445 // FIXME: Prefix '/dev/' should really be dynamic!
2446 if (parse_mdstat(raidlist, "/dev/")) {
2447 break;
2448 }
2449 }
2450 close_evalcall_form();
2451 }
2452 }
2453 }
2454 paranoid_free(screen_message);
2455 paranoid_free(raidlist);
2456}
2457
2458
Note: See TracBrowser for help on using the repository browser.