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

Last change on this file since 1548 was 1548, checked in by Bruno Cornec, 17 years ago
  • Add the possibiilty to edit in interactive mode mtab and device.map for grub
  • Remove blkid cache files after restore to avoid problems in cloning mode
  • Fix what seems to appear a huge number of bugs in hack-fstab (illustration of 1 LOC = 1 bug :-)
  • Especially improve LABEL and UUID support.
  • Should fix #185
  • Exclude_path should be 4*MAX_STR_LEN everywhere. Fixed now.
  • Increasing that value will allow to having larger exclude paths.
  • Should solve bug #137 (and maybe #3 as well)
  • Adds support for fedora 7

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