Changeset 1663 in MondoRescue for branches/stable/mondo/src/mondorestore


Ignore:
Timestamp:
Sep 27, 2007, 12:21:18 PM (17 years ago)
Author:
Bruno Cornec
Message:
  • Fix bug #197 (based on an initial patch of Scott Cummings)
  • Fix a bug where df was using locale to print messages and wasn't filtered correctly
  • mkdtemp checked in configure
  • reset_bkpinfo called as early as possible by both main program.
  • It creates a tmpdir cleanly with mkdtemp in setup_tmpdir subfunction, which takes in account TMPIR and TMP env var. Remains to see what tmpfs does and tests
  • configure.in should also be filtered.
  • Remove g_bkpinfo_DONTUSETHIS
  • remove bkpinfo also from header files
  • Render bkpinfo global (potential issue on thread, but should not be a problem as that structure is indeed static during archive)
  • Apply patch from Andree Leidenfrost, modified a bit to use bkpinfo->tmpdir instead of /tmp or MINDI_CACHE when appropriate. Fix security issues in mondo. Thanks al ot Andree for catching all those issues.
  • /tmp => /var/log for mondorestore.log in mindi
  • Update linux terminfo to fix a color issue (Andree Leidenfrost)
  • Removes useless log file (Andree Leidenfrost)
  • replace vi with find_my_editor during restore (Andree Leidenfrost)
  • sync in bg in mindi (VMWare issue to look at)
  • mindi/mindi-busybox have a different version than mondo for pb
  • PB-SUF also added to spec file
  • Fix a bug for pb build (omission of PB-SUF declaration)

(merge -r1631:1662 $SVN_M/branches/2.2.5)

Location:
branches/stable/mondo/src/mondorestore
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • branches/stable/mondo/src/mondorestore/mondo-restore-EXT.h

    r1213 r1663  
    2525
    2626extern void ask_about_these_imagedevs(char *, char *);
    27 extern int catchall_mode(struct s_bkpinfo *, struct mountlist_itself *,
     27extern int catchall_mode(struct mountlist_itself *,
    2828                         struct raidlist_itself *);
    2929extern void sort_mountlist_by_device(struct mountlist_itself *);
    30 extern int interactive_mode(struct s_bkpinfo *, struct mountlist_itself *,
     30extern int interactive_mode(struct mountlist_itself *,
    3131                            struct raidlist_itself *);
    32 extern int nuke_mode(struct s_bkpinfo *, struct mountlist_itself *,
     32extern int nuke_mode(struct mountlist_itself *,
    3333                     struct raidlist_itself *);
    34 extern int compare_mode(struct s_bkpinfo *, struct mountlist_itself *,
     34extern int compare_mode(struct mountlist_itself *,
    3535                        struct raidlist_itself *);
    36 extern int iso_mode(struct s_bkpinfo *bkpinfo,
     36extern int iso_mode(
    3737                    struct mountlist_itself *mountlist,
    3838                    struct raidlist_itself *raidlist, bool nuke_me_please);
    3939extern int load_mountlist(struct mountlist_itself *, char *);
    4040extern int load_raidtab_into_raidlist(struct raidlist_itself *, char *);
    41 extern int restore_mode(struct s_bkpinfo *, struct mountlist_itself *,
     41extern int restore_mode(struct mountlist_itself *,
    4242                        struct raidlist_itself *);
    4343extern int save_raidlist_to_raidtab(struct raidlist_itself *, char *);
    4444extern void process_raidtab_line(FILE *, struct raid_device_record *,
    4545                                 char *, char *);
    46 extern int restore_a_biggiefile_from_CD(struct s_bkpinfo *, long,
     46extern int restore_a_biggiefile_from_CD(long,
    4747                                        struct s_node *);
    48 extern int restore_a_biggiefile_from_stream(struct s_bkpinfo *, char *,
     48extern int restore_a_biggiefile_from_stream(char *,
    4949                                            long, char *, long long,
    5050                                            struct s_node *);
    5151extern int restore_a_tarball_from_CD(char *, int, struct s_node *, struct s_bkpinfo *);
    52 extern int restore_a_tarball_from_stream(struct s_bkpinfo *, char *, int,
     52extern int restore_a_tarball_from_stream(char *, int,
    5353                                         struct s_node *, long long);
    54 extern int restore_all_biggiefiles_from_CD(struct s_bkpinfo *,
     54extern int restore_all_biggiefiles_from_CD(
    5555                                           struct s_node *);
    56 extern int restore_all_biggiefiles_from_stream(struct s_bkpinfo *,
     56extern int restore_all_biggiefiles_from_stream(
    5757                                               struct s_node *);
    58 extern int restore_all_tarballs_from_CD(struct s_bkpinfo *,
     58extern int restore_all_tarballs_from_CD(
    5959                                        struct s_node *);
    60 extern int restore_all_tarballs_from_stream(struct s_bkpinfo *,
     60extern int restore_all_tarballs_from_stream(
    6161                                            struct s_node *);
    62 extern int restore_everything(struct s_bkpinfo *, struct s_node *);
    63 extern int restore_live_from_monitas_server(struct s_bkpinfo *, char *,
     62extern int restore_everything(struct s_node *);
     63extern int restore_live_from_monitas_server(char *,
    6464                                            char *, char *);
    65 extern int restore_to_live_filesystem(struct s_bkpinfo *);
     65extern int restore_to_live_filesystem();
    6666extern void swap_mountlist_entries(struct mountlist_itself *, int, int);
    6767extern void sort_mountlist_by_mountpoint(struct mountlist_itself *, bool);
     
    7474extern int save_raidlist_to_raidtab(struct raidlist_itself *raidlist,
    7575                                    char *fname);
    76 extern int what_number_cd_is_this(struct s_bkpinfo *);
     76extern int what_number_cd_is_this();
    7777
    7878#ifdef __FreeBSD__
  • branches/stable/mondo/src/mondorestore/mondo-restore.h

    r1200 r1663  
    88
    99void ask_about_these_imagedevs(char *, char *);
    10 int catchall_mode(struct s_bkpinfo *, struct mountlist_itself *,
     10int catchall_mode(struct mountlist_itself *,
    1111                  struct raidlist_itself *);
    12 int interactive_mode(struct s_bkpinfo *, struct mountlist_itself *,
     12int interactive_mode(struct mountlist_itself *,
    1313                     struct raidlist_itself *);
    14 int nuke_mode(struct s_bkpinfo *, struct mountlist_itself *,
     14int nuke_mode(struct mountlist_itself *,
    1515              struct raidlist_itself *);
    16 int compare_mode(struct s_bkpinfo *, struct mountlist_itself *,
     16int compare_mode(struct mountlist_itself *,
    1717                 struct raidlist_itself *);
    18 int iso_mode(struct s_bkpinfo *bkpinfo, struct mountlist_itself *mountlist,
     18int iso_mode(struct mountlist_itself *mountlist,
    1919             struct raidlist_itself *raidlist, bool nuke_me_please);
    20 int restore_mode(struct s_bkpinfo *, struct mountlist_itself *,
     20int restore_mode(struct mountlist_itself *,
    2121                 struct raidlist_itself *);
    22 int restore_a_biggiefile_from_CD(struct s_bkpinfo *, long, struct s_node *,
     22int restore_a_biggiefile_from_CD(long, struct s_node *,
    2323                                 char *);
    24 int restore_a_biggiefile_from_stream(struct s_bkpinfo *, char *, long,
     24int restore_a_biggiefile_from_stream(char *, long,
    2525                                     char *, long long, struct s_node *,
    2626                                     int, char *);
    2727int restore_a_tarball_from_CD(char *, long, struct s_node *, struct s_bkpinfo *);
    28 int restore_a_tarball_from_stream(struct s_bkpinfo *, char *, long,
     28int restore_a_tarball_from_stream(char *, long,
    2929                                  struct s_node *, long long, char *,
    3030                                  char *);
    31 int restore_all_biggiefiles_from_CD(struct s_bkpinfo *, struct s_node *);
    32 int restore_all_biggiefiles_from_stream(struct s_bkpinfo *,
     31int restore_all_biggiefiles_from_CD(struct s_node *);
     32int restore_all_biggiefiles_from_stream(
    3333                                        struct s_node *);
    34 int restore_all_tarballs_from_CD(struct s_bkpinfo *, struct s_node *);
    35 int restore_all_tarballs_from_stream(struct s_bkpinfo *, struct s_node *);
    36 int restore_everything(struct s_bkpinfo *, struct s_node *);
    37 int restore_live_from_monitas_server(struct s_bkpinfo *, char *, char *,
     34int restore_all_tarballs_from_CD(struct s_node *);
     35int restore_all_tarballs_from_stream(struct s_node *);
     36int restore_everything(struct s_node *);
     37int restore_live_from_monitas_server(char *, char *,
    3838                                     char *);
    39 int restore_to_live_filesystem(struct s_bkpinfo *);
     39int restore_to_live_filesystem();
    4040void swap_mountlist_entries(struct mountlist_itself *, int, int);
    4141void sort_mountlist_by_mountpoint(struct mountlist_itself *, bool);
    4242void sort_mountlist_by_device(struct mountlist_itself *);
    43 int what_number_cd_is_this(struct s_bkpinfo *);
     43int what_number_cd_is_this();
  • branches/stable/mondo/src/mondorestore/mondo-rstr-compare-EXT.h

    r1200 r1663  
    44
    55
    6 extern int compare_to_CD(struct s_bkpinfo *);
    7 extern int compare_to_cdstream(struct s_bkpinfo *);
    8 extern int compare_to_tape(struct s_bkpinfo *);
    9 extern int compare_mode(struct s_bkpinfo *bkpinfo,
    10                         struct mountlist_itself *mountlist,
     6extern int compare_to_CD();
     7extern int compare_to_cdstream();
     8extern int compare_to_tape();
     9extern int compare_mode(struct mountlist_itself *mountlist,
    1110                        struct raidlist_itself *raidlist);
  • branches/stable/mondo/src/mondorestore/mondo-rstr-compare.c

    r1638 r1663  
    1919extern char *MONDO_LOGFILE;
    2020
     21/* Reference to global bkpinfo */
     22extern struct s_bkpinfo *bkpinfo;
     23
    2124//static char cvsid[] = "$Id$";
    2225
     
    3437 * @note This function uses an MD5 checksum.
    3538 */
    36 int compare_a_biggiefile(struct s_bkpinfo *bkpinfo, long bigfileno)
     39int compare_a_biggiefile(long bigfileno)
    3740{
    3841
     
    5861    if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
    5962        if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
    60             insist_on_this_cd_number(bkpinfo, (++g_current_media_number));
     63            insist_on_this_cd_number((++g_current_media_number));
    6164        } else {
    6265            mr_msg(2, "No CD's left. No biggiefiles left. No problem.");
     
    133136
    134137    if (retval) {
    135         if (!(fout = fopen("/tmp/changed.txt", "a"))) {
     138        if (!(fout = fopen(MINDI_CACHE"/changed.txt", "a"))) {
    136139            fatal_error("Cannot openout changed.txt");
    137140        }
     
    151154/**
    152155 * Compare all biggiefiles in the backup.
    153  * @param bkpinfo The backup information structure. Used only in compare_a_biggiefile().
    154156 * @return 0 for success, nonzero for failure.
    155157 */
    156 int compare_all_biggiefiles(struct s_bkpinfo *bkpinfo)
     158int compare_all_biggiefiles()
    157159{
    158160    int retval = 0;
     
    161163    char *tmp = NULL;
    162164
    163     assert(bkpinfo != NULL);
    164165    mr_msg(1, "Comparing biggiefiles");
    165166
     
    187188        mr_free(tmp);
    188189
    189         res = compare_a_biggiefile(bkpinfo, bigfileno);
     190        res = compare_a_biggiefile(bigfileno);
    190191        retval += res;
    191192        g_current_progress++;
     
    303304    if (length_of_file(logfile) > 5) {
    304305        mr_asprintf(&command,
    305                 "sed s/': \\\"'/\\|/ %s | sed s/'\\\": '/\\|/ | cut -d'|' -f2 | sort -u | grep -vE \"^dev/.*\" >> /tmp/changed.txt",
     306                "sed s/': \\\"'/\\|/ %s | sed s/'\\\": '/\\|/ | cut -d'|' -f2 | sort -u | grep -vE \"^dev/.*\" >> "MINDI_CACHE"/changed.txt",
    306307                logfile);
    307308        system(command);
     
    330331 * @return 0 for success, nonzero for failure.
    331332 */
    332 int compare_all_tarballs(struct s_bkpinfo *bkpinfo)
     333int compare_all_tarballs()
    333334{
    334335    int retval = 0;
     
    361362
    362363    for (;;) {
    363         insist_on_this_cd_number(bkpinfo, g_current_media_number);
     364        insist_on_this_cd_number(g_current_media_number);
    364365        update_progress_form(progress_str);
    365366        mr_asprintf(&tarball_fname,
     
    441442 * @return 0 for success, nonzero for failure.
    442443 */
    443 int compare_to_CD(struct s_bkpinfo *bkpinfo)
     444int compare_to_CD()
    444445{
    445446  /** needs malloc *********/
     
    460461    chdir(bkpinfo->restore_path);
    461462    getcwd(new, MAX_STR_LEN - 1);
    462     insist_on_this_cd_number(bkpinfo, g_current_media_number);
    463     unlink("/tmp/changed.txt");
    464 
    465     resA = compare_all_tarballs(bkpinfo);
    466     resB = compare_all_biggiefiles(bkpinfo);
     463    insist_on_this_cd_number(g_current_media_number);
     464    unlink(MINDI_CACHE"/changed.txt");
     465
     466    resA = compare_all_tarballs();
     467    resB = compare_all_biggiefiles();
    467468    chdir(cwd);
    468     noof_changed_files = count_lines_in_file("/tmp/changed.txt");
     469    noof_changed_files = count_lines_in_file(MINDI_CACHE"/changed.txt");
    469470    if (noof_changed_files) {
    470471        log_to_screen(_("%ld files do not match the backup            "),
    471472                noof_changed_files);
    472         mr_asprintf(&command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
     473        mr_asprintf(&command, "cat "MINDI_CACHE"/changed.txt >> %s", MONDO_LOGFILE);
    473474        paranoid_system(command);
    474475        mr_free(command);
     
    501502 */
    502503int
    503 compare_mode(struct s_bkpinfo *bkpinfo,
    504              struct mountlist_itself *mountlist,
     504compare_mode(struct mountlist_itself *mountlist,
    505505             struct raidlist_itself *raidlist)
    506506{
     
    522522    assert(raidlist != NULL);
    523523
    524     while (get_cfg_file_from_archive(bkpinfo)) {
     524    while (get_cfg_file_from_archive()) {
    525525        if (!ask_me_yes_or_no
    526526            (_
     
    529529            fatal_error("Unable to find config file/archives. Aborting.");
    530530        }
    531         interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
    532     }
    533 
    534     read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
     531        interactively_obtain_media_parameters_from_user(FALSE);
     532    }
     533
     534    read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
    535535    g_current_media_number = 1;
    536536    mvaddstr_and_log_it(1, 30, _("Comparing Automatically"));
     
    544544    if (bkpinfo->backup_media_type == tape
    545545        || bkpinfo->backup_media_type == udev) {
    546         retval += compare_to_tape(bkpinfo);
     546        retval += compare_to_tape();
    547547    } else if (bkpinfo->backup_media_type == cdstream) {
    548         retval += compare_to_cdstream(bkpinfo);
    549     } else {
    550         retval += compare_to_CD(bkpinfo);
     548        retval += compare_to_cdstream();
     549    } else {
     550        retval += compare_to_CD();
    551551    }
    552552    if (retval) {
     
    557557    }
    558558
    559     if (count_lines_in_file("/tmp/changed.txt") > 0) {
     559    if (count_lines_in_file(MINDI_CACHE"/changed.txt") > 0) {
    560560        mvaddstr_and_log_it(g_currentY++, 0,
    561561                            _
    562562                            ("Differences found while files were being compared."));
    563         streamline_changes_file("/tmp/changed.files", "/tmp/changed.txt");
    564         if (count_lines_in_file("/tmp/changed.files") <= 0) {
     563        streamline_changes_file(MINDI_CACHE"/changed.files", MINDI_CACHE"/changed.txt");
     564        if (count_lines_in_file(MINDI_CACHE"/changed.files") <= 0) {
    565565            mvaddstr_and_log_it(g_currentY++, 0,
    566566                                _
     
    569569                          ("The differences were logfiles and temporary files. Your archives are fine."));
    570570        } else {
    571             q = count_lines_in_file("/tmp/changed.files");
     571            q = count_lines_in_file(MINDI_CACHE"/changed.files");
    572572            mr_asprintf(&tmp, _("%ld significant difference%s found."), q,
    573573                    (q != 1) ? "s" : "");
     
    586586            chdir(bkpinfo->restore_path);
    587587            getcwd(new, MAX_STR_LEN - 1);
    588             popup_changelist_from_file("/tmp/changed.files");
     588            popup_changelist_from_file(MINDI_CACHE"/changed.files");
    589589            mr_msg(2, "Returning from popup_changelist_from_file()");
    590590            chdir(cwd);
     
    616616 * @return 0 for success, nonzero for failure.
    617617 */
    618 int compare_to_cdstream(struct s_bkpinfo *bkpinfo)
     618int compare_to_cdstream()
    619619{
    620620    int res;
     
    642642               last_line_of_file("/tmp/CDROM-LIVES-HERE"));
    643643    }
    644     res = verify_tape_backups(bkpinfo);
     644    res = verify_tape_backups();
    645645    chdir(dir);
    646     if (length_of_file("/tmp/changed.txt") > 2
    647         && length_of_file("/tmp/changed.files") > 2) {
     646    if (length_of_file(MINDI_CACHE"/changed.txt") > 2
     647        && length_of_file(MINDI_CACHE"/changed.files") > 2) {
    648648        mr_msg(0,
    649                 "Type 'less /tmp/changed.files' to see which files don't match the archives");
     649                "Type 'less "MINDI_CACHE"/changed.files' to see which files don't match the archives");
    650650        mr_msg(2, "Calling popup_changelist_from_file()");
    651         popup_changelist_from_file("/tmp/changed.files");
     651        popup_changelist_from_file(MINDI_CACHE"/changed.files");
    652652        mr_msg(2, "Returned from popup_changelist_from_file()");
    653653    }
     
    674674 * returns: int                                                           *
    675675 **************************************************************************/
    676 int compare_to_tape(struct s_bkpinfo *bkpinfo)
     676int compare_to_tape()
    677677{
    678678    int res = 0;
     
    692692    mvaddstr_and_log_it(g_currentY,
    693693                        0, _("Verifying archives against filesystem"));
    694     res = verify_tape_backups(bkpinfo);
     694    res = verify_tape_backups();
    695695    chdir(dir);
    696696    if (res) {
  • branches/stable/mondo/src/mondorestore/mondo-rstr-compare.h

    r1200 r1663  
    44
    55
    6 int compare_to_CD(struct s_bkpinfo *);
    7 int compare_to_cdstream(struct s_bkpinfo *);
    8 int compare_to_tape(struct s_bkpinfo *);
     6int compare_to_CD();
     7int compare_to_cdstream();
     8int compare_to_tape();
    99
    1010int
    11 compare_mode(struct s_bkpinfo *bkpinfo,
    12              struct mountlist_itself *mountlist,
     11compare_mode(struct mountlist_itself *mountlist,
    1312             struct raidlist_itself *raidlist);
  • branches/stable/mondo/src/mondorestore/mondo-rstr-newt.c

    r1555 r1663  
    2626
    2727extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
    28 
    2928
    3029/**
  • branches/stable/mondo/src/mondorestore/mondo-rstr-newt.h

    r1297 r1663  
    4343extern struct s_node *find_node_in_filelist(struct s_node *,
    4444                                            char *filename);
    45 extern int what_number_cd_is_this(struct s_bkpinfo *);
     45extern int what_number_cd_is_this();
    4646//extern void fatal_error (char *);
    4747extern void sort_mountlist_by_device(struct mountlist_itself *);
  • branches/stable/mondo/src/mondorestore/mondo-rstr-tools-EXT.h

    r1580 r1663  
    44
    55extern void free_MR_global_filenames(void);
    6 extern void get_cfg_file_from_archive_or_bust(struct s_bkpinfo *);
     6extern void get_cfg_file_from_archive_or_bust();
    77extern bool is_file_in_list(char *, char *, char *);    /* needle, haystack, preamble */
    8 extern int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please);
     8extern int iso_fiddly_bits(bool nuke_me_please);
    99extern void kill_petris(void);
    10 extern int mount_cdrom(struct s_bkpinfo *bkpinfo);
     10extern int mount_cdrom();
    1111extern int mount_all_devices(struct mountlist_itself *, bool);
    1212extern void protect_against_braindead_sysadmins(void);
    13 extern int read_cfg_file_into_bkpinfo(char *cfg_file,
    14                                       struct s_bkpinfo *bkpinfo);
    15 struct s_node *process_filelist_and_biggielist(struct s_bkpinfo *);
     13extern int read_cfg_file_into_bkpinfo(char *cfg_file);
     14struct s_node *process_filelist_and_biggielist();
    1615extern int backup_crucial_file(char *path_root, char *filename);
    1716extern int run_boot_loader(bool);
     
    2423extern void streamline_changes_file(char *, char *);
    2524extern void set_signals(int on);
    26 extern void setup_MR_global_filenames(struct s_bkpinfo *bkpinfo);
     25extern void setup_MR_global_filenames();
    2726extern void terminate_daemon(int);
    2827extern void termination_in_progress(int);
    2928extern int unmount_all_devices(struct mountlist_itself *);
    30 extern int get_cfg_file_from_archive(struct s_bkpinfo *bkpinfo);
     29extern int get_cfg_file_from_archive();
    3130extern int
    32 extract_config_file_from_ramdisk(struct s_bkpinfo *bkpinfo,
     31extract_config_file_from_ramdisk(
    3332                                 char *ramdisk_fname,
    3433                                 char *output_cfg_file,
  • branches/stable/mondo/src/mondorestore/mondo-rstr-tools.c

    r1639 r1663  
    4949extern char *MONDO_LOGFILE;
    5050
     51/* Reference to global bkpinfo */
     52extern struct s_bkpinfo *bkpinfo;
     53
    5154/* Should we use or not extended attributes and acl when restoring */
    5255char *g_getfattr = NULL;
     
    141144 */
    142145int
    143 extract_config_file_from_ramdisk(struct s_bkpinfo *bkpinfo,
    144                                  char *ramdisk_fname,
    145                                  char *output_cfg_file,
    146                                  char *output_mountlist_file)
     146extract_config_file_from_ramdisk(char *ramdisk_fname,
     147                         char *output_cfg_file,
     148                         char *output_mountlist_file)
    147149{
    148150    char *mountpt = NULL;
     
    211213/**
    212214 * Keep trying to get mondo-restore.cfg from the archive, until the user gives up.
    213  * @param bkpinfo The backup information structure.
    214  */
    215 void get_cfg_file_from_archive_or_bust(struct s_bkpinfo *bkpinfo)
    216 {
    217     while (get_cfg_file_from_archive(bkpinfo)) {
     215 */
     216void get_cfg_file_from_archive_or_bust()
     217{
     218    while (get_cfg_file_from_archive()) {
    218219        if (!ask_me_yes_or_no
    219220            (_
     
    222223            fatal_error("Could not find config file/archives. Aborting.");
    223224        }
    224         interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
     225        interactively_obtain_media_parameters_from_user(FALSE);
    225226    }
    226227}
     
    285286 * @return 0 for success, nonzero for failure.
    286287 */
    287 int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please)
     288int iso_fiddly_bits(bool nuke_me_please)
    288289{
    289290    char *mount_isodir_command = NULL;
     
    341342    }
    342343    if (!IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    343         mount_cdrom(bkpinfo);
    344     }
    345     i = what_number_cd_is_this(bkpinfo);    /* has the side-effect of calling mount_cdrom() */
     344        mount_cdrom();
     345    }
     346    i = what_number_cd_is_this();   /* has the side-effect of calling mount_cdrom() */
    346347    mr_msg(1, "%s #%d has been mounted via loopback mount",
    347348            bkpinfo->backup_media_string, i);
     
    601602 * @return 0 for success, nonzero for failure.
    602603 */
    603 int mount_cdrom(struct s_bkpinfo *bkpinfo)
     604int mount_cdrom()
    604605{
    605606    char *mount_cmd = NULL;
     
    750751 * @return 0 for success, nonzero for failure.
    751752 */
    752 int read_cfg_file_into_bkpinfo(char *cfgf, struct s_bkpinfo *bkpinfo)
     753int read_cfg_file_into_bkpinfo(char *cfgf)
    753754{
    754755    char *value = NULL;
     
    10191020                    mr_asprintf(&iso_mnt, "");
    10201021                    mr_asprintf(&iso_path, "");
    1021                     if (mount_cdrom(bkpinfo)) {
     1022                    if (mount_cdrom()) {
    10221023                        fatal_error
    10231024                            ("Unable to mount isodir. Failed to mount CD-ROM as well.");
     
    10431044                mr_msg(2,
    10441045                        "bkpinfo->backup_media_type != media_specified_by_user, so I'd better ask :)");
    1045                 interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
     1046                interactively_obtain_media_parameters_from_user(FALSE);
    10461047                media_specified_by_user = bkpinfo->backup_media_type;
    1047                 get_cfg_file_from_archive(bkpinfo);
     1048                get_cfg_file_from_archive();
    10481049            }
    10491050        }
     
    10721073 */
    10731074struct
    1074 s_node *process_filelist_and_biggielist(struct s_bkpinfo *bkpinfo)
     1075s_node *process_filelist_and_biggielist()
    10751076{
    10761077    struct s_node *filelist = NULL;
     
    11151116                    "Calling insist_on_this_cd_number; bkpinfo->isodir=%s",
    11161117                    bkpinfo->isodir);
    1117             insist_on_this_cd_number(bkpinfo, 1);
     1118            insist_on_this_cd_number(1);
    11181119            mr_msg(2, "Back from iotcn");
    11191120            run_program_and_log_output("mount", 1);
     
    11251126                    FILELIST_FULL_STUB,
    11261127                    "tmp/i-want-my-lvm", MONDO_CFG_FILE_STUB);
    1127 
    11281128            mr_msg(1, "tarcommand = %s", command);
    11291129            run_program_and_log_output(command, 1);
     
    17901790 * - @c bkpinfo->disaster_recovery
    17911791 */
    1792 void setup_MR_global_filenames(struct s_bkpinfo *bkpinfo)
     1792void setup_MR_global_filenames()
    17931793{
    17941794    char *temppath;
     
    20812081 * @return 0 for success, nonzero for failure.
    20822082 */
    2083 int get_cfg_file_from_archive(struct s_bkpinfo *bkpinfo)
     2083int get_cfg_file_from_archive()
    20842084{
    20852085    int retval = 0;
     
    21252125        } else {
    21262126            mr_msg(2, "gcffa --- calling mount_cdrom now :)");
    2127             if (!mount_cdrom(bkpinfo)) {
     2127            if (!mount_cdrom()) {
    21282128                mr_msg(2,
    21292129                        "gcffa --- managed to mount CD; so, no need for Plan B");
     
    21322132                try_plan_B = TRUE;
    21332133            }
    2134             if (what_number_cd_is_this(bkpinfo) > 1) {
    2135                 insist_on_this_cd_number(bkpinfo,
    2136                                          (g_current_media_number = 1));
     2134            if (what_number_cd_is_this() > 1) {
     2135                insist_on_this_cd_number((g_current_media_number = 1));
    21372136            }
    21382137        }
  • branches/stable/mondo/src/mondorestore/mondo-rstr-tools.h

    r1580 r1663  
    44
    55void free_global_filenames(void);
    6 void get_cfg_file_from_archive_or_bust(struct s_bkpinfo *);
     6void get_cfg_file_from_archive_or_bust();
    77bool is_file_in_list(char *, char *, char *);   /* needle, haystack, preamble */
    8 int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please);
     8int iso_fiddly_bits(bool nuke_me_please);
    99void kill_petris(void);
    10 int mount_cdrom(struct s_bkpinfo *bkpinfo);
     10int mount_cdrom();
    1111int mount_device(char *, char *, char *, bool);
    1212int mount_all_devices(struct mountlist_itself *, bool);
    1313void protect_against_braindead_sysadmins(void);
    14 int read_cfg_file_into_bkpinfo(char *cfg_file, struct s_bkpinfo *bkpinfo);
    15 struct s_node *process_filelist_and_biggielist(struct s_bkpinfo *);
     14int read_cfg_file_into_bkpinfo(char *cfg_file);
     15struct s_node *process_filelist_and_biggielist();
    1616int backup_crucial_file(char *path_root, char *filename);
    1717
     
    2424void streamline_changes_file(char *, char *);
    2525void set_signals(int on);
    26 void setup_global_filenames(struct s_bkpinfo *bkpinfo);
     26void setup_global_filenames();
    2727void twenty_seconds_til_yikes(void);
    2828int run_raw_mbr(bool offer_to_hack_scripts, char *bd);
     
    3030void termination_in_progress(int);
    3131int unmount_all_devices(struct mountlist_itself *);
    32 int get_cfg_file_from_archive(struct s_bkpinfo *bkpinfo);
     32int get_cfg_file_from_archive();
    3333void ask_about_these_imagedevs(char *infname, char *outfname);
  • branches/stable/mondo/src/mondorestore/mondorestore.c

    r1639 r1663  
    3535
    3636extern void twenty_seconds_til_yikes(void);
     37
     38/* Reference to global bkpinfo */
     39struct s_bkpinfo *bkpinfo;
    3740
    3841/* For use in other programs (ex. XMondo) */
     
    205208 * @ingroup restoreGuiGroup
    206209 */
    207 int let_user_edit_the_mountlist(struct s_bkpinfo *bkpinfo,
    208                                 struct mountlist_itself *mountlist,
     210int let_user_edit_the_mountlist(struct mountlist_itself *mountlist,
    209211                                struct raidlist_itself *raidlist)
    210212{
     
    306308 */
    307309int
    308 catchall_mode(struct s_bkpinfo *bkpinfo,
    309               struct mountlist_itself *mountlist,
     310catchall_mode(struct mountlist_itself *mountlist,
    310311              struct raidlist_itself *raidlist)
    311312{
     
    321322    iamhere("post wrm");
    322323    if (c == 'I' || c == 'N' || c == 'C') {
    323         interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
     324        interactively_obtain_media_parameters_from_user(FALSE);
    324325    } else {
    325326        popup_and_OK(_("No restoring or comparing will take place today."));
     
    338339
    339340    if (bkpinfo->backup_media_type == iso) {
    340         if (iso_fiddly_bits(bkpinfo, (c == 'N') ? TRUE : FALSE)) {
     341        if (iso_fiddly_bits((c == 'N') ? TRUE : FALSE)) {
    341342            mr_msg(2,
    342343                    "catchall_mode --- iso_fiddly_bits returned w/ error");
     
    349350    if (c == 'I') {
    350351        mr_msg(2, "IM selected");
    351         retval += interactive_mode(bkpinfo, mountlist, raidlist);
     352        retval += interactive_mode(mountlist, raidlist);
    352353    } else if (c == 'N') {
    353354        mr_msg(2, "NM selected");
    354         retval += nuke_mode(bkpinfo, mountlist, raidlist);
     355        retval += nuke_mode(mountlist, raidlist);
    355356    } else if (c == 'C') {
    356357        mr_msg(2, "CM selected");
    357         retval += compare_mode(bkpinfo, mountlist, raidlist);
     358        retval += compare_mode(mountlist, raidlist);
    358359    }
    359360    return (retval);
     
    368369 **************************************************************************/
    369370
    370 static void clean_blkid(struct s_bkpinfo *bkpinfo) {
     371static void clean_blkid() {
    371372
    372373    char *tmp1 = NULL;
     
    396397 */
    397398int
    398 interactive_mode(struct s_bkpinfo *bkpinfo,
    399                  struct mountlist_itself *mountlist,
     399interactive_mode(struct mountlist_itself *mountlist,
    400400                 struct raidlist_itself *raidlist)
    401401{
     
    434434
    435435    iamhere("About to load config file");
    436     get_cfg_file_from_archive_or_bust(bkpinfo);
    437     read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
     436    get_cfg_file_from_archive_or_bust();
     437    read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
    438438    iamhere("Done loading config file; resizing ML");
    439439    mr_asprintf(&tmp,bkpinfo->prefix);
     
    560560    {
    561561        mr_msg(1, "Restoring all data");
    562         retval += restore_everything(bkpinfo, NULL);
     562        retval += restore_everything(NULL);
    563563    } else if ((restore_all =
    564564             ask_me_yes_or_no
     
    567567        for (done = FALSE; !done;) {
    568568            unlink("/tmp/filelist.full");
    569             filelist = process_filelist_and_biggielist(bkpinfo);
     569            filelist = process_filelist_and_biggielist();
    570570            /* Now you have /tmp/tmpfs/filelist.restore-these and /tmp/tmpfs/biggielist.restore-these;
    571571               the former is a list of regular files; the latter, biggiefiles and imagedevs.
     
    587587                    strcpy(bkpinfo->restore_path, tmp1);
    588588                    mr_msg(1, "Restoring subset");
    589                     retval += restore_everything(bkpinfo, filelist);
     589                    retval += restore_everything(filelist);
    590590                    free_filelist(filelist);
    591591                } else {
     
    622622    }
    623623
    624     clean_blkid(bkpinfo);
     624    clean_blkid();
    625625    protect_against_braindead_sysadmins();
    626626    retval += unmount_all_devices(mountlist);
     
    671671 * Run an arbitrary restore mode (prompt the user), but from ISO images
    672672 * instead of real media.
    673  * @param bkpinfo The backup information structure. Most fields are used.
    674673 * @param mountlist The mountlist containing information about the user's partitions.
    675674 * @param raidlist The raidlist that goes with @p mountlist.
     
    678677 */
    679678int
    680 iso_mode(struct s_bkpinfo *bkpinfo,
    681          struct mountlist_itself *mountlist,
     679iso_mode(struct mountlist_itself *mountlist,
    682680         struct raidlist_itself *raidlist, bool nuke_me_please)
    683681{
     
    685683    int retval = 0;
    686684
    687     assert(bkpinfo != NULL);
    688685    assert(mountlist != NULL);
    689686    assert(raidlist != NULL);
    690     if (iso_fiddly_bits(bkpinfo, nuke_me_please)) {
     687    if (iso_fiddly_bits(nuke_me_please)) {
    691688        mr_msg(1, "iso_mode --- returning w/ error");
    692689        return (1);
     
    694691        c = which_restore_mode();
    695692        if (c == 'I' || c == 'N' || c == 'C') {
    696             interactively_obtain_media_parameters_from_user(bkpinfo,
    697                                                             FALSE);
     693            interactively_obtain_media_parameters_from_user(FALSE);
    698694        }
    699695        if (c == 'I') {
    700             retval += interactive_mode(bkpinfo, mountlist, raidlist);
     696            retval += interactive_mode(mountlist, raidlist);
    701697        } else if (c == 'N') {
    702             retval += nuke_mode(bkpinfo, mountlist, raidlist);
     698            retval += nuke_mode(mountlist, raidlist);
    703699        } else if (c == 'C') {
    704             retval += compare_mode(bkpinfo, mountlist, raidlist);
     700            retval += compare_mode(mountlist, raidlist);
    705701        } else {
    706702            log_to_screen(_("OK, I shan't restore/compare any files."));
     
    761757 */
    762758int
    763 nuke_mode(struct s_bkpinfo *bkpinfo,
    764           struct mountlist_itself *mountlist,
     759nuke_mode(struct mountlist_itself *mountlist,
    765760          struct raidlist_itself *raidlist)
    766761{
     
    778773    mr_msg(2, "nuke_mode --- starting");
    779774
    780     get_cfg_file_from_archive_or_bust(bkpinfo);
     775    get_cfg_file_from_archive_or_bust();
    781776    load_mountlist(mountlist, g_mountlist_fname);   // in case read_cfg_file_into_bkpinfo updated the mountlist
    782777#ifdef __FreeBSD__
     
    796791        if (ask_me_yes_or_no(tmp)) {
    797792            mr_free(tmp);
    798             retval = interactive_mode(bkpinfo, mountlist, raidlist);
     793            retval = interactive_mode(mountlist, raidlist);
    799794            call_me_after_the_nuke(retval);
    800795            return(retval);
     
    852847
    853848        if (ask_me_yes_or_no(_("Try in interactive mode instead?"))) {
    854             retval = interactive_mode(bkpinfo, mountlist, raidlist);
     849            retval = interactive_mode(mountlist, raidlist);
    855850            call_me_after_the_nuke(retval);
    856851            return(retval);
     
    869864    }
    870865    iamhere("Restoring everything");
    871     retval += restore_everything(bkpinfo, NULL);
     866    retval += restore_everything(NULL);
    872867    if (!run_boot_loader(FALSE)) {
    873868        mr_msg(1,
     
    875870        boot_loader_installed = TRUE;
    876871    }
    877     clean_blkid(bkpinfo);
     872    clean_blkid();
    878873    protect_against_braindead_sysadmins();
    879874    retval += unmount_all_devices(mountlist);
     
    910905 * @return 0 for success, or the number of errors encountered.
    911906 */
    912 int restore_to_live_filesystem(struct s_bkpinfo *bkpinfo)
     907int restore_to_live_filesystem()
    913908{
    914909    int retval = 0;
     
    932927        sleep(1);
    933928    }
    934     interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
     929    interactively_obtain_media_parameters_from_user(FALSE);
    935930    if (!bkpinfo->media_device) {
    936931        mr_msg(2, "Warning - failed to find media dev");
     
    944939    open_evalcall_form(_("Thinking..."));
    945940
    946     get_cfg_file_from_archive_or_bust(bkpinfo);
    947     read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
     941    get_cfg_file_from_archive_or_bust();
     942    read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
    948943    load_mountlist(mountlist, g_mountlist_fname);   // in case read_cfg_file_into_bkpinfo
    949944
     
    951946    retval = load_mountlist(mountlist, g_mountlist_fname);
    952947    load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
    953     filelist = process_filelist_and_biggielist(bkpinfo);
     948    filelist = process_filelist_and_biggielist();
    954949    if (filelist) {
    955950        save_filelist(filelist, "/tmp/selected-files.txt");
     
    959954                                 bkpinfo->restore_path, MAX_STR_LEN)) {
    960955            iamhere("Restoring everything");
    961             retval += restore_everything(bkpinfo, filelist);
     956            retval += restore_everything(filelist);
    962957        }
    963958        free_filelist(filelist);
     
    10061001 */
    10071002int
    1008 restore_a_biggiefile_from_CD(struct s_bkpinfo *bkpinfo,
    1009                              long bigfileno,
     1003restore_a_biggiefile_from_CD(long bigfileno,
    10101004                             struct s_node *filelist,
    10111005                             char *pathname_of_last_file_restored)
     
    11781172                    bkpinfo->backup_media_string,
    11791173                    g_current_media_number);
    1180             insist_on_this_cd_number(bkpinfo, g_current_media_number);
     1174            insist_on_this_cd_number(g_current_media_number);
    11811175            log_to_screen(_("Continuing to restore."));
    11821176        } else {
     
    13071301 * @return 0 for success (or skip), nonzero for failure.
    13081302 */
    1309 int restore_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo, char *orig_bf_fname, long biggiefile_number, char *orig_checksum,   //UNUSED
     1303int restore_a_biggiefile_from_stream(char *orig_bf_fname, long biggiefile_number, char *orig_checksum,  //UNUSED
    13101304                                     long long biggiefile_size, //UNUSED
    13111305                                     struct s_node *filelist,
     
    14741468        if (current_slice_number == 0) {
    14751469            res =
    1476                 read_file_from_stream_to_file(bkpinfo,
    1477                                               "/tmp/biggie-blah.txt",
     1470                read_file_from_stream_to_file("/tmp/biggie-blah.txt",
    14781471                                              slice_siz);
    14791472            if (!(fin = fopen("/tmp/biggie-blah.txt", "r"))) {
     
    14911484        } else {
    14921485            res =
    1493                 read_file_from_stream_to_stream(bkpinfo, pout, slice_siz);
     1486                read_file_from_stream_to_stream(pout, slice_siz);
    14941487        }
    14951488        retval += res;
     
    17761769 */
    17771770int
    1778 restore_a_tarball_from_stream(struct s_bkpinfo *bkpinfo,
    1779                               char *tarball_fname,
     1771restore_a_tarball_from_stream(char *tarball_fname,
    17801772                              long current_tarball_number,
    17811773                              struct s_node *filelist,
     
    18171809    mr_asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
    18181810            bkpinfo->tmpdir, current_tarball_number);
    1819     res = read_file_from_stream_to_file(bkpinfo, afio_fname, size);
     1811    res = read_file_from_stream_to_file(afio_fname, size);
    18201812    if (strstr(tarball_fname, ".star")) {
    18211813        bkpinfo->use_star = TRUE;
     
    19511943 */
    19521944int
    1953 restore_all_biggiefiles_from_CD(struct s_bkpinfo *bkpinfo,
    1954                                 struct s_node *filelist)
     1945restore_all_biggiefiles_from_CD(struct s_node *filelist)
    19551946{
    19561947    int retval = 0;
     
    20182009                        "I'll continue to scan this CD for bigfiles to be restored.");
    20192010            } else if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
    2020                 insist_on_this_cd_number(bkpinfo,
    2021                                          ++g_current_media_number);
     2011                insist_on_this_cd_number(++g_current_media_number);
    20222012                log_to_screen(_("Restoring from %s #%d"),
    2023                         bkpinfo->backup_media_string,
     2013                        media_descriptor_string(bkpinfo->backup_media_type),
    20242014                        g_current_media_number);
    20252015                just_changed_cds = TRUE;
     
    20372027
    20382028            res =
    2039                 restore_a_biggiefile_from_CD(bkpinfo, bigfileno, filelist,
    2040                                              pathname_of_last_biggie_restored);
     2029                restore_a_biggiefile_from_CD(bigfileno, filelist, pathname_of_last_biggie_restored);
    20412030            iamhere(pathname_of_last_biggie_restored);
    20422031            if (fbw && pathname_of_last_biggie_restored[0]) {
     
    20972086 */
    20982087int
    2099 restore_all_tarballs_from_CD(struct s_bkpinfo *bkpinfo,
    2100                              struct s_node *filelist)
     2088restore_all_tarballs_from_CD(struct s_node *filelist)
    21012089{
    21022090    int retval = 0;
     
    21262114        g_current_media_number = 1;
    21272115    }
    2128     insist_on_this_cd_number(bkpinfo, g_current_media_number);
     2116    insist_on_this_cd_number(g_current_media_number);
    21292117    read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp1);
    21302118    max_val = atol(tmp1) + 1;
     
    21402128                       progress_str, max_val);
    21412129    for (;;) {
    2142         insist_on_this_cd_number(bkpinfo, g_current_media_number);
     2130        insist_on_this_cd_number(g_current_media_number);
    21432131        update_progress_form(progress_str);
    21442132        mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
     
    22522240 */
    22532241int
    2254 restore_all_biggiefiles_from_stream(struct s_bkpinfo *bkpinfo,
    2255                                     struct s_node *filelist)
     2242restore_all_biggiefiles_from_stream(struct s_node *filelist)
    22562243{
    22572244    long noof_biggiefiles = 0L;
     
    23062293    if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
    23072294        res =
    2308             read_EXAT_files_from_tape(bkpinfo, &biggie_size, biggie_fname,
     2295            read_EXAT_files_from_tape(&biggie_size, biggie_fname,
    23092296                                      &ctrl_chr, xattr_fname, acl_fname);
    23102297    }
     
    23422329        mr_free(tmp);
    23432330
    2344         res = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
     2331        res = restore_a_biggiefile_from_stream(biggie_fname,
    23452332                                               current_bigfile_number,
    23462333                                               biggie_cksum,
     
    24282415 */
    24292416int
    2430 restore_all_tarballs_from_stream(struct s_bkpinfo *bkpinfo,
    2431                                  struct s_node *filelist)
     2417restore_all_tarballs_from_stream(struct s_node *filelist)
    24322418{
    24332419    int retval = 0;
     
    24932479            iamhere("Reading EXAT files from tape");
    24942480            res =
    2495                 read_EXAT_files_from_tape(bkpinfo, &tmp_size, tmp_fname,
     2481                read_EXAT_files_from_tape(&tmp_size, tmp_fname,
    24962482                                          &ctrl_chr, xattr_fname,
    24972483                                          acl_fname);
     
    25062492                */
    25072493        res =
    2508             restore_a_tarball_from_stream(bkpinfo, tmp_fname,
     2494            restore_a_tarball_from_stream(tmp_fname,
    25092495                                          current_afioball_number,
    25102496                                          filelist, tmp_size, xattr_fname,
     
    25682554 * @ingroup restoreGroup
    25692555 */
    2570 int restore_everything(struct s_bkpinfo *bkpinfo, struct s_node *filelist)
     2556int restore_everything(struct s_node *filelist)
    25712557{
    25722558    int resA;
     
    26022588    mvaddstr_and_log_it(g_currentY, 0, _("Preparing to read your archives"));
    26032589    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    2604         mount_cdrom(bkpinfo);
     2590        mount_cdrom();
    26052591        mvaddstr_and_log_it(g_currentY++, 0,
    26062592                            _("Restoring OS and data from streaming media"));
    26072593        if (bkpinfo->backup_media_type == cdstream) {
    2608             openin_cdstream(bkpinfo);
     2594            openin_cdstream();
    26092595        } else {
    2610             assert_string_is_neither_NULL_nor_zerolength(bkpinfo->
    2611                                                          media_device);
    2612             openin_tape(bkpinfo);
    2613         }
    2614         resA = restore_all_tarballs_from_stream(bkpinfo, filelist);
    2615         resB = restore_all_biggiefiles_from_stream(bkpinfo, filelist);
     2596            assert_string_is_neither_NULL_nor_zerolength(bkpinfo->media_device);
     2597            openin_tape();
     2598        }
     2599        resA = restore_all_tarballs_from_stream(filelist);
     2600        resB = restore_all_biggiefiles_from_stream(filelist);
    26162601        if (bkpinfo->backup_media_type == cdstream) {
    2617             closein_cdstream(bkpinfo);
     2602            closein_cdstream();
    26182603        } else {
    2619             closein_tape(bkpinfo);
     2604            closein_tape();
    26202605        }
    26212606    } else {
    26222607        mvaddstr_and_log_it(g_currentY++, 0,
    26232608                            _("Restoring OS and data from CD       "));
    2624         mount_cdrom(bkpinfo);
    2625         resA = restore_all_tarballs_from_CD(bkpinfo, filelist);
    2626         resB = restore_all_biggiefiles_from_CD(bkpinfo, filelist);
     2609        mount_cdrom();
     2610        resA = restore_all_tarballs_from_CD(filelist);
     2611        resB = restore_all_biggiefiles_from_CD(filelist);
    26272612    }
    26282613    chdir(cwd);
     
    26512636 */
    26522637int
    2653 restore_live_from_monitas_server(struct s_bkpinfo *bkpinfo,
    2654                                  char *monitas_device,
     2638restore_live_from_monitas_server(char *monitas_device,
    26552639                                 char *restore_this_directory,
    26562640                                 char *restore_here)
     
    27242708
    27252709    unlink(datadisks_fname);
    2726     read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
     2710    read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
    27272711    retval = load_mountlist(&the_mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo   strcpy(bkpinfo->media_device, monitas_device);
    27282712
     
    27512735    run_program_and_log_output(command, FALSE);
    27522736//  filelist = load_filelist(g_filelist_restthese);  // FIXME --- this probably doesn't work because it doesn't include the biggiefiles
    2753     retval += restore_everything(bkpinfo, filelist);
     2737    retval += restore_everything(filelist);
    27542738    free_filelist(filelist);
    27552739    mr_msg(2, "--------End of restore_live_from_monitas_server--------");
     
    28202804    struct mountlist_itself *mountlist = NULL;
    28212805    struct raidlist_itself *raidlist = NULL;
    2822     struct s_bkpinfo *bkpinfo = NULL;
    28232806    struct s_node *filelist = NULL;
    28242807    char *a = NULL, *b = NULL;
     
    28402823    mr_conf = mr_malloc(sizeof(struct mr_rs_conf));
    28412824    mr_rs_reset_conf(mr_conf);
     2825    bkpinfo = mr_malloc(sizeof(struct s_bkpinfo));
     2826    reset_bkpinfo();
    28422827
    28432828    mr_conf->log_level = DEFAULT_MR_LOGLEVEL;
     
    28592844        g_text_mode = FALSE;
    28602845    }                           // newt :-)
    2861     bkpinfo = mr_malloc(sizeof(struct s_bkpinfo));
    28622846    mountlist = mr_malloc(sizeof(struct mountlist_itself));
    28632847    raidlist = mr_malloc(sizeof(struct raidlist_itself));
     
    28732857    malloc_string(a);
    28742858    malloc_string(b);
    2875     setup_MR_global_filenames(bkpinfo); // malloc() and set globals, using bkpinfo->tmpdir etc.
    2876     reset_bkpinfo(bkpinfo);
     2859    setup_MR_global_filenames();    // malloc() and set globals, using bkpinfo->tmpdir etc.
    28772860    bkpinfo->backup_media_type = none;  // in case boot disk was made for one backup type but user wants to restore from another backup type
    28782861    strcpy(bkpinfo->backup_media_string,"");
     
    29092892
    29102893/* Init directories */
    2911     make_hole_for_dir(bkpinfo->tmpdir);
    2912     mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
    2913     run_program_and_log_output(tmp, FALSE);
    2914     mr_free(tmp);
    2915 
    29162894    make_hole_for_dir("/var/log");
    29172895    make_hole_for_dir("/tmp/tmpfs");    /* just in case... */
     
    29432921            strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
    29442922        }
    2945         res = let_user_edit_the_mountlist(bkpinfo, mountlist, raidlist);
     2923        res = let_user_edit_the_mountlist(mountlist, raidlist);
    29462924#ifdef __FreeBSD__
    29472925        system("mv -f /etc/raidtab /tmp/raidconf.txt");
     
    29772955
    29782956        malloc_string(tmp);
    2979         restore_a_biggiefile_from_CD(bkpinfo, 42, NULL, tmp);
     2957        restore_a_biggiefile_from_CD(42, NULL, tmp);
    29802958        mr_free(tmp);
    29812959    }
     
    30773055        if (argc == 5 && strcmp(argv[1], "--monitas-live") == 0) {
    30783056            retval =
    3079                 restore_live_from_monitas_server(bkpinfo,
    3080                                                  argv[2],
     3057                restore_live_from_monitas_server(argv[2],
    30813058                                                 argv[3], argv[4]);
    30823059        } else {
    30833060            mr_msg(2, "Calling restore_to_live_filesystem()");
    3084             retval = restore_to_live_filesystem(bkpinfo);
     3061            retval = restore_to_live_filesystem();
    30853062        }
    30863063        mr_msg(2, "Still here. Yay.");
     
    31033080        iamhere("About to call load_mountlist and load_raidtab");
    31043081        strcpy(bkpinfo->restore_path, MNT_RESTORING);
    3105         read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
     3082        read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
    31063083        retval = load_mountlist(mountlist, g_mountlist_fname);
    31073084        retval += load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
     
    31633140        if (argc == 2 && strcmp(argv[1], "--nuke") == 0) {
    31643141            iamhere("nuking");
    3165             retval += nuke_mode(bkpinfo, mountlist, raidlist);
     3142            retval += nuke_mode(mountlist, raidlist);
    31663143        } else if (argc == 2 && strcmp(argv[1], "--interactive") == 0) {
    31673144            iamhere("catchall");
    3168             retval += catchall_mode(bkpinfo, mountlist, raidlist);
     3145            retval += catchall_mode(mountlist, raidlist);
    31693146        } else if (argc == 2 && strcmp(argv[1], "--compare") == 0) {
    31703147            iamhere("compare");
    3171             retval += compare_mode(bkpinfo, mountlist, raidlist);
     3148            retval += compare_mode(mountlist, raidlist);
    31723149        } else if (argc == 2 && strcmp(argv[1], "--iso") == 0) {
    31733150            iamhere("iso");
    3174             retval = iso_mode(bkpinfo, mountlist, raidlist, FALSE);
     3151            retval = iso_mode(mountlist, raidlist, FALSE);
    31753152        } else if (argc == 2 && strcmp(argv[1], "--mbr") == 0) {
    31763153            iamhere("mbr");
     
    31853162        } else if (argc == 2 && strcmp(argv[1], "--isonuke") == 0) {
    31863163            iamhere("isonuke");
    3187             retval = iso_mode(bkpinfo, mountlist, raidlist, TRUE);
     3164            retval = iso_mode(mountlist, raidlist, TRUE);
    31883165        } else if (argc != 1) {
    31893166            log_to_screen(_("Invalid parameters"));
     
    31913168        } else {
    31923169            iamhere("catchall (no mode specified in command-line call");
    3193             retval += catchall_mode(bkpinfo, mountlist, raidlist);
     3170            retval += catchall_mode(mountlist, raidlist);
    31943171        }
    31953172    }
     
    31973174    /* clean up at the end */
    31983175    if (retval) {
    3199         if (does_file_exist("/tmp/changed.files")) {
     3176        if (does_file_exist(MINDI_CACHE"/changed.files")) {
    32003177            log_to_screen
    3201                 (_("See /tmp/changed.files for list of files that have changed."));
     3178                (_("See "MINDI_CACHE"/changed.files for list of files that have changed."));
    32023179        }
    32033180        mvaddstr_and_log_it(g_currentY++,
  • branches/stable/mondo/src/mondorestore/mondorestore.h

    r1346 r1663  
    88 * Compatibility #define to ease the transition to logfile-in-a-variable.
    99 */
    10 char *MONDO_LOGFILE = "/tmp/mondorestore.log";
     10char *MONDO_LOGFILE = "/var/log/mondorestore.log";
    1111
    1212/* Busybox ps has no option and PID in first pos */
  • branches/stable/mondo/src/mondorestore/mr-externs.h

    r1200 r1663  
    1616extern bool ask_me_yes_or_no(char *);
    1717extern char *calc_checksum_of_file(char *);
    18 extern int closein_tape(struct s_bkpinfo *);
     18extern int closein_tape();
    1919extern void close_evalcall_form(void);
    2020extern char *call_program_and_get_last_line_of_output(char *);
     
    5151extern void open_evalcall_form(char *);
    5252extern void open_progress_form(char *, char *, char *, char *, long);
    53 extern int openin_cdstream(struct s_bkpinfo *);
    54 extern int openin_tape(struct s_bkpinfo *);
     53extern int openin_cdstream();
     54extern int openin_tape();
    5555extern int partition_device(char *, int, int, char *, long);
    5656extern int partition_device_with_fdisk(char *, int, int, char *, long);
     
    6161extern bool popup_and_get_string(char *, char *, char *, int);
    6262extern void setup_newt_stuff(void);
    63 extern void reset_bkpinfo(struct s_bkpinfo *);
     63extern void reset_bkpinfo();
    6464extern int read_cfg_var(char *, char *, char *);
    65 extern int read_file_from_stream_to_file(struct s_bkpinfo *, char *,
     65extern int read_file_from_stream_to_file(char *,
    6666                                         long long);
    67 extern int read_file_from_stream_to_stream(struct s_bkpinfo *, FILE *,
     67extern int read_file_from_stream_to_stream(FILE *,
    6868                                           long long);
    69 extern int read_file_from_stream_FULL(struct s_bkpinfo *, char *, FILE *,
     69extern int read_file_from_stream_FULL(char *, FILE *,
    7070                                      long long);
    7171extern int read_header_block_from_stream(long long *, char *, int *);
     
    7878extern void update_evalcall_form(int);
    7979extern void update_progress_form(char *);
    80 extern int verify_tape_backups(struct s_bkpinfo *);
     80extern int verify_tape_backups();
    8181extern char which_restore_mode(void);
    8282extern int which_format_command_do_i_need(char *, char *);
     
    9191                                                                mountlist_itself
    9292                                                                *mountlist);
    93 extern int get_cfg_file_from_archive(struct s_bkpinfo *);
     93extern int get_cfg_file_from_archive();
    9494
    9595
Note: See TracChangeset for help on using the changeset viewer.