Changeset 2316 in MondoRescue for branches/2.2.10/mondo/src/mondorestore/mondo-rstr-newt.c

Timestamp:

Aug 18, 2009, 2:34:29 PM (15 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

File:

• branches/2.2.10/mondo/src/mondorestore/mondo-rstr-newt.c (modified) (13 diffs)

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