source: trunk/mondo/src/mondorestore/mondo-restore.c @ 1081

Last change on this file since 1081 was 1081, checked in by bruno, 12 years ago

merge -r1078:1080 $SVN_M/branches/stable

  • Property svn:keywords set to Id
File size: 99.5 KB
Line 
1/***************************************************************************
2* restores mondoarchive data
3* $Id: mondo-restore.c 1081 2007-01-28 22:20:07Z bruno $
4***************************************************************************/
5
6/**
7 * @file
8 * The main file for mondorestore.
9 */
10
11/**************************************************************************
12 * #include statements                                                    *
13 **************************************************************************/
14#include <unistd.h>
15
16#include "my-stuff.h"
17#include "../common/mondostructures.h"
18#include "../common/libmondo.h"
19#include "mr-externs.h"
20#include "mondo-restore.h"
21#include "mondo-rstr-compare-EXT.h"
22#include "mondo-rstr-tools-EXT.h"
23#ifndef S_SPLINT_S
24#include <pthread.h>
25#endif
26#include "mr_mem.h"
27
28extern void twenty_seconds_til_yikes(void);
29
30
31/* For use in other programs (ex. XMondo) */
32#ifdef MONDORESTORE_MODULE
33#define main __mondorestore_main
34#define g_ISO_restore_mode __mondorestore_g_ISO_restore_mode
35#endif
36
37//static char cvsid[] = "$Id: mondo-restore.c 1081 2007-01-28 22:20:07Z bruno $";
38
39/**************************************************************************
40 * Globals                                                                *
41 **************************************************************************/
42extern char *g_tmpfs_mountpt;   // declared in libmondo-tools.c
43extern struct s_bkpinfo *g_bkpinfo_DONTUSETHIS; // used by finish() to free
44                                                // up global bkpinfo struct
45extern bool g_text_mode;
46extern FILE *g_fprep;
47extern double g_kernel_version;
48extern int g_partition_table_locked_up;
49extern int g_noof_rows;
50
51extern int partition_everything(struct mountlist_itself *mountlist);
52
53
54/**
55 * @name Restore-Time Globals
56 * @ingroup globalGroup
57 * @{
58 */
59/**
60 * If TRUE, then SIGPIPE was just caught.
61 * Set by the signal handler; cleared after it's handled.
62 */
63bool g_sigpipe_caught = FALSE;
64
65/**
66 * If TRUE, then we're restoring from ISOs or an NFS server.
67 * If FALSE, then we're restoring from some kind of real media (tape, CD, etc.)
68 */
69bool g_ISO_restore_mode = FALSE;    /* are we in Iso Mode? */
70
71/**
72 * If TRUE, then we have had a successful "nuke" restore.
73 */
74bool g_I_have_just_nuked = FALSE;
75
76/**
77 * The device to mount to get at the ISO images. Ignored unless @p g_ISO_restore_mode.
78 */
79char *g_isodir_device = NULL;
80
81/**
82 * The format of @p g_isodir_device. Ignored unless @p g_ISO_restore_mode.
83 */
84char *g_isodir_format = NULL;
85
86/**
87 * The location of 'biggielist.txt', containing the biggiefiles on the current archive set.
88 */
89char *g_biggielist_txt = NULL;
90
91/**
92 * The location of 'filelist.full', containing all files (<em>including biggiefiles</em>) on
93 * the current archive set.
94 */
95char *g_filelist_full = NULL;
96
97/**
98 * The location of a file containing a list of the devices that were archived
99 * as images, not as individual files.
100 */
101char *g_filelist_imagedevs = NULL;
102
103/**
104 * The location of a file containing a list of imagedevs to actually restore.
105 * @see g_filelist_imagedevs
106 */
107char *g_imagedevs_restthese = NULL;
108
109/**
110 * The location of 'mondo-restore.cfg', containing the metadata
111 * information for this backup.
112 */
113char *g_mondo_cfg_file = NULL;
114
115/**
116 * The location of 'mountlist.txt', containing the information on the
117 * user's partitions and hard drives.
118 */
119char *g_mountlist_fname = NULL;
120
121/* Busybox ps has no option and PID in first pos */
122char *ps_options = "";
123char *ps_proc_id = "$1";
124
125extern char *g_getfacl;
126extern char *g_getfattr;
127
128/* @} - end of "Restore-Time Globals" in globalGroup */
129
130extern int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived,
131                                 char direction);
132
133/**************************************************************************
134 * COMPAQ PROLIANT Stuff:  needs some special help                        *
135**************************************************************************/
136
137/**
138 * The message to display if we detect that the user is using a Compaq Proliant.
139 */
140#define COMPAQ_PROLIANTS_SUCK _("Partition and format your disk using Compaq's disaster recovery CD. After you've done that, please reboot with your Mondo CD/floppy in Interactive Mode.")
141
142
143/**
144 * Allow the user to modify the mountlist before we partition & format their drives.
145 * @param bkpinfo The backup information structure. @c disaster_recovery is the only field used.
146 * @param mountlist The mountlist to let the user modify.
147 * @param raidlist The raidlist that goes with @p mountlist.
148 * @return 0 for success, nonzero for failure.
149 * @ingroup restoreGuiGroup
150 */
151int let_user_edit_the_mountlist(struct s_bkpinfo *bkpinfo,
152                                struct mountlist_itself *mountlist,
153                                struct raidlist_itself *raidlist)
154{
155    int retval = 0, res = 0;
156
157    log_msg(2, "let_user_edit_the_mountlist() --- starting");
158
159    assert(bkpinfo != NULL);
160    assert(mountlist != NULL);
161    assert(raidlist != NULL);
162    if (!bkpinfo->disaster_recovery) {
163        mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
164        log_msg(2, "I guess you're testing edit_mountlist()");
165    }
166    if (!does_file_exist(g_mountlist_fname)) {
167        log_to_screen(g_mountlist_fname);
168        log_to_screen(_("does not exist"));
169        return (1);
170    }
171
172    retval = load_mountlist(mountlist, g_mountlist_fname);
173    load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
174    if (retval) {
175        log_to_screen
176            (_("Warning - load_raidtab_into_raidlist returned an error"));
177    }
178    res = edit_mountlist(g_mountlist_fname, mountlist, raidlist);
179    if (res) {
180        return (1);
181    }
182
183    save_mountlist_to_disk(mountlist, g_mountlist_fname);
184    save_raidlist_to_raidtab(raidlist, RAIDTAB_FNAME);
185
186    log_to_screen(_("I have finished editing the mountlist for you."));
187
188    return (retval);
189}
190
191
192/**
193 * Determine whether @p mountlist contains a Compaq diagnostic partition.
194 * @param mountlist The mountlist to examine.
195 * @return TRUE if there's a Compaq diagnostic partition; FALSE if not.
196 * @ingroup restoreUtilityGroup
197 */
198bool
199partition_table_contains_Compaq_diagnostic_partition(struct
200                                                     mountlist_itself *
201                                                     mountlist)
202{
203    int i;
204
205    assert(mountlist != NULL);
206
207    for (i = 0; i < mountlist->entries; i++) {
208        if (strstr(mountlist->el[i].format, "ompaq")) {
209            log_msg(2, "mountlist[%d] (%s) is %s (Compaq alert!)",
210                    i, mountlist->el[i].device, mountlist->el[i].format);
211
212            return (TRUE);
213        }
214    }
215    return (FALSE);
216}
217
218/**************************************************************************
219 *END_PARTITION_TABLE_CONTAINS_COMPAQ_DIAGNOSTIC_PARTITION                *
220 **************************************************************************/
221
222
223/**
224 * Allow the user to abort the backup if we find that there is a Compaq diagnostic partition.
225 * @note This function does not actually check for the presence of a Compaq partition.
226 * @ingroup restoreUtilityGroup
227 */
228void offer_to_abort_because_Compaq_Proliants_suck(void)
229{
230    popup_and_OK(COMPAQ_PROLIANTS_SUCK);
231    if (ask_me_yes_or_no
232        (_
233         ("Would you like to reboot and use your Compaq CD to prep your hard drive?")))
234    {
235        fatal_error(_
236                    ("Aborting. Please reboot and prep your hard drive with your Compaq CD."));
237    }
238}
239
240/**************************************************************************
241 *END_OFFER_TO_ABORT_BECAUSE_COMPAQ_PROLIANTS_SUCK                        *
242 **************************************************************************/
243
244
245/**
246 * Call interactive_mode(), nuke_mode(), or compare_mode() depending on the user's choice.
247 * @param bkpinfo The backup information structure. Most fields are used.
248 * @param mountlist The mountlist containing information about the user's partitions.
249 * @param raidlist The raidlist to go with @p mountlist.
250 * @return The return code from the mode function called.
251 * @ingroup restoreGroup
252 */
253int
254catchall_mode(struct s_bkpinfo *bkpinfo,
255              struct mountlist_itself *mountlist,
256              struct raidlist_itself *raidlist)
257{
258    char c, *tmp;
259    int retval = 0;
260
261    iamhere("inside catchall");
262    assert(bkpinfo != NULL);
263    assert(mountlist != NULL);
264    assert(raidlist != NULL);
265    iamhere("pre wrm");
266    c = which_restore_mode();
267    iamhere("post wrm");
268    if (c == 'I' || c == 'N' || c == 'C') {
269        interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
270    } else {
271        popup_and_OK(_
272                     ("No restoring or comparing will take place today."));
273        if (is_this_device_mounted("/mnt/cdrom")) {
274            run_program_and_log_output("umount /mnt/cdrom", FALSE);
275        }
276        if (g_ISO_restore_mode) {
277            mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
278            run_program_and_log_output(tmp, FALSE);
279            mr_free(tmp);
280        }
281        paranoid_MR_finish(0);
282    }
283
284    iamhere("post int");
285
286    if (bkpinfo->backup_media_type == iso) {
287        if (iso_fiddly_bits(bkpinfo, (c == 'N') ? TRUE : FALSE)) {
288            log_msg(2,
289                    "catchall_mode --- iso_fiddly_bits returned w/ error");
290            return (1);
291        } else {
292            log_msg(2, "catchall_mode --- iso_fiddly_bits ok");
293        }
294    }
295
296    if (c == 'I') {
297        log_msg(2, "IM selected");
298        retval += interactive_mode(bkpinfo, mountlist, raidlist);
299    } else if (c == 'N') {
300        log_msg(2, "NM selected");
301        retval += nuke_mode(bkpinfo, mountlist, raidlist);
302    } else if (c == 'C') {
303        log_msg(2, "CM selected");
304        retval += compare_mode(bkpinfo, mountlist, raidlist);
305    }
306    return (retval);
307}
308
309/**************************************************************************
310 *END_CATCHALL_MODE                                                      *
311 **************************************************************************/
312
313/**************************************************************************
314 *END_  EXTRACT_CONFIG_FILE_FROM_RAMDISK                                  *
315 **************************************************************************/
316
317
318/**
319 * @addtogroup restoreGroup
320 * @{
321 */
322/**
323 * Restore the user's data, in a disaster recovery situation, prompting the
324 * user about whether or not to do every step.
325 * The user can edit the mountlist, choose files to restore, etc.
326 * @param bkpinfo The backup information structure. Most fields are used.
327 * @param mountlist The mountlist containing information about the user's partitions.
328 * @param raidlist The raidlist to go with @p mountlist.
329 * @return 0 for success, or the number of errors encountered.
330 */
331int
332interactive_mode(struct s_bkpinfo *bkpinfo,
333                 struct mountlist_itself *mountlist,
334                 struct raidlist_itself *raidlist)
335{
336    int retval = 0;
337    int res;
338    int ptn_errs = 0;
339    int fmt_errs = 0;
340
341    bool done;
342    bool restore_all;
343
344    char *tmp = NULL;
345    char *tmp1 = NULL;
346    char *fstab_fname = NULL;
347    char *old_restpath = NULL;
348
349    struct s_node *filelist = NULL;
350
351    /* try to partition and format */
352
353    log_msg(2, "interactive_mode --- starting (great, assertions OK)");
354
355    assert(bkpinfo != NULL);
356    assert(mountlist != NULL);
357    assert(raidlist != NULL);
358
359    log_msg(2, "interactive_mode --- assertions OK");
360
361    if (g_text_mode) {
362        if (!ask_me_yes_or_no
363            (_
364             ("Interactive Mode + textonly = experimental! Proceed anyway?")))
365        {
366            fatal_error("Wise move.");
367        }
368    }
369
370    iamhere("About to load config file");
371    get_cfg_file_from_archive_or_bust(bkpinfo);
372    read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
373    iamhere("Done loading config file; resizing ML");
374#ifdef __FreeBSD__
375    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
376#else
377    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
378#endif
379    if (strstr(tmp,"noresize")) {
380        log_msg(1, "Not resizing mountlist.");
381    } else {
382        resize_mountlist_proportionately_to_suit_new_drives(mountlist);
383    }
384    for (done = FALSE; !done;) {
385        iamhere("About to edit mountlist");
386        if (g_text_mode) {
387            save_mountlist_to_disk(mountlist, g_mountlist_fname);
388            tmp1 = find_my_editor();
389            mr_asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
390            mr_free(tmp1);
391
392            res = system(tmp);
393            mr_free(tmp);
394            load_mountlist(mountlist, g_mountlist_fname);
395        } else {
396            res = edit_mountlist(g_mountlist_fname, mountlist, raidlist);
397        }
398        iamhere("Finished editing mountlist");
399        if (res) {
400            paranoid_MR_finish(1);
401        }
402        log_msg(2, "Proceeding...");
403        save_mountlist_to_disk(mountlist, g_mountlist_fname);
404        save_raidlist_to_raidtab(raidlist, RAIDTAB_FNAME);
405        mvaddstr_and_log_it(1, 30, _("Restoring Interactively"));
406        if (bkpinfo->differential) {
407            log_to_screen(_
408                          ("Because this is a differential backup, disk"));
409            log_to_screen(_
410                          (" partitioning and formatting will not take place."));
411            done = TRUE;
412        } else {
413            if (ask_me_yes_or_no
414                (_
415                 ("Do you want to erase and partition your hard drives?")))
416            {
417                if (partition_table_contains_Compaq_diagnostic_partition
418                    (mountlist)) {
419                    offer_to_abort_because_Compaq_Proliants_suck();
420                    done = TRUE;
421                } else {
422                    twenty_seconds_til_yikes();
423                    g_fprep = fopen("/tmp/prep.sh", "w");
424                    ptn_errs = partition_everything(mountlist);
425                    if (ptn_errs) {
426                        log_to_screen
427                            (_
428                             ("Warning. Errors occurred during disk partitioning."));
429                    }
430
431                    fmt_errs =
432                        format_everything(mountlist, FALSE, raidlist);
433                    if (!fmt_errs) {
434                        log_to_screen
435                            (_
436                             ("Errors during disk partitioning were handled OK."));
437                        log_to_screen(_
438                                      ("Partitions were formatted OK despite those errors."));
439                        ptn_errs = 0;
440                    }
441                    if (!ptn_errs && !fmt_errs) {
442                        done = TRUE;
443                    }
444                }
445                paranoid_fclose(g_fprep);
446            } else {
447                mvaddstr_and_log_it(g_currentY++, 0,
448                                    _
449                                    ("User opted not to partition the devices"));
450                if (ask_me_yes_or_no
451                    (_("Do you want to format your hard drives?"))) {
452                    fmt_errs =
453                        format_everything(mountlist, TRUE, raidlist);
454                    if (!fmt_errs) {
455                        done = TRUE;
456                    }
457                } else {
458                    ptn_errs = fmt_errs = 0;
459                    done = TRUE;
460                }
461            }
462            if (fmt_errs) {
463                mvaddstr_and_log_it(g_currentY++,
464                                    0,
465                                    _
466                                    ("Errors occurred. Please repartition and format drives manually."));
467                done = FALSE;
468            }
469            if (ptn_errs & !fmt_errs) {
470                mvaddstr_and_log_it(g_currentY++,
471                                    0,
472                                    _
473                                    ("Errors occurred during partitioning. Formatting, however, went OK."));
474                done = TRUE;
475            }
476            if (!done) {
477                if (!ask_me_yes_or_no(_("Re-edit the mountlist?"))) {
478                    retval++;
479                    iamhere("Leaving interactive_mode()");
480                    return (retval);
481                }
482            }
483        }
484    }
485
486    /* mount */
487    if (mount_all_devices(mountlist, TRUE)) {
488        unmount_all_devices(mountlist);
489        retval++;
490        iamhere("Leaving interactive_mode()");
491        return (retval);
492    }
493    /* restore */
494    if ((restore_all =
495         ask_me_yes_or_no(_
496                          ("Do you want me to restore all of your data?"))))
497    {
498        log_msg(1, "Restoring all data");
499        retval += restore_everything(bkpinfo, NULL);
500    } else if ((restore_all =
501             ask_me_yes_or_no
502             (_("Do you want me to restore _some_ of your data?")))) {
503        mr_asprintf(&old_restpath,bkpinfo->restore_path);
504        for (done = FALSE; !done;) {
505            unlink("/tmp/filelist.full");
506            filelist = process_filelist_and_biggielist(bkpinfo);
507            /* Now you have /tmp/tmpfs/filelist.restore-these and /tmp/tmpfs/biggielist.restore-these;
508               the former is a list of regular files; the latter, biggiefiles and imagedevs.
509             */
510            if (filelist) {
511              gotos_suck:
512// (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
513                if (popup_and_get_string
514                    (_("Restore path"), _("Restore files to where?"), bkpinfo->restore_path)) {
515                    if (!strcmp(bkpinfo->restore_path, "/")) {
516                        if (!ask_me_yes_or_no(_("Are you sure?"))) {
517                            mr_allocstr(bkpinfo->restore_path, old_restpath);
518                            goto gotos_suck;
519                        }
520                        mr_allocstr(bkpinfo->restore_path, ""); // so we restore to [blank]/file/name :)
521                    }
522                    log_msg(1, "Restoring subset");
523                    retval += restore_everything(bkpinfo, filelist);
524                    free_filelist(filelist);
525                } else {
526                    mr_allocstr(bkpinfo->restore_path,old_restpath);
527                    free_filelist(filelist);
528                }
529                if (!ask_me_yes_or_no
530                    (_("Restore another subset of your backup?"))) {
531                    done = TRUE;
532                }
533            } else {
534                done = TRUE;
535            }
536        }
537        mr_free(old_restpath);
538    } else {
539        mvaddstr_and_log_it(g_currentY++,
540                            0,
541                            _
542                            ("User opted not to restore any data.                                  "));
543    }
544    if (retval) {
545        mvaddstr_and_log_it(g_currentY++,
546                            0,
547                            _
548                            ("Errors occurred during the restore phase.            "));
549    }
550
551    if (ask_me_yes_or_no(_("Initialize the boot loader?"))) {
552        run_boot_loader(TRUE);
553    } else {
554        mvaddstr_and_log_it(g_currentY++,
555                            0,
556                            _
557                            ("User opted not to initialize the boot loader."));
558    }
559
560//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
561    protect_against_braindead_sysadmins();
562    retval += unmount_all_devices(mountlist);
563    /*  if (restore_some || restore_all || */
564    if (ask_me_yes_or_no
565        (_("Label your ext2 and ext3 partitions if necessary?"))) {
566        mvaddstr_and_log_it(g_currentY, 0,
567                            _
568                            ("Using e2label to label your ext2,3 partitions"));
569        if (does_file_exist("/tmp/fstab.new")) {
570            mr_asprintf(&fstab_fname, "/tmp/fstab.new");
571        } else {
572            mr_asprintf(&fstab_fname, "/tmp/fstab");
573        }
574        mr_asprintf(&tmp,
575                "label-partitions-as-necessary %s < %s >> %s 2>> %s",
576                g_mountlist_fname, fstab_fname, MONDO_LOGFILE,
577                MONDO_LOGFILE);
578        mr_free(fstab_fname);
579
580        res = system(tmp);
581        mr_free(tmp);
582        if (res) {
583            log_to_screen
584                (_("label-partitions-as-necessary returned an error"));
585            mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
586        } else {
587            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
588        }
589        retval += res;
590    }
591
592    iamhere("About to leave interactive_mode()");
593    if (retval) {
594        mvaddstr_and_log_it(g_currentY++,
595                            0,
596                            _
597                            ("Warning - errors occurred during the restore phase."));
598    }
599    return(retval);
600}
601
602/**************************************************************************
603 *END_INTERACTIVE_MODE                                                    *
604 **************************************************************************/
605
606
607/**
608 * Run an arbitrary restore mode (prompt the user), but from ISO images
609 * instead of real media.
610 * @param bkpinfo The backup information structure. Most fields are used.
611 * @param mountlist The mountlist containing information about the user's partitions.
612 * @param raidlist The raidlist that goes with @p mountlist.
613 * @param nuke_me_please If TRUE, we plan to run Nuke Mode.
614 * @return 0 for success, or the number of errors encountered.
615 */
616int
617iso_mode(struct s_bkpinfo *bkpinfo,
618         struct mountlist_itself *mountlist,
619         struct raidlist_itself *raidlist, bool nuke_me_please)
620{
621    char c;
622    int retval = 0;
623
624    assert(bkpinfo != NULL);
625    assert(mountlist != NULL);
626    assert(raidlist != NULL);
627    if (iso_fiddly_bits(bkpinfo, nuke_me_please)) {
628        log_msg(1, "iso_mode --- returning w/ error");
629        return (1);
630    } else {
631        c = which_restore_mode();
632        if (c == 'I' || c == 'N' || c == 'C') {
633            interactively_obtain_media_parameters_from_user(bkpinfo,
634                                                            FALSE);
635        }
636        if (c == 'I') {
637            retval += interactive_mode(bkpinfo, mountlist, raidlist);
638        } else if (c == 'N') {
639            retval += nuke_mode(bkpinfo, mountlist, raidlist);
640        } else if (c == 'C') {
641            retval += compare_mode(bkpinfo, mountlist, raidlist);
642        } else {
643            log_to_screen(_("OK, I shan't restore/compare any files."));
644        }
645    }
646    if (is_this_device_mounted(MNT_CDROM)) {
647        paranoid_system("umount " MNT_CDROM);
648    }
649//  if (! already_mounted)
650//    {
651    if (system("umount /tmp/isodir 2> /dev/null")) {
652        log_to_screen
653            (_
654             ("WARNING - unable to unmount device where the ISO files are stored."));
655    }
656//    }
657    return (retval);
658}
659
660/**************************************************************************
661 *END_ISO_MODE                                                            *
662 **************************************************************************/
663
664
665static void call_me_after_the_nuke(int retval) {
666
667    char *tmp = NULL;
668    char *tmp1 = NULL;
669
670    if (retval) {
671        log_to_screen(_("Errors occurred during the nuke phase."));
672        log_to_screen(_("Please visit our website at http://www.mondorescue.org for more information."));
673    } else {
674#ifdef __FreeBSD__
675        tmp1 = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
676#else
677        tmp1 = call_program_and_get_last_line_of_output("cat /proc/cmdline");
678#endif
679        if ((strstr(tmp1,"restore") == NULL) ||
680            (strstr(tmp1,"RESTORE") == NULL)) {
681                /* -H option */
682                mr_asprintf(&tmp,
683                    _
684                    (" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information."));
685                popup_and_OK(tmp);
686                mr_free(tmp);
687        }
688        mr_free(tmp1);
689
690        log_to_screen(_
691             ("Mondo has restored your system. Please remove the backup media and reboot."));
692        log_to_screen(_
693             ("Thank you for using Mondo Rescue."));
694        log_to_screen(_
695             ("Please visit our website at http://www.mondorescue.org for more information."));
696    }
697    g_I_have_just_nuked = TRUE;
698    return;
699}
700
701
702/**
703 * Restore the user's data automatically (no prompts), after a twenty-second
704 * warning period.
705 * @param bkpinfo The backup information structure. Most fields are used.
706 * @param mountlist The mountlist containing information about the user's partitions.
707 * @param raidlist The raidlist that goes with @p mountlist.
708 * @return 0 for success, or the number of errors encountered.
709 * @warning <b><i>THIS WILL ERASE ALL EXISTING DATA!</i></b>
710 */
711int
712nuke_mode(struct s_bkpinfo *bkpinfo,
713          struct mountlist_itself *mountlist,
714          struct raidlist_itself *raidlist)
715{
716    int retval = 0;
717    int res = 0;
718    bool boot_loader_installed = FALSE;
719    char *tmp = NULL;
720    char *tmpA = NULL;
721    char *tmpB = NULL;
722    char *tmpC = NULL;
723
724    assert(bkpinfo != NULL);
725    assert(mountlist != NULL);
726    assert(raidlist != NULL);
727
728    log_msg(2, "nuke_mode --- starting");
729
730    get_cfg_file_from_archive_or_bust(bkpinfo);
731    load_mountlist(mountlist, g_mountlist_fname);   // in case read_cfg_file_into_bkpinfo updated the mountlist
732#ifdef __FreeBSD__
733    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
734#else
735    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
736#endif
737    if (strstr(tmp,"noresize")) {
738        log_msg(2, "Not resizing mountlist.");
739    } else {
740        resize_mountlist_proportionately_to_suit_new_drives(mountlist);
741    }
742    mr_free(tmp);
743
744    if (!evaluate_mountlist(mountlist, tmpA, tmpB, tmpC)) {
745        mr_asprintf(&tmp,
746                _
747                ("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
748                tmpA, tmpB, tmpC);
749        if (ask_me_yes_or_no(tmp)) {
750            mr_free(tmp);
751            retval = interactive_mode(bkpinfo, mountlist, raidlist);
752            goto after_the_nuke;
753        } else {
754            mr_free(tmp);
755            fatal_error("Nuke Mode aborted. ");
756        }
757    }
758    save_mountlist_to_disk(mountlist, g_mountlist_fname);
759    mvaddstr_and_log_it(1, 30, _("Restoring Automatically"));
760    if (bkpinfo->differential) {
761        log_to_screen(_("Because this is a differential backup, disk"));
762        log_to_screen(_
763                      ("partitioning and formatting will not take place."));
764        res = 0;
765    } else {
766        if (partition_table_contains_Compaq_diagnostic_partition
767            (mountlist)) {
768            offer_to_abort_because_Compaq_Proliants_suck();
769        } else {
770            twenty_seconds_til_yikes();
771            g_fprep = fopen("/tmp/prep.sh", "w");
772#ifdef __FreeBSD__
773            tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
774#else
775            tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
776#endif
777            if (strstr(tmp,"nopart")) {
778                log_msg(2,
779                        "Not partitioning drives due to 'nopart' option.");
780                res = 0;
781            } else {
782                res = partition_everything(mountlist);
783                if (res) {
784                    log_to_screen
785                        (_
786                         ("Warning. Errors occurred during partitioning."));
787                    res = 0;
788                }
789            }
790            mr_free(tmp);
791
792            retval += res;
793            if (!res) {
794                log_to_screen(_("Preparing to format your disk(s)"));
795                sleep(1);
796                sync();
797                log_to_screen(_
798                              ("Please wait. This may take a few minutes."));
799                res += format_everything(mountlist, FALSE, raidlist);
800            }
801            paranoid_fclose(g_fprep);
802        }
803    }
804    retval += res;
805    if (res) {
806        mvaddstr_and_log_it(g_currentY++,
807                            0,
808                            _
809                            ("Failed to partition and/or format your hard drives."));
810
811        if (ask_me_yes_or_no(_("Try in interactive mode instead?"))) {
812            retval = interactive_mode(bkpinfo, mountlist, raidlist);
813            call_me_after_the_nuke(retval);
814        } else
815            if (!ask_me_yes_or_no
816                (_("Would you like to try to proceed anyway?"))) {
817        }
818        return(retval);
819    }
820    retval = mount_all_devices(mountlist, TRUE);
821    if (retval) {
822        unmount_all_devices(mountlist);
823        log_to_screen
824            (_
825             ("Unable to mount all partitions. Sorry, I cannot proceed."));
826        return (retval);
827    }
828    iamhere("Restoring everything");
829    retval += restore_everything(bkpinfo, NULL);
830    if (!run_boot_loader(FALSE)) {
831        log_msg(1,
832                "Great! Boot loader was installed. No need for msg at end.");
833        boot_loader_installed = TRUE;
834    }
835    protect_against_braindead_sysadmins();
836//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
837    retval += unmount_all_devices(mountlist);
838    mvaddstr_and_log_it(g_currentY,
839                        0,
840                        _
841                        ("Using e2label to label your ext2,3 partitions"));
842
843    mr_asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
844            g_mountlist_fname);
845    res = run_program_and_log_output(tmp, TRUE);
846    mr_free(tmp);
847
848    if (res) {
849        log_to_screen(_
850                      ("label-partitions-as-necessary returned an error"));
851        mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
852    } else {
853        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
854    }
855    retval += res;
856
857  after_the_nuke:
858    if (retval) {
859        log_to_screen("Errors occurred during the nuke phase.");
860    } else if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "RESTORE"))    // Bruno's thing
861    {
862        log_to_screen
863            ("PC was restored successfully. Thank you for using Mondo Rescue.");
864        log_to_screen
865            ("Please visit our website at http://www.mondorescue.org for more information.");
866    } else {
867        strcpy(tmp,"Mondo has restored your system.\n\nPlease wait for the command prompt. Then remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information.");
868        if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "restore") == NULL) {
869            popup_and_OK(tmp);
870        }
871        log_to_screen
872          ("Mondo has restored your system. Please wait for the command prompt.");
873        log_to_screen
874            ("Then remove the backup media and reboot.");
875        log_to_screen
876            ("Please visit our website at http://www.mondorescue.org for more information.");
877    }
878    g_I_have_just_nuked = TRUE;
879/*
880  if (!boot_loader_installed && !does_file_exist(DO_MBR_PLEASE))
881    {
882      log_to_screen("PLEASE RUN 'mondorestore --mbr' NOW TO INITIALIZE YOUR BOOT SECTOR");
883      write_one_liner_data_file(DO_MBR_PLEASE, "mondorestore --mbr");
884    }
885*/
886    return (retval);
887}
888/**************************************************************************
889 *END_NUKE_MODE                                                           *
890 **************************************************************************/
891
892
893/**
894 * Restore the user's data (or a subset of it) to the live filesystem.
895 * This should not be called if we're booted from CD!
896 * @param bkpinfo The backup information structure. Most fields are used.
897 * @return 0 for success, or the number of errors encountered.
898 */
899int restore_to_live_filesystem(struct s_bkpinfo *bkpinfo)
900{
901    int retval = 0;
902
903    char *old_restpath = NULL;
904
905    struct mountlist_itself *mountlist = NULL;
906    struct raidlist_itself *raidlist = NULL;
907    struct s_node *filelist = NULL;
908
909    log_msg(1, "restore_to_live_filesystem() - starting");
910    assert(bkpinfo != NULL);
911
912    mountlist = mr_malloc(sizeof(struct mountlist_itself));
913    raidlist = mr_malloc(sizeof(struct raidlist_itself));
914
915    mr_allocstr(bkpinfo->restore_path, "/");
916    if (!g_restoring_live_from_cd) {
917        popup_and_OK
918            (_
919             ("Please insert tape/CD/boot floppy, then hit 'OK' to continue."));
920        sleep(1);
921    }
922    interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
923    if (bkpinfo->media_device == NULL) {
924        log_msg(2, "Warning - failed to find media dev");
925    } else {
926        log_msg(2, "bkpinfo->media_device = %s", bkpinfo->media_device);
927    }
928
929
930    log_msg(2, "bkpinfo->isodir = %s", bkpinfo->isodir);
931
932    open_evalcall_form(_("Thinking..."));
933
934    get_cfg_file_from_archive_or_bust(bkpinfo);
935    read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
936    load_mountlist(mountlist, g_mountlist_fname);   // in case read_cfg_file_into_bkpinfo
937
938    close_evalcall_form();
939    retval = load_mountlist(mountlist, g_mountlist_fname);
940    load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
941    filelist = process_filelist_and_biggielist(bkpinfo);
942    if (filelist) {
943        save_filelist(filelist, "/tmp/selected-files.txt");
944        mr_asprintf(&old_restpath,bkpinfo->restore_path);
945        if (popup_and_get_string(_("Restore path"),
946                                 _("Restore files to where? )"),
947                                 bkpinfo->restore_path)) {
948            iamhere("Restoring everything");
949            retval += restore_everything(bkpinfo, filelist);
950        }
951        free_filelist(filelist);
952        mr_allocstr(bkpinfo->restore_path,old_restpath);
953    }
954    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
955        log_msg(2,
956                "I probably don't need to unmount or eject the CD-ROM but I'm doing it anyway.");
957    }
958    run_program_and_log_output("umount " MNT_CDROM, FALSE);
959    if ((!bkpinfo->please_dont_eject) && (bkpinfo->media_device != NULL)) {
960        eject_device(bkpinfo->media_device);
961    }
962    mr_free(mountlist);
963    mr_free(raidlist);
964    return (retval);
965}
966
967/**************************************************************************
968 *END_RESTORE_TO_LIVE_FILESYSTEM                                          *
969 **************************************************************************/
970
971/* @} - end of restoreGroup */
972
973
974#include <utime.h>
975/**
976 * @addtogroup LLrestoreGroup
977 * @{
978 */
979/**
980 * Restore biggiefile @p bigfileno from the currently mounted CD.
981 * @param bkpinfo The backup information structure. Fields used:
982 * - @c bkpinfo->backup_media_type
983 * - @c bkpinfo->restore_path
984 * @param bigfileno The biggiefile number (starting from 0) to restore.
985 * @param filelist The node structure containing the list of files to restore.
986 * If the biggiefile is not in this list, it will be skipped (return value will
987 * still indicate success).
988 * @return 0 for success (or skip), nonzero for failure.
989 */
990char *
991restore_a_biggiefile_from_CD(struct s_bkpinfo *bkpinfo,
992                             long bigfileno,
993                             struct s_node *filelist)
994{
995    FILE *fin = NULL;
996    FILE *fout = NULL;
997    FILE *fbzip2 = NULL;
998    char *checksum = NULL;
999    char *outfile_fname = NULL;
1000    char *tmp = NULL;
1001    char *tmp0 = NULL;
1002    char *tmp1 = NULL;
1003    char *tmp2 = NULL;
1004    char *tmp3 = NULL;
1005    char *bzip2_command = NULL;
1006    char *bigblk = NULL;
1007    char *pathname_of_last_file_restored = NULL;
1008    int finished = FALSE;
1009    long sliceno;
1010    long siz;
1011    long siz1;
1012    char *ntfsprog_fifo = NULL;
1013    char *file_to_openout = NULL;
1014    struct s_filename_and_lstat_info biggiestruct;
1015    struct utimbuf the_utime_buf, *ubuf = NULL;
1016    bool use_ntfsprog_hack = FALSE;
1017    pid_t pid;
1018    int res = 0;
1019    int old_loglevel;
1020    char *sz_msg;
1021    struct s_node *node = NULL;
1022
1023    old_loglevel = g_loglevel;
1024    ubuf = &the_utime_buf;
1025    assert(bkpinfo != NULL);
1026
1027    bigblk = mr_malloc(TAPE_BLOCK_SIZE);
1028
1029    tmp = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
1030    if (!(fin = fopen(tmp,"r"))) {
1031        log_to_screen(_("Cannot even open bigfile's info file"));
1032        mr_free(tmp);
1033        return (pathname_of_last_file_restored);
1034    }
1035    mr_free(tmp);
1036
1037    memset((void *) &biggiestruct, 0, sizeof(biggiestruct));
1038    if (fread((void *) &biggiestruct, 1, sizeof(biggiestruct), fin) <
1039        sizeof(biggiestruct)) {
1040        log_msg(2, "Warning - unable to get biggiestruct of bigfile #%d",
1041                bigfileno + 1);
1042    }
1043    paranoid_fclose(fin);
1044
1045    mr_asprintf(&checksum, biggiestruct.checksum);
1046
1047    if (!checksum[0]) {
1048        mr_asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
1049                bigfileno + 1);
1050        log_msg(3, tmp);
1051        mr_free(tmp);
1052        /* BERLIOS : Useless ???
1053        p = checksum;
1054        */
1055    }
1056    mr_free(checksum);
1057
1058    if (!strncmp(biggiestruct.filename, "/dev/", 5))    // Whether NTFS or not :)
1059    {
1060        mr_asprintf(&outfile_fname, biggiestruct.filename);
1061    } else {
1062        mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
1063                biggiestruct.filename);
1064    }
1065
1066    /* skip file if we have a selective restore subset & it doesn't match */
1067    if (filelist != NULL) {
1068        node = find_string_at_node(filelist, biggiestruct.filename);
1069        if (!node) {
1070            log_msg(0, "Skipping %s (name isn't in filelist)",
1071                    biggiestruct.filename);
1072            return (pathname_of_last_file_restored);
1073        } else if (!(node->selected)) {
1074            log_msg(1, "Skipping %s (name isn't in biggielist subset)",
1075                    biggiestruct.filename);
1076            return (pathname_of_last_file_restored);
1077        }
1078    }
1079    /* otherwise, continue */
1080
1081    log_msg(1, "DEFINITELY restoring %s", biggiestruct.filename);
1082    if (biggiestruct.use_ntfsprog) {
1083        if (strncmp(biggiestruct.filename, "/dev/", 5)) {
1084            log_msg(1,
1085                    "I was in error when I set biggiestruct.use_ntfsprog to TRUE.");
1086            log_msg(1, "%s isn't even in /dev", biggiestruct.filename);
1087            biggiestruct.use_ntfsprog = FALSE;
1088        }
1089    }
1090
1091    if (biggiestruct.use_ntfsprog)  // if it's an NTFS device
1092//  if (!strncmp ( biggiestruct.filename, "/dev/", 5))
1093    {
1094        g_loglevel = 4;
1095        use_ntfsprog_hack = TRUE;
1096        log_msg(2,
1097                "Calling ntfsclone in background because %s is an NTFS /dev entry",
1098                outfile_fname);
1099        mr_asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
1100                (int) (random() % 32768));
1101        mkfifo(ntfsprog_fifo, 0x770);
1102
1103        file_to_openout = ntfsprog_fifo;
1104        switch (pid = fork()) {
1105        case -1:
1106            fatal_error("Fork failure");
1107        case 0:
1108            log_msg(3,
1109                    "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
1110                    biggiestruct.filename, ntfsprog_fifo);
1111            res =
1112                feed_outfrom_ntfsprog(biggiestruct.filename,
1113                                      ntfsprog_fifo);
1114//          log_msg(3, "CHILD - fip - exiting");
1115            exit(res);
1116            break;
1117        default:
1118            log_msg(3,
1119                    "feed_into_ntfsprog() called in background --- pid=%ld",
1120                    (long int) (pid));
1121        }
1122        // BERLIOS: Is it the right place ??
1123        mr_free(ntfsprog_fifo);
1124    } else {
1125        use_ntfsprog_hack = FALSE;
1126        file_to_openout = outfile_fname;
1127        if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
1128        {
1129            make_hole_for_file(outfile_fname);
1130        }
1131    }
1132
1133    mr_asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
1134            outfile_fname);
1135    log_msg(2, tmp);
1136    mr_free(tmp);
1137
1138    /*
1139       last slice is zero-length and uncompressed; when we find it, we stop.
1140       We DON'T wait until there are no more slices; if we did that,
1141       We might stop at end of CD, not at last slice (which is 0-len and uncompd)
1142     */
1143
1144    mr_asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
1145
1146    log_msg(3, "file_to_openout = %s", file_to_openout);
1147    if (!(fout = fopen(file_to_openout, "w"))) {
1148        log_to_screen(_("Cannot openout outfile_fname - hard disk full?"));
1149        return (pathname_of_last_file_restored);
1150    }
1151    log_msg(3, "Opened out to %s", outfile_fname);  // CD/DVD --> mondorestore --> ntfsclone --> hard disk itself
1152
1153    for (sliceno = 1, finished = FALSE; !finished;) {
1154        tmp = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "");
1155        tmp0 = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "gz");
1156        tmp1 = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "lzo");
1157        tmp2 = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "bz2");
1158        if (!does_file_exist(tmp) && 
1159            !does_file_exist(tmp0) &&
1160            !does_file_exist(tmp1) &&
1161            !does_file_exist(tmp2)) {
1162            log_msg(3,
1163                    "Cannot find a data slice or terminator slice on CD %d",
1164                    g_current_media_number);
1165            g_current_media_number++;
1166            mr_asprintf(&tmp3,
1167                    "Asking for %s #%d so that I may read slice #%ld\n",
1168                    bkpinfo->backup_media_string,
1169                    g_current_media_number, sliceno);
1170            log_msg(2, tmp3);
1171            mr_free(tmp3);
1172
1173            mr_asprintf(&tmp3, _("Restoring from %s #%d"),
1174                    bkpinfo->backup_media_string,
1175                    g_current_media_number);
1176            log_to_screen(tmp3);
1177            mr_free(tmp3);
1178
1179            insist_on_this_cd_number(bkpinfo, g_current_media_number);
1180            log_to_screen(_("Continuing to restore."));
1181        } else {
1182            if (does_file_exist(tmp) && length_of_file(tmp) == 0) {
1183                log_msg(2,
1184                        "End of bigfile # %ld (slice %ld is the terminator)",
1185                        bigfileno + 1, sliceno);
1186                finished = TRUE;
1187                continue;
1188            } else {
1189                if (does_file_exist(tmp1)) {
1190                    mr_asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
1191                } else if (does_file_exist(tmp0)) {
1192                    mr_asprintf(&bzip2_command, "gzip -dc %s 2>> %s",tmp0, MONDO_LOGFILE);
1193                } else if (does_file_exist(tmp2)) {
1194                        mr_asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
1195                } else if (does_file_exist(tmp)) {
1196                        mr_asprintf(&bzip2_command, "%s", "");
1197                } else {
1198                    log_to_screen(_("OK, that's pretty fsck0red..."));
1199                    return (pathname_of_last_file_restored);
1200                }
1201            }
1202
1203            if (bzip2_command == NULL) {
1204                mr_asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
1205            }
1206            mr_asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
1207                    bkpinfo->backup_media_string,
1208                    g_current_media_number, bigfileno + 1, sliceno);
1209            log_msg(2, tmp3);
1210            if (!g_text_mode) {
1211                newtDrawRootText(0, g_noof_rows - 2, tmp3);
1212                newtRefresh();
1213                update_progress_form(tmp3);
1214            }
1215            mr_free(tmp3);
1216
1217            if (!(fbzip2 = popen(bzip2_command, "r"))) {
1218                fatal_error("Can't run popen command");
1219            }
1220            mr_free(bzip2_command);
1221
1222            while (!feof(fbzip2)) {
1223                siz = fread(bigblk, 1, TAPE_BLOCK_SIZE, fbzip2);
1224                if (siz > 0) {
1225                    siz1 = fwrite(bigblk, 1, siz, fout);
1226                    mr_asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
1227                    log_it(sz_msg);
1228                    mr_free(sz_msg);
1229                }
1230            }
1231            paranoid_pclose(fbzip2);
1232
1233
1234            sliceno++;
1235            g_current_progress++;
1236        }
1237        mr_free(tmp);
1238        mr_free(tmp1);
1239        mr_free(tmp2);
1240    }
1241    paranoid_fclose(fout);
1242    g_loglevel = old_loglevel;
1243
1244    if (use_ntfsprog_hack) {
1245        log_msg(3, "Waiting for ntfsclone to finish");
1246        mr_asprintf(&tmp,
1247                " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
1248        while (system(tmp) == 0) {
1249            sleep(1);
1250        }
1251        mr_free(tmp);
1252        log_it("OK, ntfsclone has really finished");
1253    }
1254
1255    if (strcmp(outfile_fname, "/dev/null")) {
1256        chown(outfile_fname, biggiestruct.properties.st_uid,
1257              biggiestruct.properties.st_gid);
1258        chmod(outfile_fname, biggiestruct.properties.st_mode);
1259        ubuf->actime = biggiestruct.properties.st_atime;
1260        ubuf->modtime = biggiestruct.properties.st_mtime;
1261        utime(outfile_fname, ubuf);
1262    }
1263    mr_free(outfile_fname);
1264    mr_free(bigblk);
1265
1266    return (pathname_of_last_file_restored);
1267}
1268
1269
1270/**************************************************************************
1271 *END_ RESTORE_A_BIGGIEFILE_FROM_CD                                       *
1272 **************************************************************************/
1273
1274
1275/**
1276 * Restore a biggiefile from the currently opened stream.
1277 * @param bkpinfo The backup information structure. Fields used:
1278 * - @c bkpinfo->restore_path
1279 * - @c bkpinfo->zip_exe
1280 * @param orig_bf_fname The original filename of the biggiefile.
1281 * @param biggiefile_number The number of the biggiefile (starting from 0).
1282 * @param filelist The node structure containing the list of files to be restored.
1283 * If @p orig_bf_fname is not in the list, it will be ignored.
1284 * @return 0 for success (or skip), nonzero for failure.
1285 */
1286char *restore_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo, char *orig_bf_fname, long biggiefile_number,
1287                                     struct s_node *filelist,
1288                                     int use_ntfsprog)
1289{
1290    FILE *pout;
1291    FILE *fin;
1292
1293  /** mallocs ********/
1294    char *tmp = NULL;
1295    char *tmp1 = NULL;
1296    char *command = NULL;
1297    char *outfile_fname = NULL;
1298    char *ntfsprog_fifo = NULL;
1299    char *file_to_openout = NULL;
1300    char *pathname_of_last_file_restored = NULL;
1301
1302    struct s_node *node;
1303
1304    int old_loglevel;
1305    long current_slice_number = 0;
1306    int retval = 0;
1307    int res = 0;
1308    int ctrl_chr = '\0';
1309    long long slice_siz;
1310    bool dummy_restore = FALSE;
1311    bool use_ntfsprog_hack = FALSE;
1312    pid_t pid;
1313    struct s_filename_and_lstat_info biggiestruct;
1314    struct utimbuf the_utime_buf, *ubuf;
1315    ubuf = &the_utime_buf;
1316
1317    old_loglevel = g_loglevel;
1318    assert(bkpinfo != NULL);
1319    assert(orig_bf_fname != NULL);
1320
1321    if (use_ntfsprog == BLK_START_A_PIHBIGGIE) {
1322        use_ntfsprog = 1;
1323        log_msg(1, "%s --- pih=YES", orig_bf_fname);
1324    } else if (use_ntfsprog == BLK_START_A_NORMBIGGIE) {
1325        use_ntfsprog = 0;
1326        log_msg(1, "%s --- pih=NO", orig_bf_fname);
1327    } else {
1328        use_ntfsprog = 0;
1329        log_msg(1, "%s --- pih=NO (weird marker though)", orig_bf_fname);
1330    }
1331
1332    mr_asprintf(&pathname_of_last_file_restored, orig_bf_fname);
1333
1334    /* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
1335
1336    if (filelist != NULL) {
1337        node = find_string_at_node(filelist, orig_bf_fname);
1338        if (!node) {
1339            dummy_restore = TRUE;
1340            log_msg(1,
1341                    "Skipping big file %ld (%s) - not in biggielist subset",
1342                    biggiefile_number + 1, orig_bf_fname);
1343            pathname_of_last_file_restored = NULL;
1344        } else if (!(node->selected)) {
1345            dummy_restore = TRUE;
1346            log_msg(1, "Skipping %s (name isn't in biggielist subset)",
1347                    orig_bf_fname);
1348            pathname_of_last_file_restored = NULL;
1349        }
1350    }
1351
1352    if (use_ntfsprog) {
1353        if (strncmp(orig_bf_fname, "/dev/", 5)) {
1354            log_msg(1, "I was in error when I set use_ntfsprog to TRUE.");
1355            log_msg(1, "%s isn't even in /dev", orig_bf_fname);
1356            use_ntfsprog = FALSE;
1357        }
1358    }
1359
1360    if (use_ntfsprog) {
1361        g_loglevel = 4;
1362        mr_asprintf(&outfile_fname, orig_bf_fname);
1363        use_ntfsprog_hack = TRUE;
1364        log_msg(2,
1365                "Calling ntfsclone in background because %s is a /dev entry",
1366                outfile_fname);
1367        mr_asprintf(&ntfsprog_fifo, "%s/%d.%d.000", 
1368                bkpinfo->tmpdir,
1369                (int) (random() % 32768),
1370                (int) (random() % 32768));
1371        mkfifo(ntfsprog_fifo, 0x770);
1372
1373        file_to_openout = ntfsprog_fifo;
1374        switch (pid = fork()) {
1375        case -1:
1376            fatal_error("Fork failure");
1377        case 0:
1378            log_msg(3,
1379                    "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
1380                    outfile_fname, ntfsprog_fifo);
1381            res = feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
1382//          log_msg(3, "CHILD - fip - exiting");
1383            exit(res);
1384            break;
1385        default:
1386            log_msg(3,
1387                    "feed_into_ntfsprog() called in background --- pid=%ld",
1388                    (long int) (pid));
1389        }
1390        mr_free(ntfsprog_fifo);
1391    } else {
1392        if (!strncmp(orig_bf_fname, "/dev/", 5))    // non-NTFS partition
1393        {
1394            mr_asprintf(&outfile_fname, orig_bf_fname);
1395        } else                  // biggiefile
1396        {
1397            mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
1398                    orig_bf_fname);
1399        }
1400        use_ntfsprog_hack = FALSE;
1401        file_to_openout = outfile_fname;
1402        if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
1403        {
1404            make_hole_for_file(outfile_fname);
1405        }
1406        mr_asprintf(&tmp1, "Reassembling big file %ld (%s)",
1407                biggiefile_number + 1, orig_bf_fname);
1408        log_msg(2, tmp1);
1409        mr_free(tmp1);
1410    }
1411
1412    if (dummy_restore) {
1413        mr_free(outfile_fname);
1414        mr_asprintf(&outfile_fname, "/dev/null");
1415    }
1416
1417    if (bkpinfo->zip_exe == NULL) {
1418        mr_asprintf(&command, "cat > \"%s\"", file_to_openout);
1419    } else {
1420        mr_asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
1421                file_to_openout, MONDO_LOGFILE);
1422    }
1423    mr_asprintf(&tmp1, "Pipe command = '%s'", command);
1424    log_msg(3, tmp1);
1425    mr_free(tmp1);
1426
1427    /* restore biggiefile, one slice at a time */
1428    if (!(pout = popen(command, "w"))) {
1429        fatal_error("Cannot pipe out");
1430    }
1431    mr_free(command);
1432
1433    for (res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr);
1434         ctrl_chr != BLK_STOP_A_BIGGIE;
1435         res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr)) {
1436        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
1437            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
1438        }
1439        mr_asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
1440                biggiefile_number + 1, current_slice_number);
1441        log_msg(2, tmp1);
1442
1443        if (!g_text_mode) {
1444            newtDrawRootText(0, g_noof_rows - 2, tmp1);
1445            newtRefresh();
1446        }
1447        strip_spaces(tmp1);
1448        update_progress_form(tmp1);
1449        mr_free(tmp1);
1450
1451        if (current_slice_number == 0) {
1452            res =
1453                read_file_from_stream_to_file(bkpinfo,
1454                                              "/tmp/biggie-blah.txt",
1455                                              slice_siz);
1456            if (!(fin = fopen("/tmp/biggie-blah.txt", "r"))) {
1457                log_OS_error("blah blah");
1458            } else {
1459                if (fread
1460                    ((void *) &biggiestruct, 1, sizeof(biggiestruct),
1461                     fin) < sizeof(biggiestruct)) {
1462                    log_msg(2,
1463                            "Warning - unable to get biggiestruct of bigfile #%d",
1464                            biggiefile_number + 1);
1465                }
1466                paranoid_fclose(fin);
1467            }
1468        } else {
1469            res =
1470                read_file_from_stream_to_stream(bkpinfo, pout, slice_siz);
1471        }
1472        retval += res;
1473        res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr);
1474        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
1475            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
1476        }
1477        current_slice_number++;
1478        g_current_progress++;
1479    }
1480    mr_free(tmp);
1481    paranoid_pclose(pout);
1482
1483    log_msg(1, "pathname_of_last_file_restored is now %s",
1484            pathname_of_last_file_restored);
1485
1486    if (use_ntfsprog_hack) {
1487        log_msg(3, "Waiting for ntfsclone to finish");
1488        mr_asprintf(&tmp,
1489                " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
1490        while (system(tmp) == 0) {
1491            sleep(1);
1492        }   
1493        mr_free(tmp);
1494        log_msg(3, "OK, ntfsclone has really finished");
1495    }
1496
1497    log_msg(3, "biggiestruct.filename = %s", biggiestruct.filename);
1498    log_msg(3, "biggiestruct.checksum = %s", biggiestruct.checksum);
1499    if (strcmp(outfile_fname, "/dev/null")) {
1500        chmod(outfile_fname, biggiestruct.properties.st_mode);
1501        chown(outfile_fname, biggiestruct.properties.st_uid,
1502              biggiestruct.properties.st_gid);
1503        ubuf->actime = biggiestruct.properties.st_atime;
1504        ubuf->modtime = biggiestruct.properties.st_mtime;
1505        utime(outfile_fname, ubuf);
1506    }
1507
1508    mr_free(outfile_fname);
1509    g_loglevel = old_loglevel;
1510    return (pathname_of_last_file_restored);
1511}
1512
1513/**************************************************************************
1514 *END_RESTORE_A_BIGGIEFILE_FROM_STREAM                                    *
1515 **************************************************************************/
1516
1517
1518/**
1519 * Restore @p tarball_fname from CD.
1520 * @param tarball_fname The filename of the tarball to restore (in /mnt/cdrom).
1521 * This will be used unmodified.
1522 * @param current_tarball_number The number (starting from 0) of the fileset
1523 * we're restoring now.
1524 * @param filelist The node structure containing the list of files to be
1525 * restored. If no file in the afioball is in this list, afio will still be
1526 * called, but nothing will be written.
1527 * @return 0 for success, nonzero for failure.
1528 */
1529int
1530restore_a_tarball_from_CD(char *tarball_fname,
1531                          long current_tarball_number,
1532                          struct s_node *filelist)
1533{
1534    int retval = 0;
1535    int res;
1536    char *p;
1537
1538  /** malloc **/
1539    char *command;
1540    char *tmp = NULL;
1541    char *filelist_name;
1542    char *filelist_subset_fname = NULL;
1543    char *executable = NULL;
1544    char *temp_log = NULL;
1545    long matches = 0;
1546    bool use_star;
1547    char *xattr_fname = NULL;
1548    char *acl_fname = NULL;
1549
1550    assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
1551
1552    log_msg(5, "Entering");
1553    use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
1554    mr_asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
1555    run_program_and_log_output(command, 9);
1556    mr_free(command);
1557
1558    mr_asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
1559            current_tarball_number);
1560    if (length_of_file(filelist_name) <= 2) {
1561        log_msg(2, "There are _zero_ files in filelist '%s'",
1562                filelist_name);
1563        log_msg(2,
1564                "This is a bit silly (ask dev-team to fix mondo_makefilelist, please)");
1565        log_msg(2,
1566                "but it's non-critical. It's cosmetic. Don't worry about it.");
1567        retval = 0;
1568        log_msg(5, "Leaving");
1569        return (retval);
1570    }
1571    if (count_lines_in_file(filelist_name) <= 0
1572        || length_of_file(tarball_fname) <= 0) {
1573        log_msg(3, "length_of_file(%s) = %llu", tarball_fname,
1574                length_of_file(tarball_fname));
1575        mr_asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
1576                current_tarball_number);
1577        log_to_screen(tmp);
1578        mr_free(tmp);
1579        retval = 1;
1580        log_msg(5, "Leaving");
1581        return (retval);
1582    }
1583
1584    if (filelist) {
1585        mr_asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
1586                current_tarball_number);
1587        if ((matches =
1588             save_filelist_entries_in_common(filelist_name, filelist,
1589                                             filelist_subset_fname,
1590                                             use_star))
1591            <= 0) {
1592            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
1593            log_msg(1, tmp);
1594            mr_free(tmp);
1595        } else {
1596            log_msg(3, "Saved fileset %ld's subset to %s",
1597                    current_tarball_number, filelist_subset_fname);
1598        }
1599        mr_asprintf(&tmp, "Tarball #%ld --- %ld matches",
1600                current_tarball_number, matches);
1601        log_to_screen(tmp);
1602        mr_free(tmp);
1603    } else {
1604        filelist_subset_fname = NULL;
1605    }
1606    mr_free(filelist_name);
1607
1608    if (filelist == NULL || matches > 0) {
1609        if (g_getfattr) {
1610            mr_asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
1611                MNT_CDROM "/archives", current_tarball_number);
1612        }
1613        if (g_getfacl) {
1614            mr_asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
1615                current_tarball_number);
1616        }
1617        if (strstr(tarball_fname, ".bz2")) {
1618            mr_asprintf(&executable, "bzip2");
1619        } else if (strstr(tarball_fname, ".gz")) {
1620            strcpy(executable, "gzip");
1621        } else if (strstr(tarball_fname, ".gz")) {
1622            strcpy(executable, "gzip");
1623        } else if (strstr(tarball_fname, ".lzo")) {
1624            mr_asprintf(&executable, "lzop");
1625        } else {
1626            executable = NULL;
1627        }
1628
1629        if (executable == NULL) {
1630            mr_asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
1631            if (run_program_and_log_output(tmp, FALSE)) {
1632                log_to_screen
1633                    (_
1634                     ("(compare_a_tarball) Compression program not found - oh no!"));
1635                paranoid_MR_finish(1);
1636            }
1637            mr_free(tmp);
1638
1639            mr_asprintf(&tmp, executable);
1640            mr_asprintf(&executable, "-P %s -Z", tmp);
1641            mr_free(tmp);
1642        }
1643#ifdef __FreeBSD__
1644#define BUFSIZE 512
1645#else
1646#define BUFSIZE (1024L*1024L)/TAPE_BLOCK_SIZE
1647#endif
1648
1649        mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
1650            (int) (random() % 32768));
1651
1652        if (use_star) {
1653            if (strstr(tarball_fname, ".bz2")) {
1654                mr_asprintf(&tmp, " -bz");
1655            } else {
1656                mr_asprintf(&tmp, "%s", "");
1657            }
1658            mr_asprintf(&command,
1659                    "star -x -force-remove -U " STAR_ACL_SZ
1660                    " errctl= file=%s %s 2>> %s >> %s", tarball_fname, tmp, temp_log, temp_log);
1661            mr_free(tmp);
1662        } else {
1663            if (filelist_subset_fname != NULL) {
1664                mr_asprintf(&command,
1665                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s 2>> %s >> %s",
1666                        TAPE_BLOCK_SIZE,
1667                        BUFSIZE, executable, filelist_subset_fname,
1668//             files_to_restore_this_time_fname,
1669                        tarball_fname, temp_log, temp_log);
1670            } else {
1671                mr_asprintf(&command,
1672                        "afio -i -b %ld -c %ld -M 8m %s %s 2>> %s >> %s",
1673                        TAPE_BLOCK_SIZE,
1674                        BUFSIZE, executable, tarball_fname, temp_log, temp_log);
1675            }
1676        }
1677        mr_free(executable);
1678
1679#undef BUFSIZE
1680        log_msg(1, "command = '%s'", command);
1681        unlink(temp_log);
1682        res = system(command);
1683        if (res) {
1684            p = strstr(command, "-acl ");
1685            if (p) {
1686                p[0] = p[1] = p[2] = p[3] = ' ';
1687                log_msg(1, "new command = '%s'", command);
1688                res = system(command);
1689            }
1690        }
1691        mr_free(command);
1692
1693        if (res && length_of_file(temp_log) < 5) {
1694            res = 0;
1695        }
1696
1697        if (g_getfattr) {
1698            log_msg(1, "Setting fattr list %s", xattr_fname);
1699            if (length_of_file(xattr_fname) > 0) {
1700                res = set_fattr_list(filelist_subset_fname, xattr_fname);
1701                if (res) {
1702                    log_to_screen
1703                        ("Errors occurred while setting extended attributes");
1704                } else {
1705                    log_msg(1, "I set xattr OK");
1706                }
1707                retval += res;
1708            }
1709        }
1710        if (g_getfacl) {
1711            log_msg(1, "Setting acl list %s", acl_fname);
1712            if (length_of_file(acl_fname) > 0) {
1713                res = set_acl_list(filelist_subset_fname, acl_fname);
1714                if (res) {
1715                    log_to_screen
1716                        ("Errors occurred while setting access control lists");
1717                } else {
1718                    log_msg(1, "I set ACL OK");
1719                }
1720                retval += res;
1721            }
1722        }
1723        if (retval) {
1724            mr_asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
1725            system(command);
1726            mr_free(command);
1727            log_msg(2, "Errors occurred while processing fileset #%d",
1728                    current_tarball_number);
1729        } else {
1730            log_msg(2, "Fileset #%d processed OK", current_tarball_number);
1731        }
1732        unlink(xattr_fname);
1733        mr_free(xattr_fname);
1734    }
1735    if (does_file_exist("/PAUSE")) {
1736        popup_and_OK
1737            (_
1738             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
1739    }
1740    unlink(filelist_subset_fname);
1741    unlink(acl_fname);
1742    unlink(temp_log);
1743
1744    mr_free(filelist_subset_fname);
1745    mr_free(acl_fname);
1746    mr_free(temp_log);
1747    log_msg(5, "Leaving");
1748    return (retval);
1749}
1750
1751/**************************************************************************
1752 *END_RESTORE_A_TARBALL_FROM_CD                                           *
1753 **************************************************************************/
1754
1755
1756/**
1757 * Restore a tarball from the currently opened stream.
1758 * @param bkpinfo The backup information structure. Fields used:
1759 * - @c bkpinfo->backup_media_type
1760 * - @c bkpinfo->media_device
1761 * - @c bkpinfo->zip_exe
1762 * @param tarball_fname The filename of the afioball to restore.
1763 * @param current_tarball_number The number (starting from 0) of the fileset
1764 * we're restoring now.
1765 * @param filelist The node structure containing the list of files to be
1766 * restored. If no file in the afioball is in this list, afio will still be
1767 * called, but nothing will be written.
1768 * @param size The size (in @b bytes) of the afioball.
1769 * @return 0 for success, nonzero for failure.
1770 */
1771int
1772restore_a_tarball_from_stream(struct s_bkpinfo *bkpinfo,
1773                              char *tarball_fname,
1774                              long current_tarball_number,
1775                              struct s_node *filelist,
1776                              long long size, char *xattr_fname,
1777                              char *acl_fname)
1778{
1779    int retval = 0;
1780    int res = 0;
1781
1782  /** malloc add ***/
1783    char *tmp = NULL;
1784    char *command = NULL;
1785    char *afio_fname = NULL;
1786    char *filelist_fname = NULL;
1787    char *filelist_subset_fname = NULL;
1788    char *executable = NULL;
1789    long matches = 0;
1790    bool restore_this_fileset = FALSE;
1791    bool use_star;
1792
1793    assert(bkpinfo != NULL);
1794    assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
1795    /* to do it with a file... */
1796    use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
1797    mr_asprintf(&tmp,
1798            "Restoring from fileset #%ld (%ld KB) on %s #%d",
1799            current_tarball_number, (long) size >> 10,
1800            bkpinfo->backup_media_string,
1801            g_current_media_number);
1802    log_msg(2, tmp);
1803    mr_free(tmp);
1804    run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
1805
1806  /****************************************************************************
1807   * Use RAMDISK's /tmp; saves time; oh wait, it's too small                  *
1808   * Well, pipe from tape to afio, then; oh wait, can't do that either: bug   *
1809   * in afio or someting; oh darn.. OK, use tmpfs :-)                         *
1810   ****************************************************************************/
1811    mr_asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
1812            current_tarball_number);
1813    mr_asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
1814            current_tarball_number);
1815    mr_asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
1816            bkpinfo->tmpdir, current_tarball_number);
1817    res = read_file_from_stream_to_file(bkpinfo, afio_fname, size);
1818    if (strstr(tarball_fname, ".star")) {
1819        bkpinfo->use_star = TRUE;
1820    }
1821    if (res) {
1822        log_msg(1, "Warning - error reading afioball from tape");
1823    }
1824    if (bkpinfo->compression_level != 0) {
1825        if (bkpinfo->use_star) {
1826            mr_asprintf(&executable, " -bz");
1827        } else {
1828            mr_asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
1829        }
1830    }
1831
1832    if (!filelist)              // if unconditional restore then restore entire fileset
1833    {
1834        restore_this_fileset = TRUE;
1835    } else                      // If restoring selectively then get TOC from tarball
1836    {
1837        if (strstr(tarball_fname, ".star.")) {
1838            use_star = TRUE;
1839            mr_asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
1840        } else {
1841            use_star = FALSE;
1842            mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
1843                    executable, afio_fname, filelist_fname, MONDO_LOGFILE);
1844        }
1845        log_msg(1, "command = %s", command);
1846        if (system(command)) {
1847            log_msg(4, "Warning - error occurred while retrieving TOC");
1848        }
1849        mr_free(command);
1850        if ((matches =
1851             save_filelist_entries_in_common(filelist_fname, filelist,
1852                                             filelist_subset_fname,
1853                                             use_star))
1854            <= 0 || length_of_file(filelist_subset_fname) < 2) {
1855            if (length_of_file(filelist_subset_fname) < 2) {
1856                log_msg(1, "No matches found in fileset %ld",
1857                        current_tarball_number);
1858            }
1859            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
1860            log_msg(2, tmp);
1861            mr_free(tmp);
1862            restore_this_fileset = FALSE;
1863        } else {
1864            log_msg(5, "%ld matches. Saved fileset %ld's subset to %s",
1865                    matches, current_tarball_number,
1866                    filelist_subset_fname);
1867            restore_this_fileset = TRUE;
1868        }
1869    }
1870    unlink(filelist_fname);
1871    mr_free(filelist_fname);
1872
1873// Concoct the call to star/afio to restore files
1874    if (strstr(tarball_fname, ".star.")) {
1875        // star
1876        if (filelist) {
1877            mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
1878                    filelist_subset_fname,MONDO_LOGFILE);
1879        } else {
1880            mr_asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
1881        }
1882    } else {
1883        // afio
1884        if (filelist) {
1885            mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
1886        } else {
1887            mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
1888        }
1889    }
1890    mr_free(executable);
1891
1892    // Call if IF there are files to restore (selectively/unconditionally)
1893    if (restore_this_fileset) {
1894        log_msg(1, "Calling command='%s'", command);
1895        paranoid_system(command);
1896
1897        if (g_getfattr) {
1898            iamhere("Restoring xattr stuff");
1899            res = set_fattr_list(filelist_subset_fname, xattr_fname);
1900            if (res) {
1901                log_msg(1, "Errors occurred while setting xattr");
1902            } else {
1903                log_msg(1, "I set xattr OK");
1904            }
1905            retval += res;
1906        }
1907
1908        if (g_getfacl) {
1909            iamhere("Restoring acl stuff");
1910            res = set_acl_list(filelist_subset_fname, acl_fname);
1911            if (res) {
1912                log_msg(1, "Errors occurred while setting ACL");
1913            } else {
1914                log_msg(1, "I set ACL OK");
1915            }
1916            retval += res;
1917        }
1918
1919    } else {
1920        log_msg(1, "NOT CALLING '%s'", command);
1921    }
1922    mr_free(command);
1923
1924    if (does_file_exist("/PAUSE") && current_tarball_number >= 50) {
1925        log_to_screen(_("Paused after set %ld"), current_tarball_number);
1926        popup_and_OK(_("Pausing. Press ENTER to continue."));
1927    }
1928
1929    unlink(filelist_subset_fname);
1930    unlink(afio_fname);
1931
1932    mr_free(filelist_subset_fname);
1933    mr_free(afio_fname);
1934    return (retval);
1935}
1936
1937/**************************************************************************
1938 *END_RESTORE_A_TARBALL_FROM_STREAM                                       *
1939 **************************************************************************/
1940
1941
1942/**
1943 * Restore all biggiefiles from all media in this CD backup.
1944 * The CD with the last afioball should be currently mounted.
1945 * @param bkpinfo The backup information structure. @c backup_media_type is the
1946 * only field used in this function.
1947 * @param filelist The node structure containing the list of files to be
1948 * restored. If a prospective biggiefile is not in this list, it will be ignored.
1949 * @return 0 for success, nonzero for failure.
1950 */
1951int
1952restore_all_biggiefiles_from_CD(struct s_bkpinfo *bkpinfo,
1953                                struct s_node *filelist)
1954{
1955    int retval = 0;
1956    int res = 0;
1957    long noof_biggiefiles = 0L, bigfileno = 0L, total_slices = 0L;
1958    char *tmp = NULL;
1959    char *tmp1 = NULL;
1960    bool just_changed_cds = FALSE, finished = FALSE;
1961    char *xattr_fname = NULL;
1962    char *acl_fname = NULL;
1963    char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
1964    char *pathname_of_last_biggie_restored = NULL;
1965    FILE *fbw = NULL;
1966
1967    assert(bkpinfo != NULL);
1968
1969    mr_asprintf(&biggies_whose_EXATs_we_should_set,
1970            "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
1971    if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
1972        log_msg(1, "Warning - cannot openout %s",
1973                biggies_whose_EXATs_we_should_set);
1974    }
1975
1976    read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
1977    total_slices = atol(tmp);
1978    mr_free(tmp);
1979
1980    mr_asprintf(&tmp, _("Reassembling large files      "));
1981    mvaddstr_and_log_it(g_currentY, 0, tmp);
1982    mr_free(tmp);
1983
1984    if (length_of_file(BIGGIELIST) < 6) {
1985        log_msg(1, "OK, no biggielist; not restoring biggiefiles");
1986        return (0);
1987    }
1988    noof_biggiefiles = count_lines_in_file(BIGGIELIST);
1989    if (noof_biggiefiles <= 0) {
1990        log_msg(2,
1991                "OK, no biggiefiles in biggielist; not restoring biggiefiles");
1992        return (0);
1993    }
1994    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
1995            noof_biggiefiles);
1996    log_msg(2, tmp);
1997    mr_free(tmp);
1998
1999    open_progress_form(_("Reassembling large files"),
2000                       _("I am now reassembling all the large files."),
2001                       _("Please wait. This may take some time."),
2002                       "", total_slices);
2003    for (bigfileno = 0, finished = FALSE; !finished;) {
2004        log_msg(2, "Thinking about restoring bigfile %ld", bigfileno + 1);
2005        tmp = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
2006        if (!does_file_exist(tmp)) {
2007            log_msg(3,
2008                    "...but its first slice isn't on this CD. Perhaps this was a selective restore?");
2009            log_msg(3, "Cannot find bigfile #%ld 's first slice on %s #%d",
2010                    bigfileno + 1,
2011                    bkpinfo->backup_media_string,
2012                    g_current_media_number);
2013            tmp1 = slice_fname(bigfileno + 1, 0, ARCHIVES_PATH, "");
2014            log_msg(3, "Slicename would have been %s", tmp1);
2015            mr_free(tmp1);
2016
2017            // I'm not positive 'just_changed_cds' is even necessary...
2018            if (just_changed_cds) {
2019                just_changed_cds = FALSE;
2020                log_msg(3,
2021                        "I'll continue to scan this CD for bigfiles to be restored.");
2022            } else if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
2023                insist_on_this_cd_number(bkpinfo,
2024                                         ++g_current_media_number);
2025                mr_asprintf(&tmp, _("Restoring from %s #%d"),
2026                        bkpinfo->backup_media_string,
2027                        g_current_media_number);
2028                log_to_screen(tmp);
2029                mr_free(tmp);
2030
2031                just_changed_cds = TRUE;
2032            } else {
2033                log_msg(2, "There was no bigfile #%ld. That's OK.",
2034                        bigfileno + 1);
2035                log_msg(2, "I'm going to stop restoring bigfiles now.");
2036                finished = TRUE;
2037            }
2038        } else {
2039            just_changed_cds = FALSE;
2040            mr_asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
2041            update_progress_form(tmp);
2042            mr_free(tmp);
2043
2044            pathname_of_last_biggie_restored =
2045                restore_a_biggiefile_from_CD(bkpinfo, bigfileno, filelist);
2046            iamhere(pathname_of_last_biggie_restored);
2047            if (fbw && pathname_of_last_biggie_restored[0]) {
2048                fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
2049            }
2050            mr_free(pathname_of_last_biggie_restored);
2051            retval += res;
2052            bigfileno++;
2053
2054        }
2055        mr_free(tmp);
2056    }
2057
2058    if (fbw) {
2059        fclose(fbw);
2060        if (g_getfattr) {
2061            mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
2062            if (length_of_file(xattr_fname) > 0) {
2063                set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
2064            }
2065        }
2066        if (g_getfacl) {
2067            mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
2068            if (length_of_file(acl_fname) > 0) {
2069                set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
2070            }
2071        }
2072        mr_free(acl_fname);
2073        mr_free(xattr_fname);
2074    }
2075    mr_free(biggies_whose_EXATs_we_should_set);
2076
2077    if (does_file_exist("/PAUSE")) {
2078        popup_and_OK
2079            (_
2080             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
2081    }
2082    close_progress_form();
2083    if (retval) {
2084        mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
2085    } else {
2086        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
2087    }
2088    return (retval);
2089}
2090/**************************************************************************
2091 *END_RESTORE_ALL_BIGGIFILES_FROM_CD                                      *
2092 **************************************************************************/
2093
2094
2095/**
2096 * Restore all afioballs from all CDs in the backup.
2097 * The first CD should be inserted (if not, it will be asked for).
2098 * @param bkpinfo The backup information structure. @c backup_media_type is the
2099 * only field used in @e this function.
2100 * @param filelist The node structure containing the list of files to be
2101 * restored. If no file in some particular afioball is in this list, afio will
2102 * still be called for that fileset, but nothing will be written.
2103 * @return 0 for success, or the number of filesets that failed.
2104 */
2105int
2106restore_all_tarballs_from_CD(struct s_bkpinfo *bkpinfo,
2107                             struct s_node *filelist)
2108{
2109    int retval = 0;
2110    int res;
2111    int attempts;
2112    long current_tarball_number = 0;
2113    long max_val;
2114  /**malloc ***/
2115    char *tmp;
2116    char *tmp1;
2117    char *tarball_fname;
2118    char *progress_str;
2119    char *comment;
2120
2121    assert(bkpinfo != NULL);
2122
2123    mvaddstr_and_log_it(g_currentY, 0, _("Restoring from archives"));
2124    log_msg(2,
2125            "Insisting on 1st CD, so that I can have a look at LAST-FILELIST-NUMBER");
2126    if (g_current_media_number != 1) {
2127        log_msg(3, "OK, that's jacked up.");
2128        g_current_media_number = 1;
2129    }
2130    insist_on_this_cd_number(bkpinfo, g_current_media_number);
2131    read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
2132    max_val = atol(tmp) + 1;
2133    mr_free(tmp);
2134
2135    mr_asprintf(&progress_str, _("Restoring from %s #%d"),
2136            bkpinfo->backup_media_string,
2137            g_current_media_number);
2138    log_to_screen(progress_str);
2139    open_progress_form(_("Restoring from archives"),
2140                       _("Restoring data from the archives."),
2141                       _("Please wait. This may take some time."),
2142                       progress_str, max_val);
2143    for (;;) {
2144        insist_on_this_cd_number(bkpinfo, g_current_media_number);
2145        update_progress_form(progress_str);
2146
2147        mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
2148                current_tarball_number);
2149        if (!does_file_exist(tarball_fname)) {
2150            mr_free(tarball_fname);
2151            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
2152                current_tarball_number);
2153        }
2154        if (!does_file_exist(tarball_fname)) {
2155            mr_free(tarball_fname);
2156            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.gz",
2157                    current_tarball_number);
2158        }
2159        if (!does_file_exist(tarball_fname)) {
2160            mr_free(tarball_fname);
2161            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
2162                    current_tarball_number);
2163        }
2164        if (!does_file_exist(tarball_fname)) {
2165            mr_free(tarball_fname);
2166            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
2167                    current_tarball_number);
2168        }
2169        if (!does_file_exist(tarball_fname)) {
2170            mr_free(tarball_fname);
2171            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
2172                    current_tarball_number);
2173        }
2174        if (!does_file_exist(tarball_fname)) {
2175            mr_free(tarball_fname);
2176            if (current_tarball_number == 0) {
2177                log_to_screen
2178                    (_
2179                     ("No tarballs. Strange. Maybe you only backed up freakin' big files?"));
2180                return (0);
2181            }
2182            if (!does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")
2183                || system("find " MNT_CDROM
2184                          "/archives/slice* > /dev/null 2> /dev/null") ==
2185                0) {
2186                break;
2187            }
2188            g_current_media_number++;
2189            mr_free(progress_str);
2190            mr_asprintf(&progress_str, _("Restoring from %s #%d"),
2191                    bkpinfo->backup_media_string,
2192                    g_current_media_number);
2193            log_to_screen(progress_str);
2194        } else {
2195            mr_free(progress_str);
2196            mr_asprintf(&progress_str,
2197                    _("Restoring from fileset #%ld on %s #%d"),
2198                    current_tarball_number,
2199                    bkpinfo->backup_media_string,
2200                    g_current_media_number);
2201//    log_msg(3, "progress_str = %s", progress_str);
2202            for (res = 999, attempts = 0; attempts < 3 && res != 0;
2203                 attempts++) {
2204                res =
2205                    restore_a_tarball_from_CD(tarball_fname,
2206                                              current_tarball_number,
2207                                              filelist);
2208            }
2209            if (res) {
2210                mr_asprintf(&tmp1, _("reported errors"));
2211            } else {
2212                mr_asprintf(&tmp1, _("succeeded"));
2213            }
2214            mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
2215                    bkpinfo->backup_media_string,
2216                    g_current_media_number, current_tarball_number,tmp1);
2217            mr_free(tmp1);
2218           
2219            if (attempts > 1) {
2220                mr_asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
2221            }
2222            mr_asprintf(&comment, "%s%s", tmp, tmp1);
2223            mr_free(tmp);
2224            mr_free(tmp1);
2225            if (attempts > 1) {
2226                log_to_screen(comment);
2227            }
2228            mr_free(comment);
2229
2230            retval += res;
2231            current_tarball_number++;
2232            g_current_progress++;
2233        }
2234        mr_free(tarball_fname);
2235    }
2236    mr_free(progress_str);
2237    close_progress_form();
2238
2239    if (retval) {
2240        mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
2241    } else {
2242        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
2243    }
2244
2245    return (retval);
2246}
2247
2248/**************************************************************************
2249 *END_RESTORE_ALL_TARBALLS_FROM_CD                                        *
2250 **************************************************************************/
2251
2252
2253/**
2254 * Restore all biggiefiles from the currently opened stream.
2255 * @param bkpinfo The backup information structure. Passed to other functions.
2256 * @param filelist The node structure containing the list of files to be
2257 * restored. If a prospective biggiefile is not in the list, it will be ignored.
2258 * @return 0 for success, or the number of biggiefiles that failed.
2259 */
2260int
2261restore_all_biggiefiles_from_stream(struct s_bkpinfo *bkpinfo,
2262                                    struct s_node *filelist)
2263{
2264    long noof_biggiefiles;
2265    long current_bigfile_number = 0;
2266    long total_slices;
2267
2268    int retval = 0;
2269    int res = 0;
2270    int ctrl_chr;
2271
2272  /** malloc add ****/
2273    char *tmp = NULL;
2274    char *biggie_fname = NULL;
2275    char *xattr_fname = NULL;
2276    char *acl_fname = NULL;
2277    char *pathname_of_last_biggie_restored = NULL;
2278    char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
2279    long long biggie_size = (long long)0;
2280    FILE *fbw;
2281
2282    assert(bkpinfo != NULL);
2283
2284    read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
2285    total_slices = atol(tmp);
2286    mr_free(tmp);
2287
2288    mr_asprintf(&tmp, "Reassembling large files      ");
2289    if (g_getfattr) {
2290        mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2291    }
2292    if (g_getfacl) {
2293        mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2294    }
2295    mvaddstr_and_log_it(g_currentY, 0, tmp);
2296    mr_free(tmp);
2297
2298    mr_asprintf(&biggies_whose_EXATs_we_should_set,
2299            "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
2300    if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
2301        log_msg(1, "Warning - cannot openout %s",
2302                biggies_whose_EXATs_we_should_set);
2303    }
2304// get xattr and acl files if they're there
2305    res =
2306        read_header_block_from_stream(&biggie_size, biggie_fname,
2307                                      &ctrl_chr);
2308    if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
2309        res =
2310            read_EXAT_files_from_tape(bkpinfo, &biggie_size, biggie_fname,
2311                                      &ctrl_chr, xattr_fname, acl_fname);
2312    }
2313
2314    noof_biggiefiles = atol(biggie_fname);
2315    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
2316            noof_biggiefiles);
2317    log_msg(2, tmp);
2318    mr_free(tmp);
2319
2320    open_progress_form(_("Reassembling large files"),
2321                       _("I am now reassembling all the large files."),
2322                       _("Please wait. This may take some time."),
2323                       "", total_slices);
2324
2325    for (res =
2326         read_header_block_from_stream(&biggie_size, biggie_fname,
2327                                       &ctrl_chr);
2328         ctrl_chr != BLK_STOP_BIGGIEFILES;
2329         res =
2330         read_header_block_from_stream(&biggie_size, biggie_fname,
2331                                       &ctrl_chr)) {
2332        if (ctrl_chr != BLK_START_A_NORMBIGGIE
2333            && ctrl_chr != BLK_START_A_PIHBIGGIE) {
2334            wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
2335        }
2336        /* BERLIOS: useless
2337        p = strrchr(biggie_fname, '/');
2338        if (!p) {
2339            p = biggie_fname;
2340        } else {
2341            p++;
2342        }
2343        */
2344        mr_asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
2345                current_bigfile_number + 1, biggie_size / 1024);
2346        update_progress_form(tmp);
2347        mr_free(tmp);
2348
2349        pathname_of_last_biggie_restored = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
2350                                               current_bigfile_number,
2351                                               filelist, ctrl_chr);
2352        log_msg(1, "I believe I have restored %s",
2353                pathname_of_last_biggie_restored);
2354        if (fbw && pathname_of_last_biggie_restored[0]) {
2355            fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
2356        }
2357        mr_free(pathname_of_last_biggie_restored);
2358
2359        retval += res;
2360        current_bigfile_number++;
2361
2362    }
2363    if (current_bigfile_number != noof_biggiefiles
2364        && noof_biggiefiles != 0) {
2365        mr_asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
2366                current_bigfile_number, noof_biggiefiles);
2367    } else {
2368        mr_asprintf(&tmp,
2369                "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
2370                noof_biggiefiles, current_bigfile_number);
2371    }
2372    log_msg(1, tmp);
2373    mr_free(tmp);
2374
2375    if (fbw) {
2376        fclose(fbw);
2377        if (length_of_file(biggies_whose_EXATs_we_should_set) > 2) {
2378            iamhere("Setting biggie-EXATs");
2379            if (g_getfattr) {
2380                if (length_of_file(xattr_fname) > 0) {
2381                    log_msg(1, "set_fattr_List(%s,%s)",
2382                        biggies_whose_EXATs_we_should_set, xattr_fname);
2383                    set_fattr_list(biggies_whose_EXATs_we_should_set,
2384                               xattr_fname);
2385                }
2386            }
2387            if (g_getfacl) {
2388                if (length_of_file(acl_fname) > 0) {
2389                    log_msg(1, "set_acl_list(%s,%s)",
2390                            biggies_whose_EXATs_we_should_set, acl_fname);
2391                    set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
2392                }
2393            }
2394        } else {
2395            iamhere
2396                ("No biggiefiles selected. So, no biggie-EXATs to set.");
2397        }
2398    }
2399    mr_free(xattr_fname);
2400    mr_free(acl_fname);
2401    mr_free(biggies_whose_EXATs_we_should_set);
2402
2403    if (does_file_exist("/PAUSE")) {
2404        popup_and_OK
2405            (_
2406             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
2407    }
2408
2409    close_progress_form();
2410    if (retval) {
2411        mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
2412    } else {
2413        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
2414    }
2415    mr_free(biggie_fname);
2416    return (retval);
2417}
2418
2419/**************************************************************************
2420 *END_RESTORE_ALL_BIGGIEFILES_FROM_STREAM                                 *
2421 **************************************************************************/
2422
2423
2424/**
2425 * Restore all afioballs from the currently opened tape stream.
2426 * @param bkpinfo The backup information structure. Fields used:
2427 * - @c bkpinfo->backup_media_type
2428 * - @c bkpinfo->restore_path
2429 * @param filelist The node structure containing the list of files to be
2430 * restored. If no file in an afioball is in this list, afio will still be
2431 * called for that fileset, but nothing will be written.
2432 * @return 0 for success, or the number of filesets that failed.
2433 */
2434int
2435restore_all_tarballs_from_stream(struct s_bkpinfo *bkpinfo,
2436                                 struct s_node *filelist)
2437{
2438    int retval = 0;
2439    int res;
2440    long current_afioball_number = 0;
2441    int ctrl_chr;
2442    long max_val /*, total_noof_files */ ;
2443
2444  /** malloc **/
2445    char *tmp = NULL;
2446    char *progress_str = NULL;
2447    char *tmp_fname = NULL;
2448    char *xattr_fname = NULL;
2449    char *acl_fname = NULL;
2450
2451    long long tmp_size;
2452
2453    assert(bkpinfo != NULL);
2454    mvaddstr_and_log_it(g_currentY, 0, _("Restoring from archives"));
2455    read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
2456    max_val = atol(tmp) + 1;
2457    mr_free(tmp);
2458
2459    chdir(bkpinfo->restore_path);   /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
2460
2461    run_program_and_log_output("pwd", 5);
2462
2463    mr_asprintf(&progress_str, _("Restoring from media #%d"),
2464            g_current_media_number);
2465    log_to_screen(progress_str);
2466    open_progress_form(_("Restoring from archives"),
2467                       _("Restoring data from the archives."),
2468                       _("Please wait. This may take some time."),
2469                       progress_str, max_val);
2470
2471    log_msg(3, "hey");
2472
2473    res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2474    if (res) {
2475        log_msg(2, "Warning - error reading afioball from tape");
2476    }
2477    retval += res;
2478    if (ctrl_chr != BLK_START_AFIOBALLS) {
2479        wrong_marker(BLK_START_AFIOBALLS, ctrl_chr);
2480    }
2481    log_msg(2, "ho");
2482    res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2483    while (ctrl_chr != BLK_STOP_AFIOBALLS) {
2484        update_progress_form(progress_str);
2485        if (g_getfattr) {
2486            mr_asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
2487                current_afioball_number);
2488            unlink(xattr_fname);
2489        }
2490        if (g_getfacl) {
2491            mr_asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
2492                current_afioball_number);
2493            unlink(acl_fname);
2494        }
2495        if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
2496            iamhere("Reading EXAT files from tape");
2497            res =
2498                read_EXAT_files_from_tape(bkpinfo, &tmp_size, tmp_fname,
2499                                          &ctrl_chr, xattr_fname,
2500                                          acl_fname);
2501        }
2502        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
2503            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
2504        }
2505        /* BERLIOS: useless ?
2506        mr_asprintf(&tmp,
2507                _("Restoring from fileset #%ld (name=%s, size=%ld K)"),
2508                current_afioball_number, tmp_fname, (long) tmp_size >> 10);
2509                */
2510        res =
2511            restore_a_tarball_from_stream(bkpinfo, tmp_fname,
2512                                          current_afioball_number,
2513                                          filelist, tmp_size, xattr_fname,
2514                                          acl_fname);
2515        retval += res;
2516        if (res) {
2517            mr_asprintf(&tmp, _("Fileset %ld - errors occurred"),
2518                    current_afioball_number);
2519            log_to_screen(tmp);
2520            mr_free(tmp);
2521        }
2522        res =
2523            read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2524        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
2525            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
2526        }
2527
2528        current_afioball_number++;
2529        g_current_progress++;
2530
2531        mr_free(progress_str);
2532        mr_asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
2533                current_afioball_number,
2534                bkpinfo->backup_media_string,
2535                g_current_media_number);
2536        res =
2537            read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2538        if (g_getfattr) {
2539            unlink(xattr_fname);
2540        }
2541        if (g_getfacl) {
2542            unlink(acl_fname);
2543        }
2544        mr_free(xattr_fname);
2545        mr_free(acl_fname);
2546    }                           // next
2547    mr_free(progress_str);
2548    mr_free(tmp_fname);
2549
2550    log_msg(1, "All done with afioballs");
2551    close_progress_form();
2552    if (retval) {
2553        mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
2554    } else {
2555        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
2556    }
2557    return (retval);
2558}
2559
2560/**************************************************************************
2561 *END_ RESTORE_ALL_TARBALLS_FROM_STREAM                                   *
2562 **************************************************************************/
2563
2564/* @} - end of LLrestoreGroup */
2565
2566
2567/**
2568 * Restore all files in @p filelist.
2569 * @param bkpinfo The backup information structure. Most fields are used.
2570 * @param filelist The node structure containing the list of files to be
2571 * restored.
2572 * @return 0 for success, or the number of afioballs and biggiefiles that failed.
2573 * @ingroup restoreGroup
2574 */
2575int restore_everything(struct s_bkpinfo *bkpinfo, struct s_node *filelist)
2576{
2577    int resA;
2578    int resB;
2579
2580  /** mallco ***/
2581    char *cwd = NULL;
2582    char *newpath = NULL;
2583    char *tmp = NULL;
2584    assert(bkpinfo != NULL);
2585
2586    malloc_string(cwd);
2587    malloc_string(newpath);
2588    log_msg(2, "restore_everything() --- starting");
2589    g_current_media_number = 1;
2590    /* BERLIOS: should test return value, or better change the function */
2591    getcwd(cwd, MAX_STR_LEN - 1);
2592    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
2593    run_program_and_log_output(tmp, FALSE);
2594    mr_free(tmp);
2595
2596    log_msg(1, "Changing dir to %s", bkpinfo->restore_path);
2597    chdir(bkpinfo->restore_path);
2598    /* BERLIOS: should test return value, or better change the function */
2599    getcwd(newpath, MAX_STR_LEN - 1);
2600    log_msg(1, "path is now %s", newpath);
2601    log_msg(1, "restoring everything");
2602    tmp = find_home_of_exe("petris");
2603    if (!tmp && !g_text_mode) {
2604        newtDrawRootText(0, g_noof_rows - 2,
2605                         _
2606                         ("Press ALT-<left cursor> twice to play Petris :-) "));
2607        newtRefresh();
2608    }
2609    mr_free(tmp);
2610
2611    mvaddstr_and_log_it(g_currentY, 0,
2612                        _("Preparing to read your archives"));
2613    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2614        mount_cdrom(bkpinfo);
2615        mvaddstr_and_log_it(g_currentY++, 0,
2616                            _
2617                            ("Restoring OS and data from streaming media"));
2618        if (bkpinfo->backup_media_type == cdstream) {
2619            openin_cdstream(bkpinfo);
2620        } else {
2621            assert_string_is_neither_NULL_nor_zerolength(bkpinfo->
2622                                                         media_device);
2623            openin_tape(bkpinfo);
2624        }
2625        resA = restore_all_tarballs_from_stream(bkpinfo, filelist);
2626        resB = restore_all_biggiefiles_from_stream(bkpinfo, filelist);
2627        if (bkpinfo->backup_media_type == cdstream) {
2628            closein_cdstream(bkpinfo);
2629        } else {
2630            closein_tape(bkpinfo);
2631        }
2632    } else {
2633        mvaddstr_and_log_it(g_currentY++, 0,
2634                            _("Restoring OS and data from CD       "));
2635        mount_cdrom(bkpinfo);
2636        resA = restore_all_tarballs_from_CD(bkpinfo, filelist);
2637        resB = restore_all_biggiefiles_from_CD(bkpinfo, filelist);
2638    }
2639    chdir(cwd);
2640    if (resA + resB) {
2641        log_to_screen(_("Errors occurred while data was being restored."));
2642    }
2643    if (length_of_file("/etc/raidtab") > 0) {
2644        log_msg(2, "Copying local raidtab to restored filesystem");
2645        run_program_and_log_output("cp -f /etc/raidtab " MNT_RESTORING
2646                                   "/etc/raidtab", FALSE);
2647    }
2648    kill_petris();
2649    log_msg(2, "restore_everything() --- leaving");
2650    mr_free(cwd);
2651    mr_free(newpath);
2652    return (resA + resB);
2653}
2654
2655/**************************************************************************
2656 *END_RESTORE_EVERYTHING                                                  *
2657 **************************************************************************/
2658
2659
2660/**
2661 * @brief Haha. You wish! (This function is not implemented :-)
2662 */
2663int
2664restore_live_from_monitas_server(struct s_bkpinfo *bkpinfo,
2665                                 char *monitas_device,
2666                                 char *restore_this_directory,
2667                                 char *restore_here)
2668     /* NB: bkpinfo hasn't been populated yet, except for ->tmp which is "/tmp" */
2669{
2670    FILE *fout;
2671    int retval = 0;
2672    int i;
2673    int j;
2674    struct mountlist_itself the_mountlist;
2675    static struct raidlist_itself the_raidlist;
2676  /** malloc **/
2677    char tmp[MAX_STR_LEN + 1];
2678    char command[MAX_STR_LEN + 1];
2679    char datablock[256 * 1024];
2680    char datadisks_fname[MAX_STR_LEN + 1];
2681    long k;
2682    long length;
2683    long long llt;
2684    struct s_node *filelist = NULL;
2685    assert(bkpinfo != NULL);
2686    assert_string_is_neither_NULL_nor_zerolength(monitas_device);
2687    assert(restore_this_directory != NULL);
2688    assert(restore_here != NULL);
2689
2690    sprintf(tmp, "restore_here = '%s'", restore_here);
2691
2692    log_msg(2, tmp);
2693
2694    log_msg(2, "restore_live_from_monitas_server() - starting");
2695    unlink("/tmp/mountlist.txt");
2696    unlink("/tmp/filelist.full");
2697    unlink("/tmp/biggielist.txt");
2698    if (restore_here[0] == '\0') {
2699        strcpy(bkpinfo->restore_path, MNT_RESTORING);
2700    } else {
2701        strcpy(bkpinfo->restore_path, restore_here);
2702    }
2703    log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
2704    sprintf(tmp, "FYI - data will be restored to %s",
2705            bkpinfo->restore_path);
2706    log_msg(3, tmp);
2707    log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
2708    sprintf(datadisks_fname, "/tmp/mondorestore.datadisks.%d",
2709            (int) (random() % 32768));
2710    chdir(bkpinfo->tmpdir);
2711
2712    sprintf(command, "cat %s", monitas_device);
2713    g_tape_stream = popen(command, "r");    // for compatibility with openin_tape()
2714    if (!(fout = fopen(datadisks_fname, "w"))) {
2715        log_OS_error(datadisks_fname);
2716        return (1);
2717    }
2718    for (i = 0; i < 32; i++) {
2719        for (j = 0; j < 4; j++) {
2720            for (length = k = 0; length < 256 * 1024; length += k) {
2721                k = fread(datablock + length, 1, 256 * 1024 - length,
2722                          g_tape_stream);
2723            }
2724            fwrite(datablock, 1, length, fout);
2725            g_tape_posK += length;
2726        }
2727    }
2728    paranoid_fclose(fout);
2729    sprintf(command,
2730            "tar -zxvf %s tmp/mondo-restore.cfg tmp/mountlist.txt tmp/filelist.full tmp/biggielist.txt",
2731            datadisks_fname);
2732    run_program_and_log_output(command, 4);
2733    read_header_block_from_stream(&llt, tmp, &i);
2734    read_header_block_from_stream(&llt, tmp, &i);
2735
2736    unlink(datadisks_fname);
2737    read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
2738    retval = load_mountlist(&the_mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo   strcpy(bkpinfo->media_device, monitas_device);
2739
2740
2741    load_raidtab_into_raidlist(&the_raidlist, RAIDTAB_FNAME);
2742    iamhere("FIXME");
2743    fatal_error("This will fail");
2744    sprintf(command,
2745            "grep -E '^%s.*$' %s > %s",
2746            restore_this_directory, g_filelist_full, g_filelist_full);
2747    if (system(command)) {
2748        retval++;
2749        log_to_screen
2750            ("Error(s) occurred while processing filelist and wildcard");
2751    }
2752    iamhere("FIXME");
2753    fatal_error("This will fail");
2754    sprintf(command,
2755            "grep -E '^%s.*$' %s > %s",
2756            restore_this_directory, g_biggielist_txt, g_biggielist_txt);
2757    if (system(command)) {
2758        log_msg(1,
2759                "Error(s) occurred while processing biggielist and wildcard");
2760    }
2761    sprintf(command, "touch %s", g_biggielist_txt);
2762    run_program_and_log_output(command, FALSE);
2763//  filelist = load_filelist(g_filelist_restthese);  // FIXME --- this probably doesn't work because it doesn't include the biggiefiles
2764    retval += restore_everything(bkpinfo, filelist);
2765    free_filelist(filelist);
2766    log_msg(2, "--------End of restore_live_from_monitas_server--------");
2767    return (retval);
2768}
2769
2770/**************************************************************************
2771 *END_RESTORE_LIVE_FROM_MONITAS_SERVER                                    *
2772 **************************************************************************/
2773
2774
2775
2776
2777extern void wait_until_software_raids_are_prepped(char *, int);
2778
2779char which_restore_mode(void);
2780
2781
2782/**
2783 * Log a "don't panic" message to the logfile.
2784 */
2785void welcome_to_mondorestore()
2786{
2787    log_msg(0, "-------------- Mondo Restore v%s -------------",
2788            PACKAGE_VERSION);
2789    log_msg(0,
2790            "DON'T PANIC! Mondorestore logs almost everything, so please ");
2791    log_msg(0,
2792            "don't break out in a cold sweat just because you see a few  ");
2793    log_msg(0,
2794            "error messages in the log. Read them; analyze them; see if  ");
2795    log_msg(0,
2796            "they are significant; above all, verify your backups! Please");
2797    log_msg(0,
2798            "attach a compressed copy of this log to any e-mail you send ");
2799    log_msg(0,
2800            "to the Mondo mailing list when you are seeking technical    ");
2801    log_msg(0,
2802            "support. Without it, we can't help you.            - DevTeam");
2803    log_msg(0,
2804            "------------------------------------------------------------");
2805    log_msg(0,
2806            "BTW, despite (or perhaps because of) the wealth of messages,");
2807    log_msg(0,
2808            "some users are inclined to stop reading this log.  If Mondo ");
2809    log_msg(0,
2810            "stopped for some reason, chances are it's detailed here.    ");
2811    log_msg(0,
2812            "More than likely there's a message near the end of this     ");
2813    log_msg(0,
2814            "log that will tell you what is wrong.  Please read it!      ");
2815    log_msg(0,
2816            "------------------------------------------------------------");
2817}
2818
2819
2820/**
2821 * Restore the user's data.
2822 * What did you think it did, anyway? :-)
2823 */
2824int main(int argc, char *argv[])
2825{
2826    FILE *fin = NULL;
2827    FILE *fout = NULL;
2828    int retval = 0;
2829    int res = 0;
2830    char *tmp = NULL;
2831
2832    struct mountlist_itself *mountlist = NULL;
2833    struct raidlist_itself *raidlist = NULL;
2834    struct s_bkpinfo *bkpinfo = NULL;
2835    struct s_node *filelist = NULL;
2836    char *a = NULL, *b = NULL;
2837    bool run_postnuke = FALSE;
2838
2839  /**************************************************************************
2840   * hugo-                                                                  *
2841   * busy stuff here - it needs some comments -stan                           *
2842   *                                                                        *
2843   **************************************************************************/
2844
2845#ifdef ENABLE_NLS
2846    setlocale(LC_ALL, "");
2847    (void) textdomain("mondo");
2848#endif
2849
2850    if (getuid() != 0) {
2851        fprintf(stderr, _("Please run as root.\n"));
2852        exit(127);
2853    }
2854
2855    g_loglevel = DEFAULT_MR_LOGLEVEL;
2856
2857/* Configure global variables */
2858#ifdef __FreeBSD__
2859    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
2860#else
2861    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
2862#endif
2863    if (strstr(tmp,"textonly")) {
2864        g_text_mode = TRUE;
2865        log_msg(1, "TEXTONLY MODE");
2866    } else {
2867        g_text_mode = FALSE;
2868    }                           // newt :-)
2869    mr_free(tmp);
2870
2871    bkpinfo = g_bkpinfo_DONTUSETHIS = mr_malloc(sizeof(struct s_bkpinfo));
2872    mountlist = mr_malloc(sizeof(struct mountlist_itself));
2873    raidlist = mr_malloc(sizeof(struct raidlist_itself));
2874
2875    malloc_libmondo_global_strings();
2876
2877    mr_allocstr(g_tmpfs_mountpt, "/tmp/tmpfs");
2878    make_hole_for_dir(g_tmpfs_mountpt);
2879    g_current_media_number = 1; // precaution
2880
2881    run_program_and_log_output("mkdir -p " MNT_CDROM, FALSE);
2882    run_program_and_log_output("mkdir -p /mnt/floppy", FALSE);
2883
2884    setup_MR_global_filenames(bkpinfo); // malloc() and set globals, using bkpinfo->tmpdir etc.
2885    reset_bkpinfo(bkpinfo);
2886    bkpinfo->backup_media_type = none;  // in case boot disk was made for one backup type but user wants to restore from another backup type
2887    bkpinfo->backup_media_string = NULL;
2888    bkpinfo->restore_data = TRUE;   // Well, yeah :-)
2889    if (am_I_in_disaster_recovery_mode()) {
2890        run_program_and_log_output("mount / -o remount,rw", 2);
2891    }                           // for b0rken distros
2892    g_main_pid = getpid();
2893    srandom((int) (time(NULL)));
2894    register_pid(getpid(), "mondo");
2895    set_signals(TRUE);
2896    g_kernel_version = get_kernel_version();
2897
2898    log_msg(1, "FYI - g_mountlist_fname = %s", g_mountlist_fname);
2899    mkdir(MNT_CDROM, 0x770);
2900
2901/* Backup original mountlist.txt */
2902    mr_asprintf(&tmp, "%s.orig", g_mountlist_fname);
2903    if (!does_file_exist(g_mountlist_fname)) {
2904        log_msg(2,
2905                "%ld: Warning - g_mountlist_fname (%s) does not exist yet",
2906                __LINE__, g_mountlist_fname);
2907    } else if (!does_file_exist(tmp)) {
2908        mr_free(tmp);
2909        mr_asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
2910                g_mountlist_fname);
2911        run_program_and_log_output(tmp, FALSE);
2912    }
2913    mr_free(tmp);
2914
2915/* Init directories */
2916    make_hole_for_dir(bkpinfo->tmpdir);
2917    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
2918    run_program_and_log_output(tmp, FALSE);
2919    mr_free(tmp);
2920
2921    make_hole_for_dir("/var/log");
2922    make_hole_for_dir("/tmp/tmpfs");    /* just in case... */
2923    run_program_and_log_output("umount " MNT_CDROM, FALSE);
2924    run_program_and_log_output
2925        ("ln -sf " MONDO_LOGFILE " /tmp/mondo-restore.log", FALSE);
2926
2927    run_program_and_log_output("rm -Rf /tmp/tmpfs/mondo.tmp.*", FALSE);
2928
2929/* Init GUI */
2930    malloc_libmondo_global_strings();
2931    setup_newt_stuff();         /* call newtInit and setup screen log */
2932    welcome_to_mondorestore();
2933    if (bkpinfo->disaster_recovery) {
2934        log_msg(1, "I am in disaster recovery mode");
2935    } else {
2936        log_msg(1, "I am in normal, live mode");
2937    }
2938
2939    iamhere("what time is it");
2940
2941/* Process command-line parameters */
2942    if (argc == 2 && strcmp(argv[1], "--edit-mountlist") == 0) {
2943#ifdef __FreeBSD__
2944        system("mv -f /tmp/raidconf.txt /etc/raidtab");
2945        if (!does_file_exist("/etc/raidtab"))
2946            system("vinum printconfig > /etc/raidtab");
2947#endif
2948        load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
2949        if (!does_file_exist(g_mountlist_fname)) {
2950            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
2951        }
2952        res = let_user_edit_the_mountlist(bkpinfo, mountlist, raidlist);
2953#ifdef __FreeBSD__
2954        system("mv -f /etc/raidtab /tmp/raidconf.txt");
2955#endif
2956        paranoid_MR_finish(res);
2957    }
2958
2959    g_loglevel = DEFAULT_MR_LOGLEVEL;
2960    if (argc == 3 && strcmp(argv[1], "--echo-to-screen") == 0) {
2961        fout = fopen("/tmp/out.txt", "w");
2962        fput_string_one_char_at_a_time(stderr, argv[2]);
2963        finish(0);
2964    }
2965
2966    if (argc == 3 && strcmp(argv[1], "--gendf") == 0) {
2967        make_grub_install_scriptlet(argv[2]);
2968        finish(0);
2969    }
2970
2971    if (argc >= 2 && strcmp(argv[1], "--pih") == 0) {
2972        if (system("mount | grep cdrom 2> /dev/null > /dev/null")) {
2973            system("mount " MNT_CDROM);
2974        }
2975        bkpinfo->compression_level = 1;
2976        g_current_media_number = 2;
2977        mr_allocstr(bkpinfo->restore_path, "/tmp/TESTING");
2978        bkpinfo->backup_media_type = dvd;
2979        mr_free(bkpinfo->backup_media_string);
2980        bkpinfo->backup_media_string = bkptype_to_string(bkpinfo->backup_media_type);
2981        open_progress_form(_("Reassembling /dev/hda1"),
2982                           _("Shark is a bit of a silly person."),
2983                           _("Please wait. This may take some time."),
2984                           "", 1999);
2985        system("rm -Rf /tmp/*pih*");
2986
2987        (void)restore_a_biggiefile_from_CD(bkpinfo, 42, NULL);
2988    }
2989
2990    if (argc == 5 && strcmp(argv[1], "--common") == 0) {
2991        g_loglevel = 6;
2992        filelist = load_filelist(argv[2]);
2993        if (!filelist) {
2994            fatal_error("Failed to load filelist");
2995        }
2996        toggle_node_selection(filelist, FALSE);
2997        toggle_all_root_dirs_on(filelist);
2998        // BERLIOS: /usr/lib ???
2999        toggle_path_selection(filelist, "/usr/share", TRUE);
3000//      show_filelist(filelist);
3001        save_filelist(filelist, "/tmp/out.txt");
3002//      finish(0);
3003//      toggle_path_selection (filelist, "/root/stuff", TRUE);
3004        mr_asprintf(&a, argv[3]);
3005        mr_asprintf(&b, argv[4]);
3006
3007        res = save_filelist_entries_in_common(a, filelist, b, FALSE);
3008        free_filelist(filelist);
3009        mr_free(a);
3010        mr_free(b);
3011        printf("res = %d", res);
3012        finish(0);
3013    }
3014
3015    if (argc == 3 && strcmp(argv[1], "--popuplist") == 0) {
3016        popup_changelist_from_file(argv[2]);
3017        paranoid_MR_finish(0);
3018    }
3019
3020    if (argc == 5 && strcmp(argv[1], "--copy") == 0) {
3021        log_msg(1, "SCORE");
3022        g_loglevel = 10;
3023        if (strstr(argv[2], "save")) {
3024            log_msg(1, "Saving from %s to %s", argv[3], argv[4]);
3025            fin = fopen(argv[3], "r");
3026            fout = fopen(argv[4], "w");
3027            copy_from_src_to_dest(fin, fout, 'w');
3028            fclose(fin);
3029            fin = fopen(argv[3], "r");
3030            copy_from_src_to_dest(fin, fout, 'w');
3031            fclose(fout);
3032            fclose(fin);
3033        } else if (strstr(argv[2], "restore")) {
3034            fout = fopen(argv[3], "w");
3035            fin = fopen(argv[4], "r");
3036            copy_from_src_to_dest(fout, fin, 'r');
3037            fclose(fin);
3038            fin = fopen(argv[4], "r");
3039            copy_from_src_to_dest(fout, fin, 'r');
3040            fclose(fout);
3041            fclose(fin);
3042        } else {
3043            fatal_error("Unknown additional param");
3044        }
3045        finish(0);
3046    }
3047
3048    if (argc == 3 && strcmp(argv[1], "--mdstat") == 0) {
3049        wait_until_software_raids_are_prepped(argv[2], 100);
3050        finish(0);
3051    }
3052
3053    if (argc == 3 && strcmp(argv[1], "--mdconv") == 0) {
3054        finish(create_raidtab_from_mdstat(argv[2]));
3055    }
3056
3057
3058    if (argc == 2 && strcmp(argv[1], "--live-grub") == 0) {
3059        retval = run_grub(FALSE, "/dev/hda");
3060        if (retval) {
3061            log_to_screen(_("Failed to write Master Boot Record"));
3062        }
3063        paranoid_MR_finish(0);
3064    }
3065    if (argc == 3 && strcmp(argv[1], "--paa") == 0) {
3066        g_current_media_number = atoi(argv[2]);
3067        pause_and_ask_for_cdr(5, NULL);
3068        paranoid_MR_finish(0);
3069    } else if (!bkpinfo->disaster_recovery) {   // live!
3070        if (argc != 1) {
3071            popup_and_OK
3072                (_
3073                 ("Live mode doesn't support command-line parameters yet."));
3074            paranoid_MR_finish(1);
3075//    return(1);
3076        }
3077        log_msg(1, "I am in normal, live mode.");
3078        log_msg(2, "FYI, MOUNTLIST_FNAME = %s", g_mountlist_fname);
3079        mount_boot_if_necessary();  /* for Gentoo users */
3080        log_msg(2, "Still here.");
3081        if (argc > 1 && strcmp(argv[argc - 1], "--live-from-cd") == 0) {
3082            g_restoring_live_from_cd = TRUE;
3083        } else {
3084            log_msg(2, "Calling restore_to_live_filesystem()");
3085            retval = restore_to_live_filesystem(bkpinfo);
3086        }
3087        log_msg(2, "Still here. Yay.");
3088        if (strlen(bkpinfo->tmpdir) > 0) {
3089            mr_asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
3090            run_program_and_log_output(tmp, FALSE);
3091            mr_free(tmp);
3092        }
3093        unmount_boot_if_necessary();    /* for Gentoo users */
3094        paranoid_MR_finish(retval);
3095    } else {
3096        /* Disaster recovery mode (must be) */
3097        log_msg(1, "I must be in disaster recovery mode.");
3098        log_msg(2, "FYI, MOUNTLIST_FNAME = %s ", g_mountlist_fname);
3099        if (argc == 3 && strcmp(argv[1], "--monitas-memorex") == 0) {
3100            log_to_screen(_("Uh, that hasn't been implemented yet."));
3101            paranoid_MR_finish(1);
3102        }
3103
3104        iamhere("About to call load_mountlist and load_raidtab");
3105        mr_allocstr(bkpinfo->restore_path, MNT_RESTORING);
3106        read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
3107        retval = load_mountlist(mountlist, g_mountlist_fname);
3108        retval += load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
3109        iamhere
3110            ("Returned from calling load_mountlist and load_raidtab successfully");
3111
3112        if (argc > 1
3113            && (strcmp(argv[1], "--compare") == 0
3114                || strcmp(argv[1], "--nuke") == 0)) {
3115            if (bkpinfo->backup_media_type == nfs
3116                && !is_this_device_mounted(bkpinfo->nfs_mount)) {
3117                log_msg(1, "Mounting nfs dir");
3118                mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
3119                run_program_and_log_output("mkdir -p /tmp/isodir", 5);
3120                mr_asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
3121                        bkpinfo->nfs_mount);
3122                run_program_and_log_output(tmp, 1);
3123                mr_free(tmp);
3124            }
3125        }
3126
3127
3128        if (retval) {
3129            log_to_screen
3130                (_
3131                 ("Warning - load_raidtab_into_raidlist returned an error"));
3132        }
3133
3134
3135        log_msg(1, "Send in the clowns.");
3136
3137        if (argc == 2 && strcmp(argv[1], "--partition-only") == 0) {
3138            log_msg(0, "Partitioning only.");
3139            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
3140            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
3141            load_mountlist(mountlist, g_mountlist_fname);
3142            res = partition_everything(mountlist);
3143            finish(res);
3144        }
3145
3146        if (argc == 2 && strcmp(argv[1], "--format-only") == 0) {
3147            log_msg(0, "Formatting only.");
3148            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
3149            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
3150            load_mountlist(mountlist, g_mountlist_fname);
3151            res = format_everything(mountlist, FALSE, raidlist);
3152            finish(res);
3153        }
3154
3155        if (argc == 2 && strcmp(argv[1], "--stop-lvm-and-raid") == 0) {
3156            log_msg(0, "Stopping LVM and RAID");
3157            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
3158            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
3159            load_mountlist(mountlist, g_mountlist_fname);
3160            res = do_my_funky_lvm_stuff(TRUE, FALSE);
3161            res += stop_all_raid_devices(mountlist);
3162            finish(res);
3163        }
3164
3165        if (argc == 2 && strcmp(argv[1], "--nuke") == 0) {
3166            iamhere("nuking");
3167            retval += nuke_mode(bkpinfo, mountlist, raidlist);
3168        } else if (argc == 2 && strcmp(argv[1], "--interactive") == 0) {
3169            iamhere("catchall");
3170            retval += catchall_mode(bkpinfo, mountlist, raidlist);
3171        } else if (argc == 2 && strcmp(argv[1], "--compare") == 0) {
3172            iamhere("compare");
3173            retval += compare_mode(bkpinfo, mountlist, raidlist);
3174        } else if (argc == 2 && strcmp(argv[1], "--iso") == 0) {
3175            iamhere("iso");
3176            retval = iso_mode(bkpinfo, mountlist, raidlist, FALSE);
3177        } else if (argc == 2 && strcmp(argv[1], "--mbr") == 0) {
3178            iamhere("mbr");
3179            retval = mount_all_devices(mountlist, TRUE);
3180            if (!retval) {
3181                retval += run_boot_loader(FALSE);
3182                retval += unmount_all_devices(mountlist);
3183            }
3184            if (retval) {
3185                log_to_screen(_("Failed to write Master Boot Record"));
3186            }
3187        } else if (argc == 2 && strcmp(argv[1], "--isonuke") == 0) {
3188            iamhere("isonuke");
3189            retval = iso_mode(bkpinfo, mountlist, raidlist, TRUE);
3190        } else if (argc != 1) {
3191            log_to_screen(_("Invalid paremeters"));
3192            paranoid_MR_finish(1);
3193        } else {
3194            iamhere("catchall (no mode specified in command-line call");
3195            retval += catchall_mode(bkpinfo, mountlist, raidlist);
3196        }
3197    }
3198
3199    /* clean up at the end */
3200    if (retval) {
3201        if (does_file_exist("/tmp/changed.files")) {
3202            log_to_screen
3203                (_
3204                 ("See /tmp/changed.files for list of files that have changed."));
3205        }
3206        mvaddstr_and_log_it(g_currentY++,
3207                            0,
3208                            _
3209                            ("Run complete. Errors were reported. Please review the logfile."));
3210    } else {
3211        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3212            mvaddstr_and_log_it(g_currentY++,
3213                                0,
3214                                _
3215                                ("Run complete. Please remove floppy/CD/media and reboot."));
3216        } else {
3217            run_program_and_log_output("sync", FALSE);
3218            if (is_this_device_mounted(MNT_CDROM)) {
3219                res =
3220                    run_program_and_log_output("umount " MNT_CDROM, FALSE);
3221            } else {
3222                res = 0;
3223            }
3224
3225            if (!bkpinfo->please_dont_eject) {
3226                res = eject_device("/dev/cdrom");
3227/*
3228              if (res)
3229        {
3230          log_to_screen( "WARNING - failed to eject CD-ROM disk" );
3231        }
3232*/
3233            }
3234            mvaddstr_and_log_it(g_currentY++,
3235                                0,
3236                                _
3237                                ("Run complete. Please remove media and reboot."));
3238        }
3239    }
3240
3241// g_I_have_just_nuked is set true by nuke_mode() just before it returns
3242    if (!system("which post-nuke > /dev/null 2> /dev/null")) {
3243      log_msg(1, "post-nuke found; find out whether we should run it...");
3244      if (g_I_have_just_nuked || does_file_exist("/POST-NUKE-ANYWAY")) {
3245        run_postnuke = TRUE;
3246        log_msg(1, "Yes, will run post-nuke because in nuke mode or file /POST-NUKE-ANYWAY exists.");
3247      } else if (ask_me_yes_or_no("post-nuke script found. Do you want to run it?")) {
3248        run_postnuke = TRUE;
3249        log_msg(1, "Yes, will run post-nuke because user interactively asked for it.");
3250      } else {
3251        run_postnuke = FALSE;
3252        log_msg(1, "No, will not run post-nuke.");
3253      }
3254    } else {
3255      log_msg(1, "No post-nuke found.");
3256    }
3257    if (run_postnuke) {
3258      log_to_screen("Running post-nuke...");
3259      if (mount_all_devices(mountlist, TRUE)) {
3260        log_to_screen
3261          ("Unable to re-mount partitions for post-nuke stuff");
3262      } else {
3263        log_msg(1, "Re-mounted partitions for post-nuke stuff");
3264        sprintf(tmp, "post-nuke %s %d", bkpinfo->restore_path,
3265            retval);
3266        log_msg(2, "Calling '%s'", tmp);
3267        if ((res = run_program_and_log_output(tmp, 0))) {
3268          log_OS_error(tmp);
3269        }
3270        log_msg(1, "post-nuke returned w/ res=%d", res);
3271      }
3272      unmount_all_devices(mountlist);
3273      log_to_screen("I've finished post-nuking.");
3274    }
3275
3276/* 
3277  log_to_screen("If you are REALLY in a hurry, hit Ctrl-Alt-Del now.");
3278  log_to_screen("Otherwise, please wait until the RAID disks are done.");
3279  wait_until_software_raids_are_prepped("/proc/mdstat", 100);
3280  log_to_screen("Thank you.");
3281*/
3282    unlink("/tmp/mondo-run-prog.tmp");
3283    set_signals(FALSE);
3284    mr_asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
3285    run_program_and_log_output(tmp, FALSE);
3286    mr_free(tmp);
3287
3288    log_to_screen
3289        (_
3290         ("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
3291    mr_asprintf(&tmp,
3292            _
3293            ("Mondo-restore is exiting (retval=%d)                                      "),
3294            retval);
3295    log_to_screen(tmp);
3296    mr_free(tmp);
3297
3298    mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
3299    run_program_and_log_output(tmp, 5);
3300    mr_free(tmp);
3301
3302    mr_free(mountlist);
3303    mr_free(raidlist);
3304    if (am_I_in_disaster_recovery_mode()) {
3305        run_program_and_log_output("mount / -o remount,rw", 2);
3306    }                           // for b0rken distros
3307    paranoid_MR_finish(retval); // frees global stuff plus bkpinfo
3308    free_libmondo_global_strings(); // it's fine to have this here :) really :)
3309
3310    unlink("/tmp/filelist.full");
3311    unlink("/tmp/filelist.full.gz");
3312
3313    exit(retval);
3314}
3315
3316/**************************************************************************
3317 *END_MAIN                                                                *
3318 **************************************************************************/
3319
3320
3321/**************************************************************************
3322 *END_MONDO-RESTORE.C                                                     *
3323 **************************************************************************/
Note: See TracBrowser for help on using the repository browser.