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

Timestamp:

Aug 18, 2009, 2:34:29 PM (16 years ago)

Author:

Bruno Cornec

Message:

r3327@localhost: bruno | 2009-08-04 00:17:46 +0200
popup_and_get_string and build_partition_name now return an allocated string

Location:

branches/2.2.10/mondo/src/mondorestore

Files:

• mondo-prep.c (modified) (21 diffs)
• mondo-rstr-newt.c (modified) (13 diffs)
• mondo-rstr-newt.h (modified) (1 diff)
• mondo-rstr-tools.c (modified) (18 diffs)
• mondoprep.h (modified) (1 diff)
• mondorestore.c (modified) (6 diffs)
• mr-externs.h (modified) (1 diff)

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

@@ -1457 +1457 @@
 
     /** buffers *********************************************************/
-    char *device_str;
+    char *device_str = NULL;
     char *format;
     char *tmp = NULL;
@@ -1466 +1466 @@
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
-    malloc_string(device_str);
     malloc_string(format);
 
@@ -1483 +1482 @@
     if (!pout_to_fdisk) {
         log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
-        paranoid_free(device_str);
         paranoid_free(format);
         return (1);
@@ -1489 +1487 @@
 #endif
     for (current_devno = 1; current_devno < 99; current_devno++) {
-        build_partition_name(device_str, drivename, current_devno);
+        device_str = build_partition_name(drivename, current_devno);
         lino = find_device_in_mountlist(mountlist, device_str);
 
@@ -1518 +1516 @@
                     }
                     mr_free(command);
-                    paranoid_free(device_str);
+                    mr_free(device_str);
                     paranoid_free(format);
                     return r;
@@ -1547 +1545 @@
                 }
             } else {
+                mr_free(device_str);
                 continue;
             }
 #else
+            mr_free(device_str);
             continue;
 #endif
@@ -1606 +1606 @@
             log_to_screen
                 ("You must leave at least one partition spare as the Extended partition.");
-            paranoid_free(device_str);
+            mr_free(device_str);
             paranoid_free(format);
             return (1);
@@ -1627 +1627 @@
         }
 #endif
+        mr_free(device_str);
 
         previous_devno = current_devno;
@@ -1666 +1667 @@
         }
     }
-    paranoid_free(device_str);
     paranoid_free(format);
     return (retval);
@@ -1690 +1690 @@
     /** buffers **********************************************************/
     char *program = NULL;
-    char *partition_name;
+    char *partition_name = NULL;
     char *tmp = NULL;
     char *output = NULL;
@@ -1701 +1701 @@
     /** end ***************************************************************/
 
-    malloc_string(partition_name);
-
     assert_string_is_neither_NULL_nor_zerolength(drive);
     assert(format != NULL);
@@ -1714 +1712 @@
         mr_free(tmp);
 
-        paranoid_free(partition_name);
         return (0);
     }
-    build_partition_name(partition_name, drive, partno);
+    partition_name = build_partition_name(drive, partno);
     if (partsize <= 0) {
         mr_asprintf(&tmp, "Partitioning device %s (max size)", partition_name);
@@ -1731 +1728 @@
         log_to_screen(tmp);
         mr_free(tmp);
-        paranoid_free(partition_name);
+        mr_free(partition_name);
         return (1);
     }
@@ -1749 +1746 @@
             if (partno == 5) {
                 if (prev_partno >= 4) {
-                    log_to_screen
-                        ("You need to leave at least one partition free, for 'extended/logical'");
-                    paranoid_free(partition_name);
+                    log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
+                    mr_free(partition_name);
                     paranoid_free(output);
                     return (1);
@@ -1776 +1772 @@
     log_it(tmp);
     mr_free(tmp);
+
     log_it("---fdisk command---");
     log_it(output);
@@ -1867 +1864 @@
     }
     mr_free(program);
+    mr_free(partition_name);
     paranoid_free(output);
 
     g_current_progress++;
     log_it("partition_device() --- leaving");
-    paranoid_free(partition_name);
     return (retval);
 }
@@ -1979 +1976 @@
 {
     /** buffers *********************************************************/
-    char *partition;
+    char *partition = NULL;
     char *command = NULL;
     char *output = NULL;
     char *tmp = NULL;
-    char *partcode;
+    char *partcode = NULL;
 
     /** pointers *********************************************************/
@@ -1997 +1994 @@
     assert(format != NULL);
 
-    malloc_string(partition);
-    malloc_string(partcode);
-
-    build_partition_name(partition, drive, partno);
+    partition = build_partition_name(drive, partno);
     p = (char *) strrchr(partition, '/');
     if (strcmp(format, "swap") == 0) {
-        strcpy(partcode, "82");
+        mr_asprintf(&partcode, "82");
     } else if (strcmp(format, "vfat") == 0) {
         if (partsize / 1024 > 8192) {
-            strcpy(partcode, "c");
+            mr_asprintf(&partcode, "c");
         } else {
-            strcpy(partcode, "b");
+            mr_asprintf(&partcode, "b");
         }
     } else if (strcmp(format, "ext2") == 0
@@ -2016 +2010 @@
                || strcmp(format, "xfs") == 0
                || strcmp(format, "jfs") == 0) {
-        strcpy(partcode, "83");
+        mr_asprintf(&partcode, "83");
     } else if (strcmp(format, "minix") == 0) {
-        strcpy(partcode, "81");
+        mr_asprintf(&partcode, "81");
     } else if (strcmp(format, "vmfs3") == 0) {
-        strcpy(partcode, "fb");
+        mr_asprintf(&partcode, "fb");
     } else if (strcmp(format, "vmkcore") == 0) {
-        strcpy(partcode, "fc");
+        mr_asprintf(&partcode, "fc");
     } else if (strcmp(format, "raid") == 0) {
-        strcpy(partcode, "fd");
+        mr_asprintf(&partcode, "fd");
     } else if (strcmp(format, "ntfs") == 0) {
-        strcpy(partcode, "7");
+        mr_asprintf(&partcode, "7");
     } else if ((strcmp(format, "ufs") == 0)
                || (strcmp(format, "ffs") == 0)) {   /* raid autodetect */
-        strcpy(partcode, "a5");
+        mr_asprintf(&partcode, "a5");
     } else if (strcmp(format, "lvm") == 0) {
-        strcpy(partcode, "8e");
+        mr_asprintf(&partcode, "8e");
     } else if (format[0] == '\0') { /* LVM physical partition */
-        partcode[0] = '\0';
+        mr_asprintf(&partcode, "");
     } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-        strcpy(partcode, format);
+        mr_asprintf(&partcode, format);
     } else {
         /* probably an image */
@@ -2042 +2036 @@
         mr_free(tmp);
 #ifdef __FreeBSD__
-        strcpy(partcode, format);   // was a5
+        mr_asprintf(&partcode, format); // was a5
 #else
-        strcpy(partcode, format);   // was 83
+        mr_asprintf(&partcode, format); // was 83
 #endif
     }
     log_msg(1, tmp, "Setting %s's type to %s (%s)", partition, format, partcode);
-    if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
+    mr_free(partition);
+
+    if (partcode != NULL && strcmp(partcode, "83")) {   /* no need to set type if 83: 83 is default */
 
         if (pout_to_fdisk) {
@@ -2104 +2100 @@
     }
 
-    paranoid_free(partition);
-    paranoid_free(partcode);
-
+    mr_free(partcode);
     return (res);
 }

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

@@ -12 +12 @@
 #include "mondo-rstr-newt.h"
 #include "mr_mem.h"
+#include "mr_str.h"
 
 //static char cvsid[] = "$Id$";
@@ -255 +256 @@
 {
 
-    /** buffers ***********************************************************/
-    char sz_out[MAX_STR_LEN];
-
     /** int ****************************************************************/
     int items = 0;
     int i = 0;
 
+    char *p = NULL;
+
     assert(raidrec != NULL);
 
-    sz_out[0] = '\0';
-    if (popup_and_get_string
-        ("Add variable", "Enter the name of the variable to add", sz_out,
-         MAX_STR_LEN)) {
-        strip_spaces(sz_out);
+    p = popup_and_get_string("Add variable", "Enter the name of the variable to add", "");
+    if (p != NULL) {
+        mr_strip_spaces(p);
         items = raidrec->additional_vars.entries;
         for (i = 0;
              i < items
-             && strcmp(raidrec->additional_vars.el[i].label, sz_out); i++);
+             && strcmp(raidrec->additional_vars.el[i].label, p); i++);
         if (i < items) {
             popup_and_OK
                 ("No need to add that variable. It is already listed here.");
         } else {
-            strcpy(raidrec->additional_vars.el[items].label, sz_out);
+            strcpy(raidrec->additional_vars.el[items].label, p);
             edit_varslist_entry(raidrec, items);
             raidrec->additional_vars.entries = ++items;
         }
     }
+    mr_free(p);
 }
 #endif
@@ -464 +463 @@
 
     /** int ***************************************************************/
-    int res = 0;
     int out = 0;
+    int i = 0;
 
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
+    char *p = NULL;
+    char *q = NULL;
     char *prompt = NULL;
-    char *sz = NULL;
 
     mr_asprintf(&prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
     if (raidrec->raidlevel == -1) {
-        strcpy(tmp, "concat");
+        mr_asprintf(&tmp, "concat");
     } else if (raidrec->raidlevel == 0) {
-        strcpy(tmp, "striped");
+        mr_asprintf(&tmp, "striped");
     } else {
-        sprintf(tmp, "raid%i", raidrec->raidlevel);
+        mr_asprintf(&tmp, "raid%i", raidrec->raidlevel);
     }
     for (out = 999; out == 999;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
+        p = popup_and_get_string("Specify RAID level", prompt, tmp);
+        if (p == NULL) {
+            mr_free(tmp);
+            mr_free(prompt);
             mr_free(prompt);
             return;
         }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            mr_asprintf(&sz, "%s", tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
+        mr_strip_spaces(p);
+        /* Suppress brakets at each hend */
+        if (p[0] == '[' && p[strlen(p) - 1] == ']') {
+            q = p+1;
+            i = 0;
+            while (*q != ']') {
+                p[i] = *q;
+                i++;
+                q++;
+            }
+            p[i] = '\0';
             mr_free(sz);
         }
-        if (!strcmp(tmp, "concat")) {
+        if (!strcmp(p, "concat")) {
             out = -1;
-        } else if (!strcmp(tmp, "striped")) {
+        } else if (!strcmp(p, "striped")) {
             out = 0;
-        } else if (!strcmp(tmp, "raid5")) {
+        } else if (!strcmp(p, "raid5")) {
             out = 5;
         }
-        log_it(tmp);
+        log_it("Raid level : %s",p);
+        mr_free(p);
+
         if (is_this_raid_personality_registered(out)) {
-            log_it
-                ("Groovy. You've picked a RAID personality which is registered.");
+            log_it("Groovy. You've picked a RAID personality which is registered.");
         } else {
-            if (ask_me_yes_or_no
-                ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
             {
                 out = 999;
@@ -512 +520 @@
         }
     }
+    mr_free(tmp);
     mr_free(prompt);
+
     raidrec->raidlevel = out;
 #else
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
     char *personalities = NULL;
     char *prompt = NULL;
-    char *sz = NULL;
-    int out = 0, res = 0;
+    char *p = NULL;
+    char *q = NULL;
+    int out = 0;
+    int i = 0;
 
 
     assert(raidrec != NULL);
-    system
-        ("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
+
+    system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
     mr_asprintf(&personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt"));
     mr_asprintf(&prompt, "Please enter the RAID level you want. %s", personalities);
@@ -531 +543 @@
 
     if (raidrec->raid_level == -1) {
-        strcpy(tmp, "linear");
+        mr_asprintf(&tmp, "linear");
     } else {
-        sprintf(tmp, "%d", raidrec->raid_level);
+        mr_asprintf(&tmp, "%d", raidrec->raid_level);
     }
     for (out = 999;
          out != -1 && out != 0 && out != 1 && out != 4 && out != 5
          && out != 10;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
+        p = popup_and_get_string("Specify RAID level", prompt, tmp);
+
+        if (p == NULL) {
+            mr_free(tmp);
+            mr_free(prompt);
             mr_free(prompt);
             return;
         }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            mr_asprintf(&sz, "%s", tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
+        mr_strip_spaces(p);
+        if (p[0] == '[' && p[strlen(p) - 1] == ']') {
+            q = p+1;
+            i = 0;
+            while (*q != ']') {
+                p[i] = *q;
+                i++;
+                q++;
+            }
+            p[i] = '\0';
             mr_free(sz);
         }
-        if (!strcmp(tmp, "linear")) {
+        if (!strcmp(p, "linear")) {
             out = -1;
-        } else if (!strncmp(tmp, "raid", 4)) {
-            out = atoi(tmp + 4);
+        } else if (!strncmp(p, "raid", 4)) {
+            out = atoi(p + 4);
         } else {
-            out = atoi(tmp);
-        }
-        log_it(tmp);
+            out = atoi(p);
+        }
+        log_it("Raid level : %s",p);
         if (is_this_raid_personality_registered(out)) {
-            log_it
-                ("Groovy. You've picked a RAID personality which is registered.");
+            log_it("Groovy. You've picked a RAID personality which is registered.");
         } else {
-            if (ask_me_yes_or_no
-                ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
-            {
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
                 out = 999;
             }
         }
     }
+    mr_free(tmp);
     mr_free(prompt);
     raidrec->raid_level = out;
@@ -1696 +1714 @@
     int currline_a, currline_u;
 
+    char *p = NULL;
+
     struct mountlist_itself *unallocparts;
 
@@ -1828 +1848 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            char tmp[64];
-            sprintf(tmp, "%i", raidrec->stripesize);
-            if (popup_and_get_string
-                ("Stripe size",
-                 "Please enter the stripe size in kilobytes.", tmp, 20)) {
-                raidrec->stripesize = atoi(tmp);
+            char *tmp = NULL;
+
+            mr_asprintf(&tmp, "%i", raidrec->stripesize);
+            p = popup_and_get_string("Stripe size", "Please enter the stripe size in kilobytes.", tmp);
+            mr_free(tmp);
+
+            if (p != NULL) {
+                raidrec->stripesize = atoi(p);
             }
+            mr_free(p);
         } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
             if (currline_u <= unallocparts->entries)
@@ -1868 +1891 @@
 
     /** buffers ***********************************************************/
-    char header[MAX_STR_LEN];
-    char comment[MAX_STR_LEN];
-    char sz_out[MAX_STR_LEN];
+    char *header = NULL;
+    char *comment = NULL;
+    char *sz_out = NULL;
+    char *p = NULL;
 
     assert(raidrec != 0);
     assert(lino >= 0);
 
-    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
-    sprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
-    sprintf(comment, "Please set %s's value (currently '%s')",
-            raidrec->additional_vars.el[lino].label, sz_out);
-    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
-        strip_spaces(sz_out);
-        strcpy(raidrec->additional_vars.el[lino].value, sz_out);
-    }
+    mr_asprintf(&sz_out, "%s", raidrec->additional_vars.el[lino].value);
+    mr_asprintf(&header, "Edit %s", raidrec->additional_vars.el[lino].label);
+    mr_asprintf(&comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
+    p = popup_and_get_string(header, comment, sz_out);
+    if (p != NULL) {
+        mr_strip_spaces(p);
+        strcpy(raidrec->additional_vars.el[lino].value, p);
+    }
+    mr_free(p);
 }
 
@@ -2242 +2267 @@
  * @return TRUE if OK was pressed, FALSE otherwise.
  */
-bool
-get_isodir_info(char *isodir_device, char *isodir_format,
-                char *isodir_path, bool nuke_me_please)
-{
+bool get_isodir_info(char *isodir_device, char *isodir_format, char *isodir_path, bool nuke_me_please)
+{
+
+    char *p = NULL;
+    char *q = NULL;
+    char *r = NULL;
+    char *idev = NULL;
+    bool ret = FALSE;       /* Should be false by default, and modfiy if conditions respected */
 
     /** initialize ********************************************************/
 
     assert(isodir_device != NULL);
-    assert(isodir_format != NULL);
     assert(isodir_path != NULL);
 
     log_it("isodir_path = %s", isodir_path);
-    isodir_format[0] = '\0';
     if (isodir_device[0] == '\0') {
-        strcpy(isodir_device, "/dev/");
-    }
+        mr_asprintf(&idev, "/dev/");
+    } else {
+        mr_asprintf(&idev, "%s", isodir_device);
+    }
+
     if (isodir_path[0] == '\0') {
         strcpy(isodir_path, "/");
     }
     if (does_file_exist("/tmp/NFS-SERVER-PATH")) {
-        strcpy(isodir_device, last_line_of_file("/tmp/NFS-SERVER-MOUNT"));
-        strcpy(isodir_format, "nfs");
+        mr_free(idev);
+        mr_asprintf(&idev, "%s", last_line_of_file("/tmp/NFS-SERVER-MOUNT"));
+        mr_asprintf(&isodir_format, "nfs");
         strcpy(isodir_path, last_line_of_file("/tmp/NFS-SERVER-PATH"));
     }
+
+    /* modify for the caller */
+    strcpy(isodir_device, idev);
     if (nuke_me_please) {
-        return (TRUE);
-    }
-
-    if (popup_and_get_string
-        ("ISO Mode - device", "On what device do the ISO files live?",
-         isodir_device, MAX_STR_LEN / 4)) {
-        if (popup_and_get_string
-            ("ISO Mode - format",
-             "What is the disk format of the device? (Hit ENTER if you don't know.)",
-             isodir_format, 16)) {
-            if (popup_and_get_string
-                ("ISO Mode - path",
-                 "At what path on this device can the ISO files be found?",
-                 isodir_path, MAX_STR_LEN / 4)) {
-                strip_spaces(isodir_device);
-                strip_spaces(isodir_format);
-                strip_spaces(isodir_path);
-                log_it("isodir_device = %s - isodir_format = %s - isodir_path = %s", isodir_device, isodir_format, isodir_path);
-                return (TRUE);
+        ret = TRUE;
+    } else {
+        p = popup_and_get_string("ISO Mode - device", "On what device do the ISO files live?", idev);
+        if (p != NULL) {
+            q = popup_and_get_string("ISO Mode - format", "What is the disk format of the device? (Hit ENTER if you don't know.)", isodir_format);
+            mr_free(isodir_format);
+    
+            if (q != NULL) {
+                r = popup_and_get_string("ISO Mode - path", "At what path on this device can the ISO files be found?", isodir_path);
+                if (r != NULL) {
+                    mr_strip_spaces(p);
+                    mr_strip_spaces(q);
+                    mr_strip_spaces(r);
+
+                    isodir_format = q;
+    
+                    /* modify for the caller */
+                    strcpy(isodir_device, p);
+                    strcpy(isodir_path, r);
+                    log_it("isodir_device = %s - isodir_format = %s - isodir_path = %s", isodir_device, isodir_format, isodir_path);
+                    mr_free(r);
+    
+                    ret = TRUE;
+                }
             }
         }
-    }
-    return (FALSE);
+        mr_free(p);
+    }
+    mr_free(idev);
+    mr_free(isodir_format);
+    return(ret);
 }
 
@@ -2700 +2742 @@
     /** buffers **********************************************************/
     void *keylist[ARBITRARY_MAXIMUM];
-    char *tmp;
-    char *help_text;
-    char *title_of_window;
-    char *sz_res;
-    char *header_text;
+    char *tmp = NULL;
+    char *help_text = NULL;
+    char *title_of_window = NULL;
+    char *sz_res = NULL;
+    char *header_text = NULL;
+    char *p = NULL;
 
   /** int **************************************************************/
@@ -2717 +2760 @@
 
     log_it("malloc'ing");
-    malloc_string(tmp);
-    malloc_string(help_text);
-    malloc_string(title_of_window);
-    malloc_string(sz_res);
-    malloc_string(header_text);
-    if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) {
-        fatal_error("Cannot malloc space for raidrec");
-    }
-    if (!(bkp_disklist = malloc(sizeof(struct list_of_disks)))) {
-        fatal_error("Cannot malloc space for disklist");
-    }
-    if (!(bkp_raidlist = malloc(sizeof(struct raidlist_itself)))) {
-        fatal_error("Cannot malloc space for raidlist");
-    }
-    if (!
-        (unallocated_raid_partitions =
-         malloc(sizeof(struct mountlist_itself)))) {
-        fatal_error("Cannot malloc space for unallocated_raid_partitions");
-    }
-
-    memcpy((void *) bkp_raidlist, (void *) raidlist,
-           sizeof(struct raidlist_itself));
-    memcpy((void *) bkp_raidrec, (void *) raidrec,
-           sizeof(struct raid_device_record));
-    memcpy((void *) bkp_disklist, (void *) disklist,
-           sizeof(struct list_of_disks));
+    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
+    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
+    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
+    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
+
+    memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself));
+    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
+    memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks));
 
     log_it("Post-malloc");
-    strcpy(help_text,
-           "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
-    sprintf(header_text, "%-24s    %s", "Device", "Index");
-    sprintf(title_of_window, "%s contains...", raidrec->raid_device);
+    mr_asprintf(&help_text, "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
+    mr_asprintf(&header_text, "%-24s    %s", "Device", "Index");
+    mr_asprintf(&title_of_window, "%s contains...", raidrec->raid_device);
     newtPushHelpLine(help_text);
     for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
@@ -2803 +2827 @@
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 } else {
-                    sprintf(tmp, "%s's index is %d. What should it be?",
-                            raidrec->raid_device,
-                            disklist->el[currline].index);
-                    sprintf(sz_res, "%d", disklist->el[currline].index);
-                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
+                    mr_asprintf(&tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
+                    mr_asprintf(&sz_res, "%d", disklist->el[currline].index);
+                    p = popup_and_get_string("Set index", tmp, sz_res);
+                    mr_free(tmp);
+                    if (p != NULL) {
                         disklist->el[currline].index = atoi(sz_res);
                     }
                     redraw_disklist(disklist, keylist, partitionsListbox);
+                    mr_free(sz_res);
                 }
             }
@@ -2818 +2843 @@
     }
     newtPopHelpLine();
+    mr_free(help_text);
+    mr_free(header_text);
+    mr_free(title_of_window);
+
     if (b_res == bCancel) {
-        memcpy((void *) raidlist, (void *) bkp_raidlist,
-               sizeof(struct raidlist_itself));
-        memcpy((void *) raidrec, (void *) bkp_raidrec,
-               sizeof(struct raid_device_record));
-        memcpy((void *) disklist, (void *) bkp_disklist,
-               sizeof(struct list_of_disks));
-    }
-    paranoid_free(tmp);
-    paranoid_free(help_text);
-    paranoid_free(title_of_window);
-    paranoid_free(sz_res);
-    paranoid_free(header_text);
-    paranoid_free(bkp_raidrec);
-    paranoid_free(bkp_disklist);
-    paranoid_free(bkp_raidlist);
-    paranoid_free(unallocated_raid_partitions);
+        memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself));
+        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
+        memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks));
+    }
+    mr_free(bkp_raidrec);
+    mr_free(bkp_disklist);
+    mr_free(bkp_raidlist);
+    mr_free(unallocated_raid_partitions);
 }
 #endif

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

@@ -159 +159 @@
 void open_progress_form(char *, char *, char *, char *, long);
 void popup_and_OK(char *);
-bool popup_and_get_string(char *, char *, char *, int);
+char *popup_and_get_string(char *, char *, char *);
 bool popup_with_buttons(char *, char *, char *);
 void redraw_disklist(struct list_of_disks *, void *keylist[],

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

@@ -42 +42 @@
 */
 extern char *g_isodir_device;
-extern char *g_isodir_format;
 extern long g_current_progress, g_maximum_progress;
 extern char *g_biggielist_txt;  // where 'biggielist.txt' is stored, on ramdisk / tempdir;
@@ -96 +95 @@
 */
 paranoid_free(g_isodir_device);
-paranoid_free(g_isodir_format);
 
 }
@@ -264 +262 @@
     int retval = 0, i;
     bool already_mounted = FALSE;
+    char *isodir_format = NULL;
 
 assert(bkpinfo != NULL);
@@ -281 +280 @@
 }
 
-if (!get_isodir_info(g_isodir_device, g_isodir_format, bkpinfo->isodir, nuke_me_please)) {
+if (!get_isodir_info(g_isodir_device, isodir_format, bkpinfo->isodir, nuke_me_please)) {
+    mr_free(isodir_format);
     return (1);
 }
@@ -291 +291 @@
 } else {
     mr_asprintf(&mount_isodir_command, "mount %s", g_isodir_device);
-    if (strlen(g_isodir_format) > 1) {
-        mr_strcat(mount_isodir_command, " -t %s", g_isodir_format);
-    }
+    if (isodir_format) {
+        mr_strcat(mount_isodir_command, " -t %s", isodir_format);
+    }
+
     mr_strcat(mount_isodir_command, " -o ro %s", bkpinfo->isodir);
     run_program_and_log_output("df -m", FALSE);
@@ -308 +309 @@
     ("I have mounted the device where the ISO files are stored.");
 }
+mr_free(isodir_format);
+
 if (!IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     mount_media();
@@ -1426 +1429 @@
   /** malloc **/
     char *command = NULL;
-    char *boot_device;
+    char *boot_device = NULL;
     char *rootdev;
     char *rootdrive;
@@ -1432 +1435 @@
     char *tmp = NULL;
     char *editor;
-
-    int res;
-    int done;
-
-    malloc_string(boot_device);
+    char *p = NULL;
+
+    int res = 0;
+    bool done;
+
     malloc_string(editor);
     malloc_string(rootdev);
@@ -1443 +1446 @@
     assert_string_is_neither_NULL_nor_zerolength(bd);
     strcpy(editor, find_my_editor());
-    strcpy(boot_device, bd);
+    mr_asprintf(&boot_device, "%s", bd);
 
     if (offer_to_run_stabgrub
-        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
+        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?")) {
         /* interactive mode */
-    {
         mvaddstr_and_log_it(g_currentY,
                             0,
                             "Modifying fstab, mtab, device.map and menu.lst, and running GRUB...                             ");
         for (done = FALSE; !done;) {
-            popup_and_get_string("Boot device",
-                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
-                                 boot_device, MAX_STR_LEN / 4);
-            mr_asprintf(&command, "stabgrub-me %s", boot_device);
+            p = popup_and_get_string("Boot device", "Please confirm/enter the boot device. If in doubt, try /dev/hda", boot_device);
+            if (p == NULL) {
+                done = TRUE;
+                mr_free(p);
+                /* we want some warnings later on */
+                res = 1;
+                continue;
+            }
+            mr_asprintf(&command, "stabgrub-me %s", p);
+            mr_free(p);
+
             res = run_program_and_log_output(command, 1);
             mr_free(command);
@@ -1494 +1503 @@
             }
         }
-    } else
+    } else {
         /* nuke mode */
-    {
         if (!run_program_and_log_output("which grub-MR", FALSE)) {
             log_msg(1, "Yay! grub-MR found...");
@@ -1521 +1529 @@
         }
     }
+    mr_free(boot_device);
+
     if (res) {
         mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
@@ -1540 +1550 @@
     paranoid_free(rootdrive);
     paranoid_free(conffile);
-    paranoid_free(boot_device);
     paranoid_free(editor);
 
@@ -1744 +1753 @@
   /** malloc **/
     char *command = NULL;
-    char *boot_device;
+    char *boot_device = NULL;
     char *tmp = NULL;
     char *editor;
+    char *p = NULL;
     int res;
     int done;
 
-    malloc_string(boot_device);
     malloc_string(editor);
     assert_string_is_neither_NULL_nor_zerolength(bd);
 
     strcpy(editor, find_my_editor());
-    strcpy(boot_device, bd);
+    mr_asprintf(&boot_device, "%s", bd);
 
     if (offer_to_hack_scripts
-        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
+        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?")) {
         /* interactive mode */
-    {
         mvaddstr_and_log_it(g_currentY, 0,
                             "Modifying fstab and restoring MBR...                           ");
@@ -1776 +1784 @@
                 }
             }
-            popup_and_get_string("Boot device",
-                                 "Please confirm/enter the boot device. If in doubt, try /dev/hda",
-                                 boot_device, MAX_STR_LEN / 4);
-            mr_asprintf(&command, "stabraw-me %s", boot_device);
+            p = popup_and_get_string("Boot device", "Please confirm/enter the boot device. If in doubt, try /dev/hda", boot_device);
+            if (p == NULL) {
+                done = TRUE;
+                mr_free(p);
+                /* we want some warnings later on */
+                res = 1;
+                continue;
+            }
+            mr_asprintf(&command, "stabraw-me %s", p);
+            mr_free(p);
+
             res = run_program_and_log_output(command, 3);
             mr_free(command);
@@ -1789 +1804 @@
             }
         }
-    } else
+    } else {
         /* nuke mode */
-    {
         mr_asprintf(&command, "raw-MR %s /tmp/mountlist.txt", boot_device);
         log_msg(2, "run_raw_mbr() --- command='%s'", command);
@@ -1800 +1814 @@
         mr_free(command);
     }
+    mr_free(boot_device);
 
     if (res) {
@@ -1808 +1823 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
-    paranoid_free(boot_device);
     paranoid_free(editor);
     return (res);
@@ -1839 +1853 @@
     malloc_string(g_mondo_home);
     malloc_string(g_isodir_device);
-    malloc_string(g_isodir_format);
 
     temppath = bkpinfo->tmpdir;

branches/2.2.10/mondo/src/mondorestore/mondoprep.h

@@ -33 +33 @@
 extern void close_progress_form(void);
 extern void popup_and_OK(char *);
-extern bool popup_and_get_string(char *, char *, char *, int);
+extern char *popup_and_get_string(char *, char *, char *);
 extern long get_time(void);
 extern bool is_this_device_mounted(char *);

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

@@ -439 +439 @@
   /** needs malloc **********/
     char *tmp;
+    char *p = NULL;
     char *tmp1 = NULL;
     char *fstab_fname;
@@ -470 +471 @@
     read_cfg_file_into_bkpinfo(g_mondo_cfg_file);
     log_it("Done loading config file; resizing ML");
-    if (bkpinfo->backup_media_type == nfs) {
-        strcpy(tmp, bkpinfo->prefix);
-        if (popup_and_get_string
-            ("Prefix", "Prefix of your ISO images ?", tmp, MAX_STR_LEN / 4)) {
-            strcpy(bkpinfo->prefix, tmp);
-            log_msg(1, "Prefix set to %s",bkpinfo->prefix);
-        }
-    }
 
 #ifdef __FreeBSD__
@@ -607 +600 @@
               gotos_suck:
                 strcpy(tmp, old_restpath);
-// (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
-                if (popup_and_get_string
-                    ("Restore path", "Restore files to where?", tmp,
-                     MAX_STR_LEN / 4)) {
+                // (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
+                p = popup_and_get_string("Restore path", "Restore files to where?", tmp);
+                if (p != NULL) {
+                    strcpy(tmp, p);
                     if (!strcmp(tmp, "/")) {
                         if (!ask_me_yes_or_no("Are you sure?")) {
@@ -625 +618 @@
                     free_filelist(filelist);
                 }
+                mr_free(p);
+
                 if (!ask_me_yes_or_no
                     ("Restore another subset of your backup?")) {
@@ -952 +947 @@
   /** malloc **/
     char *old_restpath;
+    char *p = NULL;
 
     struct mountlist_itself *mountlist = NULL;
@@ -997 +993 @@
         save_filelist(filelist, "/tmp/selected-files.txt");
         strcpy(old_restpath, bkpinfo->restore_path);
-        if (popup_and_get_string("Restore path",
-                                 "Restore files to where? )",
-                                 bkpinfo->restore_path, MAX_STR_LEN / 4)) {
+        p = popup_and_get_string("Restore path", "Restore files to where? )", bkpinfo->restore_path);
+        if (p != NULL) {
+            strcpy(bkpinfo->restore_path, p);
+            mr_free(p);
+
             log_it("Restoring everything");
             retval += restore_everything(filelist);

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

@@ -59 +59 @@
 extern int partition_everything(struct mountlist_itself *);
 extern void popup_and_OK(char *);
-extern bool popup_and_get_string(char *, char *, char *, int);
+extern char *popup_and_get_string(char *, char *, char *);
 extern void setup_newt_stuff(void);
 extern void reset_bkpinfo();