Changeset 2327 in MondoRescue for branches/2.2.10/mondo/src/common


Ignore:
Timestamp:
Aug 18, 2009, 3:20:37 PM (16 years ago)
Author:
Bruno Cornec
Message:

r3338@localhost: bruno | 2009-08-11 23:03:30 +0200
bkpinfo->zip_suffix, bkpinfo->image_devs and bkpinfo->restore_path are now allocated dynmically

Location:
branches/2.2.10/mondo/src/common
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/2.2.10/mondo/src/common/libmondo-archive.c

    r2326 r2327  
    28732873    biggiestruct.use_ntfsprog = use_ntfsprog;
    28742874    optimal_set_size = bkpinfo->optimal_set_size;
    2875     if (is_this_file_compressed(biggie_filename)
    2876         || bkpinfo->compression_level == 0) {
     2875    if (is_this_file_compressed(biggie_filename) || bkpinfo->compression_level == 0) {
    28772876        mr_asprintf(suffix, "%s", "");
    2878         //      log_it("%s is indeed compressed :-)", filename);
    28792877        should_I_compress_slices = FALSE;
    28802878    } else {

  • branches/2.2.10/mondo/src/common/libmondo-cli.c

    r2326 r2327  
    11701170
    11711171    if (flag_set['x']) {
    1172         strncpy(bkpinfo->image_devs, flag_val['x'], MAX_STR_LEN / 4);
     1172        mr_asprintf(bkpinfo->image_devs, flag_val['x']);
    11731173        if ((run_program_and_log_output("which ntfsclone", 2)) && (! bkpinfo->restore_data)) {
    11741174            fatal_error("Please install ntfsprogs package/tarball.");

  • branches/2.2.10/mondo/src/common/libmondo-devices.c

    r2326 r2327  
    18941894                finish(1);
    18951895            }
    1896             strncpy(bkpinfo->image_devs, p, MAX_STR_LEN / 4);
    1897             mr_free(p);
     1896            mr_free(bkpinfo->image_devs);
     1897            bkpinfo->image_devs = p;
    18981898        }
    18991899
    … …  
    19731973    log_it("media size = %ld", bkpinfo->media_size[1]);
    19741974    log_it("media type = %s", bkptype_to_string(bkpinfo->backup_media_type));
    1975     log_it("prefix = %s", bkpinfo->prefix);
     1975    if (bkpinfo->prefix) {
     1976        log_it("prefix = %s", bkpinfo->prefix);
     1977    }
    19761978    log_it("compression = %ld", bkpinfo->compression_level);
    1977     log_it("include_paths = '%s'", bkpinfo->include_paths);
    1978     log_it("exclude_paths = '%s'", bkpinfo->exclude_paths);
     1979    if (bkpinfo->include_paths) {
     1980        log_it("include_paths = '%s'", bkpinfo->include_paths);
     1981    }
     1982    if (bkpinfo->exclude_paths) {
     1983        log_it("exclude_paths = '%s'", bkpinfo->exclude_paths);
     1984    }
    19791985    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
    19801986    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
    1981     log_it("image_devs = '%s'", bkpinfo->image_devs);
     1987    if (bkpinfo->image_devs) {
     1988        log_it("image_devs = '%s'", bkpinfo->image_devs);
     1989    }
    19821990    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device, bkpinfo->boot_loader);
    19831991    if (bkpinfo->media_size[0] < 0) {

  • branches/2.2.10/mondo/src/common/libmondo-filelist.c

    r2325 r2327  
    8787
    8888    /*@ pointers ********************** */
    89     char *ptr;
     89    char *ptr = NULL;
    9090    FILE *fout;
    9191
    … …  
    117117    mr_free(tempfile);
    118118
    119     log_it(bkpinfo->image_devs);
    120 
    121     ptr = bkpinfo->image_devs;
    122 
    123     malloc_string(dev);
    124     while (ptr && *ptr) {
    125         strcpy(dev, ptr);
    126         log_it("Examining imagedev %s", dev);
    127         for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
    128         dev[i] = '\0';
    129         if (!strlen(dev)) {
    130             continue;
    131         }
    132         fprintf(fout, "%s\n", dev);
    133         log_it("Adding '%s' to biggielist", dev);
    134         if ((ptr = strchr(ptr, ' '))) {
    135             ptr++;
     119    if (bkpinfo->image_devs) {
     120        log_it("image_devs : %s", bkpinfo->image_devs);
     121
     122        ptr = bkpinfo->image_devs;
     123
     124        while (ptr && *ptr) {
     125            mr_asprintf(dev, "%s", ptr);
     126            log_it("Examining imagedev %s", dev);
     127            for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
     128            dev[i] = '\0';
     129            if (!strlen(dev)) {
     130                mr_free(dev);
     131                continue;
     132            }
     133            fprintf(fout, "%s\n", dev);
     134            log_it("Adding '%s' to biggielist", dev);
     135            if ((ptr = strchr(ptr, ' '))) {
     136                ptr++;
     137            }
     138            mr_free(dev);
    136139        }
    137140    }
    … …  
    139142    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    140143
    141     paranoid_free(dev);
    142144    return (retval);
    143145}
    144 
    145146
    146147

  • branches/2.2.10/mondo/src/common/libmondo-files.c

    r2325 r2327  
    12651265        mr_asprintf(tmp, "Your backup will occupy approximately %s media.", number_to_text((int) (scratchLL + 1)));
    12661266    }
    1267     if (!bkpinfo->image_devs[0] && (scratchLL < 50)) {
     1267    if (scratchLL < 50) {
    12681268        log_to_screen(tmp);
    12691269    }

  • branches/2.2.10/mondo/src/common/libmondo-tools.c

    r2326 r2327  
    479479    if (bkpinfo->use_lzo) {
    480480        mr_asprintf(bkpinfo->zip_exe, "lzop");
    481         strcpy(bkpinfo->zip_suffix, "lzo");
     481        mr_asprintf(bkpinfo->zip_suffix, "lzo");
    482482    } else if (bkpinfo->use_gzip) {
    483483        mr_asprintf(bkpinfo->zip_exe, "gzip");
    484         strcpy(bkpinfo->zip_suffix, "gz");
     484        mr_asprintf(bkpinfo->zip_suffix, "gz");
    485485    } else if (bkpinfo->compression_level != 0) {
    486486        mr_asprintf(bkpinfo->zip_exe, "bzip2");
    487         strcpy(bkpinfo->zip_suffix, "bz2");
     487        mr_asprintf(bkpinfo->zip_suffix, "bz2");
     488    } else {
     489        mr_asprintf(bkpinfo->zip_exe, "none");
     490        mr_asprintf(bkpinfo->zip_suffix, "");
    488491    }
    489492
    … …  
    798801    mr_free(bkpinfo->boot_device);
    799802    mr_free(bkpinfo->zip_exe);
     803    mr_free(bkpinfo->zip_suffix);
     804    mr_free(bkpinfo->image_devs);
    800805    mr_free(bkpinfo->isodir);
    801806    mr_free(bkpinfo->prefix);
    … …  
    804809    mr_free(bkpinfo->include_paths);
    805810    mr_free(bkpinfo->exclude_paths);
     811    mr_free(bkpinfo->restore_path);
    806812    mr_free(bkpinfo->nfs_mount);
    807813    mr_free(bkpinfo->nfs_remote_dir);
    … …  
    829835    bkpinfo->boot_device = NULL;
    830836    bkpinfo->zip_exe = NULL;
    831     bkpinfo->zip_suffix[0] = '\0';
    832     bkpinfo->image_devs[0] = '\0';
     837    bkpinfo->zip_suffix = NULL;
     838    bkpinfo->image_devs = NULL;
    833839    bkpinfo->compression_level = 3;
    834840    bkpinfo->use_lzo = FALSE;
    … …  
    853859    bkpinfo->include_paths = NULL;
    854860    bkpinfo->exclude_paths = NULL;
    855     bkpinfo->restore_path[0] = '\0';
     861    bkpinfo->restore_path = NULL;
    856862    bkpinfo->call_before_iso[0] = '\0';
    857863    bkpinfo->call_make_iso[0] = '\0';

  • branches/2.2.10/mondo/src/common/libmondo-verify.c

    r2326 r2327  
    5555    assert(bkpinfo != NULL);
    5656    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
    57     sprintf(output, "%s/archives/%d.star.%s", mountpoint, setno,
    58             bkpinfo->zip_suffix);
     57    sprintf(output, "%s/archives/%d.star.%s", mountpoint, setno, bkpinfo->zip_suffix);
    5958    if (!does_file_exist(output)) {
    60         sprintf(output, "%s/archives/%d.afio.%s", mountpoint, setno,
    61                 bkpinfo->zip_suffix);
     59        sprintf(output, "%s/archives/%d.afio.%s", mountpoint, setno, bkpinfo->zip_suffix);
    6260    }
    6361    return (output);
    … …  
    216214    char *command = NULL;
    217215    char *mds = NULL;
    218     char *sz_exe;
     216    char *sz_exe = NULL;
    219217    static char *bufblkA = NULL;
    220218    static char *bufblkB = NULL;
    … …  
    237235    int retval = 0;
    238236
    239     malloc_string(sz_exe);
    240237    if (!bufblkA) {
    241238        if (!(bufblkA = malloc(maxbufsize))) {
    … …  
    254251    if (bkpinfo->compression_level > 0) {
    255252        if (bkpinfo->use_lzo) {
    256             strcpy(sz_exe, "lzop");
     253            mr_asprintf(sz_exe, "lzop");
    257254        } else if (bkpinfo->use_gzip) {
    258             strcpy(sz_exe, "gzip");
     255            mr_asprintf(sz_exe, "gzip");
    259256        } else {
    260             strcpy(sz_exe, "bzip2");
    261         }
    262     } else {
    263         sz_exe[0] = '\0';
     257            mr_asprintf(sz_exe, "bzip2");
     258        }
    264259    }
    265260
    … …  
    289284        // handle slices until end of CD
    290285        if (slice_num == 0) {
    291             log_msg(2, "ISO=%d  bigfile=%ld --START--",
    292                     g_current_media_number, bigfile_num);
     286            log_msg(2, "ISO=%d  bigfile=%ld --START--", g_current_media_number, bigfile_num);
    293287            if (! (fin = fopen(slice_fname(bigfile_num, slice_num, mountpoint, ""), "r"))) {
    294288                log_msg(2, "Cannot open bigfile's info file");
    … …  
    299293                paranoid_fclose(fin);
    300294            }
    301             mr_asprintf(tmp, "%s/%s", bkpinfo->restore_path, biggiestruct.filename);
    302             log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
    303             forig = fopen(tmp, "r");
    304             mr_free(tmp);
    305 
    306             if (!forig) {
    307                 log_msg(2, "Failed to open bigfile. Darn.");
    308                 log_to_screen("%s/%s not found on live filesystem",
    309                             bkpinfo->restore_path,
    310                             biggiestruct.filename);
    311                 mr_asprintf(tmp, "echo \"%s/%s not found\" >> %s/biggies.changed", bkpinfo->restore_path, biggiestruct.filename, bkpinfo->tmpdir);
    312                 system(tmp);
     295            if (bkpinfo->restore_path) {
     296                mr_asprintf(tmp, "%s/%s", bkpinfo->restore_path, biggiestruct.filename);
     297                log_msg(2, "Opening biggiefile #%ld - '%s'", bigfile_num, tmp);
     298                forig = fopen(tmp, "r");
    313299                mr_free(tmp);
    314 
    315                 bigfile_num++;
    316                 slice_num = 0;
    317                 retval++;
     300   
     301                if (!forig) {
     302                    log_msg(2, "Failed to open bigfile. Darn.");
     303                    log_to_screen("%s/%s not found on live filesystem", bkpinfo->restore_path, biggiestruct.filename);
     304                    mr_asprintf(tmp, "echo \"%s/%s not found\" >> %s/biggies.changed", bkpinfo->restore_path, biggiestruct.filename, bkpinfo->tmpdir);
     305                    system(tmp);
     306                    mr_free(tmp);
     307
     308                    bigfile_num++;
     309                    slice_num = 0;
     310                    retval++;
     311                } else {
     312                    slice_num++;
     313                }
    318314            } else {
    319                 slice_num++;
     315                log_it("Unable to open bigfile as restore_path is NULL");
    320316            }
    321317        } else if (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, "")) &&
    … …  
    327323            slice_num = 0;
    328324        } else {
    329             log_msg(2, "ISO=%d  bigfile=%ld  slice=%ld",
    330                     g_current_media_number, bigfile_num, slice_num);
    331             if (!does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) {
     325            log_msg(2, "ISO=%d  bigfile=%ld  slice=%ld", g_current_media_number, bigfile_num, slice_num);
     326            if ((!does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, ""))) && (sz_exe != NULL)) {
    332327                mr_asprintf(command, "%s -dc %s 2>> %s", sz_exe, slice_fname(bigfile_num, slice_num, mountpoint, bkpinfo->zip_suffix), MONDO_LOGFILE);
    333328            } else {
    … …  
    376371    }
    377372    mr_free(mountpoint);
     373    mr_free(sz_exe);
     374
    378375    last_bigfile_num = bigfile_num;
    379376    last_slice_num = slice_num - 1;
    … …  
    388385        paranoid_free(bufblkB);
    389386    }
    390     paranoid_free(sz_exe);
    391387    return (0);
    392388}
    … …  
    435431        mr_free(bkpinfo->zip_exe);
    436432        mr_asprintf(bkpinfo->zip_exe, "lzop");
    437         strcpy(bkpinfo->zip_suffix, "lzo");
     433        mr_free(bkpinfo->zip_suffix);
     434        mr_asprintf(bkpinfo->zip_suffix, "lzo");
    438435        bkpinfo->use_lzo = TRUE;
    439436        bkpinfo->use_gzip = FALSE;
    … …  
    443440        mr_free(bkpinfo->zip_exe);
    444441        mr_asprintf(bkpinfo->zip_exe, "gzip");
    445         strcpy(bkpinfo->zip_suffix, "gz");
     442        mr_free(bkpinfo->zip_suffix);
     443        mr_asprintf(bkpinfo->zip_suffix, "gz");
    446444        bkpinfo->use_lzo = FALSE;
    447445        bkpinfo->use_gzip = TRUE;
    … …  
    451449        mr_free(bkpinfo->zip_exe);
    452450        mr_asprintf(bkpinfo->zip_exe, "bzip2");
    453         strcpy(bkpinfo->zip_suffix, "bz2");
     451        mr_free(bkpinfo->zip_suffix);
     452        mr_asprintf(bkpinfo->zip_suffix, "bz2");
    454453        bkpinfo->use_lzo = FALSE;
    455454        bkpinfo->use_gzip = FALSE;
     455    }
     456    if (bkpinfo->zip_exe == NULL) {
     457        mr_asprintf(bkpinfo->zip_exe, "none");
     458    }
     459    if (bkpinfo->zip_suffix == NULL) {
     460        mr_asprintf(bkpinfo->zip_suffix, "");
    456461    }
    457462    unlink(outlog);
    … …  
    686691 * Verify all afioballs from the opened tape/CD stream.
    687692 * @param bkpinfo The backup information structure. Fields used:
    688  * - @c bkpinfo->restore_path
    689693 * - @c bkpinfo->tmpdir
    690694 *
    … …  
    880884        mr_free(comment);
    881885
    882         mr_asprintf(logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
    883         res = verify_a_biggiefile_from_stream(logical_fname, size);
    884         mr_free(logical_fname);
    885 
    886         retval += res;
     886        if (bkpinfo->restore_path) {
     887            mr_asprintf(logical_fname, "%s/%s", bkpinfo->restore_path, orig_fname);
     888            res = verify_a_biggiefile_from_stream(logical_fname, size);
     889            mr_free(logical_fname);
     890            retval += res;
     891        } else {
     892            log_it("Unable to verify bigfile as restore_path is NULL");
     893        }
     894
    887895        current_biggiefile_number++;
    888896        g_current_progress++;

  • branches/2.2.10/mondo/src/common/mondostructures.h

    r2326 r2327  
    382382   * bz2, gzip uses gz, etc. Do not include the dot.
    383383   */
    384     char zip_suffix[MAX_STR_LEN / 4];
     384    char *zip_suffix;
    385385
    386386  /**
    … …  
    397397   * This is a useful feature, but use at your own risk.
    398398   */
    399     char image_devs[MAX_STR_LEN / 4];
     399    char *image_devs;
    400400
    401401  /**
    … …  
    519519   * without overwriting the old ones. Ignored during a backup.
    520520   */
    521     char restore_path[MAX_STR_LEN];
     521    char *restore_path;
    522522
    523523  /**
Note: See TracChangeset for help on using the changeset viewer.