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

Timestamp:

Aug 18, 2009, 5:28:18 PM (16 years ago)

Author:

Bruno Cornec

Message:

r3369@localhost: bruno | 2009-08-18 16:57:27 +0200

• Transform bout 100 strcpy in dyn. allocation. Quality is improving
• function figure_out_kernel_path_interactively_if_necessary now return a dynamically allocated string
• mondoarchive checked with valgrind in text an newt modes

Location:

branches/2.2.10/mondo/src/mondorestore

Files:

• mondo-prep.c (modified) (19 diffs)
• mondo-rstr-compare.c (modified) (13 diffs)
• mondo-rstr-newt.c (modified) (62 diffs)
• mondo-rstr-tools.c (modified) (25 diffs)
• mondorestore.c (modified) (31 diffs)

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

@@ -192 +192 @@
     char *incoming;
     char *command;
-    char *lvscan_sz;
-    char *lvremove_sz;
-    char *pvscan_sz;
-    char *vgscan_sz;
-    char *vgcreate_sz;
-    char *vgchange_sz;
-    char *vgremove_sz;
-//  char *do_this_last;
+    char *lvscan_sz = NULL;
+    char *lvremove_sz = NULL;
+    char *pvscan_sz = NULL;
+    char *vgscan_sz = NULL;
+    char *vgchange_sz = NULL;
+    char *vgremove_sz = NULL;
 
     /** char **************************************************/
@@ -229 +227 @@
     malloc_string(tmp);
     malloc_string(incoming);
-    malloc_string(lvscan_sz);
-    malloc_string(lvremove_sz);
-    malloc_string(vgscan_sz);
-    malloc_string(pvscan_sz);
-    malloc_string(vgcreate_sz);
-    malloc_string(vgchange_sz);
-    malloc_string(vgremove_sz);
-    command = malloc(512);
+    command = malloc(1024);
 
     log_it("STARTING");
@@ -243 +234 @@
     if (tmp1)   // found it :) cool
     {
-        strcpy(lvscan_sz, "lvm lvscan");
-        strcpy(lvremove_sz, "lvm lvremove");
-        strcpy(vgscan_sz, "lvm vgscan");
-        strcpy(pvscan_sz, "lvm pvscan");
-        strcpy(vgcreate_sz, "lvm vgcreate");
-        strcpy(vgchange_sz, "lvm vgchange");
-        strcpy(vgremove_sz, "lvm vgremove -f");
+        mr_asprintf(lvscan_sz, "lvm lvscan");
+        mr_asprintf(lvremove_sz, "lvm lvremove");
+        mr_asprintf(vgscan_sz, "lvm vgscan");
+        mr_asprintf(pvscan_sz, "lvm pvscan");
+        mr_asprintf(vgchange_sz, "lvm vgchange");
+        mr_asprintf(vgremove_sz, "lvm vgremove -f");
     } else {
-        strcpy(lvscan_sz, "lvscan");
-        strcpy(lvremove_sz, "lvremove");
-        strcpy(vgscan_sz, "vgscan");
-        strcpy(pvscan_sz, "pvscan");
-        strcpy(vgcreate_sz, "vgcreate");
-        strcpy(vgchange_sz, "vgchange");
-        strcpy(vgremove_sz, "vgremove");
+        mr_asprintf(lvscan_sz, "lvscan");
+        mr_asprintf(lvremove_sz, "lvremove");
+        mr_asprintf(vgscan_sz, "vgscan");
+        mr_asprintf(pvscan_sz, "pvscan");
+        mr_asprintf(vgchange_sz, "vgchange");
+        mr_asprintf(vgremove_sz, "vgremove");
     }
     mr_free(tmp1);
 
     mr_asprintf(tmp1, "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> %s ; %s -f $i; done", lvscan_sz, MONDO_LOGFILE, lvremove_sz);
+    mr_free(lvscan_sz);
+    mr_free(lvremove_sz);
+
     run_program_and_log_output(tmp1, 5);
     mr_free(tmp1);
 
     sleep(1);
-    sprintf(command,
-            "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> %s ; done", vgscan_sz, vgchange_sz, vgremove_sz, MONDO_LOGFILE);
+    sprintf(command, "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> %s ; done", vgscan_sz, vgchange_sz, vgremove_sz, MONDO_LOGFILE);
+    mr_free(vgchange_sz);
+    mr_free(vgremove_sz);
+
     run_program_and_log_output(command, 5);
     if (just_erase_existing_volumes) {
@@ -401 +395 @@
         sleep(1);
     }
+    mr_free(vgscan_sz);
+    mr_free(pvscan_sz);
+
     paranoid_fclose(fin);
     log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
@@ -407 +404 @@
     paranoid_free(incoming);
     paranoid_free(command);
-    paranoid_free(lvscan_sz);
-    paranoid_free(lvremove_sz);
-    paranoid_free(vgscan_sz);
-    paranoid_free(pvscan_sz);
-    paranoid_free(vgcreate_sz);
-    paranoid_free(vgchange_sz);
-    paranoid_free(vgremove_sz);
     system("sync");
     system("sync");
@@ -829 +819 @@
 
     if (res && strstr(program, "kludge")) {
-        mr_asprintf(&tmp, "Kludge failed; using regular mkfs.%s to format %s", format, device);
+        mr_asprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s", format, device);
         mr_free(program);
 #ifdef __FreeBSD__
@@ -895 +885 @@
 
     assert(mountlist != NULL);
-    mr_asprintf(tmp, "format_everything (mountlist, interactively = %s", (interactively) ? "true" : "false");
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("format_everything (mountlist, interactively = %s", (interactively) ? "true" : "false");
 
     mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions     ");
@@ -1423 +1411 @@
     /** buffers *********************************************************/
     char *device_str = NULL;
-    char *format;
+    char *format = NULL;
     char *tmp = NULL;
 
@@ -1430 +1418 @@
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drivename);
-
-    malloc_string(format);
 
     log_it("Partitioning drive %s", drivename);
@@ -1445 +1431 @@
     if (!pout_to_fdisk) {
         log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
-        paranoid_free(format);
         return (1);
     }
@@ -1480 +1465 @@
                     mr_free(command);
                     mr_free(device_str);
-                    paranoid_free(format);
                     return r;
                 }
@@ -1495 +1479 @@
                 int i, line;
 
-                strcpy(format, "ufs");
+                mr_asprintf(format, "ufs");
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
@@ -1552 +1536 @@
 #ifdef __FreeBSD__
         if (!fbsd_part) {
-#endif
-
-            strcpy(format, mountlist->el[lino].format);
+            mr_free(format);
+#endif
+
+            mr_asprintf(format, "%s", mountlist->el[lino].format);
             partsize = mountlist->el[lino].size;
 
@@ -1566 +1551 @@
                 ("You must leave at least one partition spare as the Extended partition.");
             mr_free(device_str);
-            paranoid_free(format);
+            mr_free(format);
             return (1);
         }
 #endif
 
-        retval +=
-            partition_device(pout_to_fdisk, drivename, current_devno,
-                             previous_devno, format, partsize);
+        retval += partition_device(pout_to_fdisk, drivename, current_devno, previous_devno, format, partsize);
+        mr_free(format);
 
 #ifdef __FreeBSD__
@@ -1626 +1610 @@
         }
     }
-    paranoid_free(format);
     return (retval);
 }
@@ -1978 +1961 @@
         mr_asprintf(partcode, "");
     } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-        mr_asprintf(partcode, format);
+        mr_asprintf(partcode, "%s", format);
     } else {
         /* probably an image */
@@ -1985 +1968 @@
         mr_free(tmp);
 #ifdef __FreeBSD__
-        mr_asprintf(partcode, format);  // was a5
+        mr_asprintf(partcode, "%s", format);    // was a5
 #else
-        mr_asprintf(partcode, format);  // was 83
+        mr_asprintf(partcode, "%s", format);    // was 83
 #endif
     }
@@ -2260 +2243 @@
 
     /** buffers *********************************************************/
-    char *tmp = NULL;
     char *program = NULL;
 
@@ -2311 +2293 @@
         mr_asprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
 #endif
-        mr_asprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format, program);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Unknown format (%s) - assuming '%s' will do", format, program);
         res = 0;
     }

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

@@ -43 +43 @@
 
   /** needs malloc *******/
-    char *checksum_ptr;
-    char *original_cksum_ptr;
-    char *bigfile_fname_ptr;
+    char *checksum_ptr = NULL;
+    char *original_cksum_ptr = NULL;
+    char *bigfile_fname_ptr = NULL;
     char *tmp_ptr = NULL;
     char *command_ptr = NULL;
 
-    char *checksum, *original_cksum, *bigfile_fname, *tmp, *command;
+    char *checksum, *bigfile_fname, *tmp, *command;
 
     char *p;
@@ -58 +58 @@
 
     malloc_string(checksum);
-    malloc_string(original_cksum);
     malloc_string(bigfile_fname);
     malloc_string(tmp);
     malloc_string(command);
-    malloc_string(checksum_ptr);
-    malloc_string(original_cksum_ptr);
-    malloc_string(bigfile_fname_ptr);
 
   /*********************************************************************
@@ -70 +66 @@
    *********************************************************************/
     assert(bkpinfo != NULL);
-    memset(checksum_ptr, '\0', sizeof(checksum));
-    memset(original_cksum_ptr, '\0', sizeof(original_cksum));
-    memset(bigfile_fname_ptr, '\0', sizeof(bigfile_fname));
   /** end **/
 
@@ -84 +77 @@
     }
     if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
-        log_to_screen("Cannot open bigfile %ld (%s)'s info file", bigfileno + 1, bigfile_fname_ptr);
+        log_to_screen("Cannot open bigfile %ld (NULL)'s info file", bigfileno + 1);
         return (1);
     }
@@ -90 +83 @@
     paranoid_fclose(fin);
 
-    strcpy(checksum_ptr, biggiestruct.checksum);
-    strcpy(bigfile_fname_ptr, biggiestruct.filename);
+    mr_asprintf(checksum_ptr, "%s", biggiestruct.checksum);
+    mr_asprintf(bigfile_fname_ptr, "%s", biggiestruct.filename);
 
     log_msg(2, "biggiestruct.filename = %s", biggiestruct.filename);
@@ -106 +99 @@
     }
     if (!strncmp(bigfile_fname_ptr, "/dev/", 5)) {
-        strcpy(original_cksum_ptr, "IGNORE");
         log_msg(2, "IGNORING %s as begining with /dev", bigfile_fname_ptr);
+        mr_free(bigfile_fname_ptr);
         return (1);
     }
@@ -122 +115 @@
     if (i) {
         log_OS_error("Warning - command failed");
-        original_cksum[0] = '\0';
         return (1);
     } else {
@@ -128 +120 @@
             log_msg(2,
                     "Unable to open /tmp/md5sum.txt; can't get live checksum");
-            original_cksum[0] = '\0';
+            mr_free(bigfile_fname_ptr);
             return (1);
         } else {
-            fgets(original_cksum_ptr, MAX_STR_LEN - 1, fin);
+            mr_getline(original_cksum_ptr, fin);
             paranoid_fclose(fin);
-            for (i = strlen(original_cksum_ptr);
-                 i > 0 && original_cksum[i - 1] < 32; i--);
-            original_cksum[i] = '\0';
-            p = (char *) strchr(original_cksum_ptr, ' ');
+            p = strchr(original_cksum_ptr, ' ');
             if (p) {
                 *p = '\0';
@@ -143 +132 @@
     }
     mr_asprintf(tmp_ptr, "bigfile #%ld ('%s') ", bigfileno + 1, bigfile_fname_ptr);
-    if (!strcmp(checksum_ptr, original_cksum_ptr) != 0) {
+    if ((original_cksum_ptr != NULL) && (strcmp(checksum_ptr, original_cksum_ptr) == 0)) {
         mr_strcat(tmp_ptr, " ... OK");
     } else {
@@ -149 +138 @@
         retval++;
     }
+    mr_free(checksum_ptr);
+    mr_free(original_cksum_ptr);
+
     log_msg(1, tmp_ptr);
     paranoid_free(tmp_ptr);
@@ -159 +151 @@
         paranoid_fclose(fout);
     }
-
-    paranoid_free(original_cksum_ptr);
-    paranoid_free(original_cksum);
-    paranoid_free(bigfile_fname_ptr);
+    mr_free(bigfile_fname_ptr);
+
     paranoid_free(bigfile_fname);
-    paranoid_free(checksum_ptr);
     paranoid_free(checksum);
     paranoid_free(command);
@@ -365 +354 @@
   /**  needs malloc **********/
 
-    char *tarball_fname, *progress_str; 
+    char *tarball_fname = NULL;
+    char *progress_str = NULL; 
     char *tmp = NULL;
     char *mds = NULL;
@@ -443 +433 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
-    paranoid_free(tarball_fname);
-    paranoid_free(progress_str);
     return (retval);
 }

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

@@ -78 +78 @@
     newtPushHelpLine
         ("   Add one of the following unallocated RAID partitions to this RAID device.");
-    mr_asprintf(&tmp, "%-26s %s", "Device", "Size");
+    mr_asprintf(tmp, "%-26s %s", "Device", "Size");
     headerMsg = newtLabel(1, 1, tmp);
     partitionsListbox =
@@ -104 +104 @@
 
             items = disklist->entries;
-            strcpy(disklist->el[items].device,
-                   unallocated_raid_partitions->el[currline].device);
+            strcpy(disklist->el[items].device, unallocated_raid_partitions->el[currline].device);
             disklist->el[items].index = index;
             disklist->entries = ++items;
@@ -154 +153 @@
 
     /** buffers **********************************************************/
-    char drive_to_add[MAX_STR_LEN];
-    char mountpoint_str[MAX_STR_LEN];
-    char size_str[MAX_STR_LEN];
-    char device_str[MAX_STR_LEN];
-    char format_str[MAX_STR_LEN];
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *device_str = NULL;
+    char *format_str = NULL;
 
     /** pointers *********************************************************/
@@ -171 +170 @@
     assert(keylist != NULL);
 
-    strcpy(device_str, "/dev/");
-    strcpy(mountpoint_str, "/");
+    mr_asprintf(device_str, "/dev/");
+    mr_asprintf(mountpoint_str, "/");
+    mr_asprintf(size_str, "");
 #ifdef __FreeBSD__
-    strcpy(format_str, "ufs");
+    mr_asprintf(format_str, "ufs");
 #else
-    strcpy(format_str, "ext3");
+    mr_asprintf(format_str, "ext3");
 #endif
-    size_str[0] = '\0';
     newtOpenWindow(20, 5, 48, 10, "Add entry");
     label0 = newtLabel(2, 1, "Device:    ");
@@ -184 +183 @@
     label2 = newtLabel(2, 3, "Size (MB): ");
     label3 = newtLabel(2, 4, "Format:    ");
-    deviceComp =
-        newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
-    mountpointComp =
-        newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
-    formatComp =
-        newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
     sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
     bOK = newtButton(5, 6, "  OK  ");
@@ -201 +197 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
-        strcpy(mountpoint_str, mountpoint_here);
-        strcpy(format_str, format_here);
-        strcpy(size_str, size_here);
-//      log_it ("Originals = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str);
+        mr_free(device_str);
+        mr_asprintf(device_str, "%s", device_here);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(mountpoint_str, "%s", mountpoint_here);
+        mr_strip_spaces(mountpoint_str);
+
+        mr_free(format_str);
+        mr_asprintf(format_str, "%s", format_here);
+        mr_strip_spaces(format_str);
+
+        mr_free(size_str);
+        mr_asprintf(size_str, "%s", size_here);
+        mr_strip_spaces(size_str);
+
         strip_spaces(device_str);
-        strip_spaces(mountpoint_str);
-        strip_spaces(format_str);
-        strip_spaces(size_str);
-//      log_it ("Modified = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str);
         if (b_res == bOK) {
             if (device_str[strlen(device_str) - 1] == '/') {
@@ -216 +218 @@
                 b_res = NULL;
             }
-            if (size_of_specific_device_in_mountlist(mountlist, device_str)
-                >= 0) {
+            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
                 popup_and_OK("Can't add this - you've got one already!");
                 b_res = NULL;
@@ -229 +230 @@
         return;
     }
-    strcpy(drive_to_add, device_str);
+    mr_asprintf(drive_to_add, "%s", device_str);
     for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
     num_to_add = atoi(drive_to_add + i);
-    drive_to_add[i] = '\0';
+    mr_free(drive_to_add);
+
     currline = mountlist->entries;
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
     strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
     mountlist->el[currline].size = atol(size_str) * 1024L;
+    mr_free(size_str);
+
     mountlist->entries++;
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline,
-                                    device_str);
-    }
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
+    }
+    mr_free(device_str);
+
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -316 +325 @@
     /** buffers ***********************************************************/
     char tmp = NULL;
-
-
-
+    char *devname = NULL;
 
     for (i = 0;
@@ -324 +331 @@
          && strcmp(raidlist->el[i].volname, basename(raid_device)); i++);
     if (i == raidlist->entries) {
-        mr_asprintf(&tmp, "Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
         return (0);             // Isn't this more sensible than 999999999? If the raid dev !exists,
         // then it has no size, right?
@@ -338 +343 @@
         int k = 0, l = 0;
         for (k = 0; k < raidrec->plex[j].subdisks; ++k) {
-            char devname[64];
-            strcpy(devname, raidrec->plex[j].sd[k].which_device);
+            mr_asprintf(devname, "%s", raidrec->plex[j].sd[k].which_device);
             for (l = 0; l < raidlist->disks.entries; ++l) {
                 if (!strcmp(devname, raidlist->disks.el[l].name)) {
@@ -367 +371 @@
                 }
             }
+            mr_free(devname);
         }
 
@@ -387 +392 @@
     }
 
-    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex);
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex);
     return (smallest_plex);
 #else
@@ -406 +409 @@
     long sp = 0;
 
-    /** buffers ***********************************************************/
-    char tmp = NULL;
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -417 +417 @@
          && strcmp(raidlist->el[i].raid_device, raid_device); i++);
     if (i == raidlist->entries) {
-        mr_asprintf(&tmp, "Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
         return (999999999);
     }
@@ -442 +440 @@
         total_size = smallest_partition * (noof_partitions - 1);
     }
-    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device, (long) total_size);
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("I have calculated %s's real size to be %ld", raid_device, (long) total_size);
     return (total_size);
 #endif
@@ -499 +495 @@
             }
             p[i] = '\0';
-            mr_free(sz);
         }
         if (!strcmp(p, "concat")) {
@@ -568 +563 @@
             }
             p[i] = '\0';
-            mr_free(sz);
         }
         if (!strcmp(p, "linear")) {
@@ -613 +607 @@
 
     /** buffers ***********************************************************/
-    char *tmp = NULL;
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -625 +617 @@
              pos++);
         if (pos < mountlist->entries) {
-            mr_asprintf(&tmp, "Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device);
 
             memcpy((void *) &mountlist->el[pos],
@@ -662 +652 @@
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
 
-    mr_asprintf(&tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
+    mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -699 +689 @@
     /** buffers ***********************************************************/
     char *tmp = NULL;
-    char device[MAX_STR_LEN];
+    char *device = NULL;
 
 
@@ -707 +697 @@
     assert(keylist != NULL);
 
-    /* BERLIOS: Why isn't device initialized here ? what is expected */
-    pos =
-        which_raid_device_is_using_this_partition(raidlist,
-                                                  mountlist->el[currline].
-                                                  device);
+    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
     if (pos >= 0) {
-        mr_asprintf(&tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
+        mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
         popup_and_OK(tmp);
         mr_free(tmp);
         return;
     }
-    mr_asprintf(&tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
+    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -726 +712 @@
     }
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        strcpy(device, mountlist->el[currline].device);
+        mr_asprintf(device, "%s", mountlist->el[currline].device);
         delete_raidlist_entry(mountlist, raidlist, device);
         for (currline = 0;
@@ -732 +718 @@
              && strcmp(mountlist->el[currline].device, device);
              currline++);
+        mr_free(device);
+
         if (currline == mountlist->entries) {
             log_it("Dev is gone. I can't delete it. Ho-hum");
@@ -775 +763 @@
         return;
     }
-    mr_asprintf(&tmp, "Do you want me to delete %s's partitions, too?", device);
+    mr_asprintf(tmp, "Do you want me to delete %s's partitions, too?", device);
     delete_partitions_too = ask_me_yes_or_no(tmp);
     if (delete_partitions_too) {
@@ -788 +776 @@
                     if (!strcmp(raidlist->el[i].plex[x].sd[y].which_device,
                                 raidlist->disks.el[z].name)) {
-                        strcpy(d.el[d.entries].name,
-                               raidlist->disks.el[z].name);
-                        strcpy(d.el[d.entries++].device,
-                               raidlist->disks.el[z].device);
+                        strcpy(d.el[d.entries].name, raidlist->disks.el[z].name);
+                        strcpy(d.el[d.entries++].device, raidlist->disks.el[z].device);
                     }
                 }
@@ -844 +830 @@
 
     av = &raidrec->additional_vars;
-    mr_asprintf(&tmp, "Delete %s - are you sure?", av->el[lino].label);
+    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -851 +837 @@
         if (!strcmp(av->el[lino].label, "persistent-superblock")
             || !strcmp(av->el[lino].label, "chunk-size")) {
-            mr_asprintf(&tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
+            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
             popup_and_OK(tmp);
             mr_free(tmp);
@@ -920 +906 @@
                 if (!warned_already) {
                     warned_already = TRUE;
-                    mr_asprintf(&tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM);
+                    mr_asprintf(tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM);
                     popup_and_OK(tmp1);
                     mr_free(tmp1);
                 }
             } else {
-                strcpy(g_strings_of_flist_window[lines_in_flist_window],
-                       current_filename);
+                strcpy(g_strings_of_flist_window[lines_in_flist_window], current_filename);
                 g_is_path_selected[lines_in_flist_window] = node->selected;
                 lines_in_flist_window++;
@@ -941 +926 @@
                 (g_strings_of_flist_window[i],
                  g_strings_of_flist_window[i - 1]) < 0) {
-                mr_asprintf(&tmp1, g_strings_of_flist_window[i]);
-                strcpy(g_strings_of_flist_window[i],
-                       g_strings_of_flist_window[i - 1]);
+                mr_asprintf(tmp1, "%s", g_strings_of_flist_window[i]);
+                strcpy(g_strings_of_flist_window[i], g_strings_of_flist_window[i - 1]);
                 strcpy(g_strings_of_flist_window[i - 1], tmp1);
                 mr_free(tmp1);
@@ -1048 +1032 @@
     void *curr_choice;
     void *keylist[ARBITRARY_MAXIMUM];
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
 
     /** bool **************************************************************/
@@ -1098 +1079 @@
                 indexno = 0;
             }
-            mr_asprintf(&tmp, "You selected '%s'", g_strings_of_flist_window[indexno]);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("You selected '%s'", g_strings_of_flist_window[indexno]);
 
             if (b_res == bMore) {
@@ -1193 +1172 @@
 
   /** buffers ***********************************************************/
-    char device_str[MAX_STR_LEN];
-    char mountpoint_str[MAX_STR_LEN];
-    char size_str[MAX_STR_LEN];
-    char format_str[MAX_STR_LEN];
+    char *device_str = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *format_str = NULL;
     char *tmp = NULL;
-    char device_used_to_be[MAX_STR_LEN];
-    char mountpt_used_to_be[MAX_STR_LEN];
+    char *device_used_to_be = NULL;
+    char *mountpt_used_to_be = NULL;
 
     /** pointers **********************************************************/
@@ -1217 +1196 @@
     memcpy((void *) &bkp_raidlist, (void *) raidlist,
            sizeof(struct raidlist_itself));
-    strcpy(device_str, mountlist->el[currline].device);
-    strcpy(device_used_to_be, mountlist->el[currline].device);
-    strcpy(mountpoint_str, mountlist->el[currline].mountpoint);
-    strcpy(mountpt_used_to_be, mountlist->el[currline].mountpoint);
-    strcpy(format_str, mountlist->el[currline].format);
-    sprintf(size_str, "%lld", mountlist->el[currline].size / 1024L);
+    mr_asprintf(device_str, "%s", mountlist->el[currline].device);
+    mr_asprintf(device_used_to_be, "%s", mountlist->el[currline].device);
+    mr_asprintf(mountpoint_str, "%s", mountlist->el[currline].mountpoint);
+    mr_asprintf(mountpt_used_to_be, "%s", mountlist->el[currline].mountpoint);
+    mr_asprintf(format_str, "%s", mountlist->el[currline].format);
+    mr_asprintf(size_str, "%lld", mountlist->el[currline].size / 1024L);
     newtOpenWindow(20, 5, 48, 10, "Edit entry");
     label0 = newtLabel(2, 1, "Device:");
@@ -1228 +1207 @@
     label2 = newtLabel(2, 3, "Size (MB): ");
     label3 = newtLabel(2, 4, "Format:    ");
-    deviceComp =
-        newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
-    mountpointComp =
-        newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
-    formatComp =
-        newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         || !strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1253 +1229 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
-        strip_spaces(device_str);
-        strcpy(mountpoint_str, mountpoint_here);
-        strip_spaces(mountpoint_str);
-        strcpy(format_str, format_here);
-        strip_spaces(format_str);
+        mr_free(device_str);
+        mr_asprintf(device_str, "%s", device_here);
+        mr_strip_spaces(device_str);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(mountpoint_str, "%s", mountpoint_here);
+        mr_strip_spaces(mountpoint_str);
+
+        mr_free(format_str);
+        mr_asprintf(format_str, "%s", format_here);
+        mr_strip_spaces(format_str);
+
         if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB)
             && strstr(device_used_to_be, RAID_DEVICE_STUB)
@@ -1273 +1255 @@
         if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
             && strcmp(mountlist->el[currline].mountpoint, "image")) {
-            strcpy(size_str, size_here);
-            strip_spaces(size_str);
+            mr_free(size_str);
+            mr_asprintf(size_str, "%s", size_here);
+            mr_strip_spaces(size_str);
         } else {
-            sprintf(size_str, "%ld",
-                    calculate_raid_device_size(mountlist, raidlist,
-                                               mountlist->el[currline].
-                                               device) / 1024);
+            mr_asprintf(size_str, "%ld", calculate_raid_device_size(mountlist, raidlist, mountlist->el[currline].device) / 1024);
             newtLabelSetText(sizeComp, size_str);
         }
@@ -1296 +1276 @@
                                                  device);
                 if (j < 0) {
-                    mr_asprintf(&tmp, "/etc/raidtab does not have an entry for %s; please delete it and add it again", mountlist->el[currline].device);
+                    mr_asprintf(tmp, "/etc/raidtab does not have an entry for %s; please delete it and add it again", mountlist->el[currline].device);
                     popup_and_OK(tmp);
                     mr_free(tmp);
@@ -1310 +1290 @@
     newtPopHelpLine();
     newtPopWindow();
+    mr_free(mountpt_used_to_be);
+
     if (b_res == bCancel) {
         memcpy((void *) raidlist, (void *) &bkp_raidlist,
                sizeof(struct raidlist_itself));
+        mr_free(device_str);
+        mr_free(device_used_to_be);
+        mr_free(format_str);
+        mr_free(size_str);
         return;
     }
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
     strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
     if (strcmp(mountlist->el[currline].mountpoint, "image")) {
         if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
@@ -1327 +1317 @@
         }
     }
+    mr_free(size_str);
     newtListboxSetEntry(listbox, (long) keylist[currline],
                         mountlist_entry_to_string(mountlist, currline));
@@ -1332 +1323 @@
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         && !strstr(device_used_to_be, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline,
-                                    device_str);
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
     }
     /* if moving from RAID to non-RAID then do funky stuff */
@@ -1350 +1340 @@
 #ifndef __FreeBSD__             /* It works fine under FBSD. */
     else if (strcmp(device_used_to_be, device_str)) {
-        popup_and_OK
-            ("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it.");
+        popup_and_OK("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it.");
     }
 #endif
+    mr_free(device_str);
+    mr_free(device_used_to_be);
+
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -1376 +1368 @@
     for (i = 0; i < raidlist->disks.entries; ++i) {
         if (!strcmp(raidlist->disks.el[i].device, temp)) {
-            strcpy(raidrec->sd[raidrec->subdisks].which_device,
-                   raidlist->disks.el[i].name);
+            strcpy(raidrec->sd[raidrec->subdisks].which_device, raidlist->disks.el[i].name);
             found = TRUE;
         }
@@ -1494 +1485 @@
                 switch (raidrec->plex[i].raidlevel) {
                 case -1:
-                    mr_asprintf(&raidlevel, "concat");
+                    mr_asprintf(raidlevel, "concat");
                     break;
                 case 0:
-                    mr_asprintf(&raidlevel, "striped");
+                    mr_asprintf(raidlevel, "striped");
                     break;
                 case 5:
-                    mr_asprintf(&raidlevel, "raid5");
+                    mr_asprintf(raidlevel, "raid5");
                     break;
                 default:
-                    mr_asprintf(&raidlevel, "raid%i", raidrec->plex[i].raidlevel);
+                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
                     break;
                 }
 
                 if (raidrec->plex[i].raidlevel == -1) {
-                    mr_asprintf(&chunksize, "N/A");
+                    mr_asprintf(chunksize, "N/A");
                 } else {
-                    mr_asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
+                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
                 }
                 snprintf(pname, 64, "%s.p%i", raidrec->volname, i);
@@ -1540 +1531 @@
 
         if (b_res == bDelete) {
-            mr_asprintf(&msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
+            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
             res = ask_me_yes_or_no(msg);
             mr_free(msg);
@@ -1578 +1569 @@
     /** buffers ***********************************************************/
     char *title_of_editraidForm_window;
-    char *sz_raid_level;
+    char *sz_raid_level = NULL;
     char *sz_data_disks = NULL;
     char *sz_spare_disks = NULL;
@@ -1600 +1591 @@
     assert(raidrec != NULL);
 
-    malloc_string(title_of_editraidForm_window);
-    malloc_string(sz_raid_level);
-
     bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
     log_it("Started edit_raidlist_entry");
 
     memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
-    sprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
+    mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
     log_msg(2, "Opening newt window");
     newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
     for (;;) {
         log_msg(2, "Main loop");
-        sprintf(title_of_editraidForm_window, "Edit %s",
-                raidrec->raid_device);
-        strcpy(sz_raid_level,
-               turn_raid_level_number_to_string(raidrec->raid_level));
+        mr_free(title_of_editraidForm_window);
+        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
+        mr_asprintf(sz_raid_level, "%s", turn_raid_level_number_to_string(raidrec->raid_level));
         /* Those 4 strings are allocated by the function  */
         sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
@@ -1666 +1653 @@
     newtPopWindow();
     mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
-    paranoid_free(title_of_editraidForm_window);
-    paranoid_free(sz_raid_level);
+    mr_free(title_of_editraidForm_window);
+    mr_free(sz_raid_level);
     paranoid_free(bkp_raidrec);
 #endif
@@ -1715 +1702 @@
 
     char *p = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
 
     struct mountlist_itself *unallocparts;
@@ -1730 +1719 @@
     for (;;) {
         int i;
-        char headerstr[MAX_STR_LEN];
-        char tmp[64];
-        snprintf(headerstr, MAX_STR_LEN, "%-24s %s", "Subdisk", "Device");
-
 
         switch (raidrec->raidlevel) {
         case -1:
-            strcpy(tmp, "concat");
+            mr_asprintf(tmp, "concat");
             break;
         case 0:
-            strcpy(tmp, "striped");
+            mr_asprintf(tmp, "striped");
             break;
         case 5:
-            strcpy(tmp, "raid5");
+            mr_asprintf(tmp, "raid5");
             break;
         default:
-            sprintf(tmp, "unknown (%i)", raidrec->raidlevel);
+            mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
             break;
         }
         bLevel = newtCompactButton(2, 2, " RAID level ");
         sLevel = newtLabel(19, 2, tmp);
+        mr_free(tmp);
 
         if (raidrec->raidlevel >= 0) {
-            sprintf(tmp, "%ik", raidrec->stripesize);
+            mr_asprintf(tmp, "%ik", raidrec->stripesize);
             bStripeSize = newtCompactButton(2, 4, " Stripe size ");
         } else {
-            strcpy(tmp, "N/A");
+            mr_asprintf(tmp, "N/A");
             bStripeSize = newtLabel(2, 4, "Stripe size:");
         }
         sStripeSize = newtLabel(19, 4, tmp);
+        mr_free(tmp);
 
         bOK = newtCompactButton(2, 16, "  OK  ");
@@ -1768 +1755 @@
 
 
-        //  plexesListbox = newtListbox (2, 7, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        //  plexesHeader  = newtLabel (2, 6, headerstr);
         unallocListbox =
             newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -1785 +1770 @@
                                                  raidlist);
         for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
-            char entry[MAX_STR_LEN];
             keylist[i] = (void *) i;
             if (i < raidrec->subdisks) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
-                         find_dev_entry_for_raid_device_name(raidlist,
-                                                             raidrec->
-                                                             sd[i].
-                                                             which_device));
+                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
                 newtListboxAppendEntry(allocListbox, entry, keylist[i]);
+                mr_free(entry);
             }
             if (i < unallocparts->entries) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
-                         unallocparts->el[i].device);
+                mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
                 newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
+                mr_free(entry);
             }
         }
@@ -1848 +1829 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            char *tmp = NULL;
-
             mr_asprintf(tmp, "%i", raidrec->stripesize);
             p = popup_and_get_string("Stripe size", "Please enter the stripe size in kilobytes.", tmp);
@@ -1973 +1952 @@
     bCancel = newtCompactButton(i += 12, 17, "Cancel");
     bOK = newtCompactButton(i += 12, 17, "  OK  ");
-    mr_asprintf(&tmp, "%-24s %-24s %-8s  %s", "Device", "Mountpoint", "Format", "Size (MB)");
+    mr_asprintf(tmp, "%-24s %-24s %-8s  %s", "Device", "Mountpoint", "Format", "Size (MB)");
     headerMsg = newtLabel(2, 1, tmp);
     flawsLabelA = newtLabel(2, 13, flaws_str_A);
@@ -2238 +2217 @@
 #ifdef __FreeBSD__
     for (i = 0; i < raidlist->entries; i++) {
-        mr_asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
         res = strcmp(device, vdev);
         mr_free(vdev);
@@ -2365 +2344 @@
     raidrec = &raidlist->el[pos_in_raidlist];
     initialize_raidrec(raidrec);
-    strcpy(raidrec->OSSWAP(raid_device, volname),
-           OSSWAP(device, basename(device)));
+    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
 #ifndef __FreeBSD__
     choose_raid_level(raidrec);
@@ -2618 +2596 @@
                                                    char *new_dev)
 {
-    /** buffers ********************************************************/
-    char *tmp = NULL;
-
     /** int ************************************************************/
     int pos = 0;
@@ -2631 +2606 @@
     pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
     if (pos < 0) {
-        mr_asprintf(&tmp, "No need to rejig %s in raidlist: it's not listed.", old_dev);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
     } else {
         if ((j =
@@ -2639 +2612 @@
                                          OSSWAP(el[pos].data_disks, disks),
                                          old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].
-                   device, new_dev);
+            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
         } else
             if ((j =
@@ -2647 +2619 @@
                                                     spares),
                                              old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].
-                   device, new_dev);
+            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
         }
 #ifndef __FreeBSD__
@@ -2665 +2636 @@
 #endif
         else {
-            mr_asprintf(&tmp, "%s is supposed to be listed in this raid dev but it's not...", old_dev);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
         }
     }

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

@@ -206 +206 @@
 {
 
-/** needs malloc **/
 char *command = NULL;
-char *file;
-char *tmp;
+char *file = NULL;
+char *tmp = NULL;
 int res;
 
-malloc_string(file);
-malloc_string(tmp);
 assert_string_is_neither_NULL_nor_zerolength(f);
 assert_string_is_neither_NULL_nor_zerolength(list_fname);
@@ -219 +216 @@
 
 if (strncmp(preamble, f, strlen(preamble)) == 0) {
-    strcpy(file, f + strlen(preamble));
+    mr_asprintf(file, "%s", f + strlen(preamble));
 } else {
-    strcpy(file, f);
+    mr_asprintf(file, "%s", f);
 }
 if (file[0] == '/' && file[1] == '/') {
-    strcpy(tmp, file);
-    strcpy(file, tmp + 1);
+    mr_asprintf(tmp, "%s", file);
+    mr_free(file);
+
+    mr_asprintf(file, "%s", tmp + 1);
+    mr_free(tmp);
 }
 log_msg(2, "Checking to see if f=%s, file=%s, is in the list of biggiefiles", f, file);
 mr_asprintf(command, "grep -E '^%s$' %s", file, list_fname);
+mr_free(file);
+
 res = run_program_and_log_output(command, FALSE);
 mr_free(command);
-paranoid_free(file);
-mr_free(tmp);
 if (res) {
     return (FALSE);
@@ -429 +429 @@
     }
     if (res) {
-        log_msg(1, "Unable to mount device %s (type %s) at %s", device,
-                format, mountdir);
+        log_msg(1, "Unable to mount device %s (type %s) at %s", device, format, mountdir);
         log_msg(1, "command was '%s'", command);
         if (!strcmp(mountpoint, "swap")) {
@@ -479 +478 @@
 char *tmp = NULL;
 char *these_failed = NULL;
-char *format;
 struct mountlist_itself *mountlist = NULL;
-
-malloc_string(format);
 
 assert(p_external_copy_of_mountlist != NULL);
@@ -511 +507 @@
             update_progress_form(tmp);
             mr_free(tmp);
-            strcpy(format, mountlist->el[lino].format);
-            res = mount_device(mountlist->el[lino].device,
-                       mountlist->el[lino].mountpoint,
-                       format, writeable);
+            res = mount_device(mountlist->el[lino].device, mountlist->el[lino].mountpoint, mountlist->el[lino].format, writeable);
+
             retval += res;
             if (res) {
@@ -556 +550 @@
     run_program_and_log_output("df -m", 3);
     paranoid_free(mountlist);
-    paranoid_free(format);
     return (retval);
 }
@@ -728 +721 @@
 char *iso_path = NULL;
 char *old_isodir = NULL;
-char cfg_file[100];
+char *cfg_file = NULL;
 t_bkptype media_specified_by_user;
 
@@ -736 +729 @@
 
 if (!cfgf) {
-    strcpy(cfg_file, g_mondo_cfg_file);
+    cfg_file = g_mondo_cfg_file;
 } else {
-    strcpy(cfg_file, cfgf);
+    cfg_file = cfgf;
 }
 
@@ -1495 +1488 @@
     char *conffile;
     char *tmp = NULL;
-    char *editor;
+    char *editor = NULL;
     char *p = NULL;
 
@@ -1501 +1494 @@
     bool done;
 
-    malloc_string(editor);
     malloc_string(rootdev);
     malloc_string(rootdrive);
     malloc_string(conffile);
     assert_string_is_neither_NULL_nor_zerolength(bd);
-    strcpy(editor, find_my_editor());
     mr_asprintf(boot_device, "%s", bd);
 
@@ -1544 +1535 @@
                 newtSuspend();
             }
+            mr_asprintf(editor, "%s", find_my_editor());
+
             mr_asprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
             paranoid_system(tmp);
@@ -1559 +1552 @@
             paranoid_system(tmp);
             mr_free(tmp);
+            mr_free(editor);
 
             if (!g_text_mode) {
@@ -1611 +1605 @@
     paranoid_free(rootdrive);
     paranoid_free(conffile);
-    paranoid_free(editor);
 
     return (res);
@@ -1631 +1624 @@
     char *command = NULL;
     char *tmp = NULL;
-    char *editor;
+    char *editor = NULL;
 
     int res;
     int done;
 
-    malloc_string(editor);
-    strcpy(editor, find_my_editor());
     if (offer_to_run_stabelilo
         && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
@@ -1657 +1648 @@
                     newtSuspend();
                 }
+                mr_asprintf(editor, "%s", find_my_editor());
+
                 mr_asprintf(tmp, "chroot %s %s /etc/fstab", MNT_RESTORING, editor);
                 paranoid_system(tmp);
@@ -1664 +1657 @@
                 paranoid_system(tmp);
                 mr_free(tmp);
+
+                mr_free(editor);
 
                 if (!g_text_mode) {
@@ -1682 +1677 @@
         res = TRUE;
     }
-    paranoid_free(editor);
     return (res);
 }
@@ -1701 +1695 @@
     char *command = NULL;
     char *tmp = NULL;
-    char *editor;
+    char *editor = NULL;
 
     int res;
     int done;
     bool run_lilo_M = FALSE;
-    malloc_string(editor);
 
     if (!run_program_and_log_output
@@ -1713 +1706 @@
     }
 
-    strcpy(editor, find_my_editor());
     if (offer_to_run_stablilo
         && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
@@ -1733 +1725 @@
                     newtSuspend();
                 }
+                mr_asprintf(editor, "%s", find_my_editor());
+
                 mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
                 paranoid_system(tmp);
@@ -1740 +1734 @@
                 paranoid_system(tmp);
                 mr_free(tmp);
+
+                mr_free(editor);
 
                 if (!g_text_mode) {
@@ -1795 +1791 @@
                                    " lilo -M /dev/sda", 3);
     }
-    paranoid_free(editor);
     return (res);
 }
@@ -1821 +1816 @@
     int done;
 
-    malloc_string(editor);
     assert_string_is_neither_NULL_nor_zerolength(bd);
 
-    strcpy(editor, find_my_editor());
     mr_asprintf(boot_device, "%s", bd);
 
@@ -1838 +1831 @@
                     newtSuspend();
                 }
+                mr_asprintf(editor, "%s", find_my_editor());
                 mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                mr_free(editor);
+
                 paranoid_system(tmp);
                 mr_free(tmp);
@@ -1884 +1880 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
-    paranoid_free(editor);
     return (res);
 }

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

@@ -443 +443 @@
     char *p = NULL;
     char *tmp1 = NULL;
-    char *fstab_fname;
+    char *fstab_fname = NULL;
     char *old_restpath = NULL;
 
@@ -453 +453 @@
 
     malloc_string(tmp);
-    malloc_string(fstab_fname);
     assert(bkpinfo != NULL);
     assert(mountlist != NULL);
@@ -640 +639 @@
                             "Using tune2fs to identify your ext2,3,4 partitions");
         if (does_file_exist("/tmp/fstab.new")) {
-            strcpy(fstab_fname, "/tmp/fstab.new");
+            mr_asprintf(fstab_fname, "/tmp/fstab.new");
         } else {
-            strcpy(fstab_fname, "/tmp/fstab");
+            mr_asprintf(fstab_fname, "/tmp/fstab");
         }
         mr_asprintf(tmp1, "label-partitions-as-necessary %s < %s >> %s 2>> %s", g_mountlist_fname, fstab_fname, MONDO_LOGFILE, MONDO_LOGFILE);
+        mr_free(fstab_fname);
+
         res = system(tmp1);
         mr_free(tmp1);
@@ -665 +666 @@
   end_of_func:
     paranoid_free(tmp);
-    paranoid_free(fstab_fname);
     log_it("Leaving interactive_mode()");
     return (retval);
@@ -1018 +1018 @@
 
   /** malloc ***/
-    char *checksum;
+    char *checksum = NULL;
     char *outfile_fname = NULL;
     char *tmp = NULL;
     char *bzip2_command = NULL;
-    char *ntfsprog_command, *suffix;
+    char *ntfsprog_command;
+    char *suffix = NULL;
     char *sz_devfile = NULL;
     char *bigblk;
-    char *p;
     char *mds = NULL;
     int retval = 0;
@@ -1031 +1031 @@
     long sliceno;
     long siz;
-    char ntfsprog_fifo[MAX_STR_LEN];
+    char *ntfsprog_fifo = NULL;
     char *file_to_openout = NULL;
     struct s_filename_and_lstat_info biggiestruct;
@@ -1045 +1045 @@
     assert(bkpinfo != NULL);
 
-    malloc_string(checksum);
     malloc_string(ntfsprog_command);
-    malloc_string(suffix);
 
     pathname_of_last_file_restored[0] = '\0';
@@ -1067 +1065 @@
     paranoid_fclose(fin);
 
-    strcpy(checksum, biggiestruct.checksum);
-
+    mr_asprintf(checksum, "%s", biggiestruct.checksum);
     if (!checksum[0]) {
         log_msg(3, "Warning - bigfile %ld does not have a checksum", bigfileno + 1);
-        p = checksum;
-    }
+    }
+    mr_free(checksum);
 
     if (!strncmp(biggiestruct.filename, "/dev/", 5))    // Whether NTFS or not :)
@@ -1085 +1082 @@
         node = find_string_at_node(filelist, biggiestruct.filename);
         if (!node) {
-            log_msg(0, "Skipping %s (name isn't in filelist)",
-                    biggiestruct.filename);
+            log_msg(0, "Skipping %s (name isn't in filelist)", biggiestruct.filename);
             pathname_of_last_file_restored[0] = '\0';
             return (0);
         } else if (!(node->selected)) {
-            log_msg(1, "Skipping %s (name isn't in biggielist subset)",
-                    biggiestruct.filename);
+            log_msg(1, "Skipping %s (name isn't in biggielist subset)", biggiestruct.filename);
             pathname_of_last_file_restored[0] = '\0';
             return (0);
         }
     }
+
     /* otherwise, continue */
-
     log_msg(1, "DEFINITELY restoring %s", biggiestruct.filename);
     if (biggiestruct.use_ntfsprog) {
         if (strncmp(biggiestruct.filename, "/dev/", 5)) {
-            log_msg(1,
-                    "I was in error when I set biggiestruct.use_ntfsprog to TRUE.");
+            log_msg(1, "I was in error when I set biggiestruct.use_ntfsprog to TRUE.");
             log_msg(1, "%s isn't even in /dev", biggiestruct.filename);
             biggiestruct.use_ntfsprog = FALSE;
@@ -1109 +1103 @@
 
     if (biggiestruct.use_ntfsprog)  // if it's an NTFS device
-//  if (!strncmp ( biggiestruct.filename, "/dev/", 5))
     {
         g_loglevel = 4;
@@ -1116 +1109 @@
         mr_asprintf(sz_devfile, "/tmp/%d.%d.000", (int) (random() % 32768), (int) (random() % 32768));
         mkfifo(sz_devfile, 0x770);
-        strcpy(ntfsprog_fifo, sz_devfile);
+        mr_asprintf(ntfsprog_fifo, "%s", sz_devfile);
         mr_free(sz_devfile);
         file_to_openout = ntfsprog_fifo;
@@ -1123 +1116 @@
             fatal_error("Fork failure");
         case 0:
-            log_msg(3,
-                    "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
-                    biggiestruct.filename, ntfsprog_fifo);
-            res =
-                feed_outfrom_ntfsprog(biggiestruct.filename,
-                                       ntfsprog_fifo);
-//          log_msg(3, "CHILD - fip - exiting");
+            log_msg(3, "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)", biggiestruct.filename, ntfsprog_fifo);
+            res = feed_outfrom_ntfsprog(biggiestruct.filename, ntfsprog_fifo);
+            mr_free(ntfsprog_fifo);
             exit(res);
             break;
         default:
-            log_msg(3,
-                    "feed_into_ntfsprog() called in background --- pid=%ld",
-                    (long int) (pid));
-        }
+            log_msg(3, "feed_into_ntfsprog() called in background --- pid=%ld", (long int) (pid));
+        }
+        mr_free(ntfsprog_fifo);
     } else {
         use_ntfsprog_hack = FALSE;
-        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1155 +1142 @@
      */
 
-    strncpy(pathname_of_last_file_restored, biggiestruct.filename,
-            MAX_STR_LEN - 1);
+    strncpy(pathname_of_last_file_restored, biggiestruct.filename, MAX_STR_LEN - 1);
     pathname_of_last_file_restored[MAX_STR_LEN - 1] = '\0';
 
@@ -1167 +1153 @@
 
     for (sliceno = 1, finished = FALSE; !finished;) {
-        if (!does_file_exist
-            (slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""))
-            &&
-            !does_file_exist(slice_fname
-                             (bigfileno, sliceno, ARCHIVES_PATH, "lzo"))
-            &&
-            !does_file_exist(slice_fname
-                             (bigfileno, sliceno, ARCHIVES_PATH, "gz"))
-            &&
-            !does_file_exist(slice_fname
-                             (bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
-            log_msg(3,
-                    "Cannot find a data slice or terminator slice on CD %d",
-                    g_current_media_number);
+        if (!does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "")) &&
+            !does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "lzo")) &&
+            !does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "gz")) &&
+            !does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
+            log_msg(3, "Cannot find a data slice or terminator slice on CD %d", g_current_media_number);
             g_current_media_number++;
             mds = media_descriptor_string(bkpinfo->backup_media_type);
@@ -1193 +1170 @@
             mr_asprintf(tmp, "%s", slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""));
             if (does_file_exist(tmp) && length_of_file(tmp) == 0) {
-                log_msg(2,
-                        "End of bigfile # %ld (slice %ld is the terminator)",
-                        bigfileno + 1, sliceno);
+                log_msg(2, "End of bigfile # %ld (slice %ld is the terminator)", bigfileno + 1, sliceno);
                 finished = TRUE;
                 mr_free(tmp);
                 continue;
             } else {
-                if (does_file_exist
-                    (slice_fname
-                     (bigfileno, sliceno, ARCHIVES_PATH, "lzo"))) {
+                if (does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "lzo"))) {
                     mr_asprintf(bzip2_command, "lzop");
-                    strcpy(suffix, "lzo");
+                    mr_asprintf(suffix, "lzo");
                 } else
-                    if (does_file_exist
-                        (slice_fname
-                         (bigfileno, sliceno, ARCHIVES_PATH, "gz"))) {
+                    if (does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "gz"))) {
                     mr_asprintf(bzip2_command, "gzip");
-                    strcpy(suffix, "gz");
+                    mr_asprintf(suffix, "gz");
                 } else
-                    if (does_file_exist
-                        (slice_fname
-                         (bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
+                    if (does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
                     mr_asprintf(bzip2_command, "bzip2");
-                    strcpy(suffix, "bz2");
+                    mr_asprintf(suffix, "bz2");
                 } else
-                    if (does_file_exist
-                        (slice_fname
-                         (bigfileno, sliceno, ARCHIVES_PATH, ""))) {
+                    if (does_file_exist(slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""))) {
                     mr_asprintf(bzip2_command, "");
-                    strcpy(suffix, "");
+                    mr_asprintf(suffix, "");
                 } else {
                     log_to_screen("OK, that's pretty fsck0red...");
@@ -1235 +1202 @@
                 mr_asprintf(bzip2_command, "cat %s 2>> %s", slice_fname(bigfileno, sliceno, ARCHIVES_PATH, suffix), MONDO_LOGFILE);
             }
+            mr_free(suffix);
+
             mds = media_descriptor_string(bkpinfo->backup_media_type);
             mr_asprintf(tmp, "Working on %s #%d, file #%ld, slice #%ld    ", mds, g_current_media_number, bigfileno + 1, sliceno);
@@ -1288 +1257 @@
     mr_free(outfile_fname);
     paranoid_free(bigblk);
-    paranoid_free(checksum);
     paranoid_free(ntfsprog_command);
-    paranoid_free(suffix);
 
     return (retval);
@@ -1331 +1298 @@
     char *ntfsprog_command;
     char *sz_devfile = NULL;
-    char *ntfsprog_fifo;
+    char *ntfsprog_fifo = NULL;
     char *file_to_openout = NULL;
 
@@ -1350 +1317 @@
 
     malloc_string(tmp);
-    malloc_string(ntfsprog_fifo);
     malloc_string(ntfsprog_command);
     old_loglevel = g_loglevel;
@@ -1407 +1373 @@
         mr_asprintf(sz_devfile, "%s/%d.%d.000", bkpinfo->tmpdir, (int) (random() % 32768), (int) (random() % 32768));
         mkfifo(sz_devfile, 0x770);
-        strcpy(ntfsprog_fifo, sz_devfile);
+        mr_asprintf(ntfsprog_fifo, "%s", sz_devfile);
         mr_free(sz_devfile);
 
@@ -1417 +1383 @@
             log_msg(3, "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)", outfile_fname, ntfsprog_fifo);
             res = feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
+            mr_free(ntfsprog_fifo);
             exit(res);
             break;
@@ -1422 +1389 @@
             log_msg(3, "feed_into_ntfsprog() called in background --- pid=%ld", (long int) (pid));
         }
+        mr_free(ntfsprog_fifo);
     } else {
         if (!strncmp(orig_bf_fname, "/dev/", 5))    {
@@ -1431 +1399 @@
         }
         use_ntfsprog_hack = FALSE;
-        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1539 +1506 @@
     paranoid_free(tmp);
     paranoid_free(ntfsprog_command);
-    paranoid_free(ntfsprog_fifo);
     g_loglevel = old_loglevel;
     return (retval);
@@ -2099 +2065 @@
     char *tarball_fname = NULL;
     char *progress_str = NULL;
-    char *comment;
-
-    malloc_string(comment);
 
     assert(bkpinfo != NULL);
@@ -2182 +2145 @@
                 mr_strcat(tmp1, " (%d attempts) - review logs", attempts);
             }
-            strcpy(comment, tmp1);
+            if (attempts > 1) {
+                log_to_screen(tmp1);
+            }
             mr_free(tmp1);
-            if (attempts > 1) {
-                log_to_screen(comment);
-            }
 
             retval += res;
@@ -2203 +2165 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
-    paranoid_free(comment);
 
     return (retval);
@@ -2633 +2594 @@
     struct raidlist_itself *raidlist;
     struct s_node *filelist;
-    char *a, *b;
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
     bool run_postnuke = FALSE;
 
@@ -2663 +2625 @@
     run_program_and_log_output("mkdir -p " MNT_CDROM, FALSE);
 
-    malloc_string(a);
-    malloc_string(b);
     setup_MR_global_filenames();    // malloc() and set globals, using bkpinfo->tmpdir etc.
     bkpinfo->backup_media_type = none;  // in case boot disk was made for one backup type but user wants to restore from another backup type
@@ -2753 +2713 @@
         toggle_path_selection(filelist, "/usr/share", TRUE);
         save_filelist(filelist, "/tmp/out.txt");
-        strcpy(a, argv[3]);
-        strcpy(b, argv[4]);
-
-        res = save_filelist_entries_in_common(a, filelist, b, FALSE);
+        mr_asprintf(tmp1, "%s", argv[3]);
+        mr_asprintf(tmp2, "%s", argv[4]);
+
+        res = save_filelist_entries_in_common(tmp1, filelist, tmp2, FALSE);
+        mr_free(tmp1);
+        mr_free(tmp2);
+
         free_filelist(filelist);
         printf("res = %d", res);
@@ -3029 +2992 @@
     paranoid_MR_finish(retval); // frees global stuff plus bkpinfo
     free_libmondo_global_strings(); // it's fine to have this here :) really :)
-    paranoid_free(a);
-    paranoid_free(b);
 
     unlink("/tmp/filelist.full");