source: trunk/mondo/mondo/mondorestore/mondo-rstr-tools.c @ 59

Last change on this file since 59 was 59, checked in by bcornec, 14 years ago

Trunk: indent on all source files

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