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

Timestamp:

Jul 20, 2009, 12:27:56 AM (16 years ago)

Author:

Bruno Cornec

Message:

r3276@localhost: bruno | 2009-07-20 00:14:55 +0200

• Replace sprintf by mr_asprintf in mondo-prep.c and change interface of function which_format_command_do_i_need

Location:

branches/2.2.10/mondo/src/mondorestore

Files:

• mondo-prep.c (modified) (98 diffs)
• mondoprep.h (modified) (1 diff)
• mr-externs.h (modified) (1 diff)

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

@@ -60 +60 @@
 void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist)
 {
-    char *command;
+    char *command = NULL;
     char *tmp;
     int lino;
     int i;
+    int res = 0;
     FILE *fout;
     char *buf;
     const int blocksize = 512;
     struct list_of_disks *drivelist = NULL;
+
 // If LVMs are present and a zero-and-reboot wasn't recently undertaken
 // then zero & insist on reboot.
-    malloc_string(command);
     malloc_string(tmp);
     buf = malloc(blocksize);
@@ -78 +79 @@
         make_list_of_drives_in_mountlist(mountlist, drivelist);
         for (lino = 0; lino < drivelist->entries; lino++) {
-            sprintf(command,
+            mr_asprintf(&command,
                     "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
                     drivelist->el[lino].device, MONDO_WAS_HERE);
-            if (!run_program_and_log_output(command, 1)) {
+            res = run_program_and_log_output(command, 1);
+            mr_free(command);
+            if (!res) {
                 log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)",
                         lino, drivelist->el[lino].device);
@@ -126 +129 @@
     }
 // Still here? Cool!
-    paranoid_free(command);
     paranoid_free(tmp);
     log_msg(1, "Cool. I didn't have to wipe anything.");
@@ -236 +238 @@
     malloc_string(vgchange_sz);
     malloc_string(vgremove_sz);
-//  malloc_string(do_this_last); // postpone lvcreate call if necessary
     command = malloc(512);
 
-//  do_this_last[0] = '\0';
     log_it("STARTING");
     log_msg(1, "OK, opened i-want-my-lvm. Shutting down LVM volumes...");
@@ -260 +260 @@
         strcpy(vgremove_sz, "vgremove");
     }
-    sprintf(command,
+    mr_asprintf(&tmp1,
             "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> %s ; %s -f $i; done", lvscan_sz, MONDO_LOGFILE, lvremove_sz);
-    run_program_and_log_output(command, 5);
+    run_program_and_log_output(tmp1, 5);
+    mr_free(tmp1);
+
     sleep(1);
     sprintf(command,
@@ -271 +273 @@
         log_msg(1, "Closed i-want-my-lvm. Finished erasing LVMs.");
         retval = 0;
-        goto end_of_i_want_my_lvm;
-    }
+    } else {
 
     log_msg(1, "OK, rewound i-want-my-lvm. Doing funky stuff...");
@@ -288 +289 @@
         }
         if ((p = strstr(incoming, "vgcreate"))) {
-// include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
+            // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
             for (fgets(tmp, MAX_STR_LEN - 1, fin); !feof(fin); fgets(tmp, MAX_STR_LEN - 1, fin)) {
                 if (tmp[0] == '#') {
@@ -307 +308 @@
             *q = '\0';
             log_msg(1, "Deleting old entries at /dev/%s", tmp);
-//             sprintf(command, "%s -f %s", vgremove_sz, tmp);
-//             run_program_and_log_output(command, 1);
-            sprintf(command, "rm -Rf /dev/%s", tmp);
-            run_program_and_log_output(command, 1);
+            mr_asprintf(&tmp1, "rm -Rf /dev/%s", tmp);
+            run_program_and_log_output(tmp1, 1);
+            mr_free(tmp1);
+
             run_program_and_log_output(vgscan_sz, 1);
             run_program_and_log_output(pvscan_sz, 1);
@@ -339 +340 @@
                 mr_asprintf(&tmp1, "tail -n5 %s | grep Insufficient | tail -n1", MONDO_LOGFILE);
                 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1));
-                free(tmp1);
+                mr_free(tmp1);
             } else {
                 mr_asprintf(&tmp1, "tail -n5 %s | grep lvcreate | tail -n1", MONDO_LOGFILE);
                 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1));
-                free(tmp1);
+                mr_free(tmp1);
             }
             for (p = tmp; *p != '\0' && !isdigit(*p); p++);
@@ -395 +396 @@
             retval++;
         }
-        sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command);
-        system(tmp);
+        mr_asprintf(&tmp1, "echo \"%s\" >> /tmp/out.sh", command);
+        system(tmp1);
+        mr_free(tmp1);
         sleep(1);
     }
     paranoid_fclose(fin);
     log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
-  end_of_i_want_my_lvm:
+    }
     paranoid_free(tmp);
     paranoid_free(incoming);
@@ -412 +414 @@
     paranoid_free(vgchange_sz);
     paranoid_free(vgremove_sz);
-//  paranoid_free(do_this_last);
     system("sync");
     system("sync");
@@ -450 +451 @@
     /** buffers **********************************************************/
     char *incoming;
-    char *tmp;
+    char *tmp = NULL;
 
     /** pointers *********************************************************/
@@ -461 +462 @@
 
     malloc_string(incoming);
-    malloc_string(tmp);
     assert(new_mountlist != NULL);
     assert(old_mountlist != NULL);
@@ -487 +487 @@
                  fgets(incoming, MAX_STR_LEN - 1, fin));
             if (!feof(fin)) {
-                sprintf(tmp, "Investigating %s",
-                        old_mountlist->el[lino].device);
+                mr_asprintf(&tmp, "Investigating %s", old_mountlist->el[lino].device);
                 log_it(tmp);
+                mr_free(tmp);
+
                 for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
                      && !strstr(incoming, "raiddev");
@@ -499 +500 @@
                         *p = '\0';
                         for (p--; p > incoming && *(p - 1) > 32; p--);
-                        sprintf(tmp, "Extrapolating %s", p);
+                        mr_asprintf(&tmp, "Extrapolating %s", p);
                         log_it(tmp);
+                        mr_free(tmp);
+
                         for (j = 0;
                              j < new_mountlist->entries
@@ -518 +521 @@
                             new_mountlist->entries++;
                         } else {
-                            sprintf(tmp,
+                            mr_asprintf(&tmp,
                                     "Not adding %s to mountlist: it's already there",
                                     p);
                             log_it(tmp);
+                            mr_free(tmp);
                         }
                     }
@@ -540 +544 @@
     }
     paranoid_free(incoming);
-    paranoid_free(tmp);
 
     return (0);
@@ -683 +686 @@
 
     /** buffers ***********************************************************/
-    char *program;
+    char *program = NULL;
     char *tmp = NULL;
     int res = 0;
@@ -690 +693 @@
     /** end ****************************************************************/
 
-    malloc_string(program);
     assert_string_is_neither_NULL_nor_zerolength(device);
     assert(format != NULL);
@@ -698 +700 @@
         log_it(tmp);
         paranoid_free(tmp);
-        paranoid_free(program);
         return (0);
     }
@@ -704 +705 @@
     if (strcmp(format, "swap") == 0) {
         log_it("Not formatting %s - it's swap", device);
-        paranoid_free(program);
-        paranoid_free(tmp);
         return (0);
     }
@@ -715 +714 @@
         log_it(tmp);
         paranoid_free(tmp);
-        paranoid_free(program);
         return (0);
     }
@@ -722 +720 @@
         log_to_screen(tmp);
         paranoid_free(tmp);
-        paranoid_free(program);
         return (1);
     }
@@ -755 +752 @@
 
             /* format raid partition */
-            //      sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003
-            sprintf(program,
-                    "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes",
-                    basename(device));
+            mr_asprintf(&program,
+                    "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes", basename(device));
             system(program);
             if (g_fprep) {
                 fprintf(g_fprep, "%s\n", program);
             }
+            mr_free(program);
+
             fin = fopen("/tmp/plexes", "r");
             while (fgets(line, MAX_STR_LEN - 1, fin)) {
@@ -809 +806 @@
         system("sync");
         sleep(1);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
 
         log_msg(1, "Making %s", device);
@@ -819 +813 @@
             log_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
         } else {
-            sprintf(program, "mkraid --really-force %s", device);
+            mr_asprintf(&program, "mkraid --really-force %s", device);
             res = run_program_and_log_output(program, 1);
             log_msg(1, "%s returned %d", program, res);
@@ -828 +822 @@
                 fprintf(g_fprep, "%s\n", program);
             }
+            mr_free(program);
         }
         system("sync");
         sleep(2);
-//      log_to_screen("Starting %s", device);
-//      sprintf(program, "raidstart %s", device);
-//      res = run_program_and_log_output(program, 1);
-//      log_msg(1, "%s returned %d", program, res);
-//      system("sync"); sleep(1);
 #endif
         system("sync");
@@ -841 +831 @@
         newtResume();
     }
-//#ifndef __FreeBSD__
-//#endif
 
     if (!strcmp(format, "lvm")) {
         log_msg(1, "Don't format %s - it's part of an lvm volume", device);
-        paranoid_free(program);
         paranoid_free(tmp);
         return (0);
     }
-    res = which_format_command_do_i_need(format, program);
+    program = which_format_command_do_i_need(format);
     mr_asprintf(&tmp, "%s %s", program, device);
     if (strstr(program, "kludge")) {
         mr_strcat(tmp, " /");
     }
-    sprintf(program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
+    mr_free(program);
+
+    mr_asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
     paranoid_free(tmp);
 
@@ -867 +856 @@
         mr_strcat(tmp, "Kludge failed; using regular mkfs.%s to format %s",
                 format, device);
+        mr_free(program);
 #ifdef __FreeBSD__
-        sprintf(program, "newfs_msdos -F 32 %s", device);
+        mr_asprintf(&program, "newfs_msdos -F 32 %s", device);
 #else
 #ifdef __IA64__
         /* For EFI partitions take fat16 
          * as we want to make small ones */
-        sprintf(program, "mkfs -t %s -F 16 %s", format, device);
+        mr_asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        sprintf(program, "mkfs -t %s -F 32 %s", format, device);
+        mr_asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
 #endif
 #endif
@@ -883 +873 @@
         }
     }
+    mr_free(program);
     retval += res;
     if (retval) {
@@ -891 +882 @@
 
     log_to_screen(tmp);
-    paranoid_free(tmp);
-
-    paranoid_free(program);
+    mr_free(tmp);
+
     system("sync");
     sleep(1);
@@ -916 +906 @@
     int lino;
     int res;
-//  int i;
-//  struct list_of_disks *drivelist;
 
     /** long *************************************************************/
@@ -926 +914 @@
 
     /** buffers **********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** pointers *********************************************************/
@@ -933 +921 @@
 
     assert(mountlist != NULL);
-    malloc_string(tmp);
-    sprintf(tmp, "format_everything (mountlist, interactively = %s",
+    Mr_asprintf(&tmp, "format_everything (mountlist, interactively = %s",
             (interactively) ? "true" : "false");
     log_it(tmp);
+    mr_free(tmp);
+
     mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions     ");
     open_progress_form("Formatting partitions",
@@ -946 +935 @@
         (mountlist->entries >
          0) ? g_maximum_progress / mountlist->entries : 1;
-// start soft-raids now (because LVM might depend on them)
-// ...and for simplicity's sake, let's format them at the same time :)
+        // start soft-raids now (because LVM might depend on them)
+        // ...and for simplicity's sake, let's format them at the same time :)
     log_msg(1, "Stopping all RAID devices");
     stop_all_raid_devices(mountlist);
@@ -961 +950 @@
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -991 +981 @@
             newtSuspend();
         }
-/*
-        for(i=0; i<3; i++)
-          {
-            res = do_my_funky_lvm_stuff(FALSE, FALSE);
-            if (!res) { break; }
-            sleep(3);
-            res = do_my_funky_lvm_stuff(TRUE, FALSE);
-            sleep(3);
-          }
-        if (res) {
-            log_msg(1, "Vacuum-packing...");
-*/
         res = do_my_funky_lvm_stuff(FALSE, TRUE);
-/*
-        }
-*/
         if (!g_text_mode) {
             newtResume();
@@ -1015 +990 @@
             log_to_screen("Failed to initialize LVM");
         }
-        // retval += res;
         if (res) {
             retval++;
@@ -1021 +995 @@
         sleep(3);
     }
-// do regulars at last
+    // do regulars at last
     sleep(2);                   // woo!
     log_msg(1, "Formatting regulars");
@@ -1027 +1001 @@
         me = &mountlist->el[lino];  // the current mountlist entry
         if (!strcmp(me->mountpoint, "image")) {
-            sprintf(tmp, "Not formatting %s - it's an image", me->device);
+            mr_asprintf(&tmp, "Not formatting %s - it's an image", me->device);
             log_it(tmp);
+            mr_free(tmp);
         } else if (!strcmp(me->format, "raid")) {
-            sprintf(tmp, "Not formatting %s - it's a raid-let",
-                    me->device);
+            mr_asprintf(&tmp, "Not formatting %s - it's a raid-let", me->device);
             log_it(tmp);
+            mr_free(tmp);
             continue;
         } else if (!strcmp(me->format, "lvm")) {
-            sprintf(tmp, "Not formatting %s - it's an LVM", me->device);
+            mr_asprintf(&tmp, "Not formatting %s - it's an LVM", me->device);
             log_it(tmp);
+            mr_free(tmp);
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            sprintf(tmp, "Already formatted %s - it's a soft-RAID dev",
-                    me->device);
+            mr_asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev", me->device);
             log_it(tmp);
+            mr_free(tmp);
             continue;
         } else if (!does_file_exist(me->device)
                    && strncmp(me->device, "/dev/hd", 7)
                    && strncmp(me->device, "/dev/sd", 7)) {
-            sprintf(tmp,
-                    "Not formatting %s yet - doesn't exist - probably an LVM",
-                    me->device);
+            mr_asprintf(&tmp, "Not formatting %s yet - doesn't exist - probably an LVM", me->device);
             log_it(tmp);
+            mr_free(tmp);
             continue;
         } else {
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
-                        me->mountpoint);
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1085 +1060 @@
     }
 
-    sprintf(tmp, "format_everything () - %s",
-            (retval) ? "failed!" : "finished successfully");
+    mr_asprintf(&tmp, "format_everything () - %s", (retval) ? "failed!" : "finished successfully");
     log_it(tmp);
+    mr_free(tmp);
 
     if (g_partition_table_locked_up > 0) {
@@ -1119 +1094 @@
     system("clear");
     newtResume();
-    paranoid_free(tmp);
     return (retval);
 }
@@ -1142 +1116 @@
 
     /** buffers **********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** end **************************************************************/
 
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
     if (devno_we_must_allow_for >= 5) {
-        sprintf(tmp, "Making dummy primary 1 on %s", drivename);
+        mr_asprintf(&tmp, "Making dummy primary 1 on %s", drivename);
         log_it(tmp);
+        mr_free(tmp);
+
         g_maximum_progress++;
         res =
@@ -1164 +1139 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        sprintf(tmp, "Creating dummy partition %d on %s", current_devno, drivename);
+        mr_asprintf(&tmp, "Creating dummy partition %d on %s", current_devno, drivename);
         log_it(tmp);
+        mr_free(tmp);
         g_maximum_progress++;
         res =
@@ -1173 +1149 @@
         previous_devno = current_devno;
     }
-    paranoid_free(tmp);
     return (previous_devno);
 }
@@ -1386 +1361 @@
                          char *drivename, struct disklabel *ret)
 {
-    char subdev_str[MAX_STR_LEN];
-    char command[MAX_STR_LEN];
+    char *subdev_str = NULL
+    char *command = NULL;
     struct disklabel *lp;
     int i, lo = 0;
@@ -1397 +1372 @@
     for (c = 'a'; c <= 'z'; ++c) {
         int idx;
-        sprintf(subdev_str, "%s%c", drivename, c);
+        mr_asprintf(&subdev_str, "%s%c", drivename, c);
         if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
             lp->d_partitions[c - 'a'].p_size = 0;
@@ -1422 +1397 @@
                 lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
         }
+        mr_free(subdev_str);
     }
 
@@ -1452 +1428 @@
     display_disklabel(ftmp, lp);
     fclose(ftmp);
-    sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
+    mr_asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
-    sprintf(command, "disklabel -R %s /tmp/disklabel",
+    mr_free(command);
+
+    mr_asprintf(&command, "disklabel -R %s /tmp/disklabel",
             canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
+    mr_free(command);
     if (ret)
         *ret = *lp;
@@ -1482 +1461 @@
 #ifdef __FreeBSD__
     bool fbsd_part = FALSE;
-    char subdev_str[MAX_STR_LEN];
+    char *subdev_str = NULL;
+    char *command = NULL;
+    int r = 0;
 #endif
 
@@ -1491 +1472 @@
     char *device_str;
     char *format;
-    char *tmp;
+    char *tmp = NULL;
 
     /** end *************************************************************/
@@ -1500 +1481 @@
     malloc_string(device_str);
     malloc_string(format);
-    malloc_string(tmp);
-
-    sprintf(tmp, "Partitioning drive %s", drivename);
+
+    mr_asprintf(&tmp, "Partitioning drive %s", drivename);
     log_it(tmp);
+    mr_free(tmp);
 
 #if __FreeBSD__
@@ -1510 +1491 @@
 #else
     make_hole_for_file(FDISK_LOG);
-    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
+    mr_asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
     pout_to_fdisk = popen(tmp, "w");
+    mr_free(tmp);
     if (!pout_to_fdisk) {
         log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
         paranoid_free(device_str);
         paranoid_free(format);
-        paranoid_free(tmp);
         return (1);
     }
@@ -1534 +1515 @@
                 // try DangerouslyDedicated mode
                 for (c = 'a'; c <= 'z'; c++) {
-                    sprintf(subdev_str, "%s%c", drivename, c);
-                    if (find_device_in_mountlist(mountlist, subdev_str) >
-                        0) {
+                    mr_asprintf(&subdev_str, "%s%c", drivename, c);
+                    if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                         fbsd_part = TRUE;
                     }
+                    mr_free(subdev_str);
                 }
                 if (fbsd_part) {
-                    int r = label_drive_or_slice(mountlist,
+                    r = label_drive_or_slice(mountlist,
                                                  drivename,
                                                  0);
-                    char command[MAX_STR_LEN];
-                    sprintf(command, "disklabel -B %s",
-                            basename(drivename));
+                    mr_asprintf(&command, "disklabel -B %s", basename(drivename));
                     if (system(command)) {
                         log_to_screen
                             ("Warning! Unable to make the drive bootable.");
                     }
+                    mr_free(command);
                     paranoid_free(device_str);
                     paranoid_free(format);
-                    paranoid_free(tmp);
                     return r;
                 }
             }
             for (c = 'a'; c <= 'z'; c++) {
-                sprintf(subdev_str, "%s%c", device_str, c);
+                mr_asprintf(&subdev_str, "%s%c", device_str, c);
                 if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                     fbsd_part = TRUE;
                 }
+                    mr_free(subdev_str);
             }
             // Now we check the subpartitions of the current partition.
@@ -1570 +1550 @@
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
-                    sprintf(subdev_str, "%s%c", device_str, i);
+                    mr_asprintf(&subdev_str, "%s%c", device_str, i);
                     line = find_device_in_mountlist(mountlist, subdev_str);
+                    mr_free(subdev_str);
+
                     if (line > 0) {
                         // We found one! Add its size to the total size.
@@ -1594 +1576 @@
 #if __FreeBSD__
             // FreeBSD doesn't let you write to blk devices in <512byte chunks.
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          if (run_program_and_log_output(tmp, TRUE)) {
             file = open(drivename, O_WRONLY);
             if (file != -1) {
-                sprintf(tmp,
+                mr_asprintf(&tmp,
                         "Warning - unable to open %s for wiping it's partition table",
                         drivename);
                 log_to_screen(tmp);
+                mr_free(tmp);
             }
 
             for (i = 0; i < 512; i++) {
                 if (!write(file, "\0", 1)) {
-                    sprintf(tmp, "Warning - unable to write to %s",
+                    mr_asprintf(&tmp, "Warning - unable to write to %s",
                             drivename);
                     log_to_screen(tmp);
+                    mr_free(tmp);
                 }
             }
@@ -1618 +1600 @@
                 fflush(pout_to_fdisk);
             }
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          run_program_and_log_output(tmp, 1);
 #endif
             if (current_devno > 1) {
@@ -1644 +1624 @@
             paranoid_free(device_str);
             paranoid_free(format);
-            paranoid_free(tmp);
             return (1);
         }
@@ -1655 +1634 @@
 #ifdef __FreeBSD__
         if ((current_devno <= 4) && fbsd_part) {
-            sprintf(tmp, "disklabel -B %s", basename(device_str));
+            mr_asprintf(&tmp, "disklabel -B %s", basename(device_str));
             retval += label_drive_or_slice(mountlist, device_str, 0);
             if (system(tmp)) {
@@ -1661 +1640 @@
                     ("Warning! Unable to make the slice bootable.");
             }
+            mr_free(tmp);
         }
 #endif
@@ -1669 +1649 @@
     if (pout_to_fdisk) {
 // mark relevant partition as bootable
-        sprintf(tmp, "a\n%s\n",
+        mr_asprintf(&tmp, "a\n%s\n",
                 call_program_and_get_last_line_of_output
                 ("make-me-bootable /tmp/mountlist.txt dummy"));
         fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+        mr_free(tmp);
+
 // close fdisk
         fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
@@ -1679 +1661 @@
         log_msg(0,
                 "------------------- fdisk.log looks like this ------------------");
-        sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
+        mr_asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
         system(tmp);
+        mr_free(tmp);
+
         log_msg(0,
                 "------------------- end of fdisk.log... word! ------------------");
-        sprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
+        mr_asprintf(&tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
         if (!run_program_and_log_output(tmp, 5)) {
             g_partition_table_locked_up++;
         }
-        sprintf(tmp, "partprobe %s", drivename);
+        mr_free(tmp);
+
+        mr_asprintf(&tmp, "partprobe %s", drivename);
         if (!run_program_and_log_output(tmp, 5)) {
             g_partition_table_locked_up--;
         }
+        mr_free(tmp);
+
         if (g_partition_table_locked_up > 0) {
             log_to_screen
@@ -1698 +1686 @@
     paranoid_free(device_str);
     paranoid_free(format);
-    paranoid_free(tmp);
     return (retval);
 }
@@ -1720 +1707 @@
 
     /** buffers **********************************************************/
-    char *program;
+    char *program = NULL;
     char *partition_name;
-    char *tmp;
-    char *logfile;
+    char *tmp = NULL;
     char *output = NULL;
 
@@ -1733 +1719 @@
     /** end ***************************************************************/
 
-    malloc_string(program);
     malloc_string(partition_name);
-    malloc_string(tmp);
-    malloc_string(logfile);
 
     assert_string_is_neither_NULL_nor_zerolength(drive);
@@ -1745 +1728 @@
 
     if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);
+        mr_asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive);
         log_it(tmp);
-        paranoid_free(program);
+        mr_free(tmp);
+
         paranoid_free(partition_name);
-        paranoid_free(tmp);
-        paranoid_free(logfile);
         return (0);
     }
     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,
-                (long long) partsize / 1024);
+        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",
+        mr_asprintf(&tmp, "%s is mounted, and should not be partitioned",
                 partition_name);
         log_to_screen(tmp);
-        paranoid_free(program);
+        mr_free(tmp);
         paranoid_free(partition_name);
-        paranoid_free(tmp);
-        paranoid_free(logfile);
         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: should not be called each time */
@@ -1801 +1770 @@
                     log_to_screen
                         ("You need to leave at least one partition free, for 'extended/logical'");
-                    paranoid_free(program);
                     paranoid_free(partition_name);
-                    paranoid_free(tmp);
-                    paranoid_free(logfile);
                     paranoid_free(output);
                     return (1);
@@ -1826 +1792 @@
     }
     mr_strcat(output, "\n");
-#if 0
-/*
-#endif
-    sprintf(tmp,"PARTSIZE = +%ld",(long)partsize);
+    mr_asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize);
     log_it(tmp);
+    mr_free(tmp);
     log_it("---fdisk command---");
     log_it(output);
     log_it("---end of fdisk---");
-#if 0
-*/
-#endif
-
-
+
+    mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
     if (pout_to_fdisk) {
         log_msg(1, "Doing the new all-in-one fdisk thing");
@@ -1844 +1805 @@
         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, "%s", last_line_of_file(FDISK_LOG));
         if (strstr(tmp, " (m ")) {
             log_msg(1, "Successfully created partition %d on %s", partno, drive);
@@ -1851 +1812 @@
             log_msg(1, "Failed to create partition %d on %s; sending 'Enter'...", partno, drive);
         }
+        mr_free(tmp);
+
         if (!retval) {
             log_msg(1, "Trying to set partition %d type now on %s", partno, drive);
@@ -1885 +1848 @@
                                  format, -1);
             if (res) {
-                sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
+                mr_asprintf(&tmp, "Failed to vacuum-pack %s", partition_name);
                 log_it(tmp);
+                mr_free(tmp);
+
                 retval++;
             } else {
@@ -1897 +1862 @@
                                    partsize);
             if (retval) {
-                sprintf(tmp, "Partitioned %s but failed to set its type",
-                        partition_name);
+                mr_asprintf(&tmp, "Partitioned %s but failed to set its type", partition_name);
                 log_it(tmp);
+                mr_free(tmp);
             } else {
                 if (partsize > 0) {
-                    sprintf(tmp, "Partition %s created+configured OK",
-                            partition_name);
+                    mr_asprintf(&tmp, "Partition %s created+configured OK", partition_name);
                     log_to_screen(tmp);
+                    mr_free(tmp);
                 } else {
                     log_it("Returning from a successful vacuum-pack");
@@ -1910 +1875 @@
             }
         } 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);
@@ -1916 +1881 @@
                 log_it(tmp);
             }
+            mr_free(tmp);
             retval++;
         }
     }
+    mr_free(program);
     paranoid_free(output);
 
     g_current_progress++;
     log_it("partition_device() --- leaving");
-    paranoid_free(program);
     paranoid_free(partition_name);
-    paranoid_free(tmp);
-    paranoid_free(logfile);
     return (retval);
 }
@@ -2035 +1999 @@
     /** buffers *********************************************************/
     char *partition;
-    char *command;
+    char *command = NULL;
     char *output = NULL;
-    char *tmp;
+    char *tmp = NULL;
     char *partcode;
-    char *logfile;
 
     /** pointers *********************************************************/
@@ -2054 +2017 @@
 
     malloc_string(partition);
-    malloc_string(command);
-    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");
@@ -2098 +2057 @@
     } 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
@@ -2108 +2068 @@
 #endif
     }
-    sprintf(tmp, "Setting %s's type to %s (%s)", partition, format,
-            partcode);
-    log_msg(1, tmp);
+    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 */
 
@@ -2119 +2077 @@
                 || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
                 log_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_free(tmp);
+
                 log_msg(5, "A - last line = '%s'",
                         last_line_of_file(FDISK_LOG));
             }
 
-            sprintf(tmp, "%s\n", partcode);
+            mr_asprintf(&tmp, "%s\n", partcode);
             fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+            mr_free(tmp);
+
             log_msg(5, "B - last line = '%s'",
                     last_line_of_file(FDISK_LOG));
@@ -2133 +2095 @@
                     last_line_of_file(FDISK_LOG));
 
-            strcpy(tmp, last_line_of_file(FDISK_LOG));
+            mr_asprintf(&tmp, "%s", last_line_of_file(FDISK_LOG));
             if (!strstr(tmp, " (m ")) {
                 log_msg(1, "last line = '%s'; part type set failed", tmp);
@@ -2139 +2101 @@
                 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 {
             mr_asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
-            sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,
+            mr_asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive,
                     MONDO_LOGFILE, MONDO_LOGFILE);
             log_msg(5, "output = '%s'", output);
@@ -2157 +2121 @@
             }
             paranoid_free(output);
-        }
-        if (res) {
-            log_OS_error(command);
+            mr_free(command);
         }
     }
 
     paranoid_free(partition);
-    paranoid_free(command);
-    paranoid_free(tmp);
     paranoid_free(partcode);
-    paranoid_free(logfile);
 
     return (res);
@@ -2180 +2139 @@
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2192 +2150 @@
         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);
+    mr_asprintf(&program, "raidstart %s", raid_device);
 #endif
     log_msg(1, "program = %s", program);
@@ -2201 +2159 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    mr_free(program);
+
     if (res) {
         log_msg(1, "Warning - failed to start RAID device %s",
@@ -2224 +2184 @@
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2236 +2195 @@
         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);
+        mr_asprintf(&program, "mdadm -S %s", raid_device);
     } else {
-        sprintf(program, "raidstop %s", raid_device);
+        mr_asprintf(&program, "raidstop %s", raid_device);
     }
 #endif
@@ -2250 +2209 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    mr_free(program);
+
     if (res) {
         log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
@@ -2371 +2332 @@
  * @return 0 for success, nonzero for failure.
  */
-int which_format_command_do_i_need(char *format, char *program)
+char *which_format_command_do_i_need(char *format)
 {
     /** int *************************************************************/
@@ -2377 +2338 @@
 
     /** buffers *********************************************************/
-    char *tmp;
+    char *tmp = NULL;
+    char *program = NULL;
 
     /** end ***************************************************************/
 
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(format);
-    assert(program != NULL);
 
     if (strcmp(format, "swap") == 0) {
 #ifdef __FreeBSD__
-        strcpy(program, "true");
+        mr_asprintf(&program, "true");
 #else
-        strcpy(program, "mkswap");
+        mr_asprintf(&program, "mkswap");
 #endif
     } else if (strcmp(format, "vfat") == 0) {
-        strcpy(program, "format-and-kludge-vfat");
+        mr_asprintf(&program, "format-and-kludge-vfat");
 #ifndef __FreeBSD__
     } else if (strcmp(format, "reiserfs") == 0) {
-        strcpy(program, "mkreiserfs -ff");
+        mr_asprintf(&program, "mkreiserfs -ff");
     } else if (strcmp(format, "xfs") == 0) {
-        strcpy(program, "mkfs.xfs -f -q");
+        mr_asprintf(&program, "mkfs.xfs -f -q");
     } else if (strcmp(format, "jfs") == 0) {
-        strcpy(program, "mkfs.jfs");
+        mr_asprintf(&program, "mkfs.jfs");
     } else if (strcmp(format, "ext3") == 0) {
-        strcpy(program, "mkfs -t ext3 -F -q");
+        mr_asprintf(&program, "mkfs -t ext3 -F -q");
     } else if (strcmp(format, "ext4") == 0) {
-        strcpy(program, "mkfs -t ext4 -F -q");
+        mr_asprintf(&program, "mkfs -t ext4 -F -q");
     } else if (strcmp(format, "minix") == 0) {
-        strcpy(program, "mkfs.minix");
+        mr_asprintf(&program, "mkfs.minix");
     } else if (strcmp(format, "vmfs") == 0) {
-        strcpy(program, "mkfs -t vmfs");
+        mr_asprintf(&program, "mkfs -t vmfs");
     } else if (strcmp(format, "ntfs") == 0) { 
         /* 
@@ -2413 +2373 @@
          * so the default "mkfs -t %s -c" command structure fails 
          */ 
-        strcpy(program, "mkfs -t ntfs");
+        mr_asprintf(&program, "mkfs -t ntfs");
     } else if (strcmp(format, "ocfs2") == 0) {
         /*
@@ -2419 +2379 @@
          *
          */
-        strcpy(program, "mkfs -t ocfs2 -F");
+        mr_asprintf(&program, "mkfs -t ocfs2 -F");
 #endif
     } else if (strcmp(format, "ext2") == 0) {
-        strcpy(program, "mke2fs -F -q");
+        mr_asprintf(&program, "mke2fs -F -q");
     } else {
 #ifdef __FreeBSD__
-        sprintf(program, "newfs_%s", format);
+        mr_asprintf(&program, "newfs_%s", format);
 #else
-        sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
+        mr_asprintf(&program, "mkfs -t %s -c", format); // -c checks for bad blocks
 #endif
-        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format,
-                program);
+        mr_asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format, program);
         log_it(tmp);
+        mr_free(tmp);
         res = 0;
     }
-    paranoid_free(tmp);
-    return (res);
+    return (program);
 }
 
@@ -2455 +2414 @@
 {
     /**buffers **********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** int *************************************************************/
@@ -2477 +2436 @@
     /** end **************************************************************/
 
-    malloc_string(tmp);
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
@@ -2484 +2442 @@
         if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
             == 0) {
-            paranoid_free(tmp);
             return;
         }
@@ -2493 +2450 @@
     if (current_size_of_drive <= 0) {
         log_it("Not resizing to match %s - can't find drive", drive_name);
-        paranoid_free(tmp);
         return;
     }
-    sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name,
-            current_size_of_drive);
+    mr_asprintf(&tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name, current_size_of_drive);
     log_to_screen(tmp);
+    mr_free(tmp);
 
     drivemntlist = malloc(sizeof(struct mountlist_reference));
@@ -2516 +2472 @@
 
     if (original_size_of_drive <= 0) {
-        sprintf(tmp, "Cannot resize %s's entries. Drive not found.",
-                drive_name);
+        mr_asprintf(&tmp, "Cannot resize %s's entries. Drive not found.", drive_name);
         log_to_screen(tmp);
-        paranoid_free(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",
-            drive_name, original_size_of_drive, current_size_of_drive,
-            factor);
+    factor = (float) (current_size_of_drive) / (float) (original_size_of_drive);
+    mr_asprintf(&tmp, "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);
+    mr_free(tmp);
 
     lastpart = drivemntlist->entries - 1;
@@ -2552 +2505 @@
         }
 
-        sprintf(tmp, "Changing %s from %lld KB to %ld KB",
-                drivemntlist->el[partno]->device,
-                drivemntlist->el[partno]->size, newsizL);
+        mr_asprintf(&tmp, "Changing %s from %lld KB to %ld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size, newsizL);
         log_to_screen(tmp);
+        mr_free(tmp);
         drivemntlist->el[partno]->size = newsizL;
     }
     final_size = get_phys_size_of_drive(drive_name);
-    sprintf(tmp, "final_size = %ld MB", final_size);
+    mr_asprintf(&tmp, "final_size = %ld MB", final_size);
     log_to_screen(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 }
 

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

@@ -69 +69 @@
 int partition_everything(struct mountlist_itself *);
 int do_my_funky_lvm_stuff(bool, bool);
-int which_format_command_do_i_need(char *, char *);
+char *which_format_command_do_i_need(char *);
 int make_dummy_partitions(FILE *, char *, int);
 int make_list_of_drives(struct mountlist_itself *,

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

@@ -80 +80 @@
 extern int verify_tape_backups();
 extern char which_restore_mode(void);
-extern int which_format_command_do_i_need(char *, char *);
+extern char *which_format_command_do_i_need(char *);
 extern int write_cfg_var(char *, char *, char *);
 extern void wrong_marker(int, int);