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

Last change on this file since 870 was 870, checked in by Bruno Cornec, 14 years ago
  • Checks variables berfore getting them from env during restore
  • source start-nfs to get env. Var. correctly set for mondorestore
  • Property svn:keywords set to Id
File size: 79.9 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] = "\0";
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, "grep -x \"%s\" %s", file, list_fname);
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 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, "grep mondorescue %s > /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\
571grep -v mondorescue %s > %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 | grep -F " 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/%s-%d.iso", bkpinfo->isodir,
738                bkpinfo->nfs_remote_dir, bkpinfo->prefix, 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/%s-%d.iso -t iso9660 -o loop,ro %s",
743                bkpinfo->isodir, bkpinfo->nfs_remote_dir,
744                bkpinfo->prefix, 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/%s-%d.iso", bkpinfo->isodir,
751                bkpinfo->prefix, 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/%s-%d.iso -t iso9660 -o loop,ro %s",
756                bkpinfo->isodir, bkpinfo->prefix, 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 = NULL;
976    char *tmp = NULL;
977    char *tmp1 = NULL;
978    char *command = NULL;
979    char *iso_mnt = NULL;
980    char *iso_path = NULL;
981    char *old_isodir = NULL;
982    char cfg_file[100];
983    t_bkptype media_specified_by_user;
984
985    malloc_string(command);
986    malloc_string(iso_mnt);
987    malloc_string(iso_path);
988    malloc_string(old_isodir);
989    malloc_string(value);
990    malloc_string(tmp);
991//  assert_string_is_neither_NULL_nor_zerolength(cfg_file);
992    assert(bkpinfo != NULL);
993
994    if (!cfgf) {
995        strcpy(cfg_file, g_mondo_cfg_file);
996    } else {
997        strcpy(cfg_file, cfgf);
998    }
999
1000    media_specified_by_user = bkpinfo->backup_media_type;   // or 'none', if not specified
1001
1002    if (0 == read_cfg_var(cfg_file, "backup-media-type", value)) {
1003        if (!strcmp(value, "cdstream")) {
1004            bkpinfo->backup_media_type = cdstream;
1005        } else if (!strcmp(value, "cdr")) {
1006            bkpinfo->backup_media_type = cdr;
1007        } else if (!strcmp(value, "cdrw")) {
1008            bkpinfo->backup_media_type = cdrw;
1009        } else if (!strcmp(value, "dvd")) {
1010            bkpinfo->backup_media_type = dvd;
1011        } else if (!strcmp(value, "iso")) {
1012/*
1013      if (am_I_in_disaster_recovery_mode()
1014      && !run_program_and_log_output("mount /dev/cdrom "MNT_CDROM, 1)
1015      && does_file_exist(MNT_CDROM"/archives/filelist.0"))
1016*/
1017
1018// Patch by Conor Daly - 2004/07/12
1019            bkpinfo->backup_media_type = iso;
1020            if (am_I_in_disaster_recovery_mode()) {
1021                /* Check to see if CD is already mounted before mounting it... */
1022                if (!is_this_device_mounted("/dev/cdrom")) {
1023                    log_msg(2,
1024                            "NB: CDROM device not mounted, mounting...");
1025                    run_program_and_log_output("mount /dev/cdrom "
1026                                               MNT_CDROM, 1);
1027                }
1028                if (does_file_exist(MNT_CDROM "/archives/filelist.0")) {
1029                    bkpinfo->backup_media_type = cdr;
1030                    run_program_and_log_output("umount " MNT_CDROM, 1);
1031                    log_it
1032                        ("Re-jigging configuration AGAIN. CD-R, not ISO.");
1033                }
1034            }
1035            if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
1036                    strcpy(bkpinfo->prefix,value);
1037            } else {
1038                    strcpy(bkpinfo->prefix,STD_PREFIX);
1039            }
1040        } else if (!strcmp(value, "nfs")) {
1041            bkpinfo->backup_media_type = nfs;
1042            if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
1043                    strcpy(bkpinfo->prefix,value);
1044            } else {
1045                    strcpy(bkpinfo->prefix,STD_PREFIX);
1046            }
1047            /* We need to override prefix value in PXE mode as it's
1048             * already done in start-nfs */
1049            if (tmp = getenv("imgname") == NULL) {
1050                fatal_error("no imgname variable in environment");
1051            }
1052            if (strstr(call_program_and_get_last_line_of_output
1053               ("cat /proc/cmdline"), "pxe")) {
1054                    strcpy(bkpinfo->prefix,tmp);
1055            }
1056
1057        } else if (!strcmp(value, "tape")) {
1058            bkpinfo->backup_media_type = tape;
1059        } else if (!strcmp(value, "udev")) {
1060            bkpinfo->backup_media_type = udev;
1061        } else {
1062            fatal_error("UNKNOWN bkp-media-type");
1063        }
1064    } else {
1065        fatal_error("backup-media-type not specified!");
1066    }
1067    if (bkpinfo->disaster_recovery) {
1068        if (bkpinfo->backup_media_type == cdstream) {
1069            sprintf(bkpinfo->media_device, "/dev/cdrom");
1070//          bkpinfo->media_size[0] = -1;
1071            bkpinfo->media_size[0] = 1999 * 1024;
1072            bkpinfo->media_size[1] = 650;   /* good guess */
1073        } else if (bkpinfo->backup_media_type == tape
1074                   || bkpinfo->backup_media_type == udev) {
1075            if (read_cfg_var(cfg_file, "media-dev", value)) {
1076                fatal_error("Cannot get tape device name from cfg file");
1077            }
1078            strcpy(bkpinfo->media_device, value);
1079            read_cfg_var(cfg_file, "media-size", value);
1080            bkpinfo->media_size[1] = atol(value);
1081            sprintf(tmp, "Backup medium is TAPE --- dev=%s",
1082                    bkpinfo->media_device);
1083            log_msg(2, tmp);
1084        } else {
1085            strcpy(bkpinfo->media_device, "/dev/cdrom");    /* we don't really need this var */
1086            bkpinfo->media_size[0] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
1087            bkpinfo->media_size[1] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
1088            log_msg(2, "Backup medium is CD-R[W]");
1089        }
1090    } else {
1091        log_msg(2,
1092                "Not in Disaster Recovery Mode. No need to derive device name from config file.");
1093    }
1094
1095    read_cfg_var(cfg_file, "use-star", value);
1096    if (strstr(value, "yes")) {
1097        bkpinfo->use_star = TRUE;
1098        log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
1099    }
1100
1101    if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
1102        bkpinfo->internal_tape_block_size = atol(value);
1103        log_msg(1, "Internal tape block size has been custom-set to %ld",
1104                bkpinfo->internal_tape_block_size);
1105    } else {
1106        bkpinfo->internal_tape_block_size =
1107            DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
1108        log_msg(1, "Internal tape block size = default (%ld)",
1109                DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
1110    }
1111
1112    read_cfg_var(cfg_file, "use-lzo", value);
1113    if (strstr(value, "yes")) {
1114        bkpinfo->use_lzo = TRUE;
1115        strcpy(bkpinfo->zip_exe, "lzop");
1116        strcpy(bkpinfo->zip_suffix, "lzo");
1117    } else {
1118        read_cfg_var(cfg_file, "use-comp", value);
1119        if (strstr(value, "yes")) {
1120            bkpinfo->use_lzo = FALSE;
1121            strcpy(bkpinfo->zip_exe, "bzip2");
1122            strcpy(bkpinfo->zip_suffix, "bz2");
1123        } else {
1124            bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
1125        }
1126    }
1127
1128    value[0] = '\0';
1129    read_cfg_var(cfg_file, "differential", value);
1130    if (!strcmp(value, "yes") || !strcmp(value, "1")) {
1131        bkpinfo->differential = TRUE;
1132    }
1133    log_msg(2, "differential var = '%s'", value);
1134    if (bkpinfo->differential) {
1135        log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
1136    } else {
1137        log_msg(2, "This is a regular (full) backup");
1138    }
1139
1140    read_cfg_var(g_mondo_cfg_file, "please-dont-eject", tmp);
1141    if (tmp[0]
1142        ||
1143        strstr(call_program_and_get_last_line_of_output
1144               ("cat /proc/cmdline"), "donteject")) {
1145        bkpinfo->please_dont_eject = TRUE;
1146        log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
1147    }
1148
1149    if (bkpinfo->backup_media_type == nfs) {
1150        if (!cfgf) {
1151            log_msg(2, "nfs_mount remains %s", bkpinfo->nfs_mount);
1152            log_msg(2, "nfs_remote_dir remains %s",
1153                    bkpinfo->nfs_remote_dir);
1154            log_msg(2,
1155                    "...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
1156        } else {
1157            read_cfg_var(g_mondo_cfg_file, "nfs-server-mount",
1158                         bkpinfo->nfs_mount);
1159            read_cfg_var(g_mondo_cfg_file, "nfs-server-path",
1160                         bkpinfo->nfs_remote_dir);
1161            log_msg(2, "nfs_mount is %s", bkpinfo->nfs_mount);
1162            log_msg(2, "nfs_remote_dir is %s", bkpinfo->nfs_remote_dir);
1163        }
1164        /* We need to override values in PXE mode as it's
1165         * already done in start-nfs */
1166        if (tmp = getenv("nfsmount") == NULL) {
1167            fatal_error("no nfsmount variable in environment");
1168        }
1169        if (tmp1 = getenv("dirimg") == NULL) {
1170            fatal_error("no dirimg variable in environment");
1171        }
1172        if (strstr(call_program_and_get_last_line_of_output
1173           ("cat /proc/cmdline"), "pxe")) {
1174                strcpy(bkpinfo->nfs_mount,tmp);
1175                strcpy(bkpinfo->nfs_remote_dir,tmp1);
1176            }
1177    } else if (bkpinfo->backup_media_type == iso) {
1178        /* Patch by Conor Daly 23-june-2004
1179         * to correctly mount iso-dev and set a sensible
1180         * isodir in disaster recovery mode
1181         */
1182        strcpy(old_isodir, bkpinfo->isodir);
1183        read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
1184        read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
1185        sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
1186        if (!bkpinfo->isodir[0]) {
1187            strcpy(bkpinfo->isodir, old_isodir);
1188        }
1189        if (!bkpinfo->disaster_recovery) {
1190            if (strcmp(old_isodir, bkpinfo->isodir)) {
1191                log_it
1192                    ("user nominated isodir differs from archive, keeping user's choice: %s %s\n",
1193                     old_isodir, bkpinfo->isodir);
1194                strcpy(bkpinfo->isodir, old_isodir);
1195            }
1196        }
1197        read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
1198        log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir,
1199                g_isodir_device);
1200        if (bkpinfo->disaster_recovery) {
1201            if (is_this_device_mounted(g_isodir_device)) {
1202                log_msg(2, "NB: isodir is already mounted");
1203                /* Find out where it's mounted */
1204                sprintf(command,
1205                        "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
1206                        g_isodir_device);
1207                log_it("command = %s", command);
1208                log_it("res of it = %s",
1209                       call_program_and_get_last_line_of_output(command));
1210                sprintf(iso_mnt, "%s",
1211                        call_program_and_get_last_line_of_output(command));
1212            } else {
1213                sprintf(iso_mnt, "/tmp/isodir");
1214                sprintf(tmp, "mkdir -p %s", iso_mnt);
1215                run_program_and_log_output(tmp, 5);
1216                sprintf(tmp, "mount %s %s", g_isodir_device, iso_mnt);
1217                if (run_program_and_log_output(tmp, 3)) {
1218                    log_msg(1,
1219                            "Unable to mount isodir. Perhaps this is really a CD backup?");
1220                    bkpinfo->backup_media_type = cdr;
1221                    strcpy(bkpinfo->media_device, "/dev/cdrom");    /* superfluous */
1222                    bkpinfo->isodir[0] = iso_mnt[0] = iso_path[0] = '\0';
1223                    if (mount_cdrom(bkpinfo)) {
1224                        fatal_error
1225                            ("Unable to mount isodir. Failed to mount CD-ROM as well.");
1226                    } else {
1227                        log_msg(1,
1228                                "You backed up to disk, then burned some CDs.");
1229                    }
1230                }
1231            }
1232            /* bkpinfo->isodir should now be the true path to prefix-1.iso etc... */
1233            if (bkpinfo->backup_media_type == iso) {
1234                sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
1235            }
1236        }
1237    }
1238
1239    if (media_specified_by_user != none) {
1240        if (g_restoring_live_from_cd) {
1241            if (bkpinfo->backup_media_type != media_specified_by_user) {
1242                log_msg(2,
1243                        "bkpinfo->backup_media_type != media_specified_by_user, so I'd better ask :)");
1244                interactively_obtain_media_parameters_from_user(bkpinfo,
1245                                                                FALSE);
1246                media_specified_by_user = bkpinfo->backup_media_type;
1247                get_cfg_file_from_archive(bkpinfo);
1248/*
1249              if (media_specified_by_user != cdr && media_specified_by_user == cdrw)
1250                { g_restoring_live_from_cd = FALSE; }
1251*/
1252            }
1253        }
1254        bkpinfo->backup_media_type = media_specified_by_user;
1255    }
1256    g_backup_media_type = bkpinfo->backup_media_type;
1257    paranoid_free(value);
1258    paranoid_free(tmp);
1259    paranoid_free(command);
1260    paranoid_free(iso_mnt);
1261    paranoid_free(iso_path);
1262    paranoid_free(old_isodir);
1263    return (0);
1264
1265}
1266
1267/**************************************************************************
1268 *END_READ_CFG_FILE_INTO_BKPINFO                                          *
1269 **************************************************************************/
1270
1271
1272
1273
1274/**
1275 * Allow the user to edit the filelist and biggielist.
1276 * The filelist is unlinked after it is read.
1277 * @param bkpinfo The backup information structure. Fields used:
1278 * - @c bkpinfo->backup_media_type
1279 * - @c bkpinfo->isodir
1280 * - @c bkpinfo->media_device
1281 * - @c bkpinfo->tmpdir
1282 * @return The filelist structure containing the information read from disk.
1283 */
1284struct
1285s_node *process_filelist_and_biggielist(struct s_bkpinfo *bkpinfo)
1286{
1287    struct s_node *filelist;
1288
1289  /** add mallocs**/
1290    char *command;
1291    char *tmp;
1292    int res = 0;
1293    pid_t pid;
1294
1295    assert(bkpinfo != NULL);
1296    malloc_string(command);
1297    malloc_string(tmp);
1298
1299    if (does_file_exist(g_filelist_full)
1300        && does_file_exist(g_biggielist_txt)) {
1301        log_msg(1, "%s exists", g_filelist_full);
1302        log_msg(1, "%s exists", g_biggielist_txt);
1303        log_msg(2,
1304                "Filelist and biggielist already recovered from media. Yay!");
1305    } else {
1306        getcwd(tmp, MAX_STR_LEN);
1307        chdir(bkpinfo->tmpdir);
1308        log_msg(1, "chdir(%s)", bkpinfo->tmpdir);
1309        log_to_screen("Extracting filelist and biggielist from media...");
1310        unlink("/tmp/filelist.full");
1311        unlink("/" FILELIST_FULL_STUB);
1312        unlink("/tmp/i-want-my-lvm");
1313        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1314            sprintf(command,
1315                    "tar -zxf %s %s %s %s %s %s",
1316                    bkpinfo->media_device,
1317                    MOUNTLIST_FNAME_STUB,
1318                    BIGGIELIST_TXT_STUB,
1319                    FILELIST_FULL_STUB,
1320                    "tmp/i-want-my-lvm", MONDO_CFG_FILE_STUB);
1321            log_msg(1, "tarcommand = %s", command);
1322            run_program_and_log_output(command, 1);
1323        } else {
1324            log_msg(2,
1325                    "Calling insist_on_this_cd_number; bkpinfo->isodir=%s",
1326                    bkpinfo->isodir);
1327            insist_on_this_cd_number(bkpinfo, 1);
1328            log_msg(2, "Back from iotcn");
1329            run_program_and_log_output("mount", 1);
1330            sprintf(command,
1331                    "tar -zxf %s/images/all.tar.gz %s %s %s %s %s",
1332                    MNT_CDROM,
1333                    MOUNTLIST_FNAME_STUB,
1334                    BIGGIELIST_TXT_STUB,
1335                    FILELIST_FULL_STUB,
1336                    "tmp/i-want-my-lvm", MONDO_CFG_FILE_STUB);
1337
1338            log_msg(1, "tarcommand = %s", command);
1339            run_program_and_log_output(command, 1);
1340//    popup_and_OK("Press ENTER to continue");
1341            if (!does_file_exist(BIGGIELIST_TXT_STUB)) {
1342                fatal_error
1343                    ("all.tar.gz did not include tmp/biggielist.txt");
1344            }
1345            if (!does_file_exist(FILELIST_FULL_STUB)) {
1346                fatal_error
1347                    ("all.tar.gz did not include tmp/filelist.full.gz");
1348            }
1349        }
1350        sprintf(command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
1351                g_mondo_cfg_file);
1352        run_program_and_log_output(command, FALSE);
1353
1354        sprintf(command, "cp -f %s/%s %s", bkpinfo->tmpdir,
1355                BIGGIELIST_TXT_STUB, g_biggielist_txt);
1356        log_msg(1, "command = %s", command);
1357        paranoid_system(command);
1358        sprintf(command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
1359                FILELIST_FULL_STUB, g_filelist_full);
1360        log_msg(1, "command = %s", command);
1361        paranoid_system(command);
1362    }
1363
1364    if (am_I_in_disaster_recovery_mode()
1365        &&
1366        ask_me_yes_or_no("Do you want to retrieve the mountlist as well?"))
1367    {
1368//      sprintf(command, "cp -f tmp/mountlist.txt /tmp");
1369        sprintf(command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
1370                bkpinfo->tmpdir);
1371        paranoid_system(command);
1372    }
1373
1374    chdir(tmp);
1375
1376    if (!does_file_exist(g_biggielist_txt)) {
1377        log_msg(1, "Warning - %s not found", g_biggielist_txt);
1378    }
1379    if (!does_file_exist(g_filelist_full)) {
1380        log_msg(1, "Warning - %s does not exist", g_filelist_full);
1381    }
1382//  popup_and_OK("Wonderful.");
1383
1384    log_msg(2, "Forking");
1385    pid = fork();
1386    switch (pid) {
1387    case -1:
1388        fatal_error("Forking error");
1389        break;
1390
1391    case 0:
1392        log_to_screen("Pre-processing filelist");
1393        if (!does_file_exist(g_biggielist_txt)) {
1394            sprintf(command, "> %s", g_biggielist_txt);
1395            paranoid_system(command);
1396        }
1397        sprintf(command, "grep  -x \"/dev/.*\" %s > %s",
1398                g_biggielist_txt, g_filelist_imagedevs);
1399        paranoid_system(command);
1400        exit(0);
1401        break;
1402
1403    default:
1404        open_evalcall_form("Pre-processing filelist");
1405        while (!waitpid(pid, (int *) 0, WNOHANG)) {
1406            usleep(100000);
1407            update_evalcall_form(0);
1408        }
1409    }
1410    close_evalcall_form();
1411
1412    log_msg(3, "loading filelist");
1413    filelist = load_filelist(g_filelist_full);
1414    log_msg(3, "deleting original filelist");
1415    unlink(g_filelist_full);
1416    if (g_text_mode) {
1417        printf("Restore which directory? --> ");
1418        fgets(tmp, sizeof(tmp), stdin);
1419        toggle_path_selection(filelist, tmp, TRUE);
1420        if (strlen(tmp) == 0) {
1421            res = 1;
1422        } else {
1423            res = 0;
1424        }
1425    } else {
1426        res = edit_filelist(filelist);
1427    }
1428    if (res) {
1429        log_msg(2, "User hit 'cancel'. Freeing filelist and aborting.");
1430        free_filelist(filelist);
1431        return (NULL);
1432    }
1433    ask_about_these_imagedevs(g_filelist_imagedevs, g_imagedevs_restthese);
1434    close_evalcall_form();
1435
1436    // NB: It's not necessary to add g_biggielist_txt to the filelist.full
1437    // file. The filelist.full file already contains the filename of EVERY
1438    // file backed up - regular and biggie files.
1439
1440    // However, we do want to make sure the imagedevs selected by the user
1441    // are flagged for restoring.
1442    if (length_of_file(g_imagedevs_restthese) > 2) {
1443        add_list_of_files_to_filelist(filelist, g_imagedevs_restthese,
1444                                      TRUE);
1445    }
1446
1447    paranoid_free(command);
1448    paranoid_free(tmp);
1449    return (filelist);
1450}
1451
1452/**************************************************************************
1453 *END_ PROCESS_FILELIST_AND_BIGGIELIST                                    *
1454 **************************************************************************/
1455
1456
1457
1458
1459/**
1460 * Make a backup copy of <tt>path_root</tt>/<tt>filename</tt>.
1461 * The backup filename is the filename of the original with ".pristine" added.
1462 * @param path_root The place where the filesystem is mounted (e.g. MNT_RESTORING).
1463 * @param filename The filename (absolute path) within @p path_root.
1464 * @return 0 for success, nonzero for failure.
1465 */
1466int backup_crucial_file(char *path_root, char *filename)
1467{
1468    char *tmp;
1469    char *command;
1470    int res;
1471
1472    malloc_string(tmp);
1473    malloc_string(command);
1474    assert(path_root != NULL);
1475    assert_string_is_neither_NULL_nor_zerolength(filename);
1476
1477    sprintf(tmp, "%s/%s", path_root, filename);
1478    sprintf(command, "cp -f %s %s.pristine", tmp, tmp);
1479
1480    res = run_program_and_log_output(command, 5);
1481    paranoid_free(tmp);
1482    paranoid_free(command);
1483    return (res);
1484}
1485
1486
1487/**
1488 * Install the user's boot loader in the MBR.
1489 * Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
1490 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1491 * @return 0 for success, nonzero for failure.
1492 */
1493int run_boot_loader(bool offer_to_hack_scripts)
1494{
1495    int res;
1496    int retval = 0;
1497
1498  /** malloc *******/
1499    char *device;
1500    char *tmp;
1501    char *name;
1502
1503    malloc_string(device);
1504    malloc_string(tmp);
1505    malloc_string(name);
1506    backup_crucial_file(MNT_RESTORING, "/etc/fstab");
1507    backup_crucial_file(MNT_RESTORING, "/etc/grub.conf");
1508    backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
1509    backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
1510    read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
1511    read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
1512    sprintf(tmp, "run_boot_loader: device='%s', name='%s'", device, name);
1513    log_msg(2, tmp);
1514    system("sync");
1515    if (!strcmp(name, "LILO")) {
1516        res = run_lilo(offer_to_hack_scripts);
1517    } else if (!strcmp(name, "ELILO")) {
1518        res = run_elilo(offer_to_hack_scripts);
1519    } else if (!strcmp(name, "GRUB")) {
1520//      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?")))
1521//        {
1522        res = run_grub(offer_to_hack_scripts, device);
1523//    unlink(DO_MBR_PLEASE);
1524//  }
1525//      else
1526//        {
1527//    log_msg(1, "Not running run_grub(). Was a bad idea anyway.");
1528//    res = 1;
1529//  }
1530    } else if (!strcmp(name, "RAW")) {
1531        res = run_raw_mbr(offer_to_hack_scripts, device);
1532    }
1533#ifdef __FreeBSD__
1534    else if (!strcmp(name, "BOOT0")) {
1535        sprintf(tmp, "boot0cfg -B %s", device);
1536        res = run_program_and_log_output(tmp, FALSE);
1537    } else {
1538        sprintf(tmp, "ls /dev | grep -xq %ss[1-4].*", device);
1539        if (!system(tmp)) {
1540            sprintf(tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
1541            res = run_program_and_log_output(tmp, 3);
1542        } else {
1543            log_msg(1,
1544                    "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
1545        }
1546    }
1547#else
1548    else {
1549        log_to_screen
1550            ("Unable to determine type of boot loader. Defaulting to LILO.");
1551        res = run_lilo(offer_to_hack_scripts);
1552    }
1553#endif
1554    retval += res;
1555    if (res) {
1556        log_to_screen("Your boot loader returned an error");
1557    } else {
1558        log_to_screen("Your boot loader ran OK");
1559    }
1560    paranoid_free(device);
1561    paranoid_free(tmp);
1562    paranoid_free(name);
1563    return (retval);
1564}
1565
1566/**************************************************************************
1567 *END_ RUN_BOOT_LOADER                                                    *
1568 **************************************************************************/
1569
1570
1571
1572/**
1573 * Attempt to find the user's editor.
1574 * @return The editor found ("vi" if none could be found).
1575 * @note The returned string points to static storage that will be overwritten with each call.
1576 */
1577char *find_my_editor(void)
1578{
1579    static char output[MAX_STR_LEN];
1580    if (find_home_of_exe("pico")) {
1581        strcpy(output, "pico");
1582    } else if (find_home_of_exe("nano")) {
1583        strcpy(output, "nano");
1584    } else if (find_home_of_exe("e3em")) {
1585        strcpy(output, "e3em");
1586    } else if (find_home_of_exe("e3vi")) {
1587        strcpy(output, "e3vi");
1588    } else {
1589        strcpy(output, "vi");
1590    }
1591    if (!find_home_of_exe(output)) {
1592        log_msg(2, " (find_my_editor) --- warning - %s not found", output);
1593    }
1594    return (output);
1595}
1596
1597
1598/**
1599 * Install GRUB on @p bd.
1600 * @param offer_to_run_stabgrub If TRUE, then offer to hack the user's fstab for them.
1601 * @param bd The boot device where GRUB is installed.
1602 * @return 0 for success, nonzero for failure.
1603 */
1604int run_grub(bool offer_to_run_stabgrub, char *bd)
1605{
1606  /** malloc **/
1607    char *command;
1608    char *boot_device;
1609    char *rootdev;
1610    char *rootdrive;
1611    char *conffile;
1612    char *tmp;
1613    char *editor;
1614
1615    int res;
1616    int done;
1617
1618    malloc_string(command);
1619    malloc_string(boot_device);
1620    malloc_string(tmp);
1621    malloc_string(editor);
1622    malloc_string(rootdev);
1623    malloc_string(rootdrive);
1624    malloc_string(conffile);
1625    assert_string_is_neither_NULL_nor_zerolength(bd);
1626    strcpy(editor, "vi");       // find_my_editor() );
1627    strcpy(boot_device, bd);
1628
1629    if (!run_program_and_log_output("which grub-MR", FALSE)) {
1630        log_msg(1, "Yay! grub-MR found...");
1631        sprintf(command, "grub-MR %s /tmp/mountlist.txt", boot_device);
1632        log_msg(1, "command = %s", command);
1633    } else {
1634        sprintf(command, "chroot " MNT_RESTORING " grub-install %s",
1635                boot_device);
1636        log_msg(1, "WARNING - grub-MR not found; using grub-install");
1637    }
1638    if (offer_to_run_stabgrub
1639        && ask_me_yes_or_no("Did you change the mountlist?"))
1640        /* interactive mode */
1641    {
1642        mvaddstr_and_log_it(g_currentY,
1643                            0,
1644                            "Modifying fstab and grub.conf, and running GRUB...                             ");
1645        for (done = FALSE; !done;) {
1646            popup_and_get_string("Boot device",
1647                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1648                                 boot_device, MAX_STR_LEN / 4);
1649            sprintf(command, "stabgrub-me %s", boot_device);
1650            res = run_program_and_log_output(command, 1);
1651            if (res) {
1652                popup_and_OK
1653                    ("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.");
1654                newtSuspend();
1655                system("chroot " MNT_RESTORING);
1656                newtResume();
1657                popup_and_OK("Thank you.");
1658            } else {
1659                done = TRUE;
1660            }
1661            popup_and_OK("You will now edit fstab and grub.conf");
1662            if (!g_text_mode) {
1663                newtSuspend();
1664            }
1665            sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1666            paranoid_system(tmp);
1667            sprintf(tmp, "%s " MNT_RESTORING "/etc/grub.conf", editor);
1668            paranoid_system(tmp);
1669            if (!g_text_mode) {
1670                newtResume();
1671            }
1672        }
1673    } else
1674        /* nuke mode */
1675    {
1676        mvaddstr_and_log_it(g_currentY,
1677                            0,
1678                            "Running GRUB...                                                 ");
1679        iamhere(command);
1680        res = run_program_and_log_output(command, 1);
1681        if (res) {
1682            popup_and_OK
1683                ("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.");
1684            newtSuspend();
1685            system("chroot " MNT_RESTORING);
1686            newtResume();
1687            popup_and_OK("Thank you.");
1688        }
1689    }
1690    if (res) {
1691        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1692        log_to_screen
1693            ("GRUB ran w/error(s). See /tmp/mondo-restore.log for more info.");
1694        log_msg(1, "Type:-");
1695        log_msg(1, "    mount-me");
1696        log_msg(1, "    chroot " MNT_RESTORING);
1697        log_msg(1, "    mount /boot");
1698        log_msg(1, "    grub-install '(hd0)'");
1699        log_msg(1, "    exit");
1700        log_msg(1, "    unmount-me");
1701        log_msg(1,
1702                "If you're really stuck, please e-mail the mailing list.");
1703    } else {
1704        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1705    }
1706    paranoid_free(rootdev);
1707    paranoid_free(rootdrive);
1708    paranoid_free(conffile);
1709    paranoid_free(command);
1710    paranoid_free(boot_device);
1711    paranoid_free(tmp);
1712    paranoid_free(editor);
1713
1714    return (res);
1715}
1716
1717/**************************************************************************
1718 *END_RUN_GRUB                                                            *
1719 **************************************************************************/
1720
1721
1722/**
1723 * Install ELILO on the user's boot drive (determined by elilo.conf).
1724 * @param offer_to_run_stabelilo If TRUE, then offer to hack the user's fstab for them.
1725 * @return 0 for success, nonzero for failure.
1726 */
1727int run_elilo(bool offer_to_run_stabelilo)
1728{
1729  /** malloc **/
1730    char *command;
1731    char *tmp;
1732    char *editor;
1733
1734    int res;
1735    int done;
1736
1737    malloc_string(command);
1738    malloc_string(tmp);
1739    malloc_string(editor);
1740    strcpy(editor, find_my_editor());
1741    if (offer_to_run_stabelilo
1742        && ask_me_yes_or_no("Did you change the mountlist?"))
1743
1744        /* interactive mode */
1745    {
1746        mvaddstr_and_log_it(g_currentY,
1747                            0,
1748                            "Modifying fstab and elilo.conf...                             ");
1749        sprintf(command, "stabelilo-me");
1750        res = run_program_and_log_output(command, 3);
1751        if (res) {
1752            popup_and_OK
1753                ("You will now edit fstab and elilo.conf, to make sure they match your new mountlist.");
1754            for (done = FALSE; !done;) {
1755                if (!g_text_mode) {
1756                    newtSuspend();
1757                }
1758                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1759                paranoid_system(tmp);
1760                sprintf(tmp, "%s " MNT_RESTORING "/etc/elilo.conf",
1761                        editor);
1762                paranoid_system(tmp);
1763                if (!g_text_mode) {
1764                    newtResume();
1765                }
1766//              newtCls();
1767                if (ask_me_yes_or_no("Edit them again?")) {
1768                    continue;
1769                }
1770                done = TRUE;
1771            }
1772        } else {
1773            log_to_screen("elilo.conf and fstab were modified OK");
1774        }
1775    } else
1776        /* nuke mode */
1777    {
1778        res = TRUE;
1779    }
1780    paranoid_free(command);
1781    paranoid_free(tmp);
1782    paranoid_free(editor);
1783    return (res);
1784}
1785
1786/**************************************************************************
1787 *END_RUN_ELILO                                                            *
1788 **************************************************************************/
1789
1790
1791/**
1792 * Install LILO on the user's boot drive (determined by /etc/lilo.conf).
1793 * @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
1794 * @return 0 for success, nonzero for failure.
1795 */
1796int run_lilo(bool offer_to_run_stablilo)
1797{
1798  /** malloc **/
1799    char *command;
1800    char *tmp;
1801    char *editor;
1802
1803    int res;
1804    int done;
1805    bool run_lilo_M = FALSE;
1806    malloc_string(command);
1807    malloc_string(tmp);
1808    malloc_string(editor);
1809
1810    if (!run_program_and_log_output
1811        ("grep \"boot.*=.*/dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
1812        run_lilo_M = TRUE;
1813    }
1814
1815    strcpy(editor, find_my_editor());
1816    if (offer_to_run_stablilo
1817        && ask_me_yes_or_no("Did you change the mountlist?"))
1818
1819        /* interactive mode */
1820    {
1821        mvaddstr_and_log_it(g_currentY,
1822                            0,
1823                            "Modifying fstab and lilo.conf, and running LILO...                             ");
1824        sprintf(command, "stablilo-me");
1825        res = run_program_and_log_output(command, 3);
1826        if (res) {
1827            popup_and_OK
1828                ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
1829            for (done = FALSE; !done;) {
1830                if (!g_text_mode) {
1831                    newtSuspend();
1832                }
1833                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1834                paranoid_system(tmp);
1835                sprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
1836                paranoid_system(tmp);
1837                if (!g_text_mode) {
1838                    newtResume();
1839                }
1840//              newtCls();
1841                if (ask_me_yes_or_no("Edit them again?")) {
1842                    continue;
1843                }
1844                res =
1845                    run_program_and_log_output("chroot " MNT_RESTORING
1846                                               " lilo -L", 3);
1847                if (res) {
1848                    res =
1849                        run_program_and_log_output("chroot " MNT_RESTORING
1850                                                   " lilo", 3);
1851                }
1852                if (res) {
1853                    done =
1854                        ask_me_yes_or_no
1855                        ("LILO failed. Re-edit system files?");
1856                } else {
1857                    done = TRUE;
1858                }
1859            }
1860        } else {
1861            log_to_screen("lilo.conf and fstab were modified OK");
1862        }
1863    } else
1864        /* nuke mode */
1865    {
1866        mvaddstr_and_log_it(g_currentY,
1867                            0,
1868                            "Running LILO...                                                 ");
1869        res =
1870            run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
1871                                       3);
1872        if (res) {
1873            res =
1874                run_program_and_log_output("chroot " MNT_RESTORING " lilo",
1875                                           3);
1876        }
1877        if (res) {
1878            mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1879            log_to_screen
1880                ("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
1881        } else {
1882            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1883        }
1884    }
1885    if (run_lilo_M) {
1886        run_program_and_log_output("chroot " MNT_RESTORING
1887                                   " lilo -M /dev/hda", 3);
1888        run_program_and_log_output("chroot " MNT_RESTORING
1889                                   " lilo -M /dev/sda", 3);
1890    }
1891    paranoid_free(command);
1892    paranoid_free(tmp);
1893    paranoid_free(editor);
1894    return (res);
1895}
1896
1897/**************************************************************************
1898 *END_RUN_LILO                                                            *
1899 **************************************************************************/
1900
1901
1902/**
1903 * Install a raw MBR onto @p bd.
1904 * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
1905 * @param bd The device to copy the stored MBR to.
1906 * @return 0 for success, nonzero for failure.
1907 */
1908int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
1909{
1910  /** malloc **/
1911    char *command;
1912    char *boot_device;
1913    char *tmp;
1914    char *editor;
1915    int res;
1916    int done;
1917
1918    malloc_string(command);
1919    malloc_string(boot_device);
1920    malloc_string(tmp);
1921    malloc_string(editor);
1922    assert_string_is_neither_NULL_nor_zerolength(bd);
1923
1924    strcpy(editor, find_my_editor());
1925    strcpy(boot_device, bd);
1926    sprintf(command, "raw-MR %s /tmp/mountlist.txt", boot_device);
1927    log_msg(2, "run_raw_mbr() --- command='%s'", command);
1928
1929    if (offer_to_hack_scripts
1930        && ask_me_yes_or_no("Did you change the mountlist?"))
1931        /* interactive mode */
1932    {
1933        mvaddstr_and_log_it(g_currentY, 0,
1934                            "Modifying fstab and restoring MBR...                           ");
1935        for (done = FALSE; !done;) {
1936            if (!run_program_and_log_output("which vi", FALSE)) {
1937                popup_and_OK("You will now edit fstab");
1938                if (!g_text_mode) {
1939                    newtSuspend();
1940                }
1941                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
1942                paranoid_system(tmp);
1943                if (!g_text_mode) {
1944                    newtResume();
1945                }
1946//              newtCls();
1947            }
1948            popup_and_get_string("Boot device",
1949                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
1950                                 boot_device, MAX_STR_LEN / 4);
1951            sprintf(command, "stabraw-me %s", boot_device);
1952            res = run_program_and_log_output(command, 3);
1953            if (res) {
1954                done = ask_me_yes_or_no("Modifications failed. Re-try?");
1955            } else {
1956                done = TRUE;
1957            }
1958        }
1959    } else
1960        /* nuke mode */
1961    {
1962        mvaddstr_and_log_it(g_currentY, 0,
1963                            "Restoring MBR...                                               ");
1964        res = run_program_and_log_output(command, 3);
1965    }
1966    if (res) {
1967        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
1968        log_to_screen
1969            ("MBR+fstab processed w/error(s). See /tmp/mondo-restore.log for more info.");
1970    } else {
1971        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1972    }
1973    paranoid_free(command);
1974    paranoid_free(boot_device);
1975    paranoid_free(tmp);
1976    paranoid_free(editor);
1977    return (res);
1978}
1979
1980/**************************************************************************
1981 *END_RUN_RAW_MBR                                                         *
1982 **************************************************************************/
1983
1984
1985
1986
1987
1988/**
1989 * Turn signal trapping on or off.
1990 * @param on If TRUE, then do full cleanup when we receive a signal; if FALSE, then
1991 * print a message and exit immediately.
1992 */
1993void set_signals(int on)
1994{
1995    int signals[] =
1996        { SIGKILL, SIGPIPE, SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT,
1997SIGSTOP, 0 };
1998    int i;
1999    for (i = 0; signals[i]; i++) {
2000        if (on) {
2001            signal(signals[i], terminate_daemon);
2002        } else {
2003            signal(signals[i], termination_in_progress);
2004        }
2005    }
2006}
2007
2008/**************************************************************************
2009 *END_SET_SIGNALS                                                         *
2010 **************************************************************************/
2011
2012
2013/**
2014 * malloc() and set sensible defaults for the mondorestore filename variables.
2015 * @param bkpinfo The backup information structure. Fields used:
2016 * - @c bkpinfo->tmpdir
2017 * - @c bkpinfo->disaster_recovery
2018 */
2019void setup_MR_global_filenames(struct s_bkpinfo *bkpinfo)
2020{
2021    char *temppath;
2022
2023    assert(bkpinfo != NULL);
2024
2025    malloc_string(g_biggielist_txt);
2026    malloc_string(g_filelist_full);
2027    malloc_string(g_filelist_imagedevs);
2028    malloc_string(g_imagedevs_restthese);
2029    malloc_string(g_mondo_cfg_file);
2030    malloc_string(g_mountlist_fname);
2031    malloc_string(g_mondo_home);
2032    malloc_string(g_tmpfs_mountpt);
2033    malloc_string(g_isodir_device);
2034    malloc_string(g_isodir_format);
2035
2036    temppath = bkpinfo->tmpdir;
2037
2038    sprintf(g_biggielist_txt, "%s/%s", temppath, BIGGIELIST_TXT_STUB);
2039    sprintf(g_filelist_full, "%s/%s", temppath, FILELIST_FULL_STUB);
2040    sprintf(g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", temppath);
2041//  sprintf(g_imagedevs_pot, "%s/tmp/imagedevs.pot", temppath);
2042    sprintf(g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
2043            temppath);
2044    if (bkpinfo->disaster_recovery) {
2045        sprintf(g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
2046        sprintf(g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
2047    } else {
2048        sprintf(g_mondo_cfg_file, "%s/%s", temppath, MONDO_CFG_FILE_STUB);
2049        sprintf(g_mountlist_fname, "%s/%s", temppath,
2050                MOUNTLIST_FNAME_STUB);
2051    }
2052}
2053
2054/**************************************************************************
2055 *END_SET_GLOBAL_FILENAME                                                 *
2056 **************************************************************************/
2057
2058
2059/**
2060 * Copy @p input_file (containing the result of a compare) to @p output_file,
2061 * deleting spurious "changes" along the way.
2062 * @param output_file The output file to write with spurious changes removed.
2063 * @param input_file The input file, a list of changed files created by a compare.
2064 */
2065void streamline_changes_file(char *output_file, char *input_file)
2066{
2067    FILE *fin;
2068    FILE *fout;
2069  /** malloc **/
2070    char *incoming;
2071
2072    assert_string_is_neither_NULL_nor_zerolength(output_file);
2073    assert_string_is_neither_NULL_nor_zerolength(input_file);
2074    malloc_string(incoming);
2075
2076    if (!(fin = fopen(input_file, "r"))) {
2077        log_OS_error(input_file);
2078        return;
2079    }
2080    if (!(fout = fopen(output_file, "w"))) {
2081        fatal_error("cannot open output_file");
2082    }
2083    for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
2084         fgets(incoming, MAX_STR_LEN - 1, fin)) {
2085        if (strncmp(incoming, "etc/adjtime", 11)
2086            && strncmp(incoming, "etc/mtab", 8)
2087            && strncmp(incoming, "tmp/", 4)
2088            && strncmp(incoming, "boot/map", 8)
2089            && !strstr(incoming, "incheckentry")
2090            && strncmp(incoming, "etc/mail/statistics", 19)
2091            && strncmp(incoming, "var/", 4))
2092            fprintf(fout, "%s", incoming);  /* don't need \n here, for some reason.. */
2093    }
2094    paranoid_fclose(fout);
2095    paranoid_fclose(fin);
2096    paranoid_free(incoming);
2097}
2098
2099/**************************************************************************
2100 *END_STREAMLINE_CHANGES_FILE                                             *
2101 **************************************************************************/
2102
2103
2104/**
2105 * Exit due to a signal (normal cleanup).
2106 * @param sig The signal we're exiting due to.
2107 */
2108void terminate_daemon(int sig)
2109{
2110    log_to_screen
2111        ("Mondorestore is terminating in response to a signal from the OS");
2112    paranoid_MR_finish(254);
2113}
2114
2115/**************************************************************************
2116 *END_TERMINATE_DAEMON                                                    *
2117 **************************************************************************/
2118
2119
2120/**
2121 * Give the user twenty seconds to press Ctrl-Alt-Del before we nuke their drives.
2122 */
2123void twenty_seconds_til_yikes()
2124{
2125    int i;
2126    /* MALLOC * */
2127    char *tmp;
2128
2129    malloc_string(tmp);
2130    if (does_file_exist("/tmp/NOPAUSE")) {
2131        return;
2132    }
2133    open_progress_form("CAUTION",
2134                       "Be advised: I am about to ERASE your hard disk(s)!",
2135                       "You may press Ctrl+Alt+Del to abort safely.",
2136                       "", 20);
2137    for (i = 0; i < 20; i++) {
2138        g_current_progress = i;
2139        sprintf(tmp, "You have %d seconds left to abort.", 20 - i);
2140        update_progress_form(tmp);
2141        sleep(1);
2142    }
2143    close_progress_form();
2144    paranoid_free(tmp);
2145}
2146
2147/**************************************************************************
2148 *END_TWENTY_SECONDS_TIL_YIKES                                            *
2149 **************************************************************************/
2150
2151
2152
2153
2154
2155/**
2156 * Exit due to a signal (no cleanup).
2157 * @param sig The signal we're exiting due to.
2158 */
2159void termination_in_progress(int sig)
2160{
2161    log_msg(1, "Termination in progress");
2162    usleep(1000);
2163    pthread_exit(0);
2164}
2165
2166/**************************************************************************
2167 *END_TERMINATION_IN_PROGRESS                                             *
2168 **************************************************************************/
2169
2170
2171
2172/**
2173 * Unmount all devices in @p p_external_copy_of_mountlist.
2174 * @param p_external_copy_of_mountlist The mountlist to guide the devices to unmount.
2175 * @return 0 for success, nonzero for failure.
2176 */
2177int unmount_all_devices(struct mountlist_itself
2178                        *p_external_copy_of_mountlist)
2179{
2180    struct mountlist_itself *mountlist;
2181    int retval = 0, lino, res = 0, i;
2182    char *command;
2183    char *tmp;
2184
2185    malloc_string(command);
2186    malloc_string(tmp);
2187    assert(p_external_copy_of_mountlist != NULL);
2188
2189    mountlist = malloc(sizeof(struct mountlist_itself));
2190    memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
2191           sizeof(struct mountlist_itself));
2192    sort_mountlist_by_mountpoint(mountlist, 0);
2193
2194    run_program_and_log_output("df -m", 3);
2195    mvaddstr_and_log_it(g_currentY, 0, "Unmounting devices      ");
2196    open_progress_form("Unmounting devices",
2197                       "Unmounting all devices that were mounted,",
2198                       "in preparation for the post-restoration reboot.",
2199                       "", mountlist->entries);
2200    chdir("/");
2201    for (i = 0;
2202         i < 10
2203         &&
2204         run_program_and_log_output
2205         ("ps | grep buffer | grep -v \"grep buffer\"", TRUE) == 0;
2206         i++) {
2207        sleep(1);
2208        log_msg(2, "Waiting for buffer() to finish");
2209    }
2210
2211    paranoid_system("sync");
2212
2213    if (run_program_and_log_output
2214        ("cp -f /tmp/mondo-restore.log " MNT_RESTORING "/tmp/", FALSE)) {
2215        log_msg(1,
2216                "Error. Failed to copy log to PC's /tmp dir. (Mounted read-only?)");
2217    }
2218    if (run_program_and_log_output
2219        ("cp -f /tmp/mondo-restore.log " MNT_RESTORING "/root/", FALSE)) {
2220        log_msg(1,
2221                "Error. Failed to copy log to PC's /root dir. (Mounted read-only?)");
2222    }
2223    if (does_file_exist("/tmp/DUMBASS-GENTOO")) {
2224        run_program_and_log_output("mkdir -p " MNT_RESTORING
2225                                   "/mnt/.boot.d", 5);
2226    }
2227    for (lino = mountlist->entries - 1; lino >= 0; lino--) {
2228        if (!strcmp(mountlist->el[lino].mountpoint, "lvm")) {
2229            continue;
2230        }
2231        sprintf(tmp, "Unmounting device %s  ", mountlist->el[lino].device);
2232
2233        update_progress_form(tmp);
2234        if (is_this_device_mounted(mountlist->el[lino].device)) {
2235            if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
2236                sprintf(command, "swapoff %s", mountlist->el[lino].device);
2237            } else {
2238                if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
2239                    sprintf(command, "umount %s/", MNT_RESTORING);
2240                    log_msg(3,
2241                            "Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
2242                } else {
2243                    sprintf(command, "umount " MNT_RESTORING "%s",
2244                            mountlist->el[lino].mountpoint);
2245                }
2246            }
2247            log_msg(10, "The 'umount' command is '%s'", command);
2248            res = run_program_and_log_output(command, 3);
2249        } else {
2250            strcat(tmp, "...not mounted anyway :-) OK");
2251            res = 0;
2252        }
2253        g_current_progress++;
2254        if (res) {
2255            strcat(tmp, "...Failed");
2256            retval++;
2257            log_to_screen(tmp);
2258        } else {
2259            log_msg(2, tmp);
2260        }
2261    }
2262    close_progress_form();
2263    if (retval) {
2264        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
2265    } else {
2266        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2267    }
2268    if (retval) {
2269        log_to_screen("Unable to unmount some of your partitions.");
2270    } else {
2271        log_to_screen("All partitions were unmounted OK.");
2272    }
2273    free(mountlist);
2274    paranoid_free(command);
2275    paranoid_free(tmp);
2276    return (retval);
2277}
2278
2279/**************************************************************************
2280 *END_UNMOUNT_ALL_DEVICES                                                 *
2281 **************************************************************************/
2282
2283
2284
2285/**
2286 * Extract mondo-restore.cfg and the mountlist from the tape inserted
2287 * to the ./tmp/ directory.
2288 * @param dev The tape device to read from.
2289 * @return 0 for success, nonzero for failure.
2290 */
2291int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
2292{
2293    char *command;
2294    int res = 0;
2295    // BCO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
2296    long tape_block_size = 32768;
2297
2298    malloc_string(command);
2299
2300    // tar -zxvf-
2301    sprintf(command,
2302            "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s",
2303            dev,
2304            tape_block_size,
2305            1024L * 1024 * 32 / tape_block_size,
2306            MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB,
2307            BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");
2308    log_msg(2, "command = '%s'", command);
2309    res = run_program_and_log_output(command, -1);
2310    if (res != 0 && does_file_exist(MONDO_CFG_FILE_STUB)) {
2311        res = 0;
2312    }
2313    paranoid_free(command);
2314    return (res);
2315}
2316
2317
2318
2319/**
2320 * Get the configuration file from the floppy, tape, or CD.
2321 * @param bkpinfo The backup information structure. Fields used:
2322 * - @c bkpinfo->backup_media_type
2323 * - @c bkpinfo->media_device
2324 * - @c bkpinfo->tmpdir
2325 * @return 0 for success, nonzero for failure.
2326 */
2327int get_cfg_file_from_archive(struct s_bkpinfo *bkpinfo)
2328{
2329    int retval = 0;
2330
2331   /** malloc *****/
2332    char *device;
2333    char *command;
2334    char *cfg_file;
2335    char *mounted_cfgf_path;
2336    char *tmp;
2337    char *mountpt;
2338    char *ramdisk_fname;
2339    char *mountlist_file;
2340    int res;
2341
2342    bool try_plan_B;
2343
2344    assert(bkpinfo != NULL);
2345    malloc_string(cfg_file);
2346    malloc_string(mounted_cfgf_path);
2347    malloc_string(mountpt);
2348    malloc_string(ramdisk_fname);
2349    malloc_string(mountlist_file);
2350    malloc_string(device);
2351    malloc_string(command);
2352    malloc_string(tmp);
2353    log_msg(2, "gcffa --- starting");
2354    log_to_screen("I'm thinking...");
2355    sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
2356    device[0] = '\0';
2357    chdir(bkpinfo->tmpdir);
2358    strcpy(cfg_file, MONDO_CFG_FILE_STUB);
2359    unlink(cfg_file);           // cfg_file[] is missing the '/' at the start, FYI, by intent
2360    unlink(FILELIST_FULL_STUB);
2361    unlink(BIGGIELIST_TXT_STUB);
2362    unlink("tmp/i-want-my-lvm");
2363    sprintf(command, "mkdir -p %s", mountpt);
2364    run_program_and_log_output(command, FALSE);
2365
2366//   unlink( "tmp/mondo-restore.cfg" ); // superfluous, surely?
2367
2368    sprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
2369    sprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir,
2370            MOUNTLIST_FNAME_STUB);
2371    //   make_hole_for_file( cfg_file );
2372    //   make_hole_for_file( mountlist_file);
2373    log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
2374
2375    /* Floppy? */
2376    sprintf(tmp, "mkdir -p %s", mountpt);
2377    run_program_and_log_output(tmp, FALSE);
2378    sprintf(tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
2379    run_program_and_log_output(tmp, FALSE);
2380
2381    sprintf(command, "mount /dev/fd0u1722 %s", mountpt);
2382    sprintf(tmp,
2383            "(sleep 15; kill `ps | grep \"%s\" | cut -d' ' -f1` 2> /dev/null) &",
2384            command);
2385    log_msg(1, "tmp = '%s'", tmp);
2386    system(tmp);
2387    res = run_program_and_log_output(command, FALSE);
2388    if (res) {
2389        sprintf(command, "mount /dev/fd0H1440 %s", mountpt);
2390        res = run_program_and_log_output(command, FALSE);
2391    }
2392    if (res) {
2393        try_plan_B = TRUE;
2394    } else {
2395        try_plan_B = TRUE;
2396        log_msg(2,
2397                "Mounted floppy OK but I don't trust it because the archives might contain more up-to-date config file than the floppy does.");
2398// NB: If busybox does not support 'mount -o loop' then Plan A WILL NOT WORK.
2399        log_msg(2, "Processing floppy (plan A?)");
2400        sprintf(ramdisk_fname, "%s/mindi.rdz", mountpt);
2401        if (!does_file_exist(ramdisk_fname)) {
2402            sprintf(ramdisk_fname, "%s/initrd.img", mountpt);
2403        }
2404        if (!does_file_exist(ramdisk_fname)) {
2405            log_msg(2,
2406                    "Cannot find ramdisk file on mountpoint. Are you sure that's a boot disk in the drive?");
2407        }
2408        if (extract_config_file_from_ramdisk
2409            (bkpinfo, ramdisk_fname, cfg_file, mountlist_file)) {
2410            log_msg(2,
2411                    "Warning - failed to extract config file from ramdisk. I think this boot disk is mangled.");
2412        }
2413        sprintf(command, "umount %s", mountpt);
2414        run_program_and_log_output(command, 5);
2415        unlink(ramdisk_fname);
2416    }
2417    if (!does_file_exist(cfg_file)) {
2418        log_msg(2, "gcffa --- we don't have cfg file yet.");
2419        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2420            try_plan_B = TRUE;
2421        } else {
2422            log_msg(2, "gcffa --- calling mount_cdrom now :)");
2423            if (!mount_cdrom(bkpinfo)) {
2424                log_msg(2,
2425                        "gcffa --- managed to mount CD; so, no need for Plan B");
2426                try_plan_B = FALSE;
2427            } else {
2428                try_plan_B = TRUE;
2429            }
2430            if (what_number_cd_is_this(bkpinfo) > 1) {
2431                insist_on_this_cd_number(bkpinfo,
2432                                         (g_current_media_number = 1));
2433            }
2434        }
2435        if (try_plan_B) {
2436            log_msg(2, "gcffa --- OK, switching to Plan B");
2437            chdir(bkpinfo->tmpdir);
2438            run_program_and_log_output("mkdir -p tmp", FALSE);
2439
2440            if (strlen(bkpinfo->media_device) == 0) {
2441                strcpy(bkpinfo->media_device, "/dev/st0");
2442                log_msg(2, "media_device is blank; assuming %s");
2443            }
2444            strcpy(tmp, bkpinfo->media_device);
2445            if (extract_cfg_file_and_mountlist_from_tape_dev
2446                (bkpinfo->media_device)) {
2447                strcpy(bkpinfo->media_device, "/dev/st0");
2448                if (extract_cfg_file_and_mountlist_from_tape_dev
2449                    (bkpinfo->media_device)) {
2450                    strcpy(bkpinfo->media_device, "/dev/osst0");
2451                    if (extract_cfg_file_and_mountlist_from_tape_dev
2452                        (bkpinfo->media_device)) {
2453                        strcpy(bkpinfo->media_device, "/dev/ht0");
2454                        if (extract_cfg_file_and_mountlist_from_tape_dev
2455                            (bkpinfo->media_device)) {
2456                            log_msg(3,
2457                                    "I tried lots of devices but none worked.");
2458                            strcpy(bkpinfo->media_device, tmp);
2459                        }
2460                    }
2461                }
2462            }
2463
2464            if (!does_file_exist("tmp/mondo-restore.cfg")) {
2465                log_to_screen("Cannot find config info on tape/CD/floppy");
2466                return (1);
2467            }
2468        } else {
2469            log_msg(2,
2470                    "gcffa --- looking at mounted CD for mindi-boot.2880.img");
2471            sprintf(command,
2472                    "mount " MNT_CDROM
2473                    "/images/mindi-boot.2880.img -o loop %s", mountpt);
2474            sprintf(mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
2475            if (!does_file_exist(mounted_cfgf_path)) {
2476                log_msg(2,
2477                        "gcffa --- Plan C, a.k.a. untarring some file from all.tar.gz");
2478                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
2479                run_program_and_log_output(command, TRUE);
2480                if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
2481                    fatal_error
2482                        ("Please reinsert the disk/CD and try again.");
2483                }
2484            }
2485        }
2486    }
2487    if (does_file_exist(MONDO_CFG_FILE_STUB)) {
2488        log_msg(1, "gcffa --- great! We've got the config file");
2489        sprintf(tmp, "%s/%s",
2490                call_program_and_get_last_line_of_output("pwd"),
2491                MONDO_CFG_FILE_STUB);
2492        sprintf(command, "cp -f %s %s", tmp, cfg_file);
2493        iamhere(command);
2494        if (strcmp(tmp, cfg_file)
2495            && run_program_and_log_output(command, 1)) {
2496            log_msg(1,
2497                    "... but an error occurred when I tried to move it to %s",
2498                    cfg_file);
2499        } else {
2500            log_msg(1, "... and I moved it successfully to %s", cfg_file);
2501        }
2502        sprintf(command, "cp -f %s/%s %s",
2503                call_program_and_get_last_line_of_output("pwd"),
2504                MOUNTLIST_FNAME_STUB, mountlist_file);
2505        iamhere(command);
2506        if (strcmp(tmp, cfg_file)
2507            && run_program_and_log_output(command, 1)) {
2508            log_msg(1, "Failed to get mountlist");
2509        } else {
2510            log_msg(1, "Got mountlist too");
2511            sprintf(command, "cp -f %s %s", mountlist_file,
2512                    g_mountlist_fname);
2513            if (run_program_and_log_output(command, 1)) {
2514                log_msg(1, "Failed to copy mountlist to /tmp");
2515            } else {
2516                log_msg(1, "Copied mountlist to /tmp as well OK");
2517                sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
2518                run_program_and_log_output(command, 1);
2519/*        sprintf(command, "grep \" lvm \" %s", g_mountlist_fname);
2520          if (!run_program_and_log_output(command, 5) && !does_file_exist("/tmp/i-want-my-lvm"))
2521            {
2522          log_msg(1, "Warning. You want LVM but I don't have i-want-my-lvm. FIXME.");
2523        }
2524              else if (run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
2525                {
2526          log_msg(1, "Warning. You don't want LVM but i-want-my-lvm exists. I'll delete it. Cool.");
2527              do_my_funky_lvm_stuff(TRUE, FALSE); // ...after I stop any LVMs :)
2528          stop_raid_device("/dev/md0");
2529          stop_raid_device("/dev/md1");
2530          stop_raid_device("/dev/md2");
2531          unlink("/tmp/i-want-my-lvm");
2532        }
2533          else if (!run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
2534            {
2535          log_msg(1, "You had better pray that i-want-my-lvm patches your mountlist. FIXME.");
2536        }
2537*/
2538            }
2539        }
2540    }
2541    run_program_and_log_output("umount " MNT_CDROM, FALSE);
2542    if (!does_file_exist(cfg_file)) {
2543        iamhere(cfg_file);
2544        log_msg(1, "%s not found", cfg_file);
2545        log_to_screen
2546            ("Oh dear. Unable to recover configuration file from boot disk");
2547        return (1);
2548    }
2549
2550    log_to_screen("Recovered mondo-restore.cfg");
2551    if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
2552        log_to_screen("...but not mountlist.txt - a pity, really...");
2553    }
2554/* start SAH */
2555    else {
2556        sprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
2557                bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
2558        run_program_and_log_output(command, FALSE);
2559    }
2560/*--commented out by SAH
2561  sprintf( command, "cp -f %s %s/%s", cfg_file, bkpinfo->tmpdir, MONDO_CFG_FILE_STUB );
2562  run_program_and_log_output( command, FALSE );
2563  sprintf( command, "cp -f %s %s/%s", mountlist_file, bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB );
2564  run_program_and_log_output( command, FALSE );
2565*/
2566/* end SAH */
2567
2568    sprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
2569    run_program_and_log_output(command, FALSE);
2570    sprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
2571    run_program_and_log_output(command, FALSE);
2572    sprintf(command, "cp -f etc/raidtab /etc/");
2573    run_program_and_log_output(command, FALSE);
2574    sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
2575    run_program_and_log_output(command, FALSE);
2576    g_backup_media_type = bkpinfo->backup_media_type;
2577    paranoid_free(device);
2578    paranoid_free(command);
2579    paranoid_free(tmp);
2580    paranoid_free(cfg_file);
2581    paranoid_free(mounted_cfgf_path);
2582    paranoid_free(mountpt);
2583    paranoid_free(ramdisk_fname);
2584    paranoid_free(mountlist_file);
2585    return (retval);
2586}
2587
2588/**************************************************************************
2589 *END_GET_CFG_FILE_FROM_ARCHIVE                                           *
2590 **************************************************************************/
2591
2592/* @} - end restoreUtilityGroup */
2593
2594
2595/***************************************************************************
2596 * F@                                                                      *
2597 * () -- Hugo Rabson                                  *
2598 *                                                                         *
2599 * Purpose:                                                                *
2600 *                                                                         *
2601 * Called by:                                                              *
2602 * Params:    -                      -                                     *
2603 * Returns:   0=success; nonzero=failure                                   *
2604 ***************************************************************************/
2605
2606
2607
2608void wait_until_software_raids_are_prepped(char *mdstat_file,
2609                                           int wait_for_percentage)
2610{
2611    struct raidlist_itself *raidlist;
2612    int unfinished_mdstat_devices = 9999, i;
2613    char *screen_message;
2614
2615    malloc_string(screen_message);
2616    raidlist = malloc(sizeof(struct raidlist_itself));
2617
2618    assert(wait_for_percentage <= 100);
2619    iamhere("wait_until_software_raids_are_prepped");
2620    while (unfinished_mdstat_devices > 0) {
2621            // FIXME: Prefix '/dev/' should really be dynamic!
2622        if (parse_mdstat(raidlist, "/dev/")) {
2623            log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
2624            log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
2625            return;
2626        }
2627        for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
2628            if (raidlist->el[i].progress < wait_for_percentage) {
2629                unfinished_mdstat_devices++;
2630                if (raidlist->el[i].progress == -1) // delayed while another partition inits
2631                {
2632                    continue;
2633                }
2634                log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
2635                sprintf(screen_message, "Sync'ing %s",
2636                        raidlist->el[i].raid_device);
2637                open_evalcall_form(screen_message);
2638                while (raidlist->el[i].progress < wait_for_percentage) {
2639                    log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
2640                    update_evalcall_form(raidlist->el[i].progress);
2641                    sleep(2);
2642                    // FIXME: Prefix '/dev/' should really be dynamic!
2643                    if (parse_mdstat(raidlist, "/dev/")) {
2644                        break;
2645                    }
2646                }
2647                close_evalcall_form();
2648            }
2649        }
2650    }
2651    paranoid_free(screen_message);
2652    paranoid_free(raidlist);
2653}
Note: See TracBrowser for help on using the repository browser.