Changeset 1197 in MondoRescue

Timestamp:

Feb 22, 2007, 1:57:52 AM (17 years ago)

Author:

Bruno Cornec

Message:

merge trunk memeory management for mondo-prep.c
logging in newt-specific.c reviewed once more

Location:

branches/stable/mondo/src

Files:

• common/newt-specific.c (modified) (2 diffs)
• mondorestore/mondo-prep.c (modified) (55 diffs)

branches/stable/mondo/src/common/newt-specific.c

@@ -973 +973 @@
             }
             if (percentage >= 3) {
-                mr_asprintf(&tmp1,
-                        "] %3d%% done; %2ld:%02ld to go", percentage,
-                        time_remaining / 60, time_remaining % 60);
-                mr_strcat(taskprogress, tmp1);
-                mr_free(tmp1);
+                mr_strcat(taskprogress, _("] %3d%% done; %2ld:%02ld to go"), percentage, time_remaining / 60, time_remaining % 60);
                 printf("---evalcall------ %s\n", taskprogress);
                 mr_free(taskprogress);
@@ -1098 +1094 @@
             mr_msg(2, _("percentage = %d"), percentage);
         }
-        mr_asprintf(&tmp,_("] %3d%c done; %2ld:%02ld to go"), percentage, '%',
-            time_remaining / 60, time_remaining % 60);
-        mr_strcat(taskprogress, tmp);
-        mr_free(tmp);
+        mr_strcat(taskprogress, ,_("] %3d%% done; %2ld:%02ld to go"), percentage, time_remaining / 60, time_remaining % 60);
         printf(_("---progress-form---4--- %s\n"), taskprogress);
         mr_free(taskprogress);

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

@@ -1613 +1613 @@
 
     /** buffers **********************************************************/
-    char *program;
-    char *partition_name;
-    char *tmp;
-    char *logfile;
-    char *output;
+    char *program = NULL;
+    char *partition_name = NULL;
+    char *tmp = NULL;
+    char *output = NULL;
 
     /** pointers **********************************************************/
-    char *p;
-    char *part_table_fmt;
-    FILE *fout;
+    char *p = NULL;
+    char *part_table_fmt = NULL;
+    FILE *fout = NULL;
 
     /** end ***************************************************************/
-
-    malloc_string(program);
-    malloc_string(partition_name);
-    malloc_string(tmp);
-    malloc_string(logfile);
-    malloc_string(output);
 
     assert_string_is_neither_NULL_nor_zerolength(drive);
@@ -1639 +1632 @@
 
     if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);
-        log_it(tmp);
-        mr_free(program);
-        mr_free(partition_name);
-        mr_free(tmp);
-        mr_free(logfile);
-        mr_free(output);
+        log_it("Not partitioning %s - it is a virtual drive", drive);
         return (0);
     }
+
+    malloc_string(partition_name);
+
     build_partition_name(partition_name, drive, partno);
     if (partsize <= 0) {
-        sprintf(tmp, "Partitioning device %s (max size)", partition_name);
+        mr_asprintf(&tmp, "Partitioning device %s (max size)", partition_name);
     } else {
-        sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name,
+        mr_asprintf(&tmp, "Partitioning device %s (%lld MB)", partition_name,
                 (long long) partsize / 1024);
     }
     update_progress_form(tmp);
     log_it(tmp);
+    mr_free(tmp);
 
     if (is_this_device_mounted(partition_name)) {
-        sprintf(tmp, "%s is mounted, and should not be partitioned",
+        log_to_screen("%s is mounted, and should not be partitioned",
                 partition_name);
-        log_to_screen(tmp);
-        mr_free(program);
         mr_free(partition_name);
-        mr_free(tmp);
-        mr_free(logfile);
-        mr_free(output);
         return (1);
-/*
-    } else if (does_partition_exist(drive, partno)) {
-        sprintf(tmp, "%s already has a partition", partition_name);
-        log_to_screen(tmp);
-        return (1);
-*/
-    }
-
-
-    /*  sprintf(tmp,"Partitioning %s  ",partition_name); */
-    /*  mvaddstr_and_log_it(g_currentY+1,30,tmp); */
+    }
+
     p = (char *) strrchr(partition_name, '/');
-    sprintf(logfile, "/tmp/fdisk.log.%s", ++p);
-    sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
-            MONDO_LOGFILE);
-
-    /* BERLIOS: shoould not be called each time */
+
+    /* BERLIOS: should not be called each time */
     part_table_fmt = which_partition_format(drive);
-    output[0] = '\0';
     /* make it a primary/extended/logical */
     if (partno <= 4) {
-        sprintf(output + strlen(output), "n\np\n%d\n", partno);
+        mr_asprintf(&output,"n\np\n%d\n", partno);
     } else {
         /* MBR needs an extended partition if more than 4 partitions */
@@ -1696 +1669 @@
                 if (prev_partno >= 4) {
                     log_to_screen
-                        ("You need to leave at least one partition free, for 'extended/logical'");
-                    mr_free(program);
+                        (_
+                         ("You need to leave at least one partition free, for 'extended/logical'"));
                     mr_free(partition_name);
-                    mr_free(tmp);
-                    mr_free(logfile);
-                    mr_free(output);
                     return (1);
                 } else {
-                    sprintf(output + strlen(output), "n\ne\n%d\n\n\n",
-                            prev_partno + 1);
+                    mr_asprintf(&output,"n\ne\n%d\n\n\n",prev_partno + 1);
                 }
             }
-            strcat(output + strlen(output), "n\nl\n");
+            mr_strcat(output, "n\nl\n");
         } else {
             /* GPT allows more than 4 primary partitions */
-            sprintf(output + strlen(output), "n\np\n%d\n", partno);
-        }
-    }
-    strcat(output + strlen(output), "\n");  /*start block (ENTER for next free blk */
+            mr_asprintf(&output,"n\np\n%d\n",partno);
+        }
+    }
+    /*start block (ENTER for next free blk */
+    mr_strcat(output, "\n");    
     if (partsize > 0) {
         if (!strcmp(format, "7")) {
@@ -1720 +1690 @@
             partsize += 512;
         }
-        sprintf(output + strlen(output), "+%lldK", (long long) (partsize));
-    }
-    strcat(output + strlen(output), "\n");
+        mr_strcat(output, "+%lldK", (long long) (partsize));
+    }
+    mr_strcat(output, "\n");
 #if 0
 /*
 #endif
-    sprintf(tmp,"PARTSIZE = +%ld",(long)partsize);
-    log_it(tmp);
+    log_it("PARTSIZE = +%ld",(long)partsize);
     log_it("---fdisk command---");
     log_it(output);
@@ -1741 +1710 @@
         fput_string_one_char_at_a_time(pout_to_fdisk, output);
         fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n");
-        strcpy(tmp, last_line_of_file(FDISK_LOG));
+        mr_asprintf(&tmp, last_line_of_file(FDISK_LOG));
         if (strstr(tmp, " (m ")) {
             mr_msg(1, "Successfully created %s%d", drive, partno);
@@ -1749 +1718 @@
                     partno);
         }
+        mr_free(tmp);
+
         if (!retval) {
             mr_msg(1, "Trying to set %s%d's partition type now", drive,
@@ -1766 +1737 @@
         }
     } else {
-        strcat(output, "w\n\n");
+        mr_strcat(output, "w\n\n");
+        mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
+            MONDO_LOGFILE);
+
         if (g_fprep) {
             fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
@@ -1777 +1751 @@
             paranoid_pclose(fout);
         }
+        mr_free(program);
+
         if (!does_partition_exist(drive, partno) && partsize > 0) {
             log_it("Vaccum-packing");
@@ -1784 +1760 @@
                                  format, -1);
             if (res) {
-                sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
-                log_it(tmp);
+                log_it("Failed to vacuum-pack %s", partition_name);
                 retval++;
             } else {
@@ -1796 +1771 @@
                                    partsize);
             if (retval) {
-                sprintf(tmp, "Partitioned %s but failed to set its type",
+                log_it("Partitioned %s but failed to set its type",
                         partition_name);
-                log_it(tmp);
             } else {
                 if (partsize > 0) {
-                    sprintf(tmp, "Partition %s created+configured OK",
+                    log_to_screen(_("Partition %s created+configured OK"),
                             partition_name);
-                    log_to_screen(tmp);
                 } else {
                     log_it("Returning from a successful vacuum-pack");
@@ -1809 +1782 @@
             }
         } else {
-            sprintf(tmp, "Failed to partition %s", partition_name);
+            mr_asprintf(&tmp, "Failed to partition %s", partition_name);
             if (partsize > 0) {
                 log_to_screen(tmp);
@@ -1815 +1788 @@
                 log_it(tmp);
             }
+            mr_free(tmp);
             retval++;
         }
@@ -1820 +1794 @@
     g_current_progress++;
     log_it("partition_device() --- leaving");
-    mr_free(program);
     mr_free(partition_name);
-    mr_free(tmp);
-    mr_free(logfile);
     mr_free(output);
     return (retval);
 }
-
 
 
@@ -1840 +1810 @@
 {
     /** int ************************************************************/
-    int lino;
+    int lino = 0;
     int retval = 0;
-    int i;
-    int res;
+    int i = 0;
+    int res = 0;
 
     /** buffer *********************************************************/
-    struct list_of_disks *drivelist;
-    /*  struct mountlist_itself new_mtlist, *mountlist; */
+    struct list_of_disks *drivelist = NULL;
 
     /** end ************************************************************/
@@ -1856 +1825 @@
     log_it("partition_everything() --- starting");
     mvaddstr_and_log_it(g_currentY, 0, "Partitioning hard drives      ");
-    /*  mountlist=orig_mtlist; */
     if (mountlist_contains_raid_devices(mountlist)) {
         /*      mountlist=&new_mtlist; */
@@ -1879 +1847 @@
     mr_msg(0, "Done.");
 
-/*  
-    if (does_file_exist("/tmp/i-want-my-lvm"))
-      {
-        wipe_MBRs_and_reboot_if_necessary(mountlist); // i.e. if it wasn't done recently
-      }
-*/
-
-    open_progress_form("Partitioning devices",
-                       "I am now going to partition all your drives.",
-                       "This should not take more than five minutes.", "",
-                       mountlist->entries);
+    open_progress_form(_("Partitioning devices"),
+                       _("I am now going to partition all your drives."),
+                       _("This should not take more than five minutes."),
+                       "", mountlist->entries);
 
     make_list_of_drives_in_mountlist(mountlist, drivelist);
@@ -1900 +1861 @@
     close_progress_form();
     if (retval) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+        mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         log_to_screen
-            ("Errors occurred during the partitioning of your hard drives.");
+            (_
+             ("Errors occurred during the partitioning of your hard drives."));
     } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
         paranoid_system("rm -f /tmp/fdisk*.log 2> /dev/null");
     }
@@ -1913 +1875 @@
     return (retval);
 }
-
-
-
-
 
 
@@ -1932 +1890 @@
 {
     /** buffers *********************************************************/
-    char *partition;
-    char *command;
-    char *output;
-    char *tmp;
-    char *partcode;
-    char *logfile;
+    char *partition = NULL;
+    char *command = NULL;
+    char *output = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *partcode = NULL;
 
     /** pointers *********************************************************/
-    char *p;
-    FILE *fout;
+    char *p = NULL;
+    FILE *fout = NULL;
 
     /** int **************************************************************/
@@ -1952 +1910 @@
 
     malloc_string(partition);
-    malloc_string(command);
-    malloc_string(output);
-    malloc_string(tmp);
-    malloc_string(partcode);
-    malloc_string(logfile);
 
     build_partition_name(partition, drive, partno);
     p = (char *) strrchr(partition, '/');
-    sprintf(logfile, "/tmp/fdisk-set-type.%s.log", ++p);
     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
@@ -1973 +1925 @@
                || strcmp(format, "ext3") == 0 || 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, "raid") == 0) {
-        strcpy(partcode, "fd");
+        mr_asprintf(&partcode, "fd");
     } 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 */
-        sprintf(tmp,
+        mr_asprintf(&tmp,
                 "Unknown format ('%s') - using supplied string anyway",
                 format);
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
+        mr_free(tmp);
 #ifdef __FreeBSD__
-        strcpy(partcode, format);   // was a5
+        mr_asprintf(&partcode, format); // was a5
 #else
-        strcpy(partcode, format);   // was 83
-#endif
-    }
-    sprintf(tmp, "Setting %s's type to %s (%s)", partition, format,
+        mr_asprintf(&partcode, format); // was 83
+#endif
+    }
+    mr_asprintf(&tmp, "Setting %s's type to %s (%s)", partition, format,
             partcode);
     mr_msg(1, tmp);
+    mr_free(tmp);
+
     if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
 
@@ -2010 +1965 @@
                 || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
                 mr_msg(5, "Specifying partno (%d) - yay", partno);
-                sprintf(tmp, "%d\n", partno);
+                mr_asprintf(&tmp, "%d\n", partno);
                 fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
                 mr_msg(5, "A - last line = '%s'",
                         last_line_of_file(FDISK_LOG));
-            }
-
-            sprintf(tmp, "%s\n", partcode);
+                mr_free(tmp);
+            }
+
+            mr_asprintf(&tmp, "%s\n", partcode);
             fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+            mr_free(tmp);
+
             mr_msg(5, "B - last line = '%s'",
                     last_line_of_file(FDISK_LOG));
+
             fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
             mr_msg(5, "C - last line = '%s'",
                     last_line_of_file(FDISK_LOG));
 
-            strcpy(tmp, last_line_of_file(FDISK_LOG));
+            mr_asprintf(&tmp, last_line_of_file(FDISK_LOG));
             if (!strstr(tmp, " (m ")) {
                 mr_msg(1, "last line = '%s'; part type set failed", tmp);
@@ -2030 +1989 @@
                 fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
             }
+            mr_free(tmp);
             fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
         } else {
-            sprintf(output, "t\n%d\n%s\n", partno, partcode);
-            strcat(output, "w\n");
-            sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,
+            mr_asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
+            mr_asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive,
                     MONDO_LOGFILE, MONDO_LOGFILE);
             mr_msg(5, "output = '%s'", output);
@@ -2048 +2007 @@
                 paranoid_pclose(fout);
             }
-        }
+            mr_free(command);
+            mr_free(output);
+        }
+        /* BERLIOS: Useless as command not initialized in all cases
         if (res) {
             log_OS_error(command);
         }
+        */
     }
 
     mr_free(partition);
-    mr_free(command);
-    mr_free(output);
-    mr_free(tmp);
     mr_free(partcode);
-    mr_free(logfile);
 
     return (res);
@@ -2068 +2027 @@
 {
     /** int *************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2084 +2042 @@
         return 1;
     }
-    sprintf(program, "vinum start -f %s", raid_device);
+    mr_asprintf(&program, "vinum start -f %s", raid_device);
 #else
-    sprintf(program, "raidstart %s", raid_device);
+    // use raidstart if it exists, otherwise use mdadm
+    if (run_program_and_log_output("which raidstart", FALSE)) {
+        // BERLIOS: Not sure it's sufficient
+        mr_asprintf(&program, "mdadm -A %s", raid_device);
+    } else {
+        mr_asprintf(&program, "raidstart %s", raid_device);
+    }
 #endif
     mr_msg(1, "program = %s", program);
@@ -2093 +2057 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    mr_free(program);
+
     if (res) {
         mr_msg(1, "Warning - failed to start RAID device %s",
@@ -2101 +2067 @@
     return (retval);
 }
-
 
 
@@ -2112 +2077 @@
 {
     /** int *************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2128 +2092 @@
         return 1;
     }
-    sprintf(program, "vinum stop -f %s", raid_device);
+    mr_asprintf(&program, "vinum stop -f %s", raid_device);
 #else
-    // use raidstop if it exists, otherwise use mdadm
-    if (run_program_and_log_output("which raidstop", FALSE)) {
-        sprintf(program, "mdadm -S %s", raid_device);
+    // use raidstop if it exists, otherwise use mdadm
+    if (run_program_and_log_output("which raidstop", FALSE)) {
+        mr_asprintf(&program, "mdadm -S %s", raid_device);
     } else {
-        sprintf(program, "raidstop %s", raid_device);
+        mr_asprintf(&program, "raidstop %s", raid_device);
     }
 #endif
@@ -2142 +2106 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    mr_free(program);
+
     if (res) {
         mr_msg(1, "Warning - failed to stop RAID device %s", raid_device);
@@ -2152 +2118 @@
 int start_all_raid_devices(struct mountlist_itself *mountlist)
 {
-    int i;
+    int i = 0;
     int retval = 0;
-    int res;
+    int res = 0;
 
     for (i = 0; i < mountlist->entries; i++) {
@@ -2173 +2139 @@
 }
 
+
 /**
  * Stop all software RAID devices listed in @p mountlist.
@@ -2184 +2151 @@
     int retval = 0;
 #ifndef __FreeBSD__
-    int res;
+    int res = 0;
 #endif
 
     /** char ************************************************************/
-    char *incoming;
+    char *incoming = NULL;
 #ifndef __FreeBSD__
-    char *dev;
+    char *dev = NULL;
 #endif
     /** pointers ********************************************************/
 #ifndef __FreeBSD__
-    char *p;
-#endif
-    FILE *fin;
-    int i;
+    char *p = NULL;
+#endif
+    FILE *fin = NULL;
+    int i = 0;
+    size_t n = 0;
 
     /** end ****************************************************************/
 
-    malloc_string(dev);
-    malloc_string(incoming);
     assert(mountlist != NULL);
 
@@ -2212 +2178 @@
              "r");
         if (!fin) {
-            mr_free(dev);
-            mr_free(incoming);
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
-             fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (mr_getline(&incoming, &n, fin); !feof(fin);
+             mr_getline(&incoming, &n, fin)) {
             retval += stop_raid_device(incoming);
         }
@@ -2224 +2188 @@
         if (!fin) {
             log_OS_error("/proc/mdstat");
-            mr_free(dev);
-            mr_free(incoming);
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
-             fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (mr_getline(&incoming, &n, fin); !feof(fin);
+             mr_getline(&incoming, &n, fin)) {
             for (p = incoming;
                  *p != '\0' && (*p != 'm' || *(p + 1) != 'd'
                                 || !isdigit(*(p + 2))); p++);
             if (*p != '\0') {
-                sprintf(dev, "/dev/%s", p);
+                mr_asprintf(&dev, "/dev/%s", p);
+                /* BERLIOS : 32 Hard coded value */
                 for (p = dev; *p > 32; p++);
                 *p = '\0';
                 res = stop_raid_device(dev);
-            }
-        }
-#endif
+                mr_free(dev);
+            }
+        }
+#endif
+        mr_free(incoming);
     }
     paranoid_fclose(fin);
@@ -2246 +2211 @@
         mr_msg(1, "Warning - unable to stop some RAID devices");
     }
-    mr_free(dev);
-    mr_free(incoming);
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     sleep(1);
     return (retval);
 }
-
 
 
@@ -2268 +2230 @@
     int res = 0;
 
-    /** buffers *********************************************************/
-    char *tmp;
-
     /** end ***************************************************************/
 
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(format);
     assert(program != NULL);
@@ -2305 +2263 @@
         sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
 #endif
-        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format,
+        log_it("Unknown format (%s) - assuming '%s' will do", format,
                 program);
-        log_it(tmp);
         res = 0;
     }
-    mr_free(tmp);
     return (res);
 }
@@ -2326 +2282 @@
 {
     /** long ************************************************************/
-    long original_size_of_drive;
+    long original_size_of_drive = 0L;
 
     /** int *************************************************************/
-    int partno;
-
-    /** buffers *********************************************************/
-    char *tmp;
+    int partno = 0;
 
     /** end *************************************************************/
 
-    malloc_string(tmp);
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
@@ -2346 +2298 @@
              strlen(drive_name)) == 0) {
             original_size_of_drive += mountlist->el[partno].size;
-        } else {
-            sprintf(tmp, "Skipping %s", mountlist->el[partno].device);
-//                      log_to_screen(tmp);
         }
     }
     original_size_of_drive = original_size_of_drive / 1024;
-    mr_free(tmp);
     return (original_size_of_drive);
 }
@@ -2372 +2320 @@
                                                      char *drive_name)
 {
-    /**buffers **********************************************************/
-    char *tmp;
-
     /** int *************************************************************/
-    int partno, lastpart;
+    int partno = 0, lastpart = 0;
                /** remove driveno, noof_drives stan benoit apr 2002**/
 
@@ -2382 +2327 @@
     float factor;
     float new_size;
-//  float newcylinderno;
 
     /** long *************************************************************/
-    long newsizL;
-    long current_size_of_drive = 0;
-    long original_size_of_drive = 0;
-    long final_size;            /* all in Megabytes */
-    struct mountlist_reference *drivemntlist;
+    long newsizL = 0L;
+    long current_size_of_drive = 0L;
+    long original_size_of_drive = 0L;
+    long final_size = 0L;           /* all in Megabytes */
+    struct mountlist_reference *drivemntlist = NULL;
 
     /** structures *******************************************************/
@@ -2395 +2339 @@
     /** end **************************************************************/
 
-    malloc_string(tmp);
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
@@ -2402 +2345 @@
         if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
             == 0) {
-            mr_free(tmp);
             return;
         }
     }
-
-    /*
-       sprintf (tmp, "cp -f %s %s.pre-resize", g_mountlist_fname, g_mountlist_fname);
-       run_program_and_log_output (tmp, FALSE);
-     */
 
     current_size_of_drive = get_phys_size_of_drive(drive_name);
@@ -2416 +2353 @@
     if (current_size_of_drive <= 0) {
         log_it("Not resizing to match %s - can't find drive", drive_name);
-        mr_free(tmp);
         return;
     }
-    sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name,
+    log_to_screen("Expanding entries to suit drive %s (%ld MB)", drive_name,
             current_size_of_drive);
-    log_to_screen(tmp);
 
     drivemntlist = mr_malloc(sizeof(struct mountlist_reference));
@@ -2435 +2370 @@
 
     if (original_size_of_drive <= 0) {
-        sprintf(tmp, "Cannot resize %s's entries. Drive not found.",
+        log_to_screen(_("Cannot resize %s's entries. Drive not found."),
                 drive_name);
-        log_to_screen(tmp);
-        mr_free(tmp);
         return;
     }
     factor =
         (float) (current_size_of_drive) / (float) (original_size_of_drive);
-    sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
+    log_to_screen(_("Disk %s was %ld MB; is now %ld MB; factor = %f"),
             drive_name, original_size_of_drive, current_size_of_drive,
             factor);
-    log_to_screen(tmp);
 
     lastpart = drivemntlist->entries - 1;
@@ -2465 +2397 @@
             newsizL = (long) new_size;
         }
-        sprintf(tmp, "Changing %s from %lld KB to %ld KB",
+        log_to_screen(_("Changing %s from %lld KB to %ld KB"),
                 drivemntlist->el[partno]->device,
                 drivemntlist->el[partno]->size, newsizL);
-        log_to_screen(tmp);
         drivemntlist->el[partno]->size = newsizL;
     }
     final_size = get_phys_size_of_drive(drive_name);
-    sprintf(tmp, "final_size = %ld MB", final_size);
-    mr_free(tmp);
-    log_to_screen(tmp);
+    log_to_screen(_("final_size = %ld MB"), final_size);
 }
 
@@ -2488 +2417 @@
 {
     /** buffers *********************************************************/
-    struct list_of_disks *drivelist;
+    struct list_of_disks *drivelist = NULL;
 
     /** int *************************************************************/
-    int driveno;
+    int driveno = 0;
 
     /** end *************************************************************/
@@ -2501 +2430 @@
             ("resize_mountlist_prop...() - warning - mountlist fname is blank");
         log_it("That does NOT affect the functioning of this subroutine.");
-        log_it("--- Hugo, 2002/11/20");
     }
     iamhere("Resizing mountlist");
@@ -2512 +2440 @@
                                                         device);
     }
-    log_to_screen("Mountlist adjusted to suit current hard drive(s)");
+    log_to_screen(_("Mountlist adjusted to suit current hard drive(s)"));
     mr_free(drivelist);
 }
@@ -2528 +2456 @@
                                 struct mountlist_reference *drivemntlist)
 {
-    int partno;
-    char *tmp_drive_name, *c;
+    int partno = 0;
+    char *tmp_drive_name = NULL, *c = NULL;
 
     assert(mountlist != NULL);
@@ -2537 +2465 @@
     mr_msg(1, "Creating list of partitions for drive %s", drive_name);
 
-    tmp_drive_name = strdup(drive_name);
-    if (!tmp_drive_name)
-        fatal_error("Out of memory");
+    mr_asprintf(&tmp_drive_name, drive_name);
 
     /* devfs devices? */
@@ -2545 +2471 @@
     if (c && strncmp(c, "/disc", 5) == 0) {
         /* yup its devfs, change the "disc" to "part" so the existing code works */
-        strcpy(c + 1, "part");
+        strncpy(c + 1, "part", (size_t)5);
     }
     drivemntlist->entries = 0;
@@ -2557 +2483 @@
         }
     }
-    if (tmp_drive_name)
-        mr_free(tmp_drive_name);
+    mr_free(tmp_drive_name);
 }