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

Last change on this file since 801 was 801, checked in by Bruno Cornec, 14 years ago

Should fix bug #21 by exporting variables from start-nfs and overriding values in mondo-rstr-tools.c with thee exports

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