Changeset 3611 in MondoRescue

Timestamp:

Nov 10, 2016, 9:09:54 PM (8 years ago)

Author:

Bruno Cornec

Message:

Remove more static allocation

Location:

branches/3.2/mondo/src

Files:

• common/libmondo-files.c (modified) (2 diffs)
• common/libmondo-stream.c (modified) (5 diffs)
• common/libmondo-string.c (modified) (12 diffs)
• mondorestore/mondo-prep.c (modified) (2 diffs)
• mondorestore/mondo-rstr-mountlist.c (modified) (8 diffs)
• mondorestore/mondo-rstr-newt.c (modified) (6 diffs)

branches/3.2/mondo/src/common/libmondo-files.c

@@ -1116 +1116 @@
     /*@ buffers *************** */
     char *tmp = NULL;
+    char *tmp1 = NULL;
     char *mds = NULL;
 
@@ -1142 +1143 @@
         scratchLL++;
     }
+    tmp1 = number_to_text((int) (scratchLL + 1));
     if (scratchLL <= 1) {
         mds = media_descriptor_string(bkpinfo->backup_media_type);
         mr_asprintf(tmp, "Your backup will probably occupy a single %s. Maybe two.", mds);
         mr_free(mds);
-    } else if (scratchLL > 4) {
-        mr_asprintf(tmp, "Your backup will occupy one meeeeellion media! (maybe %s)", number_to_text((int) (scratchLL + 1)));
+    } else if (scratchLL > 5) {
+        mr_asprintf(tmp, "Your backup will occupy one meeeeellion media! (maybe %s)", tmp1);
     } else {
-        mr_asprintf(tmp, "Your backup will occupy approximately %s media.", number_to_text((int) (scratchLL + 1)));
+        mr_asprintf(tmp, "Your backup will occupy approximately %s media.", tmp1);
     }
     if (scratchLL < 50) {
         log_to_screen(tmp);
     }
+    mr_free(tmp1);
     mr_free(tmp);
 }

branches/3.2/mondo/src/common/libmondo-stream.c

@@ -1177 +1177 @@
     /*@ buffers ***************************************************** */
     char *tempblock;
+    char *tmp = NULL;
 
     /*@ int ********************************************************* */
@@ -1208 +1209 @@
     }
     tempblock[i] = '\0';
-    log_msg(6, "%s (fname=%s, size=%ld K)",
-            marker_to_string(*pcontrol_char), tempblock + 1000,
-            (long) (*plen) >> 10);
+    tmp = marker_to_string(*pcontrol_char);
+    log_msg(6, "%s (fname=%s, size=%ld K)", tmp, tempblock + 1000, (long) (*plen) >> 10);
+    mr_free(tmp);
     paranoid_free(tempblock);
     return (retval);
@@ -1751 +1752 @@
     char tempblock[TAPE_BLOCK_SIZE];
     char *p;
+    char *tmp = NULL;
 
     /*@ int ******************************************************** */
@@ -1782 +1784 @@
     strcpy(tempblock + 1000, filename);
     g_tape_posK += fwrite(tempblock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream) / 1024;
-    log_msg(6, "%s (fname=%s, size=%ld K)", marker_to_string(control_char), p, (long) length_of_incoming_file >> 10);
+    tmp = marker_to_string(control_char);
+    log_msg(6, "%s (fname=%s, size=%ld K)", tmp, p, (long) length_of_incoming_file >> 10);
+    mr_free(tmp);
     return (0);
 }
@@ -1802 +1806 @@
 void wrong_marker(int should_be, int it_is)
 {
-    log_to_screen("Wrong marker! (Should be %s, is actually %s)", marker_to_string(should_be), marker_to_string(it_is));
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    tmp1 =  marker_to_string(should_be);
+    tmp2 =  marker_to_string(it_is);
+    log_to_screen("Wrong marker! (Should be %s, is actually %s)", tmp1, tmp2);
+    mr_free(tmp1);
+    mr_free(tmp2);
 }
 

branches/3.2/mondo/src/common/libmondo-string.c

@@ -147 +147 @@
 
 /**
- * Add commas every third place in @p input.
- * @param input The string to commarize.
- * @return The string with commas.
- * @note The returned string points to static storage that will be overwritten with each call.
- */
-char *commarize(char *input)
-{
-    char pos_w_commas[MAX_STR_LEN];
-    static char output[MAX_STR_LEN];
-    char tmp[MAX_STR_LEN];
-    int j;
-
-    assert(input != NULL);
-
-    strcpy(tmp, input);
-    if (strlen(tmp) > 6) {
-        strcpy(pos_w_commas, tmp);
-        j = (int) strlen(pos_w_commas);
-        tmp[j - 6] = ',';
-        strcpy(tmp + j - 5, pos_w_commas + j - 6);
-        strcpy(pos_w_commas, tmp);
-    }
-    if (strlen(tmp) > 3) {
-        j = (int) strlen(tmp);
-        strcpy(pos_w_commas, tmp);
-        pos_w_commas[j - 3] = ',';
-        strcpy(pos_w_commas + j - 2, tmp + j - 3);
-    } else {
-        strcpy(pos_w_commas, tmp);
-    }
-    strcpy(output, pos_w_commas);
-    return (output);
-}
-
-
-/**
  * Turn an entry from the RAID editor's disklist into a GUI-friendly string.
  * The format is: the device left-aligned and padded to 24 places, followed by a space and the
@@ -190 +154 @@
  * @param lino The line number from @p disklist to convert to a string.
  * @return The string form of the disklist entry.
- * @note The returned string points to static storage and will be overwritten with each call.
+ * @note The returned string points to storage that needs to be freed by
+ * caller
  */
 char *disklist_entry_to_string(struct list_of_disks *disklist, int lino)
@@ -196 +161 @@
 
     /*@ buffers ********************************************************** */
-    static char output[MAX_STR_LEN];
+    char *output = NULL;
 
     assert(disklist != NULL);
 
-    sprintf(output, "%-24s %8d", disklist->el[lino].device,
-            disklist->el[lino].index);
-    return (output);
+    mr_asprintf(output, "%-24s %8d", disklist->el[lino].device, disklist->el[lino].index);
+    return(output);
 }
 
@@ -301 +265 @@
  * @param marker The marker byte to stringify.
  * @return @p marker as a string.
- * @note The returned string points to static storage that will be overwritten with each call.
+ * @note The returned string points to storage that needs to be freed by
+ * caller
  */
 char *marker_to_string(int marker)
 {
     /*@ buffer ****************************************************** */
-    static char outstr[MAX_STR_LEN];
+    char *outstr = NULL;
 
 
@@ -313 +278 @@
     switch (marker) {
     case BLK_START_OF_BACKUP:
-        strcpy(outstr, "BLK_START_OF_BACKUP");
+        mr_asprintf(outstr, "BLK_START_OF_BACKUP");
         break;
     case BLK_START_OF_TAPE:
-        strcpy(outstr, "BLK_START_OF_TAPE");
+        mr_asprintf(outstr, "BLK_START_OF_TAPE");
         break;
     case BLK_START_AN_AFIO_OR_SLICE:
-        strcpy(outstr, "BLK_START_AN_AFIO_OR_SLICE");
+        mr_asprintf(outstr, "BLK_START_AN_AFIO_OR_SLICE");
         break;
     case BLK_STOP_AN_AFIO_OR_SLICE:
-        strcpy(outstr, "BLK_STOP_AN_AFIO_OR_SLICE");
+        mr_asprintf(outstr, "BLK_STOP_AN_AFIO_OR_SLICE");
         break;
     case BLK_START_AFIOBALLS:
-        strcpy(outstr, "BLK_START_AFIOBALLS");
+        mr_asprintf(outstr, "BLK_START_AFIOBALLS");
         break;
     case BLK_STOP_AFIOBALLS:
-        strcpy(outstr, "BLK_STOP_AFIOBALLS");
+        mr_asprintf(outstr, "BLK_STOP_AFIOBALLS");
         break;
     case BLK_STOP_BIGGIEFILES:
-        strcpy(outstr, "BLK_STOP_BIGGIEFILES");
+        mr_asprintf(outstr, "BLK_STOP_BIGGIEFILES");
         break;
     case BLK_START_A_NORMBIGGIE:
-        strcpy(outstr, "BLK_START_A_NORMBIGGIE");
+        mr_asprintf(outstr, "BLK_START_A_NORMBIGGIE");
         break;
     case BLK_START_A_PIHBIGGIE:
-        strcpy(outstr, "BLK_START_A_PIHBIGGIE");
+        mr_asprintf(outstr, "BLK_START_A_PIHBIGGIE");
         break;
     case BLK_START_EXTENDED_ATTRIBUTES:
-        strcpy(outstr, "BLK_START_EXTENDED_ATTRIBUTES");
+        mr_asprintf(outstr, "BLK_START_EXTENDED_ATTRIBUTES");
         break;
     case BLK_STOP_EXTENDED_ATTRIBUTES:
-        strcpy(outstr, "BLK_STOP_EXTENDED_ATTRIBUTES");
+        mr_asprintf(outstr, "BLK_STOP_EXTENDED_ATTRIBUTES");
         break;
     case BLK_START_EXAT_FILE:
-        strcpy(outstr, "BLK_START_EXAT_FILE");
+        mr_asprintf(outstr, "BLK_START_EXAT_FILE");
         break;
     case BLK_STOP_EXAT_FILE:
-        strcpy(outstr, "BLK_STOP_EXAT_FILE");
+        mr_asprintf(outstr, "BLK_STOP_EXAT_FILE");
         break;
     case BLK_START_BIGGIEFILES:
-        strcpy(outstr, "BLK_START_BIGGIEFILES");
+        mr_asprintf(outstr, "BLK_START_BIGGIEFILES");
         break;
     case BLK_STOP_A_BIGGIE:
-        strcpy(outstr, "BLK_STOP_A_BIGGIE");
+        mr_asprintf(outstr, "BLK_STOP_A_BIGGIE");
         break;
     case BLK_END_OF_TAPE:
-        strcpy(outstr, "BLK_END_OF_TAPE");
+        mr_asprintf(outstr, "BLK_END_OF_TAPE");
         break;
     case BLK_END_OF_BACKUP:
-        strcpy(outstr, "BLK_END_OF_BACKUP");
+        mr_asprintf(outstr, "BLK_END_OF_BACKUP");
         break;
     case BLK_ABORTED_BACKUP:
-        strcpy(outstr, "BLK_ABORTED_BACKUP");
+        mr_asprintf(outstr, "BLK_ABORTED_BACKUP");
         break;
     case BLK_START_FILE:
-        strcpy(outstr, "BLK_START_FILE");
+        mr_asprintf(outstr, "BLK_START_FILE");
         break;
     case BLK_STOP_FILE:
-        strcpy(outstr, "BLK_STOP_FILE");
+        mr_asprintf(outstr, "BLK_STOP_FILE");
         break;
     default:
-        sprintf(outstr, "BLK_UNKNOWN (%d)", marker);
+        mr_asprintf(outstr, "BLK_UNKNOWN (%d)", marker);
         break;
     }
     return (outstr);
 }
-
-
 
 
@@ -391 +354 @@
  * @param lino The line number in @p mountlist to stringify.
  * @return The string form of <tt>mountlist</tt>-\>el[<tt>lino</tt>].
- * @note The returned string points to static storage and will be overwritten with each call.
- */
-char *mountlist_entry_to_string(struct mountlist_itself *mountlist,
-                                int lino)
-{
+ * @note The returned string points to storage that needs to be freed by
+ * caller
+ */
+char *mountlist_entry_to_string(struct mountlist_itself *mountlist, int lino) {
 
     /*@ buffer *********************************************************** */
-    static char output[MAX_STR_LEN];
+    char *output = NULL;
 
     assert(mountlist != NULL);
 
-    sprintf(output, "%-24s %-24s %-10s %8lld", mountlist->el[lino].device,
-            mountlist->el[lino].mountpoint, mountlist->el[lino].format,
-            mountlist->el[lino].size / 1024L);
-    return (output);
+    mr_asprintf(output, "%-24s %-24s %-10s %8lld", mountlist->el[lino].device, mountlist->el[lino].mountpoint, mountlist->el[lino].format, mountlist->el[lino].size / 1024L);
+    return(output);
 }
 
@@ -453 +413 @@
  * @param i The number to stringify.
  * @return The string form of @p i.
- * @note The returned value points to static strorage that will be overwritten with each call.
+ * @note The returned value points to strorage that needs to be freed by
+ * caller
  */
 char *number_to_text(int i)
@@ -459 +420 @@
 
     /*@ buffers ***************************************************** */
-    static char output[MAX_STR_LEN];
+    char *output = NULL;
 
 
@@ -466 +427 @@
     switch (i) {
     case 0:
-        strcpy(output, "zero");
+        mr_asprintf(output, "zero");
         break;
     case 1:
-        strcpy(output, "one");
+        mr_asprintf(output, "one");
         break;
     case 2:
-        strcpy(output, "two");
+        mr_asprintf(output, "two");
         break;
     case 3:
-        strcpy(output, "three");
+        mr_asprintf(output, "three");
         break;
     case 4:
-        strcpy(output, "four");
+        mr_asprintf(output, "four");
         break;
     case 5:
-        strcpy(output, "five");
+        mr_asprintf(output, "five");
         break;
     case 6:
-        strcpy(output, "six");
+        mr_asprintf(output, "six");
         break;
     case 7:
-        strcpy(output, "seven");
+        mr_asprintf(output, "seven");
         break;
     case 8:
-        strcpy(output, "eight");
+        mr_asprintf(output, "eight");
         break;
     case 9:
-        strcpy(output, "nine");
+        mr_asprintf(output, "nine");
     case 10:
-        strcpy(output, "ten");
+        mr_asprintf(output, "ten");
     default:
-        sprintf(output, "%d", i);
+        mr_asprintf(output, "%d", i);
     }
     return (output);
@@ -875 +836 @@
  * @param raid_level The RAID level to stringify.
  * @return The string form of @p raid_level.
- * @note The returned value points to static storage that will be overwritten with each call.
+ * @note The returned value points to storage that needs to be freed by caller
  */
 char *turn_raid_level_number_to_string(int raid_level)
@@ -881 +842 @@
 
     /*@ buffer ********************************************************** */
-    static char output[MAX_STR_LEN];
+    char *output = NULL;
 
 
 
     if (raid_level >= 0) {
-        sprintf(output, " RAID %-2d ", raid_level);
+        mr_asprintf(output, " RAID %-2d ", raid_level);
     } else {
-        sprintf(output, "Linear RAID");
-    }
-    return (output);
+        mr_asprintf(output, "Linear RAID");
+    }
+    return(output);
 }
 
@@ -1068 +1029 @@
     char *pos_w_commas = NULL;
     char *mds = NULL;
-    char *tmp = NULL;
 
     assert(bkpinfo != NULL);
 
     if (bkpinfo->media_size <= 0) {
-        mr_asprintf(tmp, "%lld", g_tape_posK);
-        mr_asprintf(pos_w_commas, "%s", commarize(tmp));
-        mr_free(tmp);
+        mr_asprintf(pos_w_commas, "%lld", g_tape_posK);
         mr_asprintf(outstr, "Volume %d: %s kilobytes archived so far", g_current_media_number, pos_w_commas);
         mr_free(pos_w_commas);

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

@@ -1839 +1839 @@
     mr_asprintf(partcode, "");
 } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-    mr_asprintf(partcode, format);
+    mr_asprintf(partcode, "%s", format);
 } else {
     /* probably an image */
@@ -1847 +1847 @@
 
 #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
 }

branches/3.2/mondo/src/mondorestore/mondo-rstr-mountlist.c

@@ -55 +55 @@
     /*@ buffers ******************************************************** */
     char tmp = NULL;
+    char tmp1 = NULL;
     char device[MAX_STR_LEN];
 
@@ -112 +113 @@
             }
             if (device_copies > 1) {
-                mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
+                tmp1 = number_to_text(device_copies);
+                mr_asprintf(tmp, " %s %s's.", tmp1, device);
+                mr_free(tmp1);
                 if (!strstr(flaws_str, tmp)) {
                     log_it(tmp);
@@ -209 +212 @@
             }
             if (device_copies > 1) {
-                mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
+                tmp1 = number_to_text(device_copies);
+                mr_asprintf(tmp, " %s %s's.", tmp1, device);
+                mr_free(tmp1);
                 if (!strstr(flaws_str, "%s", tmp)) {
                     log_it(tmp);
@@ -271 +276 @@
                 }
                 if (device_copies > 1) {
-                    mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
+                    tmp1 = number_to_text(device_copies);
+                    mr_asprintf(tmp, " %s %s's.", tmp1, device);
+                    mr_free(tmp1);
                     if (!strstr(flaws_str, tmp)) {
                         log_it(tmp);
@@ -374 +381 @@
     /*@ buffers ******************************************************** */
     char *tmp = NULL;
+    char *tmp1 = NULL;
     char *device = NULL;
     char *flaws_str = NULL;
@@ -452 +460 @@
         }
         if (device_copies > 1) {
-            mr_asprintf(tmp, " %s %s's.", number_to_text(device_copies), device);
+            tmp1 = number_to_text(device_copies);
+            mr_asprintf(tmp, " %s %s's.", tmp1, device);
+            mr_free(tmp1);
             if (!strstr(flaws_str, tmp)) {
                 log_it(tmp);
@@ -536 +546 @@
     struct list_of_disks *drivelist;
     char *tmp = NULL;
+    char *tmp1 = NULL;
     char *flaws_str = NULL;
 
@@ -589 +600 @@
         }
         if (copies > 1 && last_copy == currline && strcmp(curr_mountpoint, "raid")) {
-            mr_asprintf(tmp, " %s %s's.", number_to_text(copies), curr_mountpoint);
+            tmp1 = number_to_text(copies);
+            mr_asprintf(tmp, " %s %s's.", tmp1, curr_mountpoint);
+            mr_free(tmp1);
             log_msg(8,"Adding: %s to flaws_str", tmp);
             if (flaws_str != NULL) {

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

@@ -1296 +1296 @@
     }
     mr_free(size_str);
-    newtListboxSetEntry(listbox, (long) keylist[currline],
-                        mountlist_entry_to_string(mountlist, currline));
+
+    tmp = mountlist_entry_to_string(mountlist, currline);
+    newtListboxSetEntry(listbox, (long) keylist[currline], tmp);
+    mr_free(tmp);
+
     /* if new /dev/md RAID device then do funky stuff */
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
@@ -1580 +1583 @@
         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));
+        sz_raid_level = turn_raid_level_number_to_string(raidrec->raid_level);
         sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
         sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
@@ -2335 +2338 @@
     /** long **************************************************************/
     long i = 0;
+    char *tmp = NULL;
 
     assert(disklist != NULL);
@@ -2346 +2350 @@
     }
     for (i = 0; i < disklist->entries; i++) {
-        newtListboxAppendEntry(listbox,
-                               disklist_entry_to_string(disklist, i),
-                               keylist[i]);
+        tmp = disklist_entry_to_string(disklist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
     }
 }
@@ -2367 +2371 @@
     /** long **************************************************************/
     long i = 0;
+    char * tmp = NULL;
 
     assert(mountlist != NULL);
@@ -2378 +2383 @@
     }
     for (i = 0; i < mountlist->entries; i++) {
-        newtListboxAppendEntry(listbox,
-                               mountlist_entry_to_string(mountlist, i),
-                               keylist[i]);
+        tmp = mountlist_entry_to_string(mountlist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
     }
 }