Changeset 2325 in MondoRescue for branches/2.2.10/mondo/src/mondorestore


Ignore:
Timestamp:
Aug 18, 2009, 3:19:15 PM (15 years ago)
Author:
Bruno Cornec
Message:

r3336@localhost: bruno | 2009-08-11 16:32:36 +0200

  • bkpinfo->media_device, bkpinfo->nfs_remote_dir, and bkpinfo->nfs_mount are now dynamically allocated
  • new interfaces for find_cdrom_device(), find_tape_device_and_size(), find_dvd_device(), find_cdrw_device(), set_dev_to_this_if_rx_OK() and read_cfg_var() which allocate the string now returned
  • Better differentiation between ISO and NFS iso file names construction
Location:
branches/2.2.10/mondo/src/mondorestore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • branches/2.2.10/mondo/src/mondorestore/mondo-prep.c

    r2324 r2325  
    448448    /** buffers **********************************************************/
    449449    char *incoming;
    450     char *tmp = NULL;
    451450
    452451    /** pointers *********************************************************/
    … …  
    23302329                                                     char *drive_name)
    23312330{
    2332     /**buffers **********************************************************/
    2333     char *tmp = NULL;
    23342331
    23352332    /** int *************************************************************/

  • branches/2.2.10/mondo/src/mondorestore/mondo-rstr-compare.c

    r2324 r2325  
    360360  /**  needs malloc **********/
    361361
    362     char *tarball_fname = NULL;
    363     char *progress_str = NULL;
    364     char *tmp = NULL;
     362    char *tarball_fname, *progress_str;
     363    char *tmp = NULL;
    365364    char *mds = NULL;
    366365    long max_val;
    367366
     367    malloc_string(tarball_fname);
     368    malloc_string(progress_str);
    368369
    369370    assert(bkpinfo != NULL);
    370371    mvaddstr_and_log_it(g_currentY, 0, "Comparing archives");
    371 
    372     malloc_string(tmp);
    373     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     372    tmp = read_cfg_var(g_mondo_cfg_file, "last-filelist-number");
    374373    max_val = atol(tmp);
     374    mr_free(tmp);
     375
    375376    paranoid_free(tmp);
    376377
    … …  
    442443        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    443444    }
     445    paranoid_free(tarball_fname);
     446    paranoid_free(progress_str);
    444447    return (retval);
    445448}
    … …  
    671674                        0, "Verifying archives against filesystem");
    672675
     676    mr_free(bkpinfo->media_device);
    673677    if (bkpinfo->disaster_recovery && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
    674         strcpy(bkpinfo->media_device,
    675                last_line_of_file("/tmp/CDROM-LIVES-HERE"));
    676     } else {
    677         find_cdrom_device(bkpinfo->media_device, FALSE);
     678        mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
     679    } else {
     680        bkpinfo->media_device = find_cdrom_device(FALSE);
    678681    }
    679682    res = verify_tape_backups();

  • branches/2.2.10/mondo/src/mondorestore/mondo-rstr-newt.c

    r2323 r2325  
    22612261/**
    22622262 * Get information about the location of ISO images from the user.
    2263  * @param isodir_device Where to put the device (e.g. /dev/hda4) the user enters.
     2263 * @param isodir_device Where to put the device (e.g. /dev/hda4) the user enters. Allocted by the function
    22642264 * @param isodir_format Where to put the format (e.g. ext2) the user enters.
    22652265 * @param isodir_path Where to put the path (e.g. /var/cache/mondo) the user enters.
    … …  
    22672267 * @return TRUE if OK was pressed, FALSE otherwise.
    22682268 */
    2269 bool get_isodir_info(char *isodir_device, char *isodir_format, char *isodir_path, bool nuke_me_please)
    2270 {
     2269bool get_isodir_info(char *isodir_device, char *isodir_format, char *isodir_path, bool nuke_me_please) {
    22712270
    22722271    char *p = NULL;
    … …  
    22782277    /** initialize ********************************************************/
    22792278
    2280     assert(isodir_device != NULL);
    22812279    assert(isodir_path != NULL);
    22822280
    22832281    log_it("isodir_path = %s", isodir_path);
    2284     if (isodir_device[0] == '\0') {
     2282    if (isodir_device == NULL) {
    22852283        mr_asprintf(idev, "/dev/");
    22862284    } else {
    … …  
    22972295
    22982296    /* modify for the caller */
    2299     strcpy(isodir_device, idev);
     2297    mr_free(isodir_device);
     2298    isodir_device = idev;
    23002299    if (nuke_me_please) {
    23012300        ret = TRUE;
    … …  
    23162315   
    23172316                    /* modify for the caller */
    2318                     strcpy(isodir_device, p);
     2317                    mr_free(isodir_device);
     2318                    isodir_device = p;
    23192319                    mr_free(isodir_path);
    23202320                    isodir_path = r;
    … …  
    23272327        mr_free(p);
    23282328    }
    2329     mr_free(idev);
    23302329    mr_free(isodir_format);
    23312330    return(ret);

  • branches/2.2.10/mondo/src/mondorestore/mondo-rstr-tools.c

    r2324 r2325  
    9494paranoid_free(g_tmpfs_mountpt);
    9595*/
    96 paranoid_free(g_isodir_device);
     96mr_free(g_isodir_device);
    9797
    9898}
    … …  
    260260    char *command = NULL;
    261261    char *mds = NULL;
    262     char *p = NULL;
    263262    int retval = 0, i;
    264263    bool already_mounted = FALSE;
    … …  
    266265
    267266g_ISO_restore_mode = TRUE;
    268 read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
     267mr_free(g_isodir_device);
     268g_isodir_device = read_cfg_var(g_mondo_cfg_file, "iso-dev");
    269269if (bkpinfo->disaster_recovery) {
    270270    /* Patch Conor Daly 26-june-2004
    … …  
    281281}
    282282
     283/* g_isodir_device is passed and modified in this function - memory is managed correctly in it */
    283284if (!get_isodir_info(g_isodir_device, isodir_format, bkpinfo->isodir, nuke_me_please)) {
    284285    mr_free(isodir_format);
    … …  
    570571
    571572    char *mount_cmd = NULL;
    572     char *p = NULL;
    573573    int i, res;
    574574#ifdef __FreeBSD__
    … …  
    585585        log_msg(2, "mount_media() - media already mounted. Fair enough.");
    586586        return (0);
     587    }
     588
     589    if (bkpinfo->media_device == NULL) {
     590        fatal_error("No media device at that point");
    587591    }
    588592
    … …  
    594598            mr_asprintf(bkpinfo->isodir, "/tmp/isodir");
    595599            log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
     600        }
     601        if ((bkpinfo->isodir == NULL) || (bkpinfo->nfs_remote_dir == NULL) || (bkpinfo->prefix == NULL)) {
     602            fatal_error("Unable to prepare the iso filename");
    596603        }
    597604#ifdef __FreeBSD__
    … …  
    624631#endif
    625632    } else {
    626         if (bkpinfo->disaster_recovery
    627             && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
    628             strcpy(bkpinfo->media_device,
    629                 last_line_of_file("/tmp/CDROM-LIVES-HERE"));
     633        mr_free(bkpinfo->media_device);
     634        if (bkpinfo->disaster_recovery && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
     635            mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
    630636        } else {
    631             find_cdrom_device(bkpinfo->media_device, TRUE);
     637            bkpinfo->media_device = find_cdrom_device(TRUE);
    632638        }
    633639
    … …  
    720726t_bkptype media_specified_by_user;
    721727
    722 malloc_string(iso_mnt);
    723 malloc_string(iso_path);
    724 malloc_string(value);
    725728malloc_string(tmp);
    726729//  assert_string_is_neither_NULL_nor_zerolength(cfg_file);
    … …  
    735738media_specified_by_user = bkpinfo->backup_media_type;   // or 'none', if not specified
    736739
    737 if (0 == read_cfg_var(cfg_file, "backup-media-type", value)) {
    738 if (!strcmp(value, "cdstream")) {
    739     bkpinfo->backup_media_type = cdstream;
    740 } else if (!strcmp(value, "cdr")) {
    741     bkpinfo->backup_media_type = cdr;
    742 } else if (!strcmp(value, "cdrw")) {
    743     bkpinfo->backup_media_type = cdrw;
    744 } else if (!strcmp(value, "dvd")) {
    745     bkpinfo->backup_media_type = dvd;
    746 } else if (!strcmp(value, "usb")) {
    747     bkpinfo->backup_media_type = usb;
    748     bkpinfo->please_dont_eject = TRUE;
    749 } else if (!strcmp(value, "iso")) {
    750 
    751 // Patch by Conor Daly - 2004/07/12
    752     bkpinfo->backup_media_type = iso;
    753     if (am_I_in_disaster_recovery_mode()) {
    754         /* Check to see if CD is already mounted before mounting it... */
    755         if (!is_this_device_mounted("/dev/cdrom")) {
    756             log_msg(2,
    757                     "NB: CDROM device not mounted, mounting...");
    758             run_program_and_log_output("mount /dev/cdrom "
    759                                        MNT_CDROM, 1);
    760         }
    761         if (does_file_exist(MNT_CDROM "/archives/filelist.0")) {
    762             bkpinfo->backup_media_type = cdr;
    763             run_program_and_log_output("umount " MNT_CDROM, 1);
    764             log_it
    765                 ("Re-jigging configuration AGAIN. CD-R, not ISO.");
    766         }
    767     }
    768     mr_free(bkpinfo->prefix);
    769     if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
    770         mr_asprintf(bkpinfo->prefix, "%s", value);
     740if ((value = read_cfg_var(cfg_file, "backup-media-type")) == 0) {
     741    if (!strcmp(value, "cdstream")) {
     742        bkpinfo->backup_media_type = cdstream;
     743    } else if (!strcmp(value, "cdr")) {
     744        bkpinfo->backup_media_type = cdr;
     745    } else if (!strcmp(value, "cdrw")) {
     746        bkpinfo->backup_media_type = cdrw;
     747    } else if (!strcmp(value, "dvd")) {
     748        bkpinfo->backup_media_type = dvd;
     749    } else if (!strcmp(value, "usb")) {
     750        bkpinfo->backup_media_type = usb;
     751        bkpinfo->please_dont_eject = TRUE;
     752    } else if (!strcmp(value, "iso")) {
     753        // Patch by Conor Daly - 2004/07/12
     754        bkpinfo->backup_media_type = iso;
     755        if (am_I_in_disaster_recovery_mode()) {
     756            /* Check to see if CD is already mounted before mounting it... */
     757            if (!is_this_device_mounted("/dev/cdrom")) {
     758                log_msg(2, "NB: CDROM device not mounted, mounting...");
     759                run_program_and_log_output("mount /dev/cdrom " MNT_CDROM, 1);
     760            }
     761            if (does_file_exist(MNT_CDROM "/archives/filelist.0")) {
     762                bkpinfo->backup_media_type = cdr;
     763                run_program_and_log_output("umount " MNT_CDROM, 1);
     764                log_it
     765                    ("Re-jigging configuration AGAIN. CD-R, not ISO.");
     766            }
     767        }
     768        mr_free(bkpinfo->prefix);
     769        mr_free(value);
     770        if ((value = read_cfg_var(cfg_file, "iso-prefix")) == 0) {
     771            mr_asprintf(bkpinfo->prefix, "%s", value);
     772        } else {
     773            mr_asprintf(bkpinfo->prefix, "%s", STD_PREFIX);
     774        }
     775    } else if (!strcmp(value, "nfs")) {
     776        bkpinfo->backup_media_type = nfs;
     777        bkpinfo->please_dont_eject = TRUE;
     778        mr_free(bkpinfo->prefix);
     779        mr_free(value);
     780        if ((value = read_cfg_var(cfg_file, "iso-prefix")) == 0) {
     781            mr_asprintf(bkpinfo->prefix, "%s", value);
     782        } else {
     783            mr_asprintf(bkpinfo->prefix, "%s", STD_PREFIX);
     784        }
     785   
     786        if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "pxe")) {
     787            /* We need to override prefix value in PXE mode as it's
     788            * already done in start-nfs */
     789            envtmp1 = getenv("imgname");
     790            if (envtmp1 == NULL) {
     791                fatal_error("no imgname variable in environment");
     792            }
     793            mr_free(bkpinfo->prefix);
     794            mr_asprintf(bkpinfo->prefix, "%s", envtmp1);
     795        }
     796
     797    } else if (!strcmp(value, "tape")) {
     798        bkpinfo->backup_media_type = tape;
     799    } else if (!strcmp(value, "udev")) {
     800        bkpinfo->backup_media_type = udev;
    771801    } else {
    772         mr_asprintf(bkpinfo->prefix, "%s", STD_PREFIX);
    773     }
    774 } else if (!strcmp(value, "nfs")) {
    775     bkpinfo->backup_media_type = nfs;
    776     bkpinfo->please_dont_eject = TRUE;
    777     mr_free(bkpinfo->prefix);
    778     if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
    779         mr_asprintf(bkpinfo->prefix, "%s", value);
    780     } else {
    781         mr_asprintf(bkpinfo->prefix, "%s", STD_PREFIX);
    782     }
    783 
    784     if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "pxe")) {
    785         /* We need to override prefix value in PXE mode as it's
    786         * already done in start-nfs */
    787         envtmp1 = getenv("imgname");
    788         if (envtmp1 == NULL) {
    789             fatal_error("no imgname variable in environment");
    790         }
    791         mr_free(bkpinfo->prefix);
    792         mr_asprintf(bkpinfo->prefix, "%s", envtmp1);
    793     }
    794 
    795 } else if (!strcmp(value, "tape")) {
    796     bkpinfo->backup_media_type = tape;
    797 } else if (!strcmp(value, "udev")) {
    798     bkpinfo->backup_media_type = udev;
     802        fatal_error("UNKNOWN bkp-media-type");
     803    }
    799804} else {
    800     fatal_error("UNKNOWN bkp-media-type");
    801 }
    802 } else {
    803 fatal_error("backup-media-type not specified!");
    804 }
     805    fatal_error("backup-media-type not specified!");
     806}
     807mr_free(value);
     808
    805809if (bkpinfo->disaster_recovery) {
    806810    if (bkpinfo->backup_media_type == cdstream) {
    807         sprintf(bkpinfo->media_device, "/dev/cdrom");
    808 //          bkpinfo->media_size[0] = -1;
     811        mr_free(bkpinfo->media_device);
     812        mr_asprintf(bkpinfo->media_device, "/dev/cdrom");
    809813        bkpinfo->media_size[0] = 1999 * 1024;
    810814        bkpinfo->media_size[1] = 650;   /* good guess */
    … …  
    812816        envtmp1 = getenv("MRUSBDEV");
    813817        if (envtmp1 == NULL) {
    814             if (read_cfg_var(cfg_file, "usb-dev", value)) {
     818            if ((value = read_cfg_var(cfg_file, "usb-dev")) == NULL) {
    815819                fatal_error("Cannot get USB device name from cfg file");
    816820            }
    817821        } else {
    818             strcpy(value,envtmp1);
    819         }
    820         sprintf(bkpinfo->media_device, "%s1", value);
     822            mr_asprintf(value,"%s", envtmp1);
     823        }
     824        mr_free(bkpinfo->media_device);
     825        mr_asprintf(bkpinfo->media_device, "%s1", value);
     826        mr_free(value);
    821827        log_msg(2, "Backup medium is USB --- dev=%s", bkpinfo->media_device);
    822     } else if (bkpinfo->backup_media_type == tape
    823             || bkpinfo->backup_media_type == udev) {
    824         if (read_cfg_var(cfg_file, "media-dev", value)) {
     828    } else if (bkpinfo->backup_media_type == tape || bkpinfo->backup_media_type == udev) {
     829        if ((value = read_cfg_var(cfg_file, "media-dev")) == NULL) {
    825830            fatal_error("Cannot get tape device name from cfg file");
    826831        }
    827         strcpy(bkpinfo->media_device, value);
    828         read_cfg_var(cfg_file, "media-size", value);
    829         bkpinfo->media_size[1] = atol(value);
     832        mr_free(bkpinfo->media_device);
     833        bkpinfo->media_device = value;
     834
     835        value = read_cfg_var(cfg_file, "media-size");
     836        if (value != NULL) {
     837            bkpinfo->media_size[1] = atol(value);
     838            mr_free(value);
     839        } else {
     840            bkpinfo->media_size[1] = 0L;
     841        }
    830842        log_msg(2, "Backup medium is TAPE --- dev=%s", bkpinfo->media_device);
    831843    } else {
    832         strcpy(bkpinfo->media_device, "/dev/cdrom");    /* we don't really need this var */
     844        mr_free(bkpinfo->media_device);
     845        mr_asprintf(bkpinfo->media_device, "/dev/cdrom");   /* we don't really need this var */
    833846        bkpinfo->media_size[0] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
    834847        bkpinfo->media_size[1] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
    … …  
    836849    }
    837850} else {
    838     log_msg(2,
    839         "Not in Disaster Recovery Mode. No need to derive device name from config file.");
    840 }
    841 
    842 read_cfg_var(cfg_file, "use-star", value);
    843 if (strstr(value, "yes")) {
     851    log_msg(2, "Not in Disaster Recovery Mode. No need to derive device name from config file.");
     852}
     853
     854value = read_cfg_var(cfg_file, "use-star");
     855if (value && strstr(value, "yes")) {
    844856    bkpinfo->use_star = TRUE;
    845857    log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
    846858}
    847 
    848 read_cfg_var(cfg_file, "obdr", value);
    849 if (strstr(value, "TRUE")) {
     859mr_free(value);
     860
     861value = read_cfg_var(cfg_file, "obdr");
     862if (value && strstr(value, "TRUE")) {
    850863    bkpinfo->use_obdr = TRUE;
    851864    log_msg(1, "OBDR mode activated");
    852865}
    853 
    854 read_cfg_var(cfg_file, "acl", value);
    855 if (strstr(value, "TRUE")) {
     866mr_free(value);
     867
     868value = read_cfg_var(cfg_file, "acl");
     869if (value && strstr(value, "TRUE")) {
    856870    mr_asprintf(g_getfacl,"setfacl");
    857871    log_msg(1, "We will restore ACLs");
    … …  
    860874    }
    861875}
    862 read_cfg_var(cfg_file, "xattr", value);
    863 if (strstr(value, "TRUE")) {
     876mr_free(value);
     877
     878value = read_cfg_var(cfg_file, "xattr");
     879if (value && strstr(value, "TRUE")) {
    864880    mr_asprintf(g_getfattr,"setfattr");
    865881    log_msg(1, "We will restore XATTRs");
    … …  
    868884    }
    869885}
    870 
    871 if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
    872 bkpinfo->internal_tape_block_size = atol(value);
    873 log_msg(1, "Internal tape block size has been custom-set to %ld",
    874         bkpinfo->internal_tape_block_size);
     886mr_free(value);
     887
     888value = read_cfg_var(cfg_file, "internal-tape-block-size");
     889if (value != NULL) {
     890    bkpinfo->internal_tape_block_size = atol(value);
    875891} else {
    876 bkpinfo->internal_tape_block_size =
    877     DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
    878 log_msg(1, "Internal tape block size = default (%ld)",
    879         DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
    880 }
    881 
    882 read_cfg_var(cfg_file, "use-lzo", value);
    883 if (strstr(value, "yes")) {
    884 bkpinfo->use_lzo = TRUE;
    885 bkpinfo->use_gzip = FALSE;
    886 strcpy(bkpinfo->zip_exe, "lzop");
    887 strcpy(bkpinfo->zip_suffix, "lzo");
    888 } else {
    889 read_cfg_var(cfg_file, "use-gzip", value);
    890 if (strstr(value, "yes")) {
     892    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
     893}
     894log_msg(1, "Internal tape block size set to %ld", bkpinfo->internal_tape_block_size);
     895mr_free(value);
     896
     897bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
     898value = read_cfg_var(cfg_file, "use-lzo");
     899if (value && strstr(value, "yes")) {
     900    bkpinfo->use_lzo = TRUE;
     901    bkpinfo->use_gzip = FALSE;
     902    strcpy(bkpinfo->zip_exe, "lzop");
     903    strcpy(bkpinfo->zip_suffix, "lzo");
     904}
     905mr_free(value);
     906
     907value = read_cfg_var(cfg_file, "use-gzip");
     908if (value && strstr(value, "yes")) {
    891909    bkpinfo->use_lzo = FALSE;
    892910    bkpinfo->use_gzip = TRUE;
    893911    strcpy(bkpinfo->zip_exe, "gzip");
    894912    strcpy(bkpinfo->zip_suffix, "gz");
     913}
     914mr_free(value);
     915
     916value = read_cfg_var(cfg_file, "use-comp");
     917if (value && strstr(value, "yes")) {
     918    bkpinfo->use_lzo = FALSE;
     919    bkpinfo->use_gzip = FALSE;
     920    strcpy(bkpinfo->zip_exe, "bzip2");
     921    strcpy(bkpinfo->zip_suffix, "bz2");
     922}
     923mr_free(value);
     924
     925value = read_cfg_var(cfg_file, "differential");
     926if (value && (!strcmp(value, "yes") || !strcmp(value, "1"))) {
     927    bkpinfo->differential = TRUE;
     928}
     929log_msg(2, "differential var = '%s'", value);
     930mr_free(value);
     931if (bkpinfo->differential) {
     932    log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
    895933} else {
    896     read_cfg_var(cfg_file, "use-comp", value);
    897     if (strstr(value, "yes")) {
    898         bkpinfo->use_lzo = FALSE;
    899         bkpinfo->use_gzip = FALSE;
    900         strcpy(bkpinfo->zip_exe, "bzip2");
    901         strcpy(bkpinfo->zip_suffix, "bz2");
    902     } else {
    903         bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
    904     }
    905 }
    906 }
    907 
    908 value[0] = '\0';
    909 read_cfg_var(cfg_file, "differential", value);
    910 if (!strcmp(value, "yes") || !strcmp(value, "1")) {
    911 bkpinfo->differential = TRUE;
    912 }
    913 log_msg(2, "differential var = '%s'", value);
    914 if (bkpinfo->differential) {
    915 log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
    916 } else {
    917 log_msg(2, "This is a regular (full) backup");
    918 }
    919 
    920 read_cfg_var(g_mondo_cfg_file, "please-dont-eject", tmp);
    921 if (tmp[0] || strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "donteject")) {
     934    log_msg(2, "This is a regular (full) backup");
     935}
     936
     937tmp = read_cfg_var(g_mondo_cfg_file, "please-dont-eject");
     938if (tmp || strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "donteject")) {
    922939    bkpinfo->please_dont_eject = TRUE;
    923940    log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
    924941}
     942mr_free(tmp);
    925943
    926944if (bkpinfo->backup_media_type == nfs) {
    927945    if (!cfgf) {
    928         log_msg(2, "nfs_mount remains %s", bkpinfo->nfs_mount);
    929         log_msg(2, "nfs_remote_dir remains %s",
    930                 bkpinfo->nfs_remote_dir);
    931         log_msg(2,
    932                 "...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
     946        if (bkpinfo->nfs_mount) {
     947            log_msg(2, "nfs_mount remains %s", bkpinfo->nfs_mount);
     948        }
     949        if (bkpinfo->nfs_remote_dir) {
     950            log_msg(2, "nfs_remote_dir remains %s", bkpinfo->nfs_remote_dir);
     951        }
     952        log_msg(2, "...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
    933953    } else {
    934         read_cfg_var(g_mondo_cfg_file, "nfs-server-mount",
    935                     bkpinfo->nfs_mount);
    936         read_cfg_var(g_mondo_cfg_file, "nfs-server-path",
    937                     bkpinfo->nfs_remote_dir);
    938         log_msg(2, "nfs_mount is %s", bkpinfo->nfs_mount);
    939         log_msg(2, "nfs_remote_dir is %s", bkpinfo->nfs_remote_dir);
    940     }
    941     if (strstr(call_program_and_get_last_line_of_output
    942         ("cat /proc/cmdline"), "pxe")) {
     954        mr_free(bkpinfo->nfs_mount);
     955        bkpinfo->nfs_mount = read_cfg_var(g_mondo_cfg_file, "nfs-server-mount");
     956
     957        mr_free(bkpinfo->nfs_remote_dir);
     958        bkpinfo->nfs_remote_dir = read_cfg_var(g_mondo_cfg_file, "nfs-server-path");
     959
     960        if (bkpinfo->nfs_mount != NULL) {
     961            log_msg(2, "nfs_mount is %s", bkpinfo->nfs_mount);
     962        }
     963        if (bkpinfo->nfs_remote_dir != NULL) {
     964            log_msg(2, "nfs_remote_dir is %s", bkpinfo->nfs_remote_dir);
     965        }
     966    }
     967    if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "pxe")) {
    943968        /* We need to override values in PXE mode as it's
    944969        * already done in start-nfs */
    … …  
    951976            fatal_error("no dirimg variable in environment");
    952977        }
    953         strcpy(bkpinfo->nfs_mount,envtmp1);
    954         strcpy(bkpinfo->nfs_remote_dir,envtmp2);
     978        mr_free(bkpinfo->nfs_mount);
     979        mr_asprintf(bkpinfo->nfs_mount, "%s", envtmp1);
     980
     981        mr_free(bkpinfo->nfs_remote_dir);
     982        mr_asprintf(bkpinfo->nfs_remote_dir, "%s", envtmp2);
    955983    }
    956984} else if (bkpinfo->backup_media_type == iso) {
    … …  
    960988    */
    961989    mr_asprintf(old_isodir, "%s", bkpinfo->isodir);
    962     read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
    963     read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
     990    iso_mnt = read_cfg_var(g_mondo_cfg_file, "iso-mnt");
     991    iso_path = read_cfg_var(g_mondo_cfg_file, "isodir");
    964992    mr_free(bkpinfo->isodir);
    965993    mr_asprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
     994    mr_free(iso_mnt);
     995
    966996    if (!bkpinfo->isodir[0]) {
    967997        mr_free(bkpinfo->isodir);
    … …  
    9791009        }
    9801010    }
    981     read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
     1011    mr_free(g_isodir_device);
     1012    g_isodir_device = read_cfg_var(g_mondo_cfg_file, "iso-dev");
    9821013    log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir, g_isodir_device);
    9831014
    … …  
    9891020            log_it("command = %s", command);
    9901021            log_it("res of it = %s", call_program_and_get_last_line_of_output(command));
    991             sprintf(iso_mnt, "%s", call_program_and_get_last_line_of_output(command));
     1022            mr_asprintf(iso_mnt, "%s", call_program_and_get_last_line_of_output(command));
    9921023            mr_free(command);
    9931024        } else {
    994             sprintf(iso_mnt, "/tmp/isodir");
     1025            mr_asprintf(iso_mnt, "/tmp/isodir");
    9951026            mr_asprintf(tmp1, "mkdir -p %s", iso_mnt);
    9961027            run_program_and_log_output(tmp1, 5);
    … …  
    9991030            mr_asprintf(tmp1, "mount %s %s", g_isodir_device, iso_mnt);
    10001031            if (run_program_and_log_output(tmp1, 3)) {
    1001                 log_msg(1,
    1002                         "Unable to mount isodir. Perhaps this is really a CD backup?");
     1032                log_msg(1, "Unable to mount isodir. Perhaps this is really a CD backup?");
    10031033                bkpinfo->backup_media_type = cdr;
    1004                 strcpy(bkpinfo->media_device, "/dev/cdrom");    /* superfluous */
    1005                 iso_mnt[0] = iso_path[0] = '\0';
     1034                mr_free(bkpinfo->media_device);
     1035                mr_asprintf(bkpinfo->media_device, "/dev/cdrom");   /* superfluous */
    10061036                if (mount_media()) {
    10071037                    mr_free(tmp1);
    … …  
    10191049            bkpinfo->isodir = tmp1;
    10201050        }
    1021     }
     1051        mr_free(iso_mnt);
     1052    }
     1053    mr_free(iso_path);
    10221054}
    10231055
    … …  
    10411073paranoid_free(value);
    10421074paranoid_free(tmp);
    1043 paranoid_free(iso_mnt);
    1044 paranoid_free(iso_path);
    10451075return (0);
    10461076
    … …  
    13161346
    13171347  /** malloc *******/
    1318     char *device;
    1319     char *name;
     1348    char *device = NULL;
     1349    char *name = NULL;
    13201350    char *cmd = NULL;
    1321 
    1322     malloc_string(device);
    1323     malloc_string(name);
    13241351
    13251352    /* In order to have a working bootloader, we need to have all devices
    … …  
    13371364    backup_crucial_file(MNT_RESTORING, "/boot/grub/device.map");
    13381365    backup_crucial_file(MNT_RESTORING, "/etc/mtab");
    1339     read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
    1340     read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
     1366    device = read_cfg_var(g_mondo_cfg_file, "bootloader.device");
     1367    name = read_cfg_var(g_mondo_cfg_file, "bootloader.name");
    13411368    log_msg(2, "run_boot_loader: device='%s', name='%s'", device, name);
    13421369    system("sync");
    … …  
    13751402    }
    13761403#endif
     1404    mr_free(device);
     1405    mr_free(name);
     1406
    13771407    retval += res;
    13781408    if (res) {
    … …  
    13811411        log_to_screen("Your boot loader ran OK");
    13821412    }
    1383     paranoid_free(device);
    1384     paranoid_free(name);
    13851413    return (retval);
    13861414}
    … …  
    18491877    malloc_string(g_mountlist_fname);
    18501878    malloc_string(g_mondo_home);
    1851     malloc_string(g_isodir_device);
    18521879
    18531880    sprintf(g_biggielist_txt, "%s/%s", bkpinfo->tmpdir, BIGGIELIST_TXT_STUB);
    … …  
    21802207            run_program_and_log_output("mkdir -p tmp", FALSE);
    21812208
    2182             if (strlen(bkpinfo->media_device) == 0) {
    2183                 strcpy(bkpinfo->media_device, "/dev/st0");
    2184                 log_msg(2, "media_device is blank; assuming %s");
     2209            if (! bkpinfo->media_device) {
     2210                mr_asprintf(bkpinfo->media_device, "/dev/st0");
     2211                log_msg(2, "media_device is blank; assuming %s", bkpinfo->media_device);
    21852212            }
    21862213            mr_asprintf(tmp, "%s", bkpinfo->media_device);
    21872214            if (extract_cfg_file_and_mountlist_from_tape_dev (bkpinfo->media_device)) {
    2188                 strcpy(bkpinfo->media_device, "/dev/st0");
     2215                mr_free(bkpinfo->media_device);
     2216                mr_asprintf(bkpinfo->media_device, "/dev/st0");
    21892217                if (extract_cfg_file_and_mountlist_from_tape_dev (bkpinfo->media_device)) {
    2190                     strcpy(bkpinfo->media_device, "/dev/osst0");
     2218                    mr_free(bkpinfo->media_device);
     2219                    mr_asprintf(bkpinfo->media_device, "/dev/osst0");
    21912220                    if (extract_cfg_file_and_mountlist_from_tape_dev (bkpinfo->media_device)) {
    2192                         strcpy(bkpinfo->media_device, "/dev/ht0");
     2221                        mr_free(bkpinfo->media_device);
     2222                        mr_asprintf(bkpinfo->media_device, "/dev/ht0");
    21932223                        if (extract_cfg_file_and_mountlist_from_tape_dev (bkpinfo->media_device)) {
    21942224                            log_msg(3, "I tried lots of devices but none worked.");
    2195                             strcpy(bkpinfo->media_device, tmp);
     2225                            mr_free(bkpinfo->media_device);
     2226                            mr_asprintf(bkpinfo->media_device, "%s", tmp);
    21962227                        }
    21972228                    }

  • branches/2.2.10/mondo/src/mondorestore/mondorestore.c

    r2324 r2325  
    969969        interactively_obtain_media_parameters_from_user(FALSE);
    970970    }
    971     log_msg(2, "bkpinfo->media_device = %s", bkpinfo->media_device);
    972     if (!bkpinfo->media_device[0]) {
    973         log_msg(2, "Warning - failed to find media dev");
     971    if (!bkpinfo->media_device) {
     972        log_msg(2, "WARNING: failed to find media dev");
     973    } else {
     974        log_msg(2, "bkpinfo->media_device = %s", bkpinfo->media_device);
    974975    }
    975976
    … …  
    19992000    long noof_biggiefiles, bigfileno = 0, total_slices;
    20002001  /** malloc **/
    2001     char *tmp;
    20022002    char *tmp1 = NULL;
    20032003    char *mds = NULL;
    … …  
    20092009    FILE *fbw = NULL;
    20102010
    2011     malloc_string(tmp);
    20122011    malloc_string(pathname_of_last_biggie_restored);
    20132012    assert(bkpinfo != NULL);
    … …  
    20182017    }
    20192018
    2020     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
    2021     total_slices = atol(tmp);
     2019    tmp1 = read_cfg_var(g_mondo_cfg_file, "total-slices");
     2020    total_slices = atol(tmp1);
     2021    mr_free(tmp1);
     2022
    20222023    mr_asprintf(tmp1, "Reassembling large files      ");
    20232024    mvaddstr_and_log_it(g_currentY, 0, tmp1);
    … …  
    21082109        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    21092110    }
    2110     paranoid_free(tmp);
    21112111    paranoid_free(pathname_of_last_biggie_restored);
    21122112    return (retval);
    … …  
    21382138    long max_val;
    21392139  /**malloc ***/
    2140     char *tmp = NULL;
    21412140    char *mds = NULL;
    21422141    char *tmp1 = NULL;
    … …  
    21452144    char *comment;
    21462145
    2147     malloc_string(tmp);
    21482146    malloc_string(comment);
    21492147
    … …  
    21572155    }
    21582156    insist_on_this_cd_number(g_current_media_number);
    2159     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
    2160     max_val = atol(tmp) + 1;
    2161     paranoid_free(tmp);
     2157    tmp1 = read_cfg_var(g_mondo_cfg_file, "last-filelist-number");
     2158    max_val = atol(tmp1) + 1;
     2159    mr_free(tmp1);
    21622160
    21632161    mds = media_descriptor_string(bkpinfo->backup_media_type);
    … …  
    22782276
    22792277  /** malloc add ****/
    2280     char *tmp;
    2281     char *tmp1;
     2278    char *tmp1 = NULL;
    22822279    char *biggie_fname;
    22832280    char *biggie_cksum;
    … …  
    22902287    FILE *fbw = NULL;
    22912288
    2292     malloc_string(tmp);
    22932289    malloc_string(biggie_fname);
    22942290    malloc_string(biggie_cksum);
    … …  
    22962292    assert(bkpinfo != NULL);
    22972293
    2298     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
    2299 
    2300     total_slices = atol(tmp);
     2294    tmp1 = read_cfg_var(g_mondo_cfg_file, "total-slices");
     2295    total_slices = atol(tmp1);
     2296    mr_free(tmp1);
     2297
    23012298    if (g_getfattr) {
    23022299        mr_asprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    … …  
    24082405    paranoid_free(biggie_fname);
    24092406    paranoid_free(biggie_cksum);
    2410     paranoid_free(tmp);
    24112407    return (retval);
    24122408}
    … …  
    24532449    assert(bkpinfo != NULL);
    24542450    mvaddstr_and_log_it(g_currentY, 0, "Restoring from archives");
    2455     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     2451    tmp = read_cfg_var(g_mondo_cfg_file, "last-filelist-number");
    24562452    max_val = atol(tmp) + 1;
     2453    mr_free(tmp);
    24572454
    24582455    chdir(bkpinfo->restore_path);   /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
    … …  
    25952592            openin_cdstream();
    25962593        } else {
    2597             assert_string_is_neither_NULL_nor_zerolength(bkpinfo->media_device);
    25982594            openin_tape();
    25992595        }
    … …  
    29332929        // BCO:To be reviewed
    29342930        if ((bkpinfo->restore_mode == compare) || (bkpinfo->restore_mode == nuke)) {
    2935             if (bkpinfo->backup_media_type == nfs
    2936                 && !is_this_device_mounted(bkpinfo->nfs_mount)) {
     2931            if (bkpinfo->backup_media_type == nfs && bkpinfo->nfs_mount && !is_this_device_mounted(bkpinfo->nfs_mount)) {
    29372932                log_msg(1, "Mounting nfs dir");
    29382933                mr_free(bkpinfo->isodir);

  • branches/2.2.10/mondo/src/mondorestore/mr-externs.h

    r2321 r2325  
    6262extern void setup_newt_stuff(void);
    6363extern void init_bkpinfo();
    64 extern int read_cfg_var(char *, char *, char *);
     64extern char *read_cfg_var(char *, char *);
    6565extern int read_file_from_stream_to_file(char *,
    6666                                         long long);
Note: See TracChangeset for help on using the changeset viewer.