Changeset 3161


Ignore:
Timestamp:
Jun 25, 2013, 10:53:14 PM (6 years ago)
Author:
bruno
Message:
  • Apply fixes to 3.1 tree so that at least mondo compiles again (but that branch probably doesn't work at all again).
Location:
branches/3.1/mondo
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • branches/3.1/mondo/src/common/libmondo-archive.c

    r3148 r3161  
    686686            fatal_error("The de facto standard location for your boot loader's config file is /boot/grub/menu.lst, /boot/grub/grub.cfg, or /boot/grub2/grub.cfg but I cannot find it there. What is wrong with your Linux distribution?");
    687687        }
    688         mr_asprintf(&bootldr_ver, "%s", call_program_and_get_last_line_of_output("grub --version"));
     688        mr_asprintf(bootldr_ver, "%s", call_program_and_get_last_line_of_output("grub --version", TRUE));
    689689    } else if (bkpinfo->boot_loader == 'E') {
    690690        mr_asprintf(bootldr_str, "ELILO");
     
    722722    log_to_screen("Your boot loader is %s and it boots from %s", bootldr_str, bkpinfo->boot_device);
    723723    if (bootldr_ver != NULL) {
    724         mr_asprintf(&tmp, "Boot loader version string: %s", bootldr_ver);
     724        mr_asprintf(tmp, "Boot loader version string: %s", bootldr_ver);
    725725        log_to_screen(tmp);
    726726        mr_free(tmp);
    727727    }
    728728    if (bootldr_ver != NULL) {
    729         mr_asprintf(&tmp, "Boot loader version string: %s", bootldr_ver);
     729        mr_asprintf(tmp, "Boot loader version string: %s", bootldr_ver);
    730730        log_to_screen(tmp);
    731731        mr_free(tmp);
     
    15901590    /*@ buffers ****************************************** */
    15911591    char *tmp = NULL;
     1592    char *tmp2 = NULL;
    15921593    char *old_pwd;
    15931594    char *result_sz = NULL;
     
    16141615    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s", bkpinfo->scratchdir, destfile);
    16151616    tmp2 = getcwd(old_pwd, MAX_STR_LEN - 1);
     1617    if (! tmp2) {
     1618        //FIXME
     1619    }
    16161620    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
    16171621    run_program_and_log_output(tmp, FALSE);
     
    17331737        mr_free(mds);
    17341738        if (find_home_of_exe("genisoimage")) {
    1735             mr_asprintf(&isofs_cmd, "%s", MONDO_GENISOIMAGE_CMD);
     1739            mr_asprintf(isofs_cmd, "%s", MONDO_GENISOIMAGE_CMD);
    17361740        } else {
    1737             mr_asprintf(&isofs_cmd, "%s", MONDO_MKISOFS_CMD);
     1741            mr_asprintf(isofs_cmd, "%s", MONDO_MKISOFS_CMD);
    17381742        }
    17391743        if (bkpinfo->nonbootable_backup) {
    17401744            log_msg(1, "Making nonbootable backup");
    17411745            mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS);
    1742             res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1746            res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
    17431747            mr_free(full_isofs_cmd);
    17441748        } else {
     
    17561760                log_msg(1, "IA64 --> elilo");
    17571761                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS_REGULAR_ELILO);
    1758                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1762                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
    17591763                mr_free(full_isofs_cmd);
    17601764#else
     
    17621766                mr_asprintf(full_isofs_cmd, "%s%s-b images/mindi-bootroot.2880.img -c boot.cat -o '_ISO_' -J -V _CD#_ .",isofs_cmd,MONDO_MKISOFS);
    17631767                    // FIXME: fixed boot size probably wrong. lilo to be removed
    1764                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1768                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
    17651769#endif
    17661770            } else {
     
    17681772                log_msg(1, "Isolinux");
    17691773                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS_REGULAR_SYSLINUX);
    1770                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1774                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
    17711775            }
    17721776            mr_free(full_isofs_cmd);
     
    18841888    /*@ pointers ******************************************* */
    18851889    FILE *fin = NULL;
    1886     char *q;
    1887     char *q;
    18881890
    18891891    /*@ buffers ******************************************** */
  • branches/3.1/mondo/src/common/libmondo-cli.c

    r3148 r3161  
    507507                    mr_asprintf(tmp1, "sshfs %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
    508508                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    509                     sprintf(tmp, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
     509                    mr_asprintf(tmp1, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
    510510                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    511                     sprintf(tmp, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
     511                    mr_asprintf(tmp1, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
    512512                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
    513513                    mr_asprintf(tmp1, "mount %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
     
    520520                    mr_asprintf(tmp1, "sshfs %s", bkpinfo->netfs_mount);
    521521                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    522                     sprintf(tmp, "mount -t cifs %s", bkpinfo->netfs_mount);
     522                    mr_asprintf(tmp1, "mount -t cifs %s", bkpinfo->netfs_mount);
    523523                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    524                     sprintf(tmp, "mount -t cifs %s", bkpinfo->netfs_mount);
     524                    mr_asprintf(tmp1, "mount -t cifs %s", bkpinfo->netfs_mount);
    525525                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
    526526                    mr_asprintf(tmp1, "mount %s", bkpinfo->netfs_mount);
  • branches/3.1/mondo/src/common/libmondo-devices.c

    r3148 r3161  
    330330    char *incoming = NULL;
    331331    char *searchstr = NULL;
    332     char *tmp = NULL;
    333     char *p;
    334     char *p;
    335332
    336333    /*@ ints ******************************************************* */
     
    339336    /*@ pointers *************************************************** */
    340337    FILE *fin;
    341 
    342338
    343339    /*@ end vars *************************************************** */
     
    354350    mr_free(program);
    355351    return (res);
    356 #else
    357     /* To avoid compiler warnings */
    358     tmp = NULL;
    359352#endif
    360353
     
    984977    char *command = NULL;
    985978    char *format_sz = NULL;
    986     char *p;
    987     char *p;
    988979
    989980    FILE *pin;
     
    20322023                    mr_strcat(bkpinfo->exclude_paths,"|%s",mounted_on_dsf);
    20332024                } else {
    2034                     mr_asprintf(&(bkpinfo->exclude_paths),"%s",mounted_on_dsf);
     2025                    mr_asprintf(bkpinfo->exclude_paths,"%s",mounted_on_dsf);
    20352026                }
    20362027                if (bkpinfo->exclude_devs) {
    20372028                    mr_strcat(bkpinfo->exclude_devs,"|%s",token);
    20382029                } else {
    2039                     mr_asprintf(&(bkpinfo->exclude_devs),"%s",token);
     2030                    mr_asprintf(bkpinfo->exclude_devs,"%s",token);
    20402031                }
    20412032            }
     
    20522043                    mr_strcat(bkpinfo->exclude_paths, "|%s",not_mounted_on_dsf);
    20532044                } else {
    2054                     mr_asprintf(&(bkpinfo->exclude_paths),"%s",not_mounted_on_dsf);
     2045                    mr_asprintf(bkpinfo->exclude_paths,"%s",not_mounted_on_dsf);
    20552046                }
    20562047            }
     
    20652056        /*  Adds a | to ensure correct detection even at both ends */
    20662057        mr_asprintf(tmp1,"|%s",token);
    2067         mr_asprintf(&tmp2,"|%s|",token);
     2058        mr_asprintf(tmp2,"|%s|",token);
    20682059        if (mode == 'E') {
    20692060            /*  Add the token if not already in the list */
     
    29842975
    29852976        }
    2986 <<<<<<< .courant
    29872977        p = popup_and_get_string("Network protocol", "Which Network protocol should I use (nfs/sshfs/smbfs) ?", bkpinfo->netfs_proto);
    29882978        if (p == NULL) {
     
    30062996            strcpy(tmp1, "");
    30072997        }
    3008         if (!popup_and_get_string
    3009             ("Network user", "Which user should I use if any ?",
    3010              tmp1, MAX_STR_LEN)) {
     2998        if (!popup_and_get_string("Network user", "Which user should I use if any ?",tmp1)) {
    30112999            log_to_screen("User has chosen not to backup the PC");
    30123000            finish(1);
     
    30143002        mr_free(bkpinfo->netfs_user);
    30153003        if (strcmp(tmp1, "") != 0) {
    3016             mr_asprintf(&(bkpinfo->netfs_user), "%s", tmp1);
     3004            mr_asprintf(bkpinfo->netfs_user, "%s", tmp1);
    30173005        }
    30183006   
  • branches/3.1/mondo/src/common/libmondo-filelist.c

    r3148 r3161  
    399399    char *tmp = NULL;
    400400
    401     char *p;
    402 
    403     char *p;
    404 
    405401    pattr = popen(syscall, "r");
    406402    if (!pattr) {
     
    434430    char *strtmp = NULL;
    435431    char *tmp = NULL;
    436     char *p = NULL;
    437432    int i;
    438433
     
    521516    int retval = 0;
    522517    int i;
    523     char *p, *q, *r;
     518    char *p, *q;
    524519    char *tmp = NULL;
    525520    FILE *pin, *pout, *faclin;
     
    14041399
    14051400            mr_asprintf(find_skeleton_marker, "mv -f %s.new %s", g_skeleton_filelist, g_skeleton_filelist);
    1406             (void)system(find_skeleton_marker);
     1401            if (system(find_skeleton_marker)) {
     1402                //FIXME
     1403            }
    14071404            time(&this_time);
    14081405            if (this_time != last_time) {
  • branches/3.1/mondo/src/common/libmondo-files.c

    r3148 r3161  
    5151    /*@ pointers **************************************************** */
    5252    char *p = NULL;
    53     char *q;
    54     char *q;
    5553    FILE *fin;
    5654
     
    128126    char *command = NULL;
    129127    char *incoming = NULL;
    130     char *q;
    131     char *q;
    132128
    133129    /*@ long ******************************************************** */
     
    208204    char *tmp = NULL;
    209205    char *incoming = NULL;
    210     char *q;
    211     char *q;
    212206
    213207    /*@ int ********************************************************* */
     
    477471    char *output = NULL;
    478472    char *command = NULL;
    479     char *p = NULL;
    480     char *p = NULL;
    481473
    482474    /*@ pointers **************************************************** */
     
    548540    char *curr_cksum = NULL;
    549541    char *tmp = NULL;
    550     char *q;
    551     char *q;
    552542
    553543    /*@ long [long] ************************************************* */
     
    689679    /*@ buffers **************************************************** */
    690680    char *incoming = NULL;
    691     char *p = NULL;
    692     char *p = NULL;
    693681
    694682    /*@ end vars *************************************************** */
     
    755743    char *tmp = NULL;
    756744    char *command = NULL;
    757     char *comment;
    758745
    759746    /*@ long ******************************************************** */
  • branches/3.1/mondo/src/common/libmondo-fork.c

    r3148 r3161  
    4242    char *newcall = NULL;
    4343    char *tmp = NULL;
    44     char *p;
    45     char *p;
    4644
    4745    /*@ pointers **************************************************** */
    4846    FILE *fin = NULL;
     47    int res = 0;
    4948
    5049    /*@******************************************************************** */
     
    6059    mr_asprintf(result, "");
    6160
    62     system(newcall);
     61    res = system(newcall);
     62    if (res != 0) {
     63        //FIXME
     64    }
    6365    mr_free(newcall);
    6466
  • branches/3.1/mondo/src/common/libmondo-mountlist.c

    r3147 r3161  
    805805    char *tmp = NULL;
    806806    char *p = NULL;
    807     char *q = NULL;
    808807
    809808    int items = 0;
  • branches/3.1/mondo/src/common/libmondo-raid.c

    r3147 r3161  
    430430    char *incoming = NULL;
    431431    char *p;
    432     char *q;
    433432
    434433    assert(fin != NULL);
     
    974973char type;
    975974char *strtmp = NULL;
    976 char *strtmp2 = NULL;
    977 
    978   // open file
    979   if (!(fin = fopen(MDSTAT_FILE, "r"))) {
    980     log_msg(1, "Could not open %s.\n", MDSTAT_FILE);
    981     return 1;
    982   }
    983   // initialise record, build progress and row counters
    984   raidlist->entries = 0;
    985   raidlist->el[raidlist->entries].progress = 999;
    986   row = 1;
    987   // skip first output row - contains registered RAID levels
    988   res = getline(&string, &len, fin);
    989   // parse the rest
    990   while ( !feof_unlocked(fin) ) {
    991     res = getline(&string, &len, fin);
    992     if (res <= 0) break;
    993     // trim leading spaces
    994     pos = string;
    995     while (*pos == ' ') pos += 1;
    996     mr_asprintf(strtmp, "%s", pos);
    997     strcpy(string, strtmp);
    998     mr_free(strtmp);
    999     // if we have newline after only spaces, this is a blank line, update
    1000     // counters, otherwise do normal parsing
    1001     if (*string == '\n') {
    1002       row = 1;
    1003       raidlist->entries++;
    1004       raidlist->el[raidlist->entries].progress = 999;
    1005     } else {
    1006       switch (row) {
    1007       case 1:  // device information
    1008     // check whether last line of record and if so skip
    1009     pos = strcasestr(string, "unused devices: ");
    1010     if (pos == string) {
    1011       //raidlist->entries--;
    1012       break;
    1013     }
    1014     // tokenise string
    1015     token = mr_strtok(string, delims, &lastpos);
    1016     // get RAID device name
    1017     mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1018     strcpy(raidlist->el[raidlist->entries].raid_device, strtmp);
     975
     976// open file
     977if (!(fin = fopen(MDSTAT_FILE, "r"))) {
     978    log_msg(1, "Could not open %s.\n", MDSTAT_FILE);
     979    return 1;
     980}
     981// initialise record, build progress and row counters
     982raidlist->entries = 0;
     983raidlist->el[raidlist->entries].progress = 999;
     984row = 1;
     985// skip first output row - contains registered RAID levels
     986res = getline(&string, &len, fin);
     987// parse the rest
     988while ( !feof_unlocked(fin) ) {
     989    res = getline(&string, &len, fin);
     990    if (res <= 0) break;
     991    // trim leading spaces
     992    pos = string;
     993    while (*pos == ' ') pos += 1;
     994    mr_asprintf(strtmp, "%s", pos);
     995    strcpy(string, strtmp);
    1019996    mr_free(strtmp);
    1020     mr_free(token);
    1021     // skip ':' and status
    1022     token = mr_strtok(string, delims, &lastpos);
    1023     mr_free(token);
    1024     token = mr_strtok(string, delims, &lastpos);
    1025     if (!strcmp(token, "inactive")) {
    1026       log_msg(1, "RAID device '%s' inactive.\n",
    1027          raidlist->el[raidlist->entries].raid_device);
    1028       paranoid_free(string);
    1029       mr_free(token);
    1030       return 1;
    1031     }
    1032     mr_free(token);
    1033 
    1034     // get RAID level
    1035     token = mr_strtok(string, delims, &lastpos);
    1036     // skip potential auto-read-only entry
    1037     if (!strcmp(token, "(auto-read-only)")) {
    1038         mr_free(token);
    1039         token = mr_strtok (string, delims, &lastpos);
    1040     }
    1041     if (!strcmp(token, "multipath")) {
    1042       raidlist->el[raidlist->entries].raid_level = -2;
    1043     } else if (!strcmp(token, "linear")) {
    1044       raidlist->el[raidlist->entries].raid_level = -1;
    1045     } else if (!strcmp(token, "raid0")) {
    1046       raidlist->el[raidlist->entries].raid_level = 0;
    1047     } else if (!strcmp(token, "raid1")) {
    1048       raidlist->el[raidlist->entries].raid_level = 1;
    1049     } else if (!strcmp(token, "raid4")) {
    1050       raidlist->el[raidlist->entries].raid_level = 4;
    1051     } else if (!strcmp(token, "raid5")) {
    1052       raidlist->el[raidlist->entries].raid_level = 5;
    1053     } else if (!strcmp(token, "raid6")) {
    1054       raidlist->el[raidlist->entries].raid_level = 6;
    1055     } else if (!strcmp(token, "raid10")) {
    1056       raidlist->el[raidlist->entries].raid_level = 10;
     997    // if we have newline after only spaces, this is a blank line, update
     998    // counters, otherwise do normal parsing
     999    if (*string == '\n') {
     1000        row = 1;
     1001        raidlist->entries++;
     1002        raidlist->el[raidlist->entries].progress = 999;
    10571003    } else {
    10581004        switch (row) {
    10591005        case 1:  // device information
    10601006            // check whether last line of record and if so skip
    1061             log_msg(8, "This is the device line\n");
    10621007            pos = strcasestr(string, "unused devices: ");
    1063             if (pos != NULL) {
     1008            if (pos == string) {
     1009                //raidlist->entries--;
    10641010                break;
    10651011            }
     
    10711017            }
    10721018            // get RAID device name
    1073             mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    1074             strncpy(raidlist->el[raidlist->entries].raid_device, strtmp, 63);
    1075             raidlist->el[raidlist->entries].raid_device[63] = '\0';
     1019            mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1020            strcpy(raidlist->el[raidlist->entries].raid_device, strtmp);
    10761021            mr_free(strtmp);
    10771022            mr_free(token);
     
    10791024            v = raidlist->el[raidlist->entries].additional_vars.entries;
    10801025            strcpy(raidlist->el[raidlist->entries].additional_vars.el[v].label, "UUID");
    1081             mr_asprintf(&cmd,"mdadm --detail %s | grep UUID | cut -d: -f2- | sed 's/^ *//'", raidlist->el[raidlist->entries].raid_device);
    1082             mr_asprintf(&strtmp, "%s", call_program_and_get_last_line_of_output(cmd));
     1026            mr_asprintf(cmd,"mdadm --detail %s | grep UUID | cut -d: -f2- | sed 's/^ *//'", raidlist->el[raidlist->entries].raid_device);
     1027            mr_asprintf(strtmp, "%s", call_program_and_get_last_line_of_output(cmd, TRUE));
    10831028            strcpy(raidlist->el[raidlist->entries].additional_vars.el[v].value, strtmp);
    10841029            mr_free(strtmp);
     
    10861031            // store the Version value in the additional_vars structure
    10871032            strcpy(raidlist->el[raidlist->entries].additional_vars.el[v].label, "Version");
    1088             mr_asprintf(&cmd,"mdadm --detail %s | grep Version | cut -d: -f2- | sed 's/^ *//'", raidlist->el[raidlist->entries].raid_device);
    1089             mr_asprintf(&strtmp, "%s", call_program_and_get_last_line_of_output(cmd));
     1033            mr_asprintf(cmd,"mdadm --detail %s | grep Version | cut -d: -f2- | sed 's/^ *//'", raidlist->el[raidlist->entries].raid_device);
     1034            mr_asprintf(strtmp, "%s", call_program_and_get_last_line_of_output(cmd, TRUE));
    10901035            strcpy(raidlist->el[raidlist->entries].additional_vars.el[v].value, strtmp);
    10911036            mr_free(strtmp);
     
    10931038            raidlist->el[raidlist->entries].additional_vars.entries = v;
    10941039            // skip ':' and status
    1095             token = mr_strtok (string, delims, &lastpos);
     1040            token = mr_strtok(string, delims, &lastpos);
    10961041            if (token == NULL) {
    10971042                // should not happen !
     
    10991044            }
    11001045            mr_free(token);
    1101             token = mr_strtok (string, delims, &lastpos);
     1046            token = mr_strtok(string, delims, &lastpos);
    11021047            if (token == NULL) {
    11031048                // should not happen !
     
    11051050            }
    11061051            if (!strcmp(token, "inactive")) {
    1107                 log_msg(1, "RAID device '%s' inactive.\n",
    1108                 raidlist->el[raidlist->entries].raid_device);
     1052                log_msg(1, "RAID device '%s' inactive.\n", raidlist->el[raidlist->entries].raid_device);
    11091053                mr_free(string);
    11101054                mr_free(token);
     
    11131057            mr_free(token);
    11141058
    1115     // get RAID devices (type, index, device)
    1116     // Note: parity disk for RAID4 is last normal disk, there is no '(P)'
    1117     raidlist->el[raidlist->entries].data_disks.entries = 0;
    1118     raidlist->el[raidlist->entries].spare_disks.entries = 0;
    1119     raidlist->el[raidlist->entries].failed_disks.entries = 0;
    1120     while((token = mr_strtok (string, delims, &lastpos))) {
    1121       if ((pos = strstr(token, "("))) {
    1122         type = *(pos+1);
    1123       } else {
    1124         type = ' ';
    1125       }
    1126       pos = strstr(token, "[");
    1127       *pos = '\0';
    1128       switch(type) {
    1129       case ' ': // normal data disks
    1130         raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
    1131         mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1132         strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
    1133         mr_free(strtmp);
    1134         raidlist->el[raidlist->entries].data_disks.entries++;
    1135         break;
    1136       case 'S': // spare disks
    1137         raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
    1138         mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1139         strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
    1140         mr_free(strtmp);
    1141         raidlist->el[raidlist->entries].spare_disks.entries++;
    1142         break;
    1143       case 'F': // failed disks
    1144         raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
    1145         mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1146         strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
    1147         mr_free(strtmp);
    1148         raidlist->el[raidlist->entries].failed_disks.entries++;
    1149         log_it("At least one failed disk found in RAID array.\n");
    1150         break;
    1151       default: // error
    1152         log_msg(1, "Unknown device type '%c'\n", type);
    1153         paranoid_free(string);
    1154         paranoid_free(token);
    1155         return 1;
    1156         break;
    1157       }
    1158       mr_free(token);
    1159     }
    1160 
    1161     // get RAID devices (type, index, device)
    1162     // Note: parity disk for RAID4 is last normal disk, there is no '(P)'
    1163     raidlist->el[raidlist->entries].data_disks.entries = 0;
    1164     raidlist->el[raidlist->entries].spare_disks.entries = 0;
    1165     raidlist->el[raidlist->entries].failed_disks.entries = 0;
    1166     while((token = mr_strtok (string, delims, &lastpos))) {
    1167         if ((pos = strstr(token, "("))) {
    1168                 type = *(pos+1);
    1169         } else {
    1170                 type = ' ';
    1171         }
    1172         pos = strstr(token, "[");
    1173         *pos = '\0';
    1174         switch(type) {
    1175         case ' ': // normal data disks
    1176                 raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
    1177                 mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    1178                 strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
    1179                 mr_free(strtmp);
    1180                 raidlist->el[raidlist->entries].data_disks.entries++;
    1181                 break;
    1182         case 'S': // spare disks
    1183                 raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
    1184                 mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    1185                 strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
    1186                 mr_free(strtmp);
    1187                 raidlist->el[raidlist->entries].spare_disks.entries++;
    1188                 break;
    1189         case 'F': // failed disks
    1190                 raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
    1191                 mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    1192                 strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
    1193                 mr_free(strtmp);
    1194                 raidlist->el[raidlist->entries].failed_disks.entries++;
    1195                 log_it("At least one failed disk found in RAID array.\n");
    1196                 break;
    1197         default: // error
    1198                 log_msg(1, "Unknown device type '%c'\n", type);
    1199                 mr_free(string);
    1200                 mr_free(token);
    1201                 return 1;
    1202                 break;
    1203         }
    1204         mr_free(token);
    1205     }
    1206 
    1207     // adjust index for each device so that it starts with 0 for every type
    1208     index_min = 99;
    1209     for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
    1210         if (raidlist->el[raidlist->entries].data_disks.el[i].index < index_min) {
    1211             index_min = raidlist->el[raidlist->entries].data_disks.el[i].index;
    1212         }
    1213     }
    1214     if (index_min > 0) {
    1215         for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
    1216                 raidlist->el[raidlist->entries].data_disks.el[i].index = raidlist->el[raidlist->entries].data_disks.el[i].index - index_min;   
    1217         }
    1218     }
    1219     index_min = 99;
    1220     for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
    1221         if (raidlist->el[raidlist->entries].spare_disks.el[i].index < index_min) {
    1222                 index_min = raidlist->el[raidlist->entries].spare_disks.el[i].index;
    1223         }
    1224     }
    1225     if (index_min > 0) {
    1226         for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
    1227                 raidlist->el[raidlist->entries].spare_disks.el[i].index = raidlist->el[raidlist->entries].spare_disks.el[i].index - index_min; 
    1228         }
    1229     }
    1230     index_min = 99;
    1231     for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
    1232         if (raidlist->el[raidlist->entries].failed_disks.el[i].index < index_min) {
    1233                 index_min = raidlist->el[raidlist->entries].failed_disks.el[i].index;
    1234         }
    1235     }
    1236     if (index_min > 0) {
    1237         for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
    1238                 raidlist->el[raidlist->entries].failed_disks.el[i].index = raidlist->el[raidlist->entries].failed_disks.el[i].index - index_min;   
    1239         }
    1240     }
    1241     break;
    1242 case 2:  // config information
    1243     // check for persistent super block
    1244     if (strcasestr(string, "super non-persistent")) {
     1059            // get RAID level
     1060            token = mr_strtok(string, delims, &lastpos);
     1061            if (token == NULL) {
     1062                // should not happen !
     1063                break;
     1064            }
     1065            // skip potential auto-read-only entry
     1066            if (!strcmp(token, "(auto-read-only)")) {
     1067                mr_free(token);
     1068                token = mr_strtok (string, delims, &lastpos);
     1069                if (token == NULL) {
     1070                    // should not happen !
     1071                    break;
     1072                }
     1073            }
     1074            if (!strcmp(token, "multipath")) {
     1075                raidlist->el[raidlist->entries].raid_level = -2;
     1076            } else if (!strcmp(token, "linear")) {
     1077                raidlist->el[raidlist->entries].raid_level = -1;
     1078            } else if (!strcmp(token, "raid0")) {
     1079                raidlist->el[raidlist->entries].raid_level = 0;
     1080            } else if (!strcmp(token, "raid1")) {
     1081                raidlist->el[raidlist->entries].raid_level = 1;
     1082            } else if (!strcmp(token, "raid4")) {
     1083                raidlist->el[raidlist->entries].raid_level = 4;
     1084            } else if (!strcmp(token, "raid5")) {
     1085                raidlist->el[raidlist->entries].raid_level = 5;
     1086            } else if (!strcmp(token, "raid6")) {
     1087                raidlist->el[raidlist->entries].raid_level = 6;
     1088            } else if (!strcmp(token, "raid10")) {
     1089                raidlist->el[raidlist->entries].raid_level = 10;
     1090            } else {
     1091                log_msg(1, "Unknown RAID level '%s'.\n", token);
     1092                mr_free(string);
     1093                mr_free(token);
     1094                return 1;
     1095            }
     1096            mr_free(token);
     1097
     1098            // get RAID devices (type, index, device)
     1099            // Note: parity disk for RAID4 is last normal disk, there is no '(P)'
     1100            raidlist->el[raidlist->entries].data_disks.entries = 0;
     1101            raidlist->el[raidlist->entries].spare_disks.entries = 0;
     1102            raidlist->el[raidlist->entries].failed_disks.entries = 0;
     1103            while((token = mr_strtok (string, delims, &lastpos))) {
     1104                if ((pos = strstr(token, "("))) {
     1105                    type = *(pos+1);
     1106                } else {
     1107                    type = ' ';
     1108                }
     1109                pos = strstr(token, "[");
     1110                *pos = '\0';
     1111                switch(type) {
     1112                case ' ': // normal data disks
     1113                    raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
     1114                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1115                    strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
     1116                    mr_free(strtmp);
     1117                    raidlist->el[raidlist->entries].data_disks.entries++;
     1118                    break;
     1119                case 'S': // spare disks
     1120                    raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
     1121                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1122                    strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
     1123                    mr_free(strtmp);
     1124                    raidlist->el[raidlist->entries].spare_disks.entries++;
     1125                    break;
     1126                case 'F': // failed disks
     1127                    raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
     1128                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1129                    strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
     1130                    mr_free(strtmp);
     1131                    raidlist->el[raidlist->entries].failed_disks.entries++;
     1132                    log_it("At least one failed disk found in RAID array.\n");
     1133                    break;
     1134                default: // error
     1135                    log_msg(1, "Unknown device type '%c'\n", type);
     1136                    mr_free(string);
     1137                    mr_free(token);
     1138                    return 1;
     1139                    break;
     1140                }
     1141                mr_free(token);
     1142            }
     1143
     1144            // adjust index for each device so that it starts with 0 for every type
     1145            index_min = 99;
     1146            for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
     1147                if (raidlist->el[raidlist->entries].data_disks.el[i].index < index_min) {
     1148                    index_min = raidlist->el[raidlist->entries].data_disks.el[i].index;
     1149                }
     1150            }
     1151            if (index_min > 0) {
     1152                for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
     1153                    raidlist->el[raidlist->entries].data_disks.el[i].index = raidlist->el[raidlist->entries].data_disks.el[i].index - index_min;   
     1154                }
     1155            }
     1156            index_min = 99;
     1157            for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
     1158                if (raidlist->el[raidlist->entries].spare_disks.el[i].index < index_min) {
     1159                    index_min = raidlist->el[raidlist->entries].spare_disks.el[i].index;
     1160                }
     1161            }
     1162            if (index_min > 0) {
     1163                for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
     1164                        raidlist->el[raidlist->entries].spare_disks.el[i].index = raidlist->el[raidlist->entries].spare_disks.el[i].index - index_min; 
     1165                }
     1166            }
     1167            index_min = 99;
     1168            for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
     1169                if (raidlist->el[raidlist->entries].failed_disks.el[i].index < index_min) {
     1170                    index_min = raidlist->el[raidlist->entries].failed_disks.el[i].index;
     1171                }
     1172            }
     1173            if (index_min > 0) {
     1174                for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
     1175                        raidlist->el[raidlist->entries].failed_disks.el[i].index = raidlist->el[raidlist->entries].failed_disks.el[i].index - index_min;   
     1176                }
     1177            }
     1178            break;
     1179        case 2:  // config information
     1180            // check for persistent super block
     1181            if (strcasestr(string, "super non-persistent")) {
    12451182                raidlist->el[raidlist->entries].persistent_superblock = 0;
    12461183            } else {
     
    12521189            } else {
    12531190                while (*pos != ' ') {
    1254                     pos -= 1;
    1255                     if (pos < string) {
    1256                             log_it("String underflow!\n");
    1257                             mr_free(string);
    1258                             return 1;
    1259                     }
     1191                    pos -= 1;
     1192                    if (pos < string) {
     1193                        log_it("String underflow!\n");
     1194                        mr_free(string);
     1195                        return 1;
     1196                    }
    12601197                }
    12611198                raidlist->el[raidlist->entries].chunk_size = atoi(pos + 1);
     
    12711208            if (!(pos = strchr(string, '\%'))) {
    12721209                if (strcasestr(string, "delayed")) {
    1273                     raidlist->el[raidlist->entries].progress = -1;  // delayed (therefore, stuck at 0%)
     1210                    raidlist->el[raidlist->entries].progress = -1;  // delayed (therefore, stuck at 0%)
    12741211                } else {
    1275                     raidlist->el[raidlist->entries].progress = 999; // not found
     1212                    raidlist->el[raidlist->entries].progress = 999; // not found
    12761213                }
    12771214            } else {
    12781215                while (*pos != ' ') {
    1279                     pos -= 1;
    1280                     if (pos < string) {
    1281                         printf("ERROR: String underflow!\n");
    1282                             mr_free(string);
    1283                             return 1;
    1284                     }
     1216                    pos -= 1;
     1217                    if (pos < string) {
     1218                        printf("ERROR: String underflow!\n");
     1219                        mr_free(string);
     1220                        return 1;
     1221                    }
    12851222                }
    12861223                raidlist->el[raidlist->entries].progress = atoi(pos);
    12871224            }
    12881225            break;
    1289         default: // error or IN PROGRESS
     1226        default: // error or IN PROGRESS
    12901227            if (raidlist->el[raidlist->entries].progress != -1 &&
    12911228                raidlist->el[raidlist->entries].progress != 999) {
     
    12931230            }
    12941231            break;
    1295         }
    1296         row++;
    1297     }
    1298     // free string
    1299     mr_free(string);
     1232        }
     1233    row++;
     1234    }
     1235// free string
     1236mr_free(string);
    13001237}
    13011238// close file
  • branches/3.1/mondo/src/common/libmondo-stream.c

    r3147 r3161  
    535535
    536536    bufsize_K = (long long) (1024LL * (1 + g_tape_buffer_size_MB));
    537     if (strstr(latest_fname, ".afio.") || strstr(latest_fname, ".star.")) {
    538         type = fileset;
    539     } else if (strstr(latest_fname, "slice")) {
    540         type = biggieslice;
    541     } else {
    542         log_it("fname = %s", latest_fname);
    543         fatal_error("Unknown type. Internal error in maintain_collection_of_recent_archives()");
    544     }
    545537    mr_asprintf(tmpdir, "%s/tmpfs/backcatalog", bkpinfo->tmpdir);
    546538    mkdir(tmpdir, 0x700);
     
    744736
    745737    /* restore compression mode on */
    746     mr_asprintf(&command, "mt -f %s compression on",bkpinfo->media_device);
     738    mr_asprintf(command, "mt -f %s compression on",bkpinfo->media_device);
    747739    res = run_program_and_log_output(command, 1);
    748740    paranoid_free(command);
     
    13131305    char *pA;
    13141306    char *pB;
     1307    int ctrl_chr;
    13151308    int res;
    1316     int ctrl_chr;
    13171309    char *temp_fname;
    13181310    char *datablock;
     
    13421334    while (ctrl_chr != BLK_START_FILE) {
    13431335        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
     1336        if (res) {
     1337            //FIXME
     1338        }
    13441339        if (ctrl_chr == BLK_START_FILE) {
    13451340            break;
  • branches/3.1/mondo/src/common/libmondo-tools.c

    r3147 r3161  
    643643                colon++;
    644644                hent = gethostbyname(colon);
    645                 mr_asprintf(&(bkpinfo->netfs_user),"%s", hostname);
     645                mr_asprintf(bkpinfo->netfs_user,"%s", hostname);
    646646            } else {
    647647                hent = gethostbyname(hostname);
  • branches/3.1/mondo/src/common/libmondo-verify.c

    r3147 r3161  
    305305                    log_to_screen("%s/%s not found on live filesystem", bkpinfo->restore_path, biggiestruct.filename);
    306306                    mr_asprintf(tmp, "echo \"%s/%s not found\" >> %s/biggies.changed", bkpinfo->restore_path, biggiestruct.filename, bkpinfo->tmpdir);
    307                     system(tmp);
     307                    if (system(tmp)) {
     308                        //FIXME
     309                    }
    308310                    mr_free(tmp);
    309311
     
    412414    char *outlog = NULL;
    413415    char *tmp = NULL;
    414     char *p = NULL;
    415416
    416417    /*@ pointers ******************************************************* */
  • branches/3.1/mondo/src/common/newt-specific.c

    r3148 r3161  
    171171        /*@ buffer *********************************************************** */
    172172        char *tmp = NULL;
    173         char *p;
    174         char *p;
    175173        int i;
    176174
     
    442440        char *command = NULL;
    443441        char *tmp = NULL;
    444         char *p = NULL;
    445442
    446443        /*@ pointers ********************************************************* */
     
    468465                for (err_log_lines[i][0] = '\0';
    469466                     strlen(err_log_lines[i]) < 2 && !feof(fin);) {
    470                     (void) fgets(err_log_lines[i], MAX_NEWT_COMMENT_LEN, fin);
     467                    if (fgets(err_log_lines[i], MAX_NEWT_COMMENT_LEN, fin)) {
     468                        //FIXME
     469                    }
    471470                    /* Commented to make valgrind happy and avoid crash
    472471                    strip_spaces(err_log_lines[i]);
     
    782781        /*@ buffers *********************************************************** */
    783782        char *prompt = NULL;
    784         char *q;
    785         char *q;
    786783
    787784        /*@ newt ************************************************************** */
     
    11511148        static char *possible_responses[] = { "none", "cdr", "cdrw", "dvd", "tape", "cdstream", "udev", "netfs", "iso", NULL };
    11521149        char *outstr = NULL;
    1153         char *p;
    1154         char *p;
    11551150        t_bkptype backup_type;
    11561151        int i;
     
    13501345        bool done;
    13511346        char *tmp = NULL;
    1352         char *p;
    1353         char *p;
    13541347        char *tmp1 = NULL;
    13551348        FILE *fin, *fout;
  • branches/3.1/mondo/src/mondorestore/mondo-prep.c

    r3148 r3161  
    188188    char *p;
    189189    char *q;
    190     char *r;
    191190
    192191    /** int ***************************************************/
     
    391390        }
    392391        mr_asprintf(tmp1, "echo \"%s\" >> /tmp/out.sh", command);
    393         system(tmp1);
     392        if (system(tmp1)) {
     393            //FIXME
     394        }
    394395        mr_free(tmp1);
    395396        sleep(1);
     
    443444    /** pointers *********************************************************/
    444445    char *p;
    445     char *q;
    446446
    447447    /** init *************************************************************/
     
    533533    int i   = 0;
    534534    int j   = 0;
    535     int v   = 0;
    536535    int res = 0;
    537536   
     
    540539    char *level   = NULL;
    541540    char *program = NULL;
    542 
    543   malloc_string(bootdevice);
    544   malloc_string(name);
    545  
     541    char *strtmp = NULL;
     542    char *oldmd = NULL;
     543
    546544  // leave straight away if raidlist is initial or has no entries
    547545  if (!raidlist || raidlist->entries == 0) {
     
    587585  // - faulty devices ignored
    588586  // - persistent superblock always used as this is recommended
    589   // As per bug #473, the parameter "-e 0.90" is used only when:
    590   //   1) It detects that system boots from Raid-1
    591   //   2) grub bootloader < v1 is used.
    592   // Otherwise it won't boot which is bad.
    593     read_cfg_var(g_mondo_cfg_file, "bootloader.device", bootdevice);
    594     read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
    595     if (strcmp(name,"GRUB") == 0) {
    596         mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output("grub --version"));
    597         if ((strstr(tmp, "GRUB 0.9") != NULL) && (strcmp(raidlist->el[i].raid_device,device) == 0)) {
    598             mr_free(oldmd);
    599             mr_asprintf(oldmd, "-e 0.90");
    600             log_it("Forcing old metadata 0.90 for md on %s for old GRUB", device);
    601         }
    602     } else if ((strcmp(name,"LILO") == 0) && (strcmp(raidlist->el[i].raid_device,device) == 0)) {
    603         mr_free(oldmd);
    604         mr_asprintf(oldmd, "-e 0.90");
    605         log_it("Forcing old metadata 0.90 for md on %s for LILO", device);
    606     } else {
    607         mr_asprintf(oldmd, "");
    608     }
    609     mr_free(device);
    610     mr_free(name);
    611587
    612588  mr_asprintf(program, "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d %s", raidlist->el[i].raid_device, level, raidlist->el[i].data_disks.entries, oldmd);
     
    632608      break;
    633609    }
    634     paranoid_free(strtmp);
     610    mr_free(strtmp);
    635611  }
    636612  if (raidlist->el[i].chunk_size != -1) {
     
    10391015                sync();
    10401016                sync();
    1041                 system("reboot");
     1017                if (system("reboot")) {
     1018                    // FIXME
     1019                }
    10421020            }
    10431021        } else {
     
    14201398    char *tmp = NULL;
    14211399    char *tmp1 = NULL;
    1422     char *tmp1 = NULL;
    1423     char *tmp1 = NULL;
    14241400
    14251401    /** end *************************************************************/
     
    15941570        sync();
    15951571        paranoid_pclose(pout_to_fdisk);
    1596         paranoid_system("sync");
     1572        sync();
    15971573        log_msg(0,"------------------- fdisk.log looks like this ------------------");
    15981574        mr_asprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
    1599         system(tmp);
     1575        if (system(tmp)) {
     1576            // FIXME
     1577        }
    16001578        mr_free(tmp);
    16011579
     
    16451623
    16461624    /** pointers **********************************************************/
    1647     char *p;
    16481625    char *part_table_fmt = NULL;
    16491626    FILE *fout;
     
    16761653        return (1);
    16771654    }
    1678 
    1679 
    1680     p = (char *) strrchr(partition_name, '/');
    16811655
    16821656    /* BERLIOS: should not be called each time */
     
    19161890
    19171891    /** pointers *********************************************************/
    1918     char *p;
    19191892    FILE *fout;
    19201893
     
    19281901
    19291902    partition = build_partition_name(drive, partno);
    1930     p = (char *) strrchr(partition, '/');
    19311903    if (strcmp(format, "swap") == 0) {
    19321904        mr_asprintf(partcode, "82");
     
    21692141    char *dev;
    21702142    char *p;
    2171     int res;
    21722143#endif
    21732144
    21742145    /** pointers ********************************************************/
    21752146    FILE *fin;
    2176     char *q;
    21772147    int i;
    21782148
     
    22332203char *which_format_command_do_i_need(char *format)
    22342204{
    2235     /** int *************************************************************/
    2236     int res = 0;
    2237 
    22382205    /** buffers *********************************************************/
    22392206    char *program = NULL;
     
    22922259#endif
    22932260        log_it("Unknown format (%s) - assuming '%s' will do", format, program);
    2294         res = 0;
    22952261    }
    22962262    return (program);
     
    23202286    float factor;
    23212287    long long new_size;
     2288    char *tmp = NULL;
    23222289
    23232290    /** long *************************************************************/
  • branches/3.1/mondo/src/mondorestore/mondo-rstr-compare.c

    r3147 r3161  
    228228    char *archiver_exe = NULL;
    229229    char *tmp1 = NULL;
    230     char *filelist_name = NULL;
    231230    char *logfile = NULL;
    232231    char *compressor_exe = NULL;
     
    234233    use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
    235234    assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
    236     mr_asprintf(filelist_name, MNT_CDROM "/archives/filelist.%d", current_tarball_number);
    237     noof_lines = count_lines_in_file(filelist_name);
    238     mr_free(filelist_name);
    239235
    240236    if (strstr(tarball_fname, ".bz2")) {
  • branches/3.1/mondo/src/mondorestore/mondo-rstr-newt.c

    r3147 r3161  
    531531    assert(raidrec != NULL);
    532532
    533     system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
     533    if (system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null")) {
     534        // FIXME
     535    }
    534536    personalities = last_line_of_file("/tmp/raid-personalities.txt");
    535537    mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
     
    22722274    char *q = NULL;
    22732275    char *r = NULL;
    2274     char *s = NULL;
    22752276    char *idev = NULL;
    22762277    bool ret = FALSE;       /* Should be false by default, and modfiy if conditions respected */
  • branches/3.1/mondo/src/mondorestore/mondo-rstr-tools.c

    r3148 r3161  
    8080char *incoming = NULL;
    8181char *question = NULL;
    82 char *q;
    83 char *q;
    8482
    8583assert_string_is_neither_NULL_nor_zerolength(infname);
     
    182180    char *mds = NULL;
    183181    int retval = 0, i;
    184     bool already_mounted = FALSE;
    185182    char *isodir_format = NULL;
    186183
     
    553550    mr_free(command);
    554551
    555     chdir(bkpinfo->tmpdir);
     552    if (chdir(bkpinfo->tmpdir)) {
     553        //FIXME
     554    }
    556555
    557556    mr_free(mountpt);
     
    576575        if (try_plan_B) {
    577576            log_msg(2, "gcffa --- OK, switching to Plan B");
    578             chdir(bkpinfo->tmpdir);
     577            if (chdir(bkpinfo->tmpdir)) {
     578                // FIXME
     579            }
    579580            run_program_and_log_output("mkdir -p tmp", FALSE);
    580581
     
    10821083char *command = NULL;
    10831084char *tmp;
    1084 char *tmp1 = NULL;
    10851085char *q;
    10861086int res = 0;
     
    14021402    bool mntlistchg = FALSE;
    14031403    FILE *fin = NULL;
    1404     bool mntlistchg = FALSE;
    1405     FILE *fin = NULL;
    14061404
    14071405    assert_string_is_neither_NULL_nor_zerolength(bd);
     
    14361434            }
    14371435
    1438             if ((res) || (mntlistchg)){
    1439                 popup_and_OK
    1440                     ("GRUB installation failed. You will now edit fstab, mtab, device.map and menu.lst/grub.cfg in order to fix grub install");
    1441                 } else {
    1442                     popup_and_OK("The mountlist was changed. You will now edit fstab, mtab, device.map and menu.lst/grub.cfg in order to fix grub install");
    1443                 }
    1444                 if (!g_text_mode) {
    1445                     newtSuspend();
    1446                 }
    1447                 sprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
    1448                 paranoid_system(tmp);
    1449                 sprintf(tmp, "chroot %s %s /etc/mtab", MNT_RESTORING, editor);
    1450                 paranoid_system(tmp);
    1451                 if (does_file_exist(MNT_RESTORING"/boot/grub/menu.lst")) {
    1452                     sprintf(tmp, "chroot %s %s /boot/grub/menu.lst", MNT_RESTORING, editor);
    1453                 } else if (does_file_exist(MNT_RESTORING"/boot/grub/grub.cfg")) {
    1454                     sprintf(tmp, "chroot %s %s /boot/grub/grub.cfg", MNT_RESTORING, editor);
    1455                 } else if (does_file_exist(MNT_RESTORING"/boot/grub2/grub.cfg")) {
    1456                     sprintf(tmp, "chroot %s %s /boot/grub2/grub.cfg", MNT_RESTORING, editor);
    1457                 }
    1458                 paranoid_system(tmp);
    1459                 if (does_file_exist(MNT_RESTORING"/boot/grub/device.map")) {
    1460                     sprintf(tmp, "chroot %s %s /boot/grub/device.map", MNT_RESTORING, editor);
    1461                 } else if (does_file_exist(MNT_RESTORING"/boot/grub2/device.map")) {
    1462                     sprintf(tmp, "chroot %s %s /boot/grub2/device.map", MNT_RESTORING, editor);
    1463                                 }
    1464                 paranoid_system(tmp);
    1465                 if (!g_text_mode) {
    1466                     newtResume();
    1467                 }
    1468                 sprintf(command, "stabgrub-me %s", boot_device);
    1469                 res = run_program_and_log_output(command, 1);
    1470                 if (res) {
    1471                     popup_and_OK
    1472                         ("GRUB installation failed. Please fix the conf files so that a manual install using 'grub-install' or similar command works. You are now chroot()'ed to your restored system. Please type 'exit' when you are done.");
    1473                     newtSuspend();
    1474                     paranoid_system("chroot " MNT_RESTORING);
    1475                     newtResume();
    1476                     popup_and_OK("Thank you.");
    1477                 } else {
    1478                     popup_and_OK("GRUB is now installed correctly");
    1479                     done = TRUE;
    1480                 }
     1436            if ((res) || (mntlistchg)) {
     1437                popup_and_OK("GRUB installation failed. You will now edit fstab, mtab, device.map and menu.lst/grub.cfg in order to fix grub install");
    14811438            } else {
     1439                popup_and_OK("The mountlist was changed. You will now edit fstab, mtab, device.map and menu.lst/grub.cfg in order to fix grub install");
     1440            }
     1441            if (!g_text_mode) {
     1442                newtSuspend();
     1443            }
     1444            mr_asprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
     1445            paranoid_system(tmp);
     1446            mr_free(tmp);
     1447
     1448            mr_asprintf(tmp, "chroot %s %s /etc/mtab", MNT_RESTORING, editor);
     1449            paranoid_system(tmp);
     1450            mr_free(tmp);
     1451
     1452            if (does_file_exist(MNT_RESTORING"/boot/grub/menu.lst")) {
     1453                mr_asprintf(tmp, "chroot %s %s /boot/grub/menu.lst", MNT_RESTORING, editor);
     1454            } else if (does_file_exist(MNT_RESTORING"/boot/grub/grub.cfg")) {
     1455                mr_asprintf(tmp, "chroot %s %s /boot/grub/grub.cfg", MNT_RESTORING, editor);
     1456            } else if (does_file_exist(MNT_RESTORING"/boot/grub2/grub.cfg")) {
     1457                mr_asprintf(tmp, "chroot %s %s /boot/grub2/grub.cfg", MNT_RESTORING, editor);
     1458            }
     1459            paranoid_system(tmp);
     1460            mr_free(tmp);
     1461
     1462            if (does_file_exist(MNT_RESTORING"/boot/grub/device.map")) {
     1463                mr_asprintf(tmp, "chroot %s %s /boot/grub/device.map", MNT_RESTORING, editor);
     1464            } else if (does_file_exist(MNT_RESTORING"/boot/grub2/device.map")) {
     1465                mr_asprintf(tmp, "chroot %s %s /boot/grub2/device.map", MNT_RESTORING, editor);
     1466            }
     1467            paranoid_system(tmp);
     1468            mr_free(tmp);
     1469
     1470            if (!g_text_mode) {
     1471                newtResume();
     1472            }
     1473            mr_asprintf(command, "stabgrub-me %s", boot_device);
     1474            res = run_program_and_log_output(command, 1);
     1475            mr_free(command);
     1476            if (res) {
     1477                popup_and_OK("GRUB installation failed. Please fix the conf files so that a manual install using 'grub-install' or similar command works. You are now chroot()'ed to your restored system. Please type 'exit' when you are done.");
     1478                newtSuspend();
     1479                paranoid_system("chroot " MNT_RESTORING);
     1480                newtResume();
     1481                popup_and_OK("Thank you.");
     1482            } else {
     1483                popup_and_OK("GRUB is now installed correctly");
    14821484                done = TRUE;
    14831485            }
     
    18791881    FILE *fout;
    18801882    char *incoming = NULL;
    1881     char *q;
    1882     char *q;
    18831883
    18841884    assert_string_is_neither_NULL_nor_zerolength(output_file);
  • branches/3.1/mondo/src/mondorestore/mondorestore.c

    r3147 r3161  
    12301230
    12311231    if (strcmp(outfile_fname, "/dev/null")) {
    1232         chown(outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid);
     1232        if (chown(outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid)) {
     1233            // FIXME
     1234        }
    12331235        chmod(outfile_fname, biggiestruct.properties.st_mode);
    12341236        ubuf->actime = biggiestruct.properties.st_atime;
     
    14751477    if (strcmp(outfile_fname, "/dev/null")) {
    14761478        chmod(outfile_fname, biggiestruct.properties.st_mode);
    1477         chown(outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid);
     1479        if (chown(outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid)) {
     1480            // FIXME
     1481        }
    14781482        ubuf->actime = biggiestruct.properties.st_atime;
    14791483        ubuf->modtime = biggiestruct.properties.st_mtime;
  • branches/3.1/mondo/test/test-mountlist.c

    r3147 r3161  
    7070
    7171setup_newt_stuff();
    72 mr_asprintf(&g_mountlist_fname, MOUNTLIST_TEST);
    7372log_it("before mountlist");
    7473load_mountlist(mountlist, MINDI_CACHE"/mountlist.txt");
     
    9695free(raidlist);
    9796mr_free(MONDO_LOGFILE);
    98 mr_free(g_mountlist_fname);
    9997exit(0);
    10098}
Note: See TracChangeset for help on using the changeset viewer.