source: MondoRescue/branches/2.05/mondo/mondo/mondorestore/mondo-rstr-tools.c @ 148

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