source: branches/2.2.5/mondo/src/mondorestore/mondo-rstr-tools.c @ 1738

Last change on this file since 1738 was 1738, checked in by Bruno Cornec, 12 years ago

usb detection place before /dev detection in device name at restore time

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